stagent 0.9.2 → 0.9.5

package/src/lib/chat/__tests__/engine-stream-helpers.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { paragraphSeparator, inlineScreenshotMarkdown } from "../engine";
+
+describe("paragraphSeparator", () => {
+  it("returns empty string when fullText is empty", () => {
+    expect(paragraphSeparator("")).toBe("");
+  });
+
+  it("returns two newlines between adjacent text blocks ending without a newline", () => {
+    expect(paragraphSeparator("review the app.")).toBe("\n\n");
+  });
+
+  it("returns empty string when fullText already ends with a newline", () => {
+    expect(paragraphSeparator("first paragraph.\n")).toBe("");
+    expect(paragraphSeparator("first paragraph.\n\n")).toBe("");
+  });
+});
+
+describe("inlineScreenshotMarkdown", () => {
+  it("emits markdown image with leading paragraph break when prose precedes it", () => {
+    const md = inlineScreenshotMarkdown(
+      "Let me take a screenshot of the dashboard.",
+      "/screenshots/thumb-1.png"
+    );
+    expect(md).toBe("\n\n![screenshot](/screenshots/thumb-1.png)\n\n");
+  });
+
+  it("omits the leading break when fullText is empty", () => {
+    const md = inlineScreenshotMarkdown("", "/screenshots/thumb-1.png");
+    expect(md).toBe("![screenshot](/screenshots/thumb-1.png)\n\n");
+  });
+
+  it("omits the leading break when fullText already ends with a newline", () => {
+    const md = inlineScreenshotMarkdown(
+      "intro paragraph.\n\n",
+      "/screenshots/thumb-2.png"
+    );
+    expect(md).toBe("![screenshot](/screenshots/thumb-2.png)\n\n");
+  });
+
+  it("simulates a streaming sequence: text → screenshot → text stays well-separated", () => {
+    let fullText = "";
+    // first text block
+    fullText += "Now let me take a screenshot of the dashboard.";
+    // screenshot capture
+    const inline = inlineScreenshotMarkdown(fullText, "/screenshots/thumb-1.png");
+    fullText += inline;
+    // next text block (after a tool_use turn break) — engine would inject a
+    // paragraph separator on content_block_start before appending.
+    fullText += paragraphSeparator(fullText);
+    fullText += "Good, I can see the dashboard.";
+
+    expect(fullText).toBe(
+      "Now let me take a screenshot of the dashboard.\n\n![screenshot](/screenshots/thumb-1.png)\n\nGood, I can see the dashboard."
+    );
+  });
+});

package/src/lib/chat/engine.ts

@@ -102,6 +102,30 @@ function diagnoseProcessError(rawMessage: string, stderr: string): string {
   return rawMessage;
 }
 
+// ── Stream-shaping helpers (exported for unit tests) ──────────────────
+
+/**
+ * Returns the separator to insert before appending new text to `fullText`.
+ * The Anthropic stream delivers text in `content_block`s with no trailing
+ * newline, so adjacent blocks (e.g. before/after a tool_use turn break) fuse
+ * together visually unless we inject a paragraph break.
+ */
+export function paragraphSeparator(fullText: string): string {
+  return fullText.length > 0 && !fullText.endsWith("\n") ? "\n\n" : "";
+}
+
+/**
+ * Builds the inline markdown segment for a captured screenshot. The leading
+ * separator preserves paragraph spacing relative to the prose that came
+ * before; the trailing `\n\n` makes sure subsequent text starts a new block.
+ */
+export function inlineScreenshotMarkdown(
+  fullText: string,
+  thumbnailUrl: string
+): string {
+  return `${paragraphSeparator(fullText)}![screenshot](${thumbnailUrl})\n\n`;
+}
+
 // ── Public API ─────────────────────────────────────────────────────────
 
 /**
@@ -417,7 +441,16 @@ export async function* sendMessage(
       if (raw.type === "stream_event") {
         // SDK wraps Anthropic API events inside stream_event.event
         const innerEvent = raw.event as Record<string, unknown> | undefined;
-        if (innerEvent?.type === "content_block_delta") {
+        if (innerEvent?.type === "content_block_start") {
+          const block = innerEvent.content_block as Record<string, unknown> | undefined;
+          if (block?.type === "text" && fullText.length > 0 && !fullText.endsWith("\n")) {
+            // New text block after a previous block (often a tool_use turn break) —
+            // models don't end blocks with paragraph breaks, so insert one to keep
+            // sequential turns visually separated in the chat bubble.
+            fullText += "\n\n";
+            yield { type: "delta", content: "\n\n" };
+          }
+        } else if (innerEvent?.type === "content_block_delta") {
           const delta = innerEvent.delta as Record<string, unknown> | undefined;
           if (delta?.type === "text_delta" && typeof delta.text === "string") {
             fullText += delta.text;
@@ -425,6 +458,12 @@ export async function* sendMessage(
             yield { type: "delta", content: delta.text };
           }
         }
+      } else if (raw.type === "content_block_start") {
+        const block = (raw as Record<string, unknown>).content_block as Record<string, unknown> | undefined;
+        if (block?.type === "text" && fullText.length > 0 && !fullText.endsWith("\n")) {
+          fullText += "\n\n";
+          yield { type: "delta", content: "\n\n" };
+        }
       } else if (raw.type === "content_block_delta") {
         const delta = raw.delta as Record<string, unknown> | undefined;
         if (delta?.type === "text_delta" && typeof delta.text === "string") {
@@ -457,6 +496,10 @@ export async function* sendMessage(
         if (assistantBlocks) {
           for (const block of assistantBlocks) {
             if (block.type === "text" && typeof block.text === "string" && !fullText.includes(block.text)) {
+              if (fullText.length > 0 && !fullText.endsWith("\n")) {
+                fullText += "\n\n";
+                yield { type: "delta", content: "\n\n" };
+              }
               fullText += block.text;
               yield { type: "delta", content: block.text };
             }
@@ -486,6 +529,16 @@ export async function* sendMessage(
                       if (attachment) {
                         screenshotAttachments.push(attachment);
                         yield { type: "screenshot" as const, ...attachment };
+                        // Also inject the screenshot inline into the text stream as a
+                        // markdown image so it renders next to the prose that captured
+                        // it (the markdown renderer resolves the thumbnail src back to
+                        // the full attachment via the message's metadata.attachments).
+                        const inlineMd = inlineScreenshotMarkdown(
+                          fullText,
+                          attachment.thumbnailUrl
+                        );
+                        fullText += inlineMd;
+                        yield { type: "delta" as const, content: inlineMd };
                       }
                     }
                   }
@@ -513,13 +566,21 @@ export async function* sendMessage(
           const result = (raw as Record<string, unknown>).result;
           if (typeof result === "string" && result.length > 0) {
             if (result !== fullText) {
-              const remainder = result.startsWith(fullText)
-                ? result.slice(fullText.length)
-                : result;
-              if (remainder) {
-                yield { type: "delta" as const, content: remainder };
+              if (result.startsWith(fullText)) {
+                const remainder = result.slice(fullText.length);
+                if (remainder) {
+                  yield { type: "delta" as const, content: remainder };
+                }
+              } else {
+                // Result is unrelated to what we have so far — treat as a new
+                // text block and insert a paragraph break before appending.
+                if (fullText.length > 0 && !fullText.endsWith("\n")) {
+                  yield { type: "delta" as const, content: "\n\n" };
+                  fullText += "\n\n";
+                }
+                yield { type: "delta" as const, content: result };
               }
-              fullText = result;
+              fullText = result.startsWith(fullText) ? result : fullText + result;
             }
           }
         }

package/src/lib/chat/stagent-tools.ts

@@ -20,6 +20,7 @@ import { settingsTools } from "./tools/settings-tools";
 import { chatHistoryTools } from "./tools/chat-history-tools";
 import { handoffTools } from "./tools/handoff-tools";
 import { tableTools } from "./tools/table-tools";
+import { runtimeTools } from "./tools/runtime-tools";
 
 // ── Tool server types ────────────────────────────────────────────────
 
@@ -54,6 +55,7 @@ function collectAllTools(ctx: ToolContext): ToolDefinition[] {
     ...chatHistoryTools(ctx),
     ...handoffTools(ctx),
     ...tableTools(ctx),
+    ...runtimeTools(ctx),
   ];
 }
 

package/src/lib/chat/tools/runtime-tools.ts

@@ -0,0 +1,28 @@
+import { defineTool } from "../tool-registry";
+import { ok, type ToolContext } from "./helpers";
+import { listRuntimeCatalog } from "@/lib/agents/runtime/catalog";
+
+export function runtimeTools(_ctx: ToolContext) {
+  return [
+    defineTool(
+      "list_runtimes",
+      "List all available AI runtimes with their models and capabilities. Use this to discover which runtimes can be assigned to workflows.",
+      {},
+      async () => {
+        const catalog = listRuntimeCatalog();
+        return ok(
+          catalog.map((entry) => ({
+            id: entry.id,
+            label: entry.label,
+            provider: entry.providerId,
+            description: entry.description,
+            models: entry.models,
+            capabilities: Object.entries(entry.capabilities)
+              .filter(([, v]) => v)
+              .map(([k]) => k),
+          }))
+        );
+      }
+    ),
+  ];
+}

package/src/lib/chat/tools/schedule-tools.ts

@@ -4,6 +4,7 @@ import { db } from "@/lib/db";
 import { schedules } from "@/lib/db/schema";
 import { eq, and, desc } from "drizzle-orm";
 import { ok, err, type ToolContext } from "./helpers";
+import { analyzePromptEfficiency } from "@/lib/schedules/prompt-analyzer";
 
 const VALID_SCHEDULE_STATUSES = [
   "active",
@@ -97,6 +98,39 @@ export function scheduleTools(ctx: ToolContext) {
           const effectiveProjectId = args.projectId ?? ctx.projectId ?? null;
           const now = new Date();
           const id = crypto.randomUUID();
+
+          // Auto-stagger: if other active schedules in this project would
+          // collide with the requested cron, offset its minute field. We scope
+          // to the same project so unrelated workspaces don't interfere.
+          const { computeStaggeredCron } = await import(
+            "@/lib/schedules/interval-parser"
+          );
+          const existing = await db
+            .select({ cron: schedules.cronExpression })
+            .from(schedules)
+            .where(
+              effectiveProjectId
+                ? and(
+                    eq(schedules.status, "active"),
+                    eq(schedules.projectId, effectiveProjectId)
+                  )
+                : eq(schedules.status, "active")
+            );
+          const staggerResult = computeStaggeredCron(
+            cronExpression,
+            existing.map((s) => s.cron)
+          );
+          if (staggerResult.offsetApplied > 0) {
+            console.log(
+              `[scheduler] staggered "${args.name}" by ${staggerResult.offsetApplied}min to avoid collision (${cronExpression} → ${staggerResult.cronExpression})`
+            );
+            cronExpression = staggerResult.cronExpression;
+          }
+
+          // Surface prompt-efficiency warnings before creating the schedule.
+          // We still create the schedule — these are guidance, not blockers.
+          const warnings = analyzePromptEfficiency(args.prompt);
+
           const nextFireAt = computeNextFireTime(cronExpression, now);
           const expiresAt = args.expiresInHours
             ? new Date(now.getTime() + args.expiresInHours * 60 * 60 * 1000)
@@ -126,7 +160,16 @@ export function scheduleTools(ctx: ToolContext) {
             .where(eq(schedules.id, id));
 
           ctx.onToolResult?.("create_schedule", schedule);
-          return ok(schedule);
+          return ok({
+            schedule,
+            warnings,
+            staggered: staggerResult.offsetApplied > 0
+              ? {
+                  offsetMinutes: staggerResult.offsetApplied,
+                  originalCron: staggerResult.collided ? args.interval : undefined,
+                }
+              : undefined,
+          });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to create schedule");
         }

package/src/lib/chat/tools/settings-tools.ts

@@ -64,6 +64,29 @@ const WRITABLE_SETTINGS: Record<string, WritableSetting> = {
     validate: (v) =>
       v.trim().length === 0 ? "Must be non-empty string" : null,
   },
+  "budget_max_cost_per_task": {
+    description: "Max cost per task in USD (0.5–50)",
+    validate: (v) => {
+      const n = parseFloat(v);
+      return isNaN(n) || n < 0.5 || n > 50 ? "Must be number 0.5–50" : null;
+    },
+  },
+  "budget_max_tokens_per_task": {
+    description: "Max tokens per task (1000–500000)",
+    validate: (v) => {
+      const n = parseInt(v, 10);
+      return isNaN(n) || n < 1000 || n > 500000
+        ? "Must be integer 1000–500000"
+        : null;
+    },
+  },
+  "budget_max_daily_cost": {
+    description: "Max daily spend in USD (1–500)",
+    validate: (v) => {
+      const n = parseFloat(v);
+      return isNaN(n) || n < 1 || n > 500 ? "Must be number 1–500" : null;
+    },
+  },
 };
 
 const WRITABLE_KEYS_DOC = Object.entries(WRITABLE_SETTINGS)
@@ -109,10 +132,14 @@ export function settingsTools(_ctx: ToolContext) {
 
           if (args.key) {
             const value = await getSetting(args.key);
-            return ok({ key: args.key, value });
+            return ok({
+              key: args.key,
+              value,
+              writable: args.key in WRITABLE_SETTINGS,
+            });
           }
 
-          // Return common settings + workspace context
+          // Return common settings + workspace context with writability tags
           const keys = [
             "auth_method",
             "default_runtime",
@@ -121,17 +148,20 @@ export function settingsTools(_ctx: ToolContext) {
             "budget_max_cost_per_task",
             "budget_max_daily_cost",
           ];
-          const entries: Record<string, string | null> = {};
+          const entries: Record<string, { value: string | null; writable: boolean }> = {};
           for (const key of keys) {
-            entries[key] = await getSetting(key);
+            entries[key] = {
+              value: await getSetting(key),
+              writable: key in WRITABLE_SETTINGS,
+            };
           }
 
-          // Append workspace context
+          // Append workspace context (read-only)
           const ws = getWorkspaceContext();
-          entries.workspace_cwd = ws.cwd;
-          entries.workspace_git_branch = ws.gitBranch;
-          entries.workspace_is_worktree = ws.isWorktree ? "true" : "false";
-          entries.workspace_folder_name = ws.folderName;
+          entries.workspace_cwd = { value: ws.cwd, writable: false };
+          entries.workspace_git_branch = { value: ws.gitBranch, writable: false };
+          entries.workspace_is_worktree = { value: ws.isWorktree ? "true" : "false", writable: false };
+          entries.workspace_folder_name = { value: ws.folderName, writable: false };
 
           return ok(entries);
         } catch (e) {
@@ -151,7 +181,7 @@ export function settingsTools(_ctx: ToolContext) {
         const spec = WRITABLE_SETTINGS[args.key];
         if (!spec) {
           return err(
-            `Key "${args.key}" is not writable. Valid keys: ${Object.keys(WRITABLE_SETTINGS).join(", ")}`
+            `Key "${args.key}" is not writable via set_settings. Use get_settings to see which keys are writable (writable: true). Writable keys: ${Object.keys(WRITABLE_SETTINGS).join(", ")}`
           );
         }
         const validationError = spec.validate(args.value);

package/src/lib/chat/tools/workflow-tools.ts

@@ -87,6 +87,12 @@ export function workflowTools(ctx: ToolContext) {
           .describe(
             "Optional array of document IDs from the project pool to attach as input context. These documents will be injected into all workflow steps at execution time."
           ),
+        runtime: z
+          .string()
+          .optional()
+          .describe(
+            "Runtime to use for workflow execution (e.g., 'openai-direct', 'anthropic-direct'). Use list_runtimes to see available options. Omit to use the system default."
+          ),
       },
       async (args) => {
         try {
@@ -110,6 +116,16 @@ export function workflowTools(ctx: ToolContext) {
           }
           args.definition = JSON.stringify(parsedDef);
 
+          // Validate runtime if provided
+          let runtimeId: string | null = null;
+          if (args.runtime) {
+            const { isAgentRuntimeId } = await import("@/lib/agents/runtime/catalog");
+            if (!isAgentRuntimeId(args.runtime)) {
+              return err(`Invalid runtime "${args.runtime}". Use list_runtimes to see available options.`);
+            }
+            runtimeId = args.runtime;
+          }
+
           const effectiveProjectId = args.projectId ?? ctx.projectId ?? null;
           const now = new Date();
           const id = crypto.randomUUID();
@@ -119,12 +135,13 @@ export function workflowTools(ctx: ToolContext) {
             name: args.name,
             projectId: effectiveProjectId,
             definition: args.definition,
+            runtimeId,
             status: "draft",
             createdAt: now,
             updatedAt: now,
           });
 
-          // Attach pool documents if provided
+          // Attach global pool documents if provided
           const attachedDocs: string[] = [];
           if (args.documentIds && args.documentIds.length > 0) {
             for (const docId of args.documentIds) {
@@ -143,6 +160,27 @@ export function workflowTools(ctx: ToolContext) {
             }
           }
 
+          // Attach per-step documents from step definitions
+          let stepDocCount = 0;
+          for (const step of parsedDef.steps) {
+            if (step.documentIds && Array.isArray(step.documentIds)) {
+              for (const docId of step.documentIds) {
+                try {
+                  await db.insert(workflowDocumentInputs).values({
+                    id: crypto.randomUUID(),
+                    workflowId: id,
+                    documentId: docId,
+                    stepId: step.id,
+                    createdAt: now,
+                  });
+                  stepDocCount++;
+                } catch {
+                  // Skip duplicates or invalid doc IDs
+                }
+              }
+            }
+          }
+
           const [workflow] = await db
             .select()
             .from(workflows)
@@ -154,8 +192,10 @@ export function workflowTools(ctx: ToolContext) {
             name: workflow.name,
             projectId: workflow.projectId,
             status: workflow.status,
+            runtimeId: workflow.runtimeId,
             createdAt: workflow.createdAt,
             attachedDocuments: attachedDocs.length,
+            stepScopedDocuments: stepDocCount,
           });
         } catch (e) {
           return err(e instanceof Error ? e.message : "Failed to create workflow");
@@ -328,10 +368,59 @@ export function workflowTools(ctx: ToolContext) {
             .get();
 
           if (!workflow) return err(`Workflow not found: ${args.workflowId}`);
-          if (workflow.status === "active")
-            return err("Workflow is already running");
-          if (workflow.status !== "draft" && workflow.status !== "paused" && workflow.status !== "failed")
+
+          // Allow re-execution from crashed "active" if no live tasks
+          if (workflow.status === "active") {
+            const liveTasks = await db
+              .select({ id: tasks.id })
+              .from(tasks)
+              .where(
+                and(
+                  eq(tasks.workflowId, args.workflowId),
+                  inArray(tasks.status, ["running", "queued"])
+                )
+              );
+            if (liveTasks.length > 0) {
+              return err("Workflow is already running");
+            }
+            // Crashed — fall through to reset + re-execute
+          }
+
+          if (
+            workflow.status !== "draft" &&
+            workflow.status !== "paused" &&
+            workflow.status !== "failed" &&
+            workflow.status !== "active" &&
+            workflow.status !== "completed"
+          ) {
             return err(`Cannot execute a workflow in '${workflow.status}' status`);
+          }
+
+          // Reset state for re-execution from non-draft status
+          if (workflow.status !== "draft") {
+            // Cancel orphaned tasks
+            await db
+              .update(tasks)
+              .set({ status: "cancelled", updatedAt: new Date() })
+              .where(
+                and(
+                  eq(tasks.workflowId, args.workflowId),
+                  inArray(tasks.status, ["running", "queued"])
+                )
+              );
+
+            // Clear execution state
+            const { parseWorkflowState } = await import("@/lib/workflows/engine");
+            const { definition } = parseWorkflowState(workflow.definition);
+            await db
+              .update(workflows)
+              .set({
+                definition: JSON.stringify(definition),
+                status: "draft",
+                updatedAt: new Date(),
+              })
+              .where(eq(workflows.id, args.workflowId));
+          }
 
           // Atomic claim: set to active
           await db

package/src/lib/chat/types.ts

@@ -67,6 +67,27 @@ export const CHAT_MODELS: ChatModelOption[] = [
 
 export const DEFAULT_CHAT_MODEL = "haiku";
 
+// Validate CHAT_MODELS against runtime catalog at module load
+// Warns on stale model IDs that don't appear in any runtime's supported list
+try {
+  const { listRuntimeCatalog } = require("@/lib/agents/runtime/catalog");
+  const allSupportedModels = new Set<string>();
+  for (const runtime of listRuntimeCatalog()) {
+    for (const model of runtime.models.supported) {
+      allSupportedModels.add(model);
+    }
+  }
+  for (const model of CHAT_MODELS) {
+    if (!allSupportedModels.has(model.id)) {
+      console.warn(
+        `[chat-models] CHAT_MODELS entry "${model.id}" not found in any runtime's supported models — may be stale`
+      );
+    }
+  }
+} catch {
+  // Catalog not available during build/test — skip validation
+}
+
 /** Resolve a model ID to its display label (e.g., "opus" → "Opus", "gpt-5.4" → "GPT-5.4") */
 export function resolveModelLabel(modelId: string): string {
   const model = CHAT_MODELS.find((m) => m.id === modelId);

package/src/lib/data/clear.ts

@@ -42,6 +42,7 @@ import {
   taskTableInputs,
   workflowTableInputs,
   scheduleTableInputs,
+  workflowExecutionStats,
 } from "@/lib/db/schema";
 import { readdirSync, unlinkSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -119,6 +120,7 @@ export function clearAllData() {
   const documentsDeleted = db.delete(documents).run().changes;
   const agentMemoryDeleted = db.delete(agentMemory).run().changes;
   const learnedContextDeleted = db.delete(learnedContext).run().changes;
+  const executionStatsDeleted = db.delete(workflowExecutionStats).run().changes;
   const tasksDeleted = db.delete(tasks).run().changes;
   const workflowsDeleted = db.delete(workflows).run().changes;
   const schedulesDeleted = db.delete(schedules).run().changes;
@@ -194,5 +196,6 @@ export function clearAllData() {
     files: filesDeleted,
     screenshots: screenshotsDeleted,
     license: licenseDeleted,
+    workflowExecutionStats: executionStatsDeleted,
   };
 }

package/src/lib/db/bootstrap.ts

@@ -46,6 +46,7 @@ const STAGENT_TABLES = [
   "user_table_row_history",
   "snapshots",
   "license",
+  "workflow_execution_stats",
 ] as const;
 
 export function bootstrapStagentDatabase(sqlite: Database.Database): void {
@@ -74,6 +75,7 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       session_id TEXT,
       resume_count INTEGER DEFAULT 0 NOT NULL,
       workflow_run_number INTEGER,
+      max_budget_usd REAL,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION,
@@ -88,6 +90,7 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       definition TEXT NOT NULL,
       status TEXT DEFAULT 'draft' NOT NULL,
       run_number INTEGER DEFAULT 0 NOT NULL,
+      runtime_id TEXT,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION
@@ -176,6 +179,10 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       heartbeat_budget_per_day INTEGER,
       heartbeat_spent_today INTEGER DEFAULT 0 NOT NULL,
       heartbeat_budget_reset_at INTEGER,
+      avg_turns_per_firing INTEGER,
+      last_turn_count INTEGER,
+      failure_streak INTEGER DEFAULT 0 NOT NULL,
+      last_failure_reason TEXT,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL,
       FOREIGN KEY (project_id) REFERENCES projects(id) ON UPDATE NO ACTION ON DELETE NO ACTION
@@ -536,6 +543,13 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
   `);
 
   addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN delivery_channels TEXT;`);
+  // Schedule health-monitoring columns (collision-prevention feature).
+  // Nullable so existing rows backfill cleanly; failure_streak defaults to 0
+  // so the auto-pause logic treats existing schedules as "no failures yet".
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN avg_turns_per_firing INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN last_turn_count INTEGER;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN failure_streak INTEGER DEFAULT 0 NOT NULL;`);
+  addColumnIfMissing(`ALTER TABLE schedules ADD COLUMN last_failure_reason TEXT;`);
   addColumnIfMissing(`ALTER TABLE channel_configs ADD COLUMN direction TEXT DEFAULT 'outbound' NOT NULL;`);
 
   // ── Bidirectional Channel Chat ──────────────────────────────────────────
@@ -856,7 +870,31 @@ export function bootstrapStagentDatabase(sqlite: Database.Database): void {
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     );
+
+    CREATE TABLE IF NOT EXISTS workflow_execution_stats (
+      id TEXT PRIMARY KEY,
+      pattern TEXT NOT NULL,
+      step_count INTEGER NOT NULL,
+      avg_docs_per_step REAL,
+      avg_cost_per_step_micros INTEGER,
+      avg_duration_per_step_ms INTEGER,
+      success_rate REAL,
+      common_failures TEXT,
+      runtime_breakdown TEXT,
+      sample_count INTEGER NOT NULL DEFAULT 0,
+      last_updated TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
   `);
+
+  // Safety: add columns that may be missing on existing databases.
+  // SQLite ALTER TABLE ADD COLUMN is a no-op if column exists (throws, caught).
+  for (const alter of [
+    "ALTER TABLE tasks ADD COLUMN max_budget_usd REAL",
+    "ALTER TABLE workflows ADD COLUMN runtime_id TEXT",
+  ]) {
+    try { sqlite.exec(alter); } catch { /* column already exists — expected */ }
+  }
 }
 
 export function hasLegacyStagentTables(sqlite: Database.Database): boolean {

package/src/lib/db/migrations/0022_workflow_intelligence_phase1.sql

@@ -0,0 +1,5 @@
+-- Workflow Intelligence Stack — Phase 1 schema changes
+-- Feature 1: Per-task budget cap storage
+ALTER TABLE tasks ADD COLUMN max_budget_usd REAL;
+-- Feature 2: Per-workflow runtime selection
+ALTER TABLE workflows ADD COLUMN runtime_id TEXT;

package/src/lib/db/migrations/0023_add_execution_stats.sql

@@ -0,0 +1,15 @@
+-- Workflow Intelligence Stack — Phase 2: Execution learning
+CREATE TABLE IF NOT EXISTS workflow_execution_stats (
+  id TEXT PRIMARY KEY,
+  pattern TEXT NOT NULL,
+  step_count INTEGER NOT NULL,
+  avg_docs_per_step REAL,
+  avg_cost_per_step_micros INTEGER,
+  avg_duration_per_step_ms INTEGER,
+  success_rate REAL,
+  common_failures TEXT,
+  runtime_breakdown TEXT,
+  sample_count INTEGER NOT NULL DEFAULT 0,
+  last_updated TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now'))
+);