@desplega.ai/agent-swarm 1.92.2 → 1.94.0

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

@@ -0,0 +1,74 @@
+/**
+ * Post-listen backfill: embed scripts that are missing embeddings (e.g. after
+ * boot seeding with scriptEmbeddingMode: "skip"). Runs once per boot,
+ * async/non-blocking, idempotent, no-op when every non-scratch script already
+ * has an embedding row.
+ *
+ * Mirrors the memory boot-reembed pattern (src/be/memory/boot-reembed.ts).
+ */
+
+import { getDb } from "@/be/db";
+import type { ScriptScope } from "@/types";
+import { embedScript } from "./embeddings";
+
+type ScriptMissingEmbedding = {
+  id: string;
+  name: string;
+  scope: ScriptScope;
+  scopeId: string | null;
+  source: string;
+  description: string;
+  intent: string;
+  signatureJson: string;
+  argsJsonSchema: string | null;
+  contentHash: string;
+  version: number;
+  isScratch: number;
+  typeChecked: number;
+  fsMode: "none" | "workspace-rw";
+  createdByAgentId: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export async function runBootReembedScripts(): Promise<void> {
+  const db = getDb();
+
+  const missing = db
+    .prepare<ScriptMissingEmbedding, []>(
+      `SELECT s.* FROM scripts s
+       LEFT JOIN script_embeddings e ON e.scriptId = s.id
+       WHERE s.isScratch = 0 AND e.scriptId IS NULL`,
+    )
+    .all();
+
+  if (missing.length === 0) {
+    return;
+  }
+
+  console.log(`[boot-reembed-scripts] starting: ${missing.length} scripts missing embeddings`);
+
+  let embedded = 0;
+  let failed = 0;
+
+  for (const row of missing) {
+    try {
+      await embedScript({
+        ...row,
+        scopeId: row.scopeId ?? null,
+        isScratch: row.isScratch === 1,
+        typeChecked: row.typeChecked === 1,
+        createdByAgentId: row.createdByAgentId ?? null,
+      });
+      embedded++;
+    } catch (err) {
+      failed++;
+      console.error(
+        `[boot-reembed-scripts] failed to embed "${row.name}":`,
+        (err as Error).message,
+      );
+    }
+  }
+
+  console.log(`[boot-reembed-scripts] complete: embedded=${embedded} failed=${failed}`);
+}

package/src/be/scripts/db.ts

@@ -26,6 +26,7 @@ type ScriptWriteArgs = ScriptIdentity & {
   fsMode?: ScriptFsMode;
   agentId?: string | null;
   changeReason?: string | null;
+  embeddingMode?: "sync" | "skip";
 };
 
 export type UpsertScriptResult = {
@@ -178,10 +179,11 @@ export function insertScript(args: ScriptWriteArgs): ScriptRecord {
  * immediately consistent for authored/promoted scripts.
  */
 export async function upsertScriptByName(args: ScriptWriteArgs): Promise<UpsertScriptResult> {
+  const shouldEmbed = args.embeddingMode !== "skip";
   const existing = getScript(args);
   if (!existing) {
     const script = insertScript(args);
-    if (!script.isScratch) {
+    if (!script.isScratch && shouldEmbed) {
       await embedScript(script);
     }
     return {
@@ -235,7 +237,7 @@ export async function upsertScriptByName(args: ScriptWriteArgs): Promise<UpsertS
 
       if (!row) throw new Error("Failed to update script metadata");
       const script = rowToScript(row);
-      if (!script.isScratch && (trackedMetadataChanged || promotedFromScratch)) {
+      if (!script.isScratch && shouldEmbed && (trackedMetadataChanged || promotedFromScratch)) {
         await embedScript(script);
       }
       return {
@@ -318,7 +320,7 @@ export async function upsertScriptByName(args: ScriptWriteArgs): Promise<UpsertS
   });
 
   const script = txn();
-  if (!script.isScratch) {
+  if (!script.isScratch && shouldEmbed) {
     await embedScript(script);
   }
 
@@ -347,6 +349,11 @@ export function getScript(args: ScriptIdentity): ScriptRecord | null {
   return row ? rowToScript(row) : null;
 }
 
+export function getScriptById(id: string): ScriptRecord | null {
+  const row = getDb().prepare<ScriptRow, [string]>("SELECT * FROM scripts WHERE id = ?").get(id);
+  return row ? rowToScript(row) : null;
+}
+
 export function getScriptVersion(args: {
   scriptId: string;
   version?: number;
@@ -408,6 +415,15 @@ export function listScripts(args?: {
     .map(rowToScript);
 }
 
+export function listScriptVersions(scriptId: string): ScriptVersionRecord[] {
+  return getDb()
+    .prepare<ScriptVersionRow, [string]>(
+      "SELECT * FROM script_versions WHERE scriptId = ? ORDER BY version DESC",
+    )
+    .all(scriptId)
+    .map(rowToScriptVersion);
+}
+
 export function deleteScript(args: ScriptIdentity): boolean {
   const existing = getScript(args);
   if (!existing) return false;

package/src/be/seed/index.ts

@@ -6,4 +6,4 @@
 export { runAllSeeders, SEEDERS } from "./registry";
 export { runSeeder, runSeeders } from "./runner";
 export { getSeedState, recordSeedState } from "./state-db";
-export type { SeedAction, Seeder, SeederResult, SeedItem } from "./types";
+export type { SeedAction, Seeder, SeederResult, SeederRunOptions, SeedItem } from "./types";

package/src/be/seed/registry.ts

@@ -9,11 +9,11 @@
 import { scriptsSeeder } from "../seed-scripts";
 import { skillsSeeder } from "../seed-skills";
 import { runSeeders } from "./runner";
-import type { Seeder, SeederResult } from "./types";
+import type { Seeder, SeederResult, SeederRunOptions } from "./types";
 
 export const SEEDERS: Seeder[] = [scriptsSeeder, skillsSeeder];
 
 /** Apply every registered seeder. Called at API boot and by the seed CLI. */
-export function runAllSeeders(opts?: { quiet?: boolean }): Promise<SeederResult[]> {
+export function runAllSeeders(opts?: SeederRunOptions): Promise<SeederResult[]> {
   return runSeeders(SEEDERS, opts);
 }

package/src/be/seed/runner.ts

@@ -5,7 +5,7 @@
  */
 
 import { getSeedState, recordSeedState } from "./state-db";
-import type { Seeder, SeederResult } from "./types";
+import type { Seeder, SeederResult, SeederRunOptions } from "./types";
 
 /**
  * Apply one seeder. Idempotent and version-aware:
@@ -14,7 +14,7 @@ import type { Seeder, SeederResult } from "./types";
  *   - upstream pristine, src same  -> no-op
  *   - upstream user-modified       -> preserve (never overwrite)
  */
-export async function runSeeder(seeder: Seeder, opts?: { quiet?: boolean }): Promise<SeederResult> {
+export async function runSeeder(seeder: Seeder, opts?: SeederRunOptions): Promise<SeederResult> {
   const result: SeederResult = {
     kind: seeder.kind,
     created: 0,
@@ -31,7 +31,7 @@ export async function runSeeder(seeder: Seeder, opts?: { quiet?: boolean }): Pro
 
       // Absent upstream -> create.
       if (upstream === null) {
-        await seeder.apply(item, "create");
+        await seeder.apply(item, "create", opts);
         recordSeedState(seeder.kind, item.key, item.contentHash);
         result.created += 1;
         continue;
@@ -60,7 +60,7 @@ export async function runSeeder(seeder: Seeder, opts?: { quiet?: boolean }): Pro
       }
 
       // Pristine upstream + changed source -> update to the new source version.
-      await seeder.apply(item, "update");
+      await seeder.apply(item, "update", opts);
       recordSeedState(seeder.kind, item.key, item.contentHash);
       result.updated += 1;
     } catch (err) {
@@ -88,7 +88,7 @@ export async function runSeeder(seeder: Seeder, opts?: { quiet?: boolean }): Pro
 /** Apply a list of seeders in order. */
 export async function runSeeders(
   seeders: Seeder[],
-  opts?: { quiet?: boolean },
+  opts?: SeederRunOptions,
 ): Promise<SeederResult[]> {
   const results: SeederResult[] = [];
   for (const seeder of seeders) {

package/src/be/seed/types.ts

@@ -35,6 +35,11 @@ export interface SeedItem {
   readonly contentHash: string;
 }
 
+export type SeederRunOptions = {
+  quiet?: boolean;
+  scriptEmbeddingMode?: "sync" | "skip";
+};
+
 export interface Seeder<TItem extends SeedItem = SeedItem> {
   /** Kind discriminator — namespaces this seeder's rows in `seed_state`. */
   readonly kind: string;
@@ -46,7 +51,7 @@ export interface Seeder<TItem extends SeedItem = SeedItem> {
    */
   upstreamHash(item: TItem): string | null | Promise<string | null>;
   /** Create or update the upstream entity so it matches the source definition. */
-  apply(item: TItem, action: "create" | "update"): void | Promise<void>;
+  apply(item: TItem, action: "create" | "update", opts?: SeederRunOptions): void | Promise<void>;
 }
 
 export type SeederResult = {

package/src/be/seed-pricing.ts

@@ -67,6 +67,8 @@ const MANUAL_PRICING_OVERRIDES: Array<{
  * fields the models.dev snapshot doesn't index directly; we map them here.
  */
 const ANTHROPIC_SHORTNAME_TO_MODELSDEV: Record<string, string> = {
+  fable: "claude-fable-5",
+  mythos: "claude-mythos-5",
   opus: "claude-opus-4-8",
   sonnet: "claude-sonnet-4-6",
   haiku: "claude-haiku-4-5",

package/src/be/seed-scripts/catalog/boot-triage.inline.ts

@@ -0,0 +1,221 @@
+import { z } from "zod";
+
+export const argsSchema = z.object({
+  nowIso: z.string().optional().describe("Triage clock override (default: current time)"),
+  failureLookbackMinutes: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Look back this many minutes for real failures (default 60)"),
+  stuckMinutes: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Flag in-progress tasks older than this on offline agents (default 5)"),
+  deployWindowMinutes: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe("Window around now for merged agent-swarm PRs (default 15)"),
+  repo: z
+    .string()
+    .optional()
+    .describe("Optional GitHub repository in 'owner/name' form for restart/deploy PR detection"),
+});
+
+const BENIGN_FAILURE_RE = /^(superseded_workflow_task|cancelled|reboot-sweep)$/i;
+
+function rowsToObjects(res: any): any[] {
+  const p = res?.data ?? res;
+  const cols: string[] = p?.columns ?? [];
+  return (p?.rows ?? []).map((r: any) =>
+    Array.isArray(r) ? Object.fromEntries(cols.map((c, i) => [c, r[i]])) : r,
+  );
+}
+
+async function query(ctx: any, sql: string, params?: unknown[]): Promise<any[]> {
+  try {
+    return rowsToObjects(await ctx.swarm.db_query({ sql, params }));
+  } catch (error) {
+    return [{ unavailable: error instanceof Error ? error.message : String(error) }];
+  }
+}
+
+function taskPreview(task: unknown): string {
+  return String(task || "").replace(/\s+/g, " ").trim().slice(0, 180);
+}
+
+function summarizeTask(row: any): any {
+  return {
+    id: row.id,
+    status: row.status,
+    taskType: row.taskType || null,
+    agentId: row.agentId || null,
+    agentName: row.agentName || null,
+    scheduleId: row.scheduleId || null,
+    parentTaskId: row.parentTaskId || null,
+    failureReason: row.failureReason || null,
+    createdAt: row.createdAt,
+    lastUpdatedAt: row.lastUpdatedAt,
+    taskPreview: taskPreview(row.task),
+  };
+}
+
+async function recentMergedPrs(
+  ctx: any,
+  repo: string | undefined,
+  nowMs: number,
+  windowMinutes: number,
+): Promise<any> {
+  if (!repo) return { skipped: "repo not provided" };
+  if (!/^[^/\s]+\/[^/\s]+$/.test(repo)) return { error: "repo must be in 'owner/name' form" };
+
+  const windowMs = windowMinutes * 60 * 1000;
+  try {
+    const response = await ctx.stdlib.fetch(
+      "https://api.github.com/repos/" +
+        repo +
+        "/pulls?state=closed&sort=updated&direction=desc&per_page=20",
+      {
+        headers: {
+          Accept: "application/vnd.github+json",
+          "User-Agent": "agent-swarm-boot-triage",
+        },
+      },
+    );
+    if (!response.ok) return { error: `GitHub API ${response.status}` };
+    const prs = (await response.json()) as any[];
+    return prs
+      .filter((pr) => pr?.merged_at)
+      .map((pr) => {
+        const mergedAtMs = Date.parse(pr.merged_at);
+        return {
+          repo,
+          number: pr.number,
+          title: pr.title,
+          url: pr.html_url,
+          mergedAt: pr.merged_at,
+          minutesFromRestart: Math.round((mergedAtMs - nowMs) / 60000),
+        };
+      })
+      .filter((pr) => Math.abs(pr.minutesFromRestart * 60000) <= windowMs);
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/** Read-only post-restart triage snapshot for the heartbeat.boot-triage prompt. */
+export default async function bootTriage(args: any, ctx: any) {
+  const parsed = argsSchema.safeParse(args || {});
+  if (!parsed.success) return { error: "invalid args: " + parsed.error.message };
+
+  const now = parsed.data.nowIso ? new Date(parsed.data.nowIso) : new Date();
+  const nowMs = now.getTime();
+  const failureLookbackMinutes = parsed.data.failureLookbackMinutes || 60;
+  const stuckMinutes = parsed.data.stuckMinutes || 5;
+  const deployWindowMinutes = parsed.data.deployWindowMinutes || 15;
+  const repo = parsed.data.repo;
+
+  const mergedPrs = await recentMergedPrs(ctx, repo, nowMs, deployWindowMinutes);
+
+  const recentFailureRows = await query(
+    ctx,
+    `SELECT t.id, t.task, t.status, t.taskType, t.agentId, a.name as agentName,
+            t.scheduleId, t.parentTaskId, t.failureReason, t.createdAt, t.lastUpdatedAt
+     FROM agent_tasks t
+     LEFT JOIN agents a ON a.id = t.agentId
+     WHERE t.status = 'failed'
+       AND datetime(t.lastUpdatedAt) >= datetime(?, ?)
+     ORDER BY datetime(t.lastUpdatedAt) DESC
+     LIMIT 50`,
+    [now.toISOString(), `-${failureLookbackMinutes} minutes`],
+  );
+  const recentlyFailedTasks = recentFailureRows
+    .filter((row) => !row.unavailable)
+    .filter((row) => !BENIGN_FAILURE_RE.test(String(row.failureReason || "")))
+    .map(summarizeTask);
+
+  const stuckOfflineRows = await query(
+    ctx,
+    `SELECT t.id, t.task, t.status, t.taskType, t.agentId, a.name as agentName,
+            t.scheduleId, t.parentTaskId, t.failureReason, t.createdAt, t.lastUpdatedAt
+     FROM agent_tasks t
+     JOIN agents a ON a.id = t.agentId
+     WHERE t.status = 'in_progress'
+       AND a.status = 'offline'
+       AND datetime(t.lastUpdatedAt) <= datetime(?, ?)
+     ORDER BY datetime(t.lastUpdatedAt) ASC
+     LIMIT 50`,
+    [now.toISOString(), `-${stuckMinutes} minutes`],
+  );
+  const stuckInProgressOnOfflineAgents = stuckOfflineRows
+    .filter((row) => !row.unavailable)
+    .map(summarizeTask);
+
+  const orphanRows = await query(
+    ctx,
+    `SELECT t.id, t.task, t.status, t.taskType, t.agentId, a.name as agentName,
+            t.scheduleId, t.parentTaskId, t.failureReason, t.createdAt, t.lastUpdatedAt
+     FROM agent_tasks t
+     JOIN agents a ON a.id = t.agentId
+     WHERE t.status IN ('pending', 'offered')
+       AND a.status = 'offline'
+     ORDER BY datetime(t.lastUpdatedAt) ASC
+     LIMIT 50`,
+  );
+  const orphanedPendingOrOfferedOnOfflineWorkers = orphanRows
+    .filter((row) => !row.unavailable)
+    .map(summarizeTask);
+
+  const supersededRows = await query(
+    ctx,
+    `SELECT p.id, p.task, p.status, p.taskType, p.agentId, a.name as agentName,
+            p.scheduleId, p.parentTaskId, p.failureReason, p.createdAt, p.lastUpdatedAt
+     FROM agent_tasks p
+     LEFT JOIN agents a ON a.id = p.agentId
+     WHERE p.status = 'superseded'
+       AND datetime(p.lastUpdatedAt) >= datetime(?, ?)
+       AND NOT EXISTS (
+         SELECT 1
+         FROM agent_tasks c
+         WHERE c.parentTaskId = p.id
+           AND c.taskType = 'resume'
+           AND c.status NOT IN ('completed', 'failed', 'cancelled', 'superseded')
+       )
+     ORDER BY datetime(p.lastUpdatedAt) DESC
+     LIMIT 50`,
+    [now.toISOString(), `-${failureLookbackMinutes} minutes`],
+  );
+  const supersededTasksMissingResumeChild = supersededRows
+    .filter((row) => !row.unavailable)
+    .map(summarizeTask);
+
+  return {
+    generatedAt: now.toISOString(),
+    windows: {
+      failureLookbackMinutes,
+      stuckMinutes,
+      deployWindowMinutes,
+    },
+    deployRestartDetection: {
+      source: repo ? "github:" + repo : null,
+      mergedPrsWithinWindow: Array.isArray(mergedPrs) ? mergedPrs : [],
+      skipped: Array.isArray(mergedPrs) ? null : mergedPrs.skipped || null,
+      error: Array.isArray(mergedPrs) ? null : mergedPrs.error,
+    },
+    recentlyFailedTasks,
+    stuckInProgressOnOfflineAgents,
+    orphanedPendingOrOfferedOnOfflineWorkers,
+    supersededTasksMissingResumeChild,
+    summary: {
+      mergedPrsWithinWindow: Array.isArray(mergedPrs) ? mergedPrs.length : 0,
+      recentlyFailedTasks: recentlyFailedTasks.length,
+      stuckInProgressOnOfflineAgents: stuckInProgressOnOfflineAgents.length,
+      orphanedPendingOrOfferedOnOfflineWorkers: orphanedPendingOrOfferedOnOfflineWorkers.length,
+      supersededTasksMissingResumeChild: supersededTasksMissingResumeChild.length,
+    },
+  };
+}