@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/be/extensions/db.ts

@@ -0,0 +1,461 @@
+import type {
+  Extension,
+  ExtensionManifest,
+  ExtensionRun,
+  ExtensionStatus,
+  ExtensionVersion,
+} from "../../types";
+import { computeContentHash, getDbClient } from "../db";
+
+type ExtensionRow = Omit<Extension, "enabled"> & { enabled: number };
+type ExtensionVersionRow = ExtensionVersion;
+type ExtensionRunRow = ExtensionRun;
+
+export type InstallExtensionArgs = {
+  manifest: ExtensionManifest;
+  files: Record<string, string>;
+  priority?: number;
+  config?: Record<string, unknown>;
+  agentId?: string | null;
+  createdBy?: string | null;
+  activate?: boolean;
+  changeReason?: string | null;
+};
+
+export type InstallExtensionResult = {
+  extension: Extension;
+  isNew: boolean;
+  contentDeduped: boolean;
+};
+
+function rowToExtension(row: ExtensionRow): Extension {
+  return {
+    ...row,
+    enabled: row.enabled === 1,
+    lastError: row.lastError ?? null,
+    agentId: row.agentId ?? null,
+    createdByAgentId: row.createdByAgentId ?? null,
+  };
+}
+
+function canonicalFiles(files: Record<string, string>): Record<string, string> {
+  return Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b)));
+}
+
+function bundleContentHash(manifest: ExtensionManifest, files: Record<string, string>): string {
+  return computeContentHash(JSON.stringify({ manifest, files: canonicalFiles(files) }));
+}
+
+export async function installExtension(
+  args: InstallExtensionArgs,
+): Promise<InstallExtensionResult> {
+  const files = canonicalFiles(args.files);
+  const manifestJson = JSON.stringify(args.manifest);
+  const filesJson = JSON.stringify(files);
+  const contentHash = bundleContentHash(args.manifest, files);
+  const actor = args.createdBy ?? null;
+
+  return await getDbClient().transaction(async (tx) => {
+    const existingRow = await tx.get<ExtensionRow>("SELECT * FROM extensions WHERE name = ?", [
+      args.manifest.name,
+    ]);
+    const existing = existingRow ? rowToExtension(existingRow) : null;
+    const now = new Date().toISOString();
+
+    if (!existing) {
+      const id = crypto.randomUUID();
+      const row = await tx.get<ExtensionRow>(
+        `INSERT INTO extensions (
+          id, name, description, runtime, manifestJson, contentHash, version,
+          activeVersion, enabled, priority, configJson, status,
+          consecutiveFailures, lastError, agentId, createdByAgentId,
+          created_by, updated_by, createdAt, updatedAt
+        ) VALUES (?, ?, ?, ?, ?, ?, 1, 1, 0, ?, ?, 'disabled', 0, NULL, NULL, ?, ?, ?, ?, ?)
+        RETURNING *`,
+        [
+          id,
+          args.manifest.name,
+          args.manifest.description,
+          args.manifest.runtime,
+          manifestJson,
+          contentHash,
+          args.priority ?? 100,
+          JSON.stringify(args.config ?? {}),
+          args.agentId ?? null,
+          actor,
+          actor,
+          now,
+          now,
+        ],
+      );
+      if (!row) throw new Error("Failed to insert extension");
+
+      for (const [path, content] of Object.entries(files)) {
+        await tx.run(
+          `INSERT INTO extension_files (
+            id, extensionId, path, content, contentHash, created_by, updated_by
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+          [crypto.randomUUID(), id, path, content, computeContentHash(content), actor, actor],
+        );
+      }
+
+      await tx.run(
+        `INSERT INTO extension_versions (
+          id, extensionId, version, manifestJson, filesJson, contentHash,
+          changedByAgentId, changedAt, changeReason, created_by, updated_by
+        ) VALUES (?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          crypto.randomUUID(),
+          id,
+          manifestJson,
+          filesJson,
+          contentHash,
+          args.agentId ?? null,
+          now,
+          args.changeReason ?? "Initial installation",
+          actor,
+          actor,
+        ],
+      );
+
+      return { extension: rowToExtension(row), isNew: true, contentDeduped: false };
+    }
+
+    if (existing.contentHash === contentHash) {
+      const row = await tx.get<ExtensionRow>(
+        `UPDATE extensions SET
+          priority = ?, configJson = ?, activeVersion = ?, updated_by = ?, updatedAt = ?
+        WHERE id = ?
+        RETURNING *`,
+        [
+          args.priority ?? existing.priority,
+          args.config === undefined ? existing.configJson : JSON.stringify(args.config),
+          args.activate ? existing.version : existing.activeVersion,
+          actor,
+          now,
+          existing.id,
+        ],
+      );
+      if (!row) throw new Error("Failed to update extension metadata");
+      return { extension: rowToExtension(row), isNew: false, contentDeduped: true };
+    }
+
+    const newVersion = existing.version + 1;
+    const row = await tx.get<ExtensionRow>(
+      `UPDATE extensions SET
+        description = ?, runtime = ?, manifestJson = ?, contentHash = ?, version = ?,
+        activeVersion = ?, priority = ?, configJson = ?, updated_by = ?, updatedAt = ?
+      WHERE id = ?
+      RETURNING *`,
+      [
+        args.manifest.description,
+        args.manifest.runtime,
+        manifestJson,
+        contentHash,
+        newVersion,
+        args.activate ? newVersion : existing.activeVersion,
+        args.priority ?? existing.priority,
+        args.config === undefined ? existing.configJson : JSON.stringify(args.config),
+        actor,
+        now,
+        existing.id,
+      ],
+    );
+    if (!row) throw new Error("Failed to update extension");
+
+    await tx.run("DELETE FROM extension_files WHERE extensionId = ?", [existing.id]);
+    for (const [path, content] of Object.entries(files)) {
+      await tx.run(
+        `INSERT INTO extension_files (
+          id, extensionId, path, content, contentHash, created_by, updated_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [
+          crypto.randomUUID(),
+          existing.id,
+          path,
+          content,
+          computeContentHash(content),
+          actor,
+          actor,
+        ],
+      );
+    }
+
+    await tx.run(
+      `INSERT INTO extension_versions (
+        id, extensionId, version, manifestJson, filesJson, contentHash,
+        changedByAgentId, changedAt, changeReason, created_by, updated_by
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        crypto.randomUUID(),
+        existing.id,
+        newVersion,
+        manifestJson,
+        filesJson,
+        contentHash,
+        args.agentId ?? null,
+        now,
+        args.changeReason ?? null,
+        actor,
+        actor,
+      ],
+    );
+
+    return { extension: rowToExtension(row), isNew: false, contentDeduped: false };
+  });
+}
+
+export async function getExtensionFiles(extensionId: string): Promise<Record<string, string>> {
+  const rows = await getDbClient().query<{ path: string; content: string }>(
+    "SELECT path, content FROM extension_files WHERE extensionId = ? ORDER BY path",
+    [extensionId],
+  );
+  return Object.fromEntries(rows.map((row) => [row.path, row.content]));
+}
+
+export async function getExtensionById(id: string): Promise<Extension | null> {
+  const row = await getDbClient().get<ExtensionRow>("SELECT * FROM extensions WHERE id = ?", [id]);
+  return row ? rowToExtension(row) : null;
+}
+
+export async function getExtensionByName(name: string): Promise<Extension | null> {
+  const row = await getDbClient().get<ExtensionRow>("SELECT * FROM extensions WHERE name = ?", [
+    name,
+  ]);
+  return row ? rowToExtension(row) : null;
+}
+
+export async function listExtensions(): Promise<Extension[]> {
+  const rows = await getDbClient().query<ExtensionRow>(
+    "SELECT * FROM extensions ORDER BY priority ASC, name ASC",
+  );
+  return rows.map(rowToExtension);
+}
+
+export async function listExtensionVersions(extensionId: string): Promise<ExtensionVersion[]> {
+  return await getDbClient().query<ExtensionVersionRow>(
+    "SELECT * FROM extension_versions WHERE extensionId = ? ORDER BY version DESC",
+    [extensionId],
+  );
+}
+
+export async function getExtensionVersion(
+  extensionId: string,
+  version: number,
+): Promise<ExtensionVersion | null> {
+  return (
+    (await getDbClient().get<ExtensionVersionRow>(
+      "SELECT * FROM extension_versions WHERE extensionId = ? AND version = ?",
+      [extensionId, version],
+    )) ?? null
+  );
+}
+
+export async function activateExtensionVersionSnapshot(
+  extensionId: string,
+  version: number,
+  updatedBy?: string | null,
+): Promise<Extension | null> {
+  return await getDbClient().transaction(async (tx) => {
+    const snapshot = await tx.get<ExtensionVersionRow>(
+      "SELECT * FROM extension_versions WHERE extensionId = ? AND version = ?",
+      [extensionId, version],
+    );
+    if (!snapshot) return null;
+
+    const manifest = JSON.parse(snapshot.manifestJson) as ExtensionManifest;
+    const files = JSON.parse(snapshot.filesJson) as Record<string, string>;
+    const now = new Date().toISOString();
+    const row = await tx.get<ExtensionRow>(
+      `UPDATE extensions SET
+        description = ?, runtime = ?, manifestJson = ?, contentHash = ?, activeVersion = ?,
+        updated_by = ?, updatedAt = ?
+       WHERE id = ?
+       RETURNING *`,
+      [
+        manifest.description,
+        manifest.runtime,
+        snapshot.manifestJson,
+        snapshot.contentHash,
+        version,
+        updatedBy ?? null,
+        now,
+        extensionId,
+      ],
+    );
+    if (!row) return null;
+
+    await tx.run("DELETE FROM extension_files WHERE extensionId = ?", [extensionId]);
+    for (const [path, content] of Object.entries(files)) {
+      await tx.run(
+        `INSERT INTO extension_files (
+          id, extensionId, path, content, contentHash, created_by, updated_by
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [
+          crypto.randomUUID(),
+          extensionId,
+          path,
+          content,
+          computeContentHash(content),
+          updatedBy ?? null,
+          updatedBy ?? null,
+        ],
+      );
+    }
+    return rowToExtension(row);
+  });
+}
+
+export async function updateExtensionMeta(
+  id: string,
+  args: {
+    priority?: number;
+    config?: Record<string, unknown>;
+    description?: string;
+    updatedBy?: string | null;
+  },
+): Promise<Extension | null> {
+  const sets: string[] = [];
+  const values: Array<string | number | null> = [];
+  if (args.priority !== undefined) {
+    sets.push("priority = ?");
+    values.push(args.priority);
+  }
+  if (args.config !== undefined) {
+    sets.push("configJson = ?");
+    values.push(JSON.stringify(args.config));
+  }
+  if (args.description !== undefined) {
+    sets.push("description = ?");
+    values.push(args.description);
+  }
+  if (sets.length === 0) return getExtensionById(id);
+
+  sets.push("updated_by = ?", "updatedAt = ?");
+  values.push(args.updatedBy ?? null, new Date().toISOString(), id);
+  const row = await getDbClient().get<ExtensionRow>(
+    `UPDATE extensions SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
+    values,
+  );
+  return row ? rowToExtension(row) : null;
+}
+
+export async function setExtensionState(
+  id: string,
+  args: {
+    enabled?: boolean;
+    status?: ExtensionStatus;
+    activeVersion?: number;
+    agentId?: string | null;
+    consecutiveFailures?: number;
+    lastError?: string | null;
+    updatedBy?: string | null;
+  },
+): Promise<Extension | null> {
+  const sets: string[] = [];
+  const values: Array<string | number | null> = [];
+  const fields = [
+    ["enabled", args.enabled === undefined ? undefined : args.enabled ? 1 : 0],
+    ["status", args.status],
+    ["activeVersion", args.activeVersion],
+    ["agentId", args.agentId],
+    ["consecutiveFailures", args.consecutiveFailures],
+    ["lastError", args.lastError],
+  ] as const;
+  for (const [column, value] of fields) {
+    if (value !== undefined) {
+      sets.push(`${column} = ?`);
+      values.push(value);
+    }
+  }
+  if (sets.length === 0) return getExtensionById(id);
+
+  sets.push("updated_by = ?", "updatedAt = ?");
+  values.push(args.updatedBy ?? null, new Date().toISOString(), id);
+  const row = await getDbClient().get<ExtensionRow>(
+    `UPDATE extensions SET ${sets.join(", ")} WHERE id = ? RETURNING *`,
+    values,
+  );
+  return row ? rowToExtension(row) : null;
+}
+
+export async function recordExtensionFailure(
+  id: string,
+  lastError: string,
+  maxConsecutiveFailures: number,
+): Promise<Extension | null> {
+  const row = await getDbClient().get<ExtensionRow>(
+    `UPDATE extensions SET
+      consecutiveFailures = consecutiveFailures + 1,
+      lastError = ?,
+      enabled = CASE WHEN consecutiveFailures + 1 >= ? THEN 0 ELSE enabled END,
+      status = CASE
+        WHEN consecutiveFailures + 1 >= ? THEN 'auto-disabled'
+        ELSE status
+      END,
+      updatedAt = ?
+     WHERE id = ?
+     RETURNING *`,
+    [lastError, maxConsecutiveFailures, maxConsecutiveFailures, new Date().toISOString(), id],
+  );
+  return row ? rowToExtension(row) : null;
+}
+
+export async function deleteExtension(id: string): Promise<boolean> {
+  const result = await getDbClient().run("DELETE FROM extensions WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+
+export async function insertExtensionRun(args: {
+  extensionId: string;
+  version: number;
+  event: string;
+  action: ExtensionRun["action"];
+  durationMs?: number | null;
+  message?: string | null;
+  agentId?: string | null;
+  subject?: string | null;
+}): Promise<ExtensionRun> {
+  const row = await getDbClient().get<ExtensionRunRow>(
+    `INSERT INTO extension_runs (
+      id, extensionId, version, event, action, durationMs, message, agentId, subject, createdAt
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+    [
+      crypto.randomUUID(),
+      args.extensionId,
+      args.version,
+      args.event,
+      args.action,
+      args.durationMs ?? null,
+      args.message ?? null,
+      args.agentId ?? null,
+      args.subject ?? null,
+      new Date().toISOString(),
+    ],
+  );
+  if (!row) throw new Error("Failed to insert extension run");
+  return row;
+}
+
+export async function pruneExtensionRuns(extensionId: string, keep = 500): Promise<void> {
+  await getDbClient().run(
+    `DELETE FROM extension_runs
+     WHERE extensionId = ? AND id IN (
+       SELECT id FROM extension_runs
+       WHERE extensionId = ?
+       ORDER BY createdAt DESC, rowid DESC
+       LIMIT -1 OFFSET ?
+     )`,
+    [extensionId, extensionId, keep],
+  );
+}
+
+export async function listExtensionRuns(extensionId: string, limit = 100): Promise<ExtensionRun[]> {
+  return await getDbClient().query<ExtensionRunRow>(
+    `SELECT * FROM extension_runs
+     WHERE extensionId = ?
+     ORDER BY createdAt DESC, rowid DESC
+     LIMIT ?`,
+    [extensionId, Math.max(1, Math.min(500, limit))],
+  );
+}

package/src/be/extensions/validate.ts

@@ -0,0 +1,107 @@
+import { isSafeBundlePath } from "../../extensions/bundle-path";
+import { EXTENSION_TYPE_DEFINITIONS } from "../../extensions/contract-types.generated";
+import { checkImportAllowlist } from "../../scripts-runtime/import-allowlist";
+import { type ExtensionManifest, ExtensionManifestSchema } from "../../types";
+import {
+  SCRIPT_SDK_TYPES,
+  SCRIPT_STDLIB_MODULE_TYPES,
+  typecheckWithAmbient,
+} from "../scripts/typecheck";
+
+export type BundleValidationResult =
+  | { ok: true; manifest: ExtensionManifest }
+  | { ok: false; diagnostics: string[] };
+
+export async function validateBundle(input: {
+  manifest: unknown;
+  files: Record<string, string>;
+}): Promise<BundleValidationResult> {
+  const parsedManifest = ExtensionManifestSchema.safeParse(input.manifest);
+  const pathDiagnostics = Object.keys(input.files)
+    .filter((path) => !isSafeBundlePath(path))
+    .map((path) => `Unsafe bundle file path: ${JSON.stringify(path)}`);
+  if (!parsedManifest.success) {
+    return {
+      ok: false,
+      diagnostics: [
+        ...pathDiagnostics,
+        ...parsedManifest.error.issues.map(
+          (issue) => `${issue.path.join(".") || "manifest"}: ${issue.message}`,
+        ),
+      ],
+    };
+  }
+  if (pathDiagnostics.length > 0) return { ok: false, diagnostics: pathDiagnostics };
+
+  const manifest = parsedManifest.data;
+  if (manifest.runtime === "worker") {
+    return { ok: false, diagnostics: ['runtime "worker" is not supported in v1'] };
+  }
+
+  for (const asset of ["skills", "workflows", "schedules"] as const) {
+    if ((manifest.assets[asset]?.length ?? 0) > 0) {
+      return { ok: false, diagnostics: [`assets.${asset} is not supported in v1`] };
+    }
+  }
+
+  const hookPath = manifest.assets.hooks;
+  if (!(hookPath in input.files)) {
+    return {
+      ok: false,
+      diagnostics: [`assets.hooks "${hookPath}" does not name a file in files`],
+    };
+  }
+  const extraPaths = Object.keys(input.files).filter((path) => path !== hookPath);
+  if (extraPaths.length > 0) {
+    return {
+      ok: false,
+      diagnostics: [
+        `Only the hooks asset is supported in v1. Unexpected files: ${extraPaths.join(", ")}`,
+      ],
+    };
+  }
+
+  const source = input.files[hookPath]!;
+  const imports = checkImportAllowlist(source, {
+    allowedBare: ["swarm-extension", "zod", "stdlib"],
+    allowRelative: false,
+    strictDynamic: true,
+  });
+  if (!imports.ok) return { ok: false, diagnostics: [imports.diagnostic] };
+
+  const typecheck = await typecheckWithAmbient({
+    source,
+    modules: {
+      "swarm-extension": EXTENSION_TYPE_DEFINITIONS,
+      "swarm-sdk": SCRIPT_SDK_TYPES,
+      stdlib: SCRIPT_STDLIB_MODULE_TYPES,
+    },
+    checkFile: `/// <reference path="./runtime-globals.d.ts" />
+import * as hooks from "./user-script";
+import type { SwarmExtension } from "swarm-extension";
+import type { ZodTypeAny } from "zod";
+const manifest = ${JSON.stringify(manifest)} as const;
+type Manifest = typeof hooks extends { config: infer Config extends ZodTypeAny }
+  ? typeof manifest & { config: Config }
+  : typeof manifest;
+const _extension: SwarmExtension<Manifest> = hooks.default;
+type ConfigIsValid = typeof hooks extends { config: infer Config }
+  ? Config extends ZodTypeAny ? true : false
+  : true;
+const _configIsValid: ConfigIsValid = true;
+void _extension;
+void _configIsValid;
+`,
+  });
+  if (!typecheck.ok) {
+    return {
+      ok: false,
+      diagnostics: typecheck.structured.map(
+        (diagnostic) =>
+          `${diagnostic.file}:${diagnostic.line}:${diagnostic.column} TS${diagnostic.code}: ${diagnostic.message}`,
+      ),
+    };
+  }
+
+  return { ok: true, manifest };
+}

package/src/be/memory/boot-reembed.ts

@@ -1,10 +1,15 @@
 /**
- * Startup backfill: detect agent_memory rows with wrong-dimension embeddings
- * (not 512d) and re-embed them in the background. Runs once per boot,
- * async/non-blocking, idempotent, no-op when the DB is clean.
+ * Backfill: detect agent_memory rows with no embedding at all (never
+ * embedded — e.g. every row written while no key was configured) or a
+ * wrong-dimension embedding (not 512d — legacy rows), and re-embed them in
+ * the background. Runs once per boot, and again whenever a config reload
+ * turns embeddings on for the first time (see scheduleIntegrationsReload in
+ * src/http/core.ts). Async/non-blocking, idempotent, no-op when the DB is
+ * clean or no key resolves.
  *
  * This is the app-level equivalent of a forward-only migration — SQL can't
- * call OpenAI, so the backfill runs at startup instead.
+ * call OpenAI, so the backfill runs at startup (and on the on-transition)
+ * instead.
  */
 
 import { getDbClient } from "@/be/db";
@@ -13,13 +18,13 @@ import { getEmbeddingProvider, getMemoryStore } from "./index";
 
 const VECTOR_BYTES = EMBEDDING_DIMENSIONS * Float32Array.BYTES_PER_ELEMENT;
 const BATCH_SIZE = 20;
+const INVALID_EMBEDDING_WHERE = `embedding IS NULL OR length(embedding) != ${VECTOR_BYTES}`;
 
 export async function runBootReembed(): Promise<void> {
   const invalidCount =
     (
       await getDbClient().get<{ count: number }>(
-        `SELECT COUNT(*) as count FROM agent_memory
-       WHERE embedding IS NOT NULL AND length(embedding) != ${VECTOR_BYTES}`,
+        `SELECT COUNT(*) as count FROM agent_memory WHERE ${INVALID_EMBEDDING_WHERE}`,
       )
     )?.count ?? 0;
 
@@ -31,17 +36,18 @@ export async function runBootReembed(): Promise<void> {
   const testEmbed = await provider.embed("test");
   if (!testEmbed) {
     console.warn(
-      `[boot-reembed] skipped: ${invalidCount} wrong-dimension rows found but no OpenAI key configured`,
+      `[boot-reembed] skipped: ${invalidCount} missing/wrong-dimension rows found but no OpenAI key configured`,
     );
     return;
   }
 
-  console.log(`[boot-reembed] starting: ${invalidCount} rows with wrong embedding dimensions`);
+  console.log(
+    `[boot-reembed] starting: ${invalidCount} rows missing or with wrong embedding dimensions`,
+  );
 
   const store = getMemoryStore();
   const rows = await getDbClient().query<{ id: string; content: string }>(
-    `SELECT id, content FROM agent_memory
-       WHERE embedding IS NOT NULL AND length(embedding) != ${VECTOR_BYTES}`,
+    `SELECT id, content FROM agent_memory WHERE ${INVALID_EMBEDDING_WHERE}`,
   );
 
   let reembedded = 0;
@@ -69,8 +75,7 @@ export async function runBootReembed(): Promise<void> {
   const afterInvalid =
     (
       await getDbClient().get<{ count: number }>(
-        `SELECT COUNT(*) as count FROM agent_memory
-       WHERE embedding IS NOT NULL AND length(embedding) != ${VECTOR_BYTES}`,
+        `SELECT COUNT(*) as count FROM agent_memory WHERE ${INVALID_EMBEDDING_WHERE}`,
       )
     )?.count ?? 0;
 

package/src/be/memory/index.ts

@@ -12,6 +12,18 @@ export function getEmbeddingProvider(): EmbeddingProvider {
   return embeddingProvider;
 }
 
+/**
+ * Drop the memoized embedding provider so the next `getEmbeddingProvider()`
+ * re-reads process.env. The provider captures its API key once at
+ * construction (see OpenAIEmbeddingProvider), so without a reset here a key
+ * set after boot (or after the first embed attempt) stays inert until the
+ * process restarts. Called from the config reload path — mirrors
+ * `resetFileStorageProvider` in src/fs/registry.ts.
+ */
+export function resetEmbeddingProvider(): void {
+  embeddingProvider = null;
+}
+
 export function getMemoryStore(): MemoryStore {
   if (!memoryStore) {
     const { SqliteMemoryStore } =

package/src/be/memory/providers/openai-embedding.ts

@@ -28,6 +28,10 @@ export class OpenAIEmbeddingProvider implements EmbeddingProvider {
       : (process.env.EMBEDDING_MODEL ?? DEFAULT_EMBEDDING_MODEL);
   }
 
+  isConfigured(): boolean {
+    return !!this.apiKey;
+  }
+
   private getClient(): OpenAI | null {
     if (!this.apiKey) return null;
     if (!this.client)

package/src/be/memory/types.ts

@@ -9,6 +9,8 @@ export interface EmbeddingProvider {
   readonly dimensions: number;
   embed(text: string): Promise<Float32Array | null>;
   embedBatch(texts: string[]): Promise<(Float32Array | null)[]>;
+  /** True when the provider has a usable API key — no network call. */
+  isConfigured(): boolean;
 }
 
 // ============================================================================

package/src/be/migrations/153_deferred_task_wait_members.sql

@@ -0,0 +1,25 @@
+-- One claim and deadline per wait; each member independently follows deferrals.
+ALTER TABLE deferred_task_waits ADD COLUMN mode TEXT NOT NULL DEFAULT 'all'
+  CHECK (mode IN ('all', 'any'));
+
+CREATE TABLE deferred_task_wait_members (
+  scheduleId TEXT NOT NULL REFERENCES deferred_task_waits(scheduleId) ON DELETE CASCADE,
+  taskId TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  created_by TEXT,
+  updated_by TEXT,
+  PRIMARY KEY (scheduleId, taskId)
+);
+CREATE INDEX idx_deferred_task_wait_members_task ON deferred_task_wait_members(taskId);
+
+-- Preserve pending and fired legacy waits, including already-retargeted IDs.
+INSERT INTO deferred_task_wait_members
+  (scheduleId, taskId, created_at, updated_at, created_by, updated_by)
+SELECT scheduleId, taskId, created_at, updated_at, created_by, updated_by
+FROM deferred_task_waits;
+
+DROP INDEX idx_deferred_task_waits_pending;
+ALTER TABLE deferred_task_waits DROP COLUMN taskId;
+CREATE INDEX idx_deferred_task_waits_pending
+  ON deferred_task_waits(scheduleId) WHERE status = 'pending';