@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/scheduler/scheduler.ts

@@ -16,6 +16,7 @@ import {
   getUserById,
   getWorkflow,
   getWorkflowRun,
+  type UpdateScheduledTaskData,
   updateScheduledTask,
 } from "@/be/db";
 import {
@@ -38,11 +39,12 @@ import {
   reconcileDeferredTaskWaits,
   stopDeferredTaskWaits,
 } from "./deferred-task-waits";
-import { createStandaloneScheduleTask } from "./schedule-task";
+import { createStandaloneScheduleTask, prepareStandaloneScheduleTask } from "./schedule-task";
 
 export { createStandaloneScheduleTask } from "./schedule-task";
 
 let schedulerInterval: ReturnType<typeof setInterval> | null = null;
+let schedulerRun: object | null = null;
 let isProcessing = false;
 let executorRegistry: ExecutorRegistry | null = null;
 
@@ -201,8 +203,10 @@ export async function dispatchScheduleTarget(
         }
       }
       if (!triggeredWorkflows) {
+        // Extension hooks must run before the transaction opens (see schedule-task.ts).
+        const prepared = await prepareStandaloneScheduleTask(schedule, extraTags);
         const task = await getDbClient().transaction(async () =>
-          createStandaloneScheduleTask(schedule, extraTags),
+          createStandaloneScheduleTask(schedule, extraTags, prepared),
         );
         return { triggeredWorkflows, task };
       }
@@ -220,96 +224,75 @@ async function throwIfWorkflowNeedsSetup(scheduleId: string, runIds: string[]):
   }
 }
 
-async function advanceScheduleAfterNeedsSetup(
-  schedule: ScheduledTask,
-  now: Date = new Date(),
-): Promise<void> {
-  schedule = renderScheduledTaskParams(schedule);
-  const timestamp = now.toISOString();
-  if (schedule.scheduleType === "one_time") {
-    await updateScheduledTask(schedule.id, {
-      nextRunAt: null,
-      lastUpdatedAt: timestamp,
-    });
-    return;
-  }
-  await updateScheduledTask(schedule.id, {
-    nextRunAt: calculateNextRun(
-      schedule.timezone?.includes("{{") ? { ...schedule, timezone: "UTC" } : schedule,
-      now,
-    ),
-    lastUpdatedAt: timestamp,
+/**
+ * Claim the snapshot's occurrence under BEGIN IMMEDIATE. A competing poller,
+ * recovery pass, or schedule edit invalidates it before any target is dispatched.
+ */
+async function claimScheduleOccurrence(snapshot: ScheduledTask, extraTags: string[]) {
+  return getDbClient().transaction(async () => {
+    const current = await getScheduledTaskById(snapshot.id);
+    if (!current?.enabled || !current.nextRunAt || current.nextRunAt !== snapshot.nextRunAt) {
+      return null;
+    }
+    const schedule = renderScheduledTaskParams(current);
+
+    // Event-driven waits already atomically create their child and consume the
+    // ceiling. Keep that transaction (and its afterCommit emits) intact: disabling
+    // a one-time schedule first would prevent its wake-up task from being created.
+    const deferred = await dispatchDeferredTaskWait(schedule.id, "ceiling", extraTags);
+    if (deferred) {
+      return {
+        schedule,
+        claimed: (await getScheduledTaskById(schedule.id))!,
+        dispatched: { triggeredWorkflows: false, ...deferred },
+      };
+    }
+
+    const now = new Date();
+    const nextRunAt =
+      schedule.scheduleType === "one_time"
+        ? null
+        : calculateNextRun(
+            schedule.timezone?.includes("{{") ? { ...schedule, timezone: "UTC" } : schedule,
+            new Date(Math.max(now.getTime(), new Date(current.nextRunAt).getTime())),
+          );
+    const claimed = (await updateScheduledTask(schedule.id, {
+      lastRunAt: now.toISOString(),
+      nextRunAt,
+      ...(schedule.scheduleType === "one_time" ? { enabled: false } : {}),
+    }))!;
+    return { schedule, claimed, dispatched: undefined };
   });
 }
 
-/**
- * Recover missed scheduled task runs from downtime.
- * Fires ONE catch-up run per schedule (not N missed runs).
- * Tags the task with "recovered" so it's distinguishable.
- */
+/** A slow target must not overwrite a newer occurrence or a schedule edit. */
+async function updateClaimedSchedule(claimed: ScheduledTask, updates: UpdateScheduledTaskData) {
+  await getDbClient().transaction(async () => {
+    const current = await getScheduledTaskById(claimed.id);
+    if (
+      current?.nextRunAt !== claimed.nextRunAt ||
+      current?.lastRunAt !== claimed.lastRunAt ||
+      current?.enabled !== claimed.enabled ||
+      current?.lastUpdatedAt !== claimed.lastUpdatedAt
+    )
+      return;
+    await updateScheduledTask(claimed.id, updates);
+  });
+}
+
+/** Recover ONE catch-up occurrence per schedule, using the poller's same claim. */
 async function recoverMissedSchedules(): Promise<void> {
-  const now = new Date();
+  const now = Date.now();
   const dueSchedules = await getDueScheduledTasks();
-
-  for (const storedSchedule of dueSchedules) {
-    const schedule = renderScheduledTaskParams(storedSchedule);
+  for (const schedule of dueSchedules) {
     if (!schedule.nextRunAt) continue;
-    const missedBy = now.getTime() - new Date(schedule.nextRunAt).getTime();
+    const missedBy = now - new Date(schedule.nextRunAt).getTime();
     if (missedBy < 15000) continue; // Less than 15s — normal timing jitter
-
     console.log(
       `[Scheduler] Recovering missed schedule "${schedule.name}" ` +
         `(was due ${Math.round(missedBy / 1000)}s ago)`,
     );
-
-    let triggeredWorkflows = false;
-    try {
-      ({ triggeredWorkflows } = await dispatchScheduleTarget(schedule, ["recovered"]));
-
-      // Update schedule state regardless of workflow/task path
-      if (schedule.scheduleType === "one_time") {
-        await updateScheduledTask(schedule.id, {
-          lastRunAt: now.toISOString(),
-          nextRunAt: null,
-          enabled: false,
-          lastUpdatedAt: now.toISOString(),
-        });
-      } else {
-        const nextRun = calculateNextRun(schedule, now);
-        await updateScheduledTask(schedule.id, {
-          lastRunAt: now.toISOString(),
-          nextRunAt: nextRun,
-          lastUpdatedAt: now.toISOString(),
-        });
-      }
-
-      if (schedule.scheduleType === "one_time") {
-        console.log(`[Scheduler] One-time schedule "${schedule.name}" recovered and auto-disabled`);
-      }
-      telemetry.schedule("executed", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: true,
-      });
-    } catch (err) {
-      if (err instanceof AutomationNeedsSetupError) {
-        await advanceScheduleAfterNeedsSetup(schedule, now);
-        telemetry.schedule("error", {
-          scheduleType: schedule.scheduleType,
-          triggeredWorkflows,
-          wasRecovered: true,
-          consecutiveErrors: schedule.consecutiveErrors ?? 0,
-        });
-        continue;
-      }
-      telemetry.schedule("error", {
-        scheduleType: schedule.scheduleType,
-        triggeredWorkflows,
-        wasRecovered: true,
-        consecutiveErrors: schedule.consecutiveErrors ?? 0,
-      });
-      console.error(`[Scheduler] Error recovering "${schedule.name}":`, err);
-    }
+    await executeSchedule(schedule, ["recovered"]);
   }
 }
 
@@ -360,49 +343,43 @@ function getBackoffMs(consecutiveErrors: number): number {
  * Execute a single scheduled task by creating an agent task.
  * Tracks consecutive errors and applies exponential backoff on failure.
  */
-export async function executeSchedule(schedule: ScheduledTask): Promise<void> {
-  schedule = renderScheduledTaskParams(schedule);
+export async function executeSchedule(
+  schedule: ScheduledTask,
+  extraTags: string[] = [],
+): Promise<void> {
+  let claimed = schedule;
   let triggeredWorkflows = false;
+  const wasRecovered = extraTags.includes("recovered");
   try {
-    ({ triggeredWorkflows } = await dispatchScheduleTarget(schedule));
-
-    // Update schedule state regardless of workflow/task path
-    const now = new Date().toISOString();
-    if (schedule.scheduleType === "one_time") {
-      await updateScheduledTask(schedule.id, {
-        lastRunAt: now,
-        nextRunAt: null,
-        enabled: false,
-        lastUpdatedAt: now,
-        consecutiveErrors: 0,
-        lastErrorAt: null,
-        lastErrorMessage: null,
-      });
-      console.log(`[Scheduler] Executed one-time schedule "${schedule.name}", auto-disabled`);
-    } else {
-      const nextRun = calculateNextRun(schedule, new Date());
-      await updateScheduledTask(schedule.id, {
-        lastRunAt: now,
-        nextRunAt: nextRun,
-        lastUpdatedAt: now,
-        consecutiveErrors: 0,
-        lastErrorAt: null,
-        lastErrorMessage: null,
-      });
-      console.log(`[Scheduler] Executed schedule "${schedule.name}", next run: ${nextRun}`);
-    }
+    const occurrence = await claimScheduleOccurrence(schedule, extraTags);
+    if (!occurrence) return;
+    ({ schedule, claimed } = occurrence);
+    // The claim has committed before external workflow/script dispatch begins.
+    // Never re-arm it: a target may have produced effects before reporting failure.
+    ({ triggeredWorkflows } =
+      occurrence.dispatched ?? (await dispatchScheduleTarget(schedule, extraTags)));
+
+    await updateClaimedSchedule(claimed, {
+      consecutiveErrors: 0,
+      lastErrorAt: null,
+      lastErrorMessage: null,
+    });
+    console.log(
+      `[Scheduler] Executed schedule "${schedule.name}", next run: ${claimed.nextRunAt ?? "disabled"}`,
+    );
     telemetry.schedule("executed", {
       scheduleType: schedule.scheduleType,
       triggeredWorkflows,
-      wasRecovered: false,
+      wasRecovered,
     });
   } catch (err) {
     if (err instanceof AutomationNeedsSetupError) {
-      await advanceScheduleAfterNeedsSetup(schedule);
+      // Preflight records its own diagnostic. The claim already advanced the
+      // cadence, so no retry/backoff or second schedule advancement is needed.
       telemetry.schedule("error", {
         scheduleType: schedule.scheduleType,
         triggeredWorkflows,
-        wasRecovered: false,
+        wasRecovered,
         consecutiveErrors: schedule.consecutiveErrors ?? 0,
       });
       return;
@@ -446,11 +423,11 @@ export async function executeSchedule(schedule: ScheduledTask): Promise<void> {
       console.log(`[Scheduler] Backing off "${schedule.name}" for ${backoff / 1000}s`);
     }
 
-    await updateScheduledTask(schedule.id, updates);
+    await updateClaimedSchedule(claimed, updates);
     telemetry.schedule("error", {
       scheduleType: schedule.scheduleType,
       triggeredWorkflows,
-      wasRecovered: false,
+      wasRecovered,
       consecutiveErrors: errorCount,
     });
   }
@@ -466,23 +443,29 @@ export function startScheduler(
   intervalMs = 10000,
   opts?: { runId?: string },
 ): void {
-  if (schedulerInterval) {
+  if (schedulerRun) {
     console.log("[Scheduler] Already running");
     return;
   }
 
+  const run = {};
+  schedulerRun = run;
   executorRegistry = registry;
   console.log(`[Scheduler] Starting with ${intervalMs}ms polling interval`);
 
-  // Recover missed schedules from downtime, then run normal processing
+  // Both success and failure resume polling, but only after recovery settles.
+  // The identity prevents stop/restart during startup from installing an old timer.
   void initDeferredTaskWaits()
-    .then(() => recoverMissedSchedules())
-    .then(() => processSchedules())
-    .catch((err) => console.error("[Scheduler] Recovery failed:", err));
-
-  schedulerInterval = setInterval(async () => {
-    await processSchedules();
-  }, intervalMs);
+    .then(() => (schedulerRun === run ? recoverMissedSchedules() : undefined))
+    .catch((err) => console.error("[Scheduler] Recovery failed:", err))
+    .then(async () => {
+      if (schedulerRun !== run) return;
+      schedulerInterval = setInterval(() => {
+        void processSchedules().catch((err) => console.error("[Scheduler] Poll failed:", err));
+      }, intervalMs);
+      await processSchedules();
+    })
+    .catch((err) => console.error("[Scheduler] Poll failed:", err));
 
   ensure({
     id: "scheduler_started",
@@ -531,11 +514,11 @@ async function processSchedules(): Promise<void> {
  * Stop the scheduler polling loop.
  */
 export function stopScheduler(): void {
+  schedulerRun = null;
   stopDeferredTaskWaits();
   if (schedulerInterval) {
     clearInterval(schedulerInterval);
     schedulerInterval = null;
-    isProcessing = false;
     console.log("[Scheduler] Stopped");
   }
 }

package/src/scripts-runtime/executors/native.ts

@@ -92,7 +92,11 @@ async function readRuntimeError(
   }
 }
 
-async function writeBareImportShim(tmpdir: string, name: string, targetUrl: URL): Promise<void> {
+export async function writeBareImportShim(
+  tmpdir: string,
+  name: string,
+  targetUrl: URL,
+): Promise<void> {
   const dir = `${tmpdir}/node_modules/${name}`;
   await Bun.$`mkdir -p ${dir}`;
   await Bun.write(`${dir}/package.json`, JSON.stringify({ type: "module", main: "index.ts" }));

package/src/scripts-runtime/executors/types.ts

@@ -15,6 +15,11 @@ export type SwarmConfigPayload = {
      * context like the agent identity — scripts never supply or override it.
      */
     runtimeInstanceId?: { value: string; isSecret: false };
+    /**
+     * Per-process secret set only by the in-process extension `ctx.swarm` SDK. The
+     * bridge requires it to grant the `extension` call origin. Never sent to scripts.
+     */
+    extensionToken?: { value: string; isSecret: true };
   };
   user: Record<string, { value: string; isSecret: boolean }>;
   egressSecrets?: EgressSecretEntry[];

package/src/scripts-runtime/import-allowlist.ts

@@ -1,9 +1,14 @@
 import ts from "typescript";
 
-const ALLOWED_BARE_IMPORTS = new Set(["swarm-sdk", "stdlib", "zod"]);
+const SCRIPT_ALLOWED_BARE_IMPORTS = ["swarm-sdk", "stdlib", "zod"] as const;
 const FORBIDDEN_HINTS = new Set(["node:", "bun:", "fs", "child_process", "crypto", "bun:sqlite"]);
-const ALLOWLIST_REMEDY =
-  'Allowed imports are "swarm-sdk", "stdlib", "zod", and relative paths ("./" or "../").';
+
+export type ImportAllowlistOptions = {
+  allowedBare: readonly string[];
+  allowRelative: boolean;
+  // Extensions need strict dynamic imports because they run in-process without a sandbox.
+  strictDynamic?: boolean;
+};
 
 export type ImportAllowlistResult =
   | { ok: true }
@@ -13,11 +18,18 @@ function isRelative(specifier: string): boolean {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
 
-function isAllowed(specifier: string): boolean {
-  return isRelative(specifier) || ALLOWED_BARE_IMPORTS.has(specifier);
+function isAllowed(specifier: string, options: ImportAllowlistOptions): boolean {
+  return (
+    (options.allowRelative && isRelative(specifier)) || options.allowedBare.includes(specifier)
+  );
 }
 
-function collectImportSpecifiers(source: string): string[] {
+type CollectedImports = {
+  imports: string[];
+  unsupportedSyntax: "import()" | "require()" | "import-equals" | null;
+};
+
+function collectImportSpecifiers(source: string, strictDynamic = false): CollectedImports {
   const sourceFile = ts.createSourceFile(
     "user-script.ts",
     source,
@@ -26,6 +38,7 @@ function collectImportSpecifiers(source: string): string[] {
     ts.ScriptKind.TS,
   );
   const imports: string[] = [];
+  let unsupportedSyntax: CollectedImports["unsupportedSyntax"] = null;
 
   const visit = (node: ts.Node) => {
     if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
@@ -34,19 +47,42 @@ function collectImportSpecifiers(source: string): string[] {
         imports.push(moduleSpecifier.text);
     }
 
+    if (
+      strictDynamic &&
+      ts.isImportEqualsDeclaration(node) &&
+      ts.isExternalModuleReference(node.moduleReference)
+    ) {
+      const specifier = node.moduleReference.expression;
+      if (specifier && ts.isStringLiteralLike(specifier)) imports.push(specifier.text);
+      else unsupportedSyntax ??= "import-equals";
+    }
+
     if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
       const [arg] = node.arguments;
-      if (arg && ts.isStringLiteral(arg)) imports.push(arg.text);
+      if (arg && (ts.isStringLiteral(arg) || (strictDynamic && ts.isStringLiteralLike(arg))))
+        imports.push(arg.text);
+      else if (strictDynamic) unsupportedSyntax ??= "import()";
+    }
+
+    if (
+      strictDynamic &&
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "require"
+    ) {
+      const [arg] = node.arguments;
+      if (arg && ts.isStringLiteralLike(arg)) imports.push(arg.text);
+      else unsupportedSyntax ??= "require()";
     }
 
     ts.forEachChild(node, visit);
   };
 
   visit(sourceFile);
-  return imports;
+  return { imports, unsupportedSyntax };
 }
 
-function findForbiddenDynamicCode(source: string): string | null {
+function findForbiddenDynamicCode(source: string, subject: string): string | null {
   const sourceFile = ts.createSourceFile(
     "user-script.ts",
     source,
@@ -64,7 +100,7 @@ function findForbiddenDynamicCode(source: string): string | null {
       node.expression.kind === ts.SyntaxKind.Identifier &&
       node.expression.getText(sourceFile) === "eval"
     ) {
-      diagnostic = "eval is not allowed in swarm scripts";
+      diagnostic = `eval is not allowed in ${subject}`;
       return;
     }
 
@@ -73,7 +109,7 @@ function findForbiddenDynamicCode(source: string): string | null {
       node.expression.kind === ts.SyntaxKind.Identifier &&
       node.expression.getText(sourceFile) === "Function"
     ) {
-      diagnostic = "Function constructor is not allowed in swarm scripts";
+      diagnostic = `Function constructor is not allowed in ${subject}`;
       return;
     }
 
@@ -82,7 +118,7 @@ function findForbiddenDynamicCode(source: string): string | null {
       node.expression.kind === ts.SyntaxKind.Identifier &&
       node.expression.getText(sourceFile) === "Function"
     ) {
-      diagnostic = "Function constructor is not allowed in swarm scripts";
+      diagnostic = `Function constructor is not allowed in ${subject}`;
       return;
     }
 
@@ -93,23 +129,47 @@ function findForbiddenDynamicCode(source: string): string | null {
   return diagnostic;
 }
 
-export function validateScriptImports(source: string): ImportAllowlistResult {
-  const dynamicDiagnostic = findForbiddenDynamicCode(source);
+export function checkImportAllowlist(
+  source: string,
+  options: ImportAllowlistOptions,
+): ImportAllowlistResult {
+  const isExtension = options.allowedBare.includes("swarm-extension");
+  const subject = isExtension ? "swarm extensions" : "swarm scripts";
+  const dynamicDiagnostic = findForbiddenDynamicCode(source, subject);
   if (dynamicDiagnostic) return { ok: false, diagnostic: dynamicDiagnostic, imports: [] };
 
-  const imports = collectImportSpecifiers(source);
-  const rejected = imports.filter((specifier) => !isAllowed(specifier));
+  const collected = collectImportSpecifiers(source, options.strictDynamic);
+  if (collected.unsupportedSyntax) {
+    return {
+      ok: false,
+      diagnostic: `Computed ${collected.unsupportedSyntax} is not allowed in ${subject}. Use a string literal from the import allowlist.`,
+      imports: collected.imports,
+    };
+  }
+  const imports = collected.imports;
+  const rejected = imports.filter((specifier) => !isAllowed(specifier, options));
   if (rejected.length === 0) return { ok: true };
 
   const hint = rejected.find(
     (specifier) => FORBIDDEN_HINTS.has(specifier) || specifier.startsWith("node:"),
   );
   const reason = hint
-    ? `Import '${hint}' is not allowed in swarm scripts`
-    : `Import '${rejected[0]}' is not on the swarm script allowlist`;
+    ? `Import '${hint}' is not allowed in ${subject}`
+    : `Import '${rejected[0]}' is not on the ${subject} allowlist`;
+  const listed = options.allowedBare.map((specifier) => `"${specifier}"`).join(", ");
+  const allowlistRemedy = options.allowRelative
+    ? `Allowed imports are ${listed}, and relative paths ("./" or "../").`
+    : `Allowed imports are ${listed}. Relative imports are not allowed.`;
   const remedy =
     hint === "crypto" || hint === "node:crypto"
       ? "The global crypto object already provides randomUUID, getRandomValues, and subtle.digest; delete the import and use crypto directly."
-      : ALLOWLIST_REMEDY;
+      : allowlistRemedy;
   return { ok: false, diagnostic: `${reason}. ${remedy}`, imports: rejected };
 }
+
+export function validateScriptImports(source: string): ImportAllowlistResult {
+  return checkImportAllowlist(source, {
+    allowedBare: SCRIPT_ALLOWED_BARE_IMPORTS,
+    allowRelative: true,
+  });
+}

package/src/scripts-runtime/sdk-allowlist.ts

@@ -56,6 +56,10 @@ export const SDK_TOOL_NAME_MAP = {
   script_getRun: "get-script-run",
   script_listRuns: "list-script-runs",
 
+  // ── extensions ──
+  extension_install: "extension-install",
+  extension_list: "extension-list",
+
   // ── swarm / agent ──
   swarm_get: "get-swarm",
   agent_info: "my-agent-info",

package/src/scripts-runtime/swarm-config.ts

@@ -7,6 +7,8 @@ export class SwarmConfig {
   readonly mcpBaseUrl: RedactedValue<string>;
   /** Per-boot runtime identity of the invoking worker; system context, never script input. */
   readonly runtimeInstanceId: RedactedValue<string> | undefined;
+  /** Per-process extension bridge secret; present only for in-process extension SDKs. */
+  readonly extensionToken: RedactedValue<string> | undefined;
 
   private readonly userValues: Map<string, RedactedValue<string>>;
 
@@ -29,6 +31,12 @@ export class SwarmConfig {
           isSecret: payload.system.runtimeInstanceId.isSecret,
         })
       : undefined;
+    this.extensionToken = payload.system.extensionToken
+      ? Redacted.make(payload.system.extensionToken.value, {
+          type: "system",
+          isSecret: payload.system.extensionToken.isSecret,
+        })
+      : undefined;
     this.userValues = new Map(
       Object.entries(payload.user ?? {}).map(([key, value]) => [
         key,

package/src/scripts-runtime/swarm-sdk.ts

@@ -20,6 +20,9 @@ function headers(config: SwarmConfig): Record<string, string> {
     ...(config.runtimeInstanceId
       ? { "X-Runtime-Instance-ID": Redacted.value(config.runtimeInstanceId) }
       : {}),
+    ...(config.extensionToken
+      ? { "X-Extension-Token": Redacted.value(config.extensionToken) }
+      : {}),
     "Content-Type": "application/json",
   };
 }

package/src/scripts-runtime/types/stdlib.d.ts

@@ -36,10 +36,14 @@ declare module "swarm-sdk" {
     | "reroute_fault";
   export type TaskSendArgs = Record<string, unknown> & {
     task: string;
-    routingNote?: string;
   } & (
-      | { agentId: string; routingReason: RoutingReason }
-      | { agentId?: never; routingReason?: never }
+      | {
+          agentId: string;
+          routingReason: RoutingReason;
+          /** At least 10 characters after trim; maximum 200. */
+          routingNote: string;
+        }
+      | { agentId?: never; routingReason?: never; routingNote?: string }
     );
   export type AgentTaskStepConfig = {
     template?: string;
@@ -513,6 +517,15 @@ declare module "swarm-sdk" {
       offset?: number;
     }): Promise<unknown>;
 
+    // --- write: extensions ---
+    extension_install(args: {
+      manifest: Record<string, unknown>;
+      files: Record<string, string>;
+      priority?: number;
+      config?: Record<string, unknown>;
+    }): Promise<unknown>;
+    extension_list(args?: { enabledOnly?: boolean }): Promise<unknown>;
+
     // --- write: repos ---
     repo_update(args: Record<string, unknown>): Promise<unknown>;