stagent 0.9.6 → 0.11.0

package/src/lib/chat/reconcile.ts

@@ -0,0 +1,117 @@
+import { db } from "@/lib/db";
+import { chatMessages } from "@/lib/db/schema";
+import { and, eq, lt } from "drizzle-orm";
+import { recordTermination } from "./stream-telemetry";
+
+const INTERRUPTED_FALLBACK =
+  "(Response interrupted. Please try again.)";
+
+const ORPHAN_FALLBACK =
+  "(Interrupted — this response was not completed. Please retry.)";
+
+/**
+ * Safety-net finalizer called from the chat engine's top-level `finally` block.
+ *
+ * Guarantees the invariant: no `chat_messages` row remains in
+ * `status='streaming'` after `sendMessage()` returns or throws. Catches every
+ * code path the engine's own `catch` block misses — most notably async
+ * iterator abandonment, where a consumer `break`ing out of a `for await` loop
+ * triggers the generator's `return()` method and jumps straight to `finally`,
+ * skipping `catch` entirely.
+ *
+ * No-op if the message is already in a terminal state. Idempotent.
+ *
+ * When the salvage path actually fires (row was still in streaming → now
+ * updated to complete/error), records a `stream.abandoned` telemetry event
+ * so maintainers can see that the engine's own happy/catch paths both
+ * missed the termination. A non-zero count here signals a real gap that
+ * may warrant investigation — e.g., the dev HMR interrupting a stream,
+ * or a consumer break pattern that bypasses the telemetry in both primary
+ * code paths.
+ */
+export async function finalizeStreamingMessage(
+  messageId: string,
+  fullText: string,
+): Promise<void> {
+  const current = db
+    .select()
+    .from(chatMessages)
+    .where(eq(chatMessages.id, messageId))
+    .get();
+
+  if (!current || current.status !== "streaming") {
+    return;
+  }
+
+  const hasContent = fullText && fullText.trim().length > 0;
+  const salvage = hasContent ? fullText : INTERRUPTED_FALLBACK;
+  const nextStatus = hasContent && fullText.length > 50 ? "complete" : "error";
+
+  db.update(chatMessages)
+    .set({ status: nextStatus, content: salvage })
+    .where(eq(chatMessages.id, messageId))
+    .run();
+
+  // Telemetry: this code path means neither stream.completed nor the
+  // engine's catch-block recordTermination fired. Capture the gap so
+  // the diagnostics endpoint can surface it.
+  recordTermination({
+    reason: "stream.abandoned",
+    conversationId: current.conversationId ?? null,
+    messageId,
+    durationMs: current.createdAt
+      ? Date.now() - new Date(current.createdAt).getTime()
+      : null,
+    error: hasContent ? undefined : "no content streamed before abandonment",
+  });
+}
+
+/**
+ * Sweep orphaned chat assistant messages left in `status='streaming'` past a
+ * reasonable cutoff. These rows are produced when the chat engine's finally
+ * block is bypassed (process crash, iterator abandonment under heavy load,
+ * HTTP disconnect before update commits, etc.).
+ *
+ * Safe to call idempotently at chat page load. Uses a 10-minute cutoff — far
+ * longer than any legitimate in-flight streaming response — so in-flight rows
+ * are never clobbered.
+ *
+ * Returns the number of rows swept. Never throws.
+ */
+export async function reconcileStreamingMessages(): Promise<number> {
+  const cutoff = new Date(Date.now() - 10 * 60 * 1000);
+  const orphans = db
+    .select()
+    .from(chatMessages)
+    .where(
+      and(
+        eq(chatMessages.status, "streaming"),
+        lt(chatMessages.createdAt, cutoff),
+      ),
+    )
+    .all();
+
+  for (const row of orphans) {
+    const salvage =
+      row.content && row.content.length > 0 ? row.content : ORPHAN_FALLBACK;
+    db.update(chatMessages)
+      .set({ status: "error", content: salvage })
+      .where(eq(chatMessages.id, row.id))
+      .run();
+
+    // Telemetry: record the orphan sweep so diagnostics can tell how often
+    // the safety net actually fires vs. how often the normal finalize path
+    // catches everything first. If this code ever logs a row, the engine's
+    // `finally` block missed it.
+    recordTermination({
+      reason: "stream.reconciled.stale",
+      conversationId: row.conversationId ?? null,
+      messageId: row.id,
+      durationMs: row.createdAt
+        ? Date.now() - new Date(row.createdAt).getTime()
+        : null,
+    });
+  }
+
+  return orphans.length;
+}

package/src/lib/chat/skill-composition.ts

@@ -0,0 +1,210 @@
+/**
+ * Shared composition service — single source of truth for activate_skill /
+ * deactivate_skill logic, used by both the chat tool handler and the thin
+ * HTTP routes (POST /api/chat/conversations/[id]/skills/activate|deactivate).
+ *
+ * The chat tool delegates here so the UI can reach the same behaviour over
+ * HTTP without going through MCP.
+ *
+ * See `features/chat-composition-ui-v1.md`.
+ */
+
+import { eq } from "drizzle-orm";
+import { db } from "@/lib/db";
+import { conversations } from "@/lib/db/schema";
+import { mergeActiveSkillIds } from "@/lib/chat/active-skills";
+import type { SkillConflict } from "@/lib/chat/skill-conflict";
+
+export type ActivateSkillResult =
+  | {
+      kind: "ok";
+      activatedSkillId: string;
+      activeSkillIds: string[];
+      skillName: string;
+      note?: string;
+    }
+  | {
+      kind: "conflicts";
+      activeSkillIds: string[];
+      conflicts: SkillConflict[];
+      hint: string;
+    }
+  | { kind: "error"; message: string };
+
+export type DeactivateSkillResult =
+  | { kind: "ok"; previousSkillId: string | null }
+  | { kind: "error"; message: string };
+
+/**
+ * Activate a skill on a conversation, respecting runtime composition limits.
+ *
+ * @param conversationId  Target conversation.
+ * @param skillId         Opaque skill id from list_skills.
+ * @param mode            "replace" (default) clears prior active skills; "add"
+ *                        appends — runtime must support composition.
+ * @param force           When mode="add", skip conflict heuristic warnings.
+ */
+export async function activateSkill(args: {
+  conversationId: string;
+  skillId: string;
+  mode?: "replace" | "add";
+  force?: boolean;
+}): Promise<ActivateSkillResult> {
+  const { conversationId, skillId, mode = "replace", force = false } = args;
+
+  try {
+    const { getSkill } = await import("@/lib/environment/list-skills");
+    const skill = getSkill(skillId);
+    if (!skill) return { kind: "error", message: `Skill not found: ${skillId}` };
+
+    const existing = await db
+      .select({
+        id: conversations.id,
+        activeSkillId: conversations.activeSkillId,
+        activeSkillIds: conversations.activeSkillIds,
+        runtimeId: conversations.runtimeId,
+      })
+      .from(conversations)
+      .where(eq(conversations.id, conversationId))
+      .get();
+
+    if (!existing) {
+      return { kind: "error", message: `Conversation not found: ${conversationId}` };
+    }
+
+    if (mode === "add") {
+      const { getRuntimeFeatures } = await import("@/lib/agents/runtime/catalog");
+      let features;
+      try {
+        features = getRuntimeFeatures(
+          existing.runtimeId as Parameters<typeof getRuntimeFeatures>[0]
+        );
+      } catch {
+        return {
+          kind: "error",
+          message: `Unknown runtime '${existing.runtimeId ?? "(none)"}' — cannot determine composition support`,
+        };
+      }
+
+      if (!features.supportsSkillComposition) {
+        return {
+          kind: "error",
+          message: `Runtime '${existing.runtimeId}' does not support skill composition — switch to a Claude/Codex/direct runtime to compose skills`,
+        };
+      }
+
+      const currentIds = mergeActiveSkillIds(existing.activeSkillId, existing.activeSkillIds);
+
+      if (currentIds.includes(skillId)) {
+        return {
+          kind: "ok",
+          activatedSkillId: skillId,
+          activeSkillIds: currentIds,
+          skillName: skill.name,
+          note: "skill already active",
+        };
+      }
+
+      if (currentIds.length >= features.maxActiveSkills) {
+        return {
+          kind: "error",
+          message: `Max active skills (${features.maxActiveSkills}) reached on '${existing.runtimeId}' — deactivate one first`,
+        };
+      }
+
+      if (!force && currentIds.length > 0) {
+        const { detectSkillConflicts } = await import("@/lib/chat/skill-conflict");
+        const allConflicts: SkillConflict[] = [];
+        for (const otherId of currentIds) {
+          const other = getSkill(otherId);
+          if (!other) continue;
+          const conflicts = detectSkillConflicts(
+            { id: skill.id, name: skill.name, content: skill.content },
+            { id: other.id, name: other.name, content: other.content }
+          );
+          allConflicts.push(...conflicts);
+        }
+        if (allConflicts.length > 0) {
+          return {
+            kind: "conflicts",
+            activeSkillIds: currentIds,
+            conflicts: allConflicts,
+            hint: "Re-call with force=true to add anyway",
+          };
+        }
+      }
+
+      // Append: store ALL composed IDs in the new column. Keep legacy
+      // activeSkillId as-is so single-skill read paths still work.
+      const newComposed = [...(existing.activeSkillIds ?? []), skillId];
+      await db
+        .update(conversations)
+        .set({ activeSkillIds: newComposed, updatedAt: new Date() })
+        .where(eq(conversations.id, conversationId));
+
+      return {
+        kind: "ok",
+        activatedSkillId: skillId,
+        activeSkillIds: mergeActiveSkillIds(existing.activeSkillId, newComposed),
+        skillName: skill.name,
+      };
+    }
+
+    // mode === "replace" (legacy / default)
+    await db
+      .update(conversations)
+      .set({
+        activeSkillId: skillId,
+        activeSkillIds: [],
+        updatedAt: new Date(),
+      })
+      .where(eq(conversations.id, conversationId));
+
+    return {
+      kind: "ok",
+      activatedSkillId: skillId,
+      activeSkillIds: [skillId],
+      skillName: skill.name,
+    };
+  } catch (e) {
+    return {
+      kind: "error",
+      message: e instanceof Error ? e.message : "activate_skill failed",
+    };
+  }
+}
+
+/**
+ * Clear the active skill (and composed skills) on a conversation.
+ */
+export async function deactivateSkill(args: {
+  conversationId: string;
+}): Promise<DeactivateSkillResult> {
+  const { conversationId } = args;
+  try {
+    const existing = await db
+      .select({
+        id: conversations.id,
+        activeSkillId: conversations.activeSkillId,
+      })
+      .from(conversations)
+      .where(eq(conversations.id, conversationId))
+      .get();
+
+    if (!existing) {
+      return { kind: "error", message: `Conversation not found: ${conversationId}` };
+    }
+
+    await db
+      .update(conversations)
+      .set({ activeSkillId: null, activeSkillIds: [], updatedAt: new Date() })
+      .where(eq(conversations.id, conversationId));
+
+    return { kind: "ok", previousSkillId: existing.activeSkillId ?? null };
+  } catch (e) {
+    return {
+      kind: "error",
+      message: e instanceof Error ? e.message : "deactivate_skill failed",
+    };
+  }
+}

package/src/lib/chat/skill-conflict.ts

@@ -0,0 +1,105 @@
+/**
+ * Lightweight heuristic that flags when two SKILL.md bodies issue
+ * divergent directives on the same topic. Pure function — no I/O.
+ *
+ * Approach (v1):
+ *   1. For each skill, extract "directive lines" containing one of:
+ *      always | never | must | prefer | use | avoid | don't | do not
+ *   2. Tokenize each directive into content words (lowercase, drop
+ *      stopwords + the directive verb itself).
+ *   3. For each pair of directives across the two skills with significant
+ *      keyword overlap (≥2 shared content words ≥4 chars), check if their
+ *      directive verbs disagree (always vs never, prefer vs avoid, etc.).
+ *   4. Surface the disagreeing pair as a SkillConflict.
+ *
+ * False positives are acceptable — the consumer presents excerpts to the
+ * user, not a binary block. False negatives (semantic conflict without
+ * keyword overlap) await the embedding-based v2.
+ */
+
+export interface SkillMarkdown {
+  id: string;
+  name: string;
+  content: string;
+}
+
+export interface SkillConflict {
+  skillA: string;       // skill name
+  skillB: string;       // skill name
+  sharedTopic: string;  // joined keywords that overlapped
+  excerptA: string;     // the directive line from A
+  excerptB: string;     // the directive line from B
+}
+
+const POSITIVE_DIRECTIVES = new Set(["always", "must", "prefer", "use", "do"]);
+const NEGATIVE_DIRECTIVES = new Set(["never", "avoid", "don't", "dont", "skip"]);
+const ALL_DIRECTIVES = new Set([...POSITIVE_DIRECTIVES, ...NEGATIVE_DIRECTIVES]);
+
+const STOPWORDS = new Set([
+  "the", "a", "an", "and", "or", "but", "for", "with", "without",
+  "to", "of", "in", "on", "at", "by", "from", "as", "is", "are",
+  "be", "this", "that", "these", "those", "it", "its", "before",
+  "after", "during", "into", "out",
+]);
+
+interface DirectiveLine {
+  raw: string;
+  polarity: "positive" | "negative";
+  keywords: Set<string>;
+}
+
+function extractDirectives(content: string): DirectiveLine[] {
+  const lines = content.split(/\r?\n/);
+  const out: DirectiveLine[] = [];
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith("```")) continue;
+    const lower = line.toLowerCase();
+    let polarity: "positive" | "negative" | null = null;
+    for (const tok of lower.split(/\s+/)) {
+      const cleaned = tok.replace(/[^a-z']/g, "");
+      if (POSITIVE_DIRECTIVES.has(cleaned)) { polarity = "positive"; break; }
+      if (NEGATIVE_DIRECTIVES.has(cleaned)) { polarity = "negative"; break; }
+    }
+    if (!polarity) continue;
+    const keywords = new Set<string>();
+    for (const tok of lower.split(/[^a-z0-9]+/)) {
+      if (tok.length < 4) continue;
+      if (STOPWORDS.has(tok) || ALL_DIRECTIVES.has(tok)) continue;
+      keywords.add(tok);
+    }
+    if (keywords.size === 0) continue;
+    out.push({ raw: line, polarity, keywords });
+  }
+  return out;
+}
+
+function intersect(a: Set<string>, b: Set<string>): string[] {
+  const out: string[] = [];
+  for (const tok of a) if (b.has(tok)) out.push(tok);
+  return out;
+}
+
+export function detectSkillConflicts(
+  a: SkillMarkdown,
+  b: SkillMarkdown
+): SkillConflict[] {
+  const directivesA = extractDirectives(a.content);
+  const directivesB = extractDirectives(b.content);
+  const conflicts: SkillConflict[] = [];
+  for (const da of directivesA) {
+    for (const db of directivesB) {
+      if (da.polarity === db.polarity) continue;
+      const shared = intersect(da.keywords, db.keywords);
+      if (shared.length < 2) continue;
+      conflicts.push({
+        skillA: a.name,
+        skillB: b.name,
+        sharedTopic: shared.slice(0, 3).join(", "),
+        excerptA: da.raw,
+        excerptB: db.raw,
+      });
+    }
+  }
+  return conflicts;
+}

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

@@ -21,6 +21,9 @@ 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";
+import { blueprintTools } from "./tools/blueprint-tools";
+import { skillTools } from "./tools/skill-tools";
+
 
 // ── Tool server types ────────────────────────────────────────────────
 
@@ -56,6 +59,8 @@ function collectAllTools(ctx: ToolContext): ToolDefinition[] {
     ...handoffTools(ctx),
     ...tableTools(ctx),
     ...runtimeTools(ctx),
+    ...blueprintTools(ctx),
+    ...skillTools(ctx),
   ];
 }
 
@@ -70,8 +75,9 @@ function collectAllTools(ctx: ToolContext): ToolDefinition[] {
 export function createToolServer(
   projectId?: string | null,
   onToolResult?: (toolName: string, result: unknown) => void,
+  projectDir?: string | null,
 ): ToolServer {
-  const ctx: ToolContext = { projectId, onToolResult };
+  const ctx: ToolContext = { projectId, projectDir, onToolResult };
   const allTools = collectAllTools(ctx);
 
   // Handler lookup map (built once, shared across modes)
@@ -113,21 +119,3 @@ export function createToolServer(
   };
 }
 
-// ── Backward-compatible export ───────────────────────────────────────
-
-/**
- * Create an in-process MCP server exposing all Stagent tools.
- * The `projectId` closure auto-scopes operations to the active project.
- * `onToolResult` is called after each successful CRUD operation with the
- * tool name and returned entity data — used by the entity detector to
- * generate deterministic Quick Access navigation links.
- *
- * @deprecated Use `createToolServer()` for new code. This wrapper exists
- *   for backward compatibility with the chat engine.
- */
-export function createStagentMcpServer(
-  projectId?: string | null,
-  onToolResult?: (toolName: string, result: unknown) => void,
-) {
-  return createToolServer(projectId, onToolResult).asMcpServer();
-}

package/src/lib/chat/stream-telemetry.ts

@@ -0,0 +1,137 @@
+/**
+ * Chat stream termination telemetry.
+ *
+ * Lightweight, in-memory ring buffer that records how SSE chat streams
+ * terminate. Added in response to a sibling-repo bug report claiming
+ * conversations refresh mid-stream — the proposed root cause (Next.js dev
+ * HMR remounting ChatShell) is already mitigated in this repo, so rather
+ * than port a speculative fix, we instrument the termination boundaries
+ * and let real data decide whether a resume protocol is worth building.
+ *
+ * Six server-side reason codes:
+ *   - stream.completed        — normal end-of-generator (success path)
+ *   - stream.aborted.signal   — req.signal fired, engine catch block entered
+ *   - stream.aborted.client   — ReadableStream cancel callback fired
+ *   - stream.finalized.error  — non-abort exception in engine catch block
+ *   - stream.abandoned        — generator return() called by consumer
+ *                               (finally ran but catch was skipped). Covers
+ *                               iterator abandonment — the case where the
+ *                               route's for-await breaks out gracefully and
+ *                               the engine's own happy/catch paths are both
+ *                               bypassed. Recorded from finalizeStreamingMessage
+ *                               when it actually performs a salvage update.
+ *   - stream.reconciled.stale — reconcileStreamingMessages swept an orphan
+ *                               at chat page load (10-min cutoff)
+ *
+ * Four client-side reason codes (logged via console.info with a stable
+ * prefix so tests and grep can find them):
+ *   - client.stream.done          — reader.read() returned done: true
+ *   - client.stream.user-abort    — user clicked Stop / AbortController fired
+ *   - client.stream.reader-error  — reader.read() or decode threw
+ *   - client.stream.view-remount  — a chat-consuming component unmounted
+ *                                    while a stream was in flight. The stream
+ *                                    itself continues in the provider; this
+ *                                    code exists so diagnostics can confirm
+ *                                    the provider-hoisting fix is holding.
+ *
+ * As of the `chat-session-persistence-provider` feature, the SSE reader
+ * loop runs inside `ChatSessionProvider` (rendered from the root layout),
+ * not inside the route-scoped `ChatShell`. Sidebar navigation no longer
+ * tears down the reader loop, so "client.stream.user-abort" should only
+ * fire when the user explicitly clicks Stop. If it starts firing on plain
+ * view switches again, something has regressed the provider hoisting.
+ * HMR in dev can still reset the provider module — that is expected.
+ *
+ * Read via the dev-only `GET /api/diagnostics/chat-streams` endpoint.
+ * The buffer is process-local — a server restart clears it, which is fine
+ * for dev diagnostics and avoids adding a persistence layer that would
+ * itself need testing.
+ */
+
+export type TerminationReason =
+  | "stream.completed"
+  | "stream.aborted.signal"
+  | "stream.aborted.client"
+  | "stream.finalized.error"
+  | "stream.abandoned"
+  | "stream.reconciled.stale";
+
+export interface TerminationEvent {
+  reason: TerminationReason;
+  conversationId: string | null;
+  messageId: string | null;
+  durationMs: number | null;
+  error?: string;
+  timestamp: number;
+}
+
+/** Ring buffer capacity — ~500 events is ~50KB, negligible for a dev tool. */
+const CAPACITY = 500;
+
+/**
+ * Module-level circular buffer. Newer events overwrite older ones once
+ * capacity is reached. Writes are O(1), reads copy-out in order.
+ *
+ * Next.js dev HMR may re-import this module and reset the buffer — that
+ * is expected behavior and not a bug. The buffer is intentionally not
+ * persisted; its purpose is "what happened in the last N minutes of this
+ * process", not forensic logging.
+ */
+const buffer: TerminationEvent[] = new Array(CAPACITY);
+let writeIndex = 0;
+let writeCount = 0;
+
+export function recordTermination(event: Omit<TerminationEvent, "timestamp">): void {
+  const full: TerminationEvent = { ...event, timestamp: Date.now() };
+  buffer[writeIndex] = full;
+  writeIndex = (writeIndex + 1) % CAPACITY;
+  writeCount++;
+}
+
+/**
+ * Return all recorded events in chronological order (oldest → newest).
+ * Copies out of the ring buffer so callers can't mutate internal state.
+ */
+export function readTerminations(): TerminationEvent[] {
+  const count = Math.min(writeCount, CAPACITY);
+  if (count === 0) return [];
+  const result: TerminationEvent[] = new Array(count);
+  // Start at the oldest slot. When the buffer is full, the oldest is at
+  // writeIndex (the next slot to be overwritten). When not full, it's at 0.
+  const start = writeCount > CAPACITY ? writeIndex : 0;
+  for (let i = 0; i < count; i++) {
+    result[i] = buffer[(start + i) % CAPACITY]!;
+  }
+  return result;
+}
+
+/**
+ * Aggregate event counts by reason code for the last `windowMs` milliseconds.
+ * Pass 0 or omit to get counts across the entire buffer.
+ */
+export function countTerminations(windowMs = 0): Record<TerminationReason, number> {
+  const counts: Record<TerminationReason, number> = {
+    "stream.completed": 0,
+    "stream.aborted.signal": 0,
+    "stream.aborted.client": 0,
+    "stream.finalized.error": 0,
+    "stream.abandoned": 0,
+    "stream.reconciled.stale": 0,
+  };
+  const cutoff = windowMs > 0 ? Date.now() - windowMs : 0;
+  for (const event of readTerminations()) {
+    if (event.timestamp >= cutoff) {
+      counts[event.reason]++;
+    }
+  }
+  return counts;
+}
+
+/**
+ * Reset the buffer. Intended for tests — do not call in production code.
+ */
+export function __resetForTesting(): void {
+  for (let i = 0; i < CAPACITY; i++) buffer[i] = undefined as never;
+  writeIndex = 0;
+  writeCount = 0;
+}

package/src/lib/chat/suggested-prompts.ts

@@ -1,5 +1,5 @@
 import { db } from "@/lib/db";
-import { projects, tasks, workflows, schedules } from "@/lib/db/schema";
+import { projects, tasks, schedules, userTables } from "@/lib/db/schema";
 import { eq, desc } from "drizzle-orm";
 import type { PromptCategory, SuggestedPrompt } from "./types";
 
@@ -40,6 +40,25 @@ async function buildExplorePrompts(): Promise<SuggestedPrompt[]> {
     });
   }
 
+  // Context-sensitive suggestion: if any user tables exist, surface an
+  // enrichment prompt for the most recently updated one. Users commonly have
+  // tables with empty cells waiting to be enriched; even without a column-level
+  // scan, pointing the chat LLM at enrich_table makes the bulk-row fan-out
+  // capability discoverable via suggested prompts rather than only via direct
+  // intent.
+  const recentTable = await db
+    .select({ id: userTables.id, name: userTables.name })
+    .from(userTables)
+    .orderBy(desc(userTables.updatedAt))
+    .limit(1);
+
+  if (recentTable.length > 0) {
+    prompts.push({
+      label: `Enrich "${truncate(recentTable[0].name, 28)}" rows`,
+      prompt: `I'd like to enrich rows in the "${recentTable[0].name}" table (id: ${recentTable[0].id}) using an agent. Ask me which column is missing data, what prompt template to use (reference row fields naturally), and which agent profile is best. Then use enrich_table to kick off the loop workflow.`,
+    });
+  }
+
   // Fill with static fallbacks
   const fallbacks: SuggestedPrompt[] = [
     {
@@ -76,6 +95,14 @@ function buildCreatePrompts(): SuggestedPrompt[] {
       label: "Set up a multi-step workflow",
       prompt: "Help me design a multi-step workflow. I want to define a sequence of tasks with dependencies. Ask me what the workflow should accomplish and suggest a structure.",
     },
+    {
+      label: "Design a drip sequence",
+      prompt: "Help me build a drip workflow with delay steps between sends. Ask me about the cadence (e.g. 3 days between touches), the number of touches, and the content goal for each step. Then use create_workflow with a sequence pattern, interleaving task steps and delay steps (delayDuration format: Nm|Nh|Nd|Nw, bounds 1m..30d). Do not create separate workflows or schedules — a single workflow with inline delay steps is the idiomatic pattern.",
+    },
+    {
+      label: "Enrich a table with an agent",
+      prompt: "I have a table with missing data that I want an agent to fill in. Help me use enrich_table to fan out rows to the agent. Ask me which table, which column is missing, what prompt template to use (the row is available as JSON context — tell the agent to read the relevant fields and return just the value, or NOT_FOUND if none can be determined), and which agent profile is best (sales-researcher, content-creator, data-analyst, etc.). Do not hand-roll a loop workflow — enrich_table already handles the loop, row binding, postAction writeback, and idempotent skip.",
+    },
     {
       label: "Draft a document outline",
       prompt: "Help me create a structured document outline. Ask me about the topic, audience, and purpose, then suggest sections and key points to cover.",