stagent 0.1.11 → 0.1.12

package/src/components/shared/light-markdown.tsx

@@ -0,0 +1,134 @@
+import { type ReactNode } from "react";
+
+interface LightMarkdownProps {
+  content: string;
+  className?: string;
+  maxHeight?: string;
+  lineClamp?: number;
+  textSize?: "xs" | "sm";
+  stripBracketTags?: boolean;
+}
+
+/**
+ * Lightweight markdown renderer for short agent output.
+ * Handles: headers, bullet lists, paragraphs, **bold**, `code`.
+ * For full markdown (tables, code fences, GFM), use ReactMarkdown instead.
+ */
+export function LightMarkdown({
+  content,
+  className = "",
+  maxHeight,
+  lineClamp,
+  textSize = "xs",
+  stripBracketTags = false,
+}: LightMarkdownProps) {
+  const sizeClass = textSize === "sm" ? "text-sm" : "text-xs";
+
+  const blocks = content.split(/\n{2,}/);
+
+  const rendered = blocks.map((block, i) => {
+    let text = block.trim();
+    if (!text) return null;
+
+    if (stripBracketTags) {
+      text = text.replace(/\s*\[.*?\]\s*/g, " ").trim();
+    }
+
+    // Header: ### Title
+    const headerMatch = text.match(/^(#{1,4})\s+(.+)/);
+    if (headerMatch) {
+      return (
+        <p key={i} className="font-semibold text-foreground">
+          {formatInline(headerMatch[2])}
+        </p>
+      );
+    }
+
+    // Bullet list: lines starting with - or *
+    const lines = text.split("\n");
+    const isList = lines.every(
+      (l) => /^\s*[-*]\s+/.test(l) || l.trim() === ""
+    );
+    if (isList && lines.some((l) => /^\s*[-*]\s+/.test(l))) {
+      return (
+        <ul key={i} className="list-disc pl-4 space-y-0.5 text-muted-foreground">
+          {lines
+            .filter((l) => /^\s*[-*]\s+/.test(l))
+            .map((l, j) => (
+              <li key={j}>{formatInline(l.replace(/^\s*[-*]\s+/, ""))}</li>
+            ))}
+        </ul>
+      );
+    }
+
+    // Paragraph
+    return (
+      <p key={i} className="leading-relaxed text-muted-foreground">
+        {formatInline(text)}
+      </p>
+    );
+  });
+
+  // Overflow / clamp styles
+  let containerClass = `${sizeClass} space-y-2 ${className}`;
+  const style: React.CSSProperties = {};
+
+  if (lineClamp) {
+    // Approximate: each "line" ~1.25rem at text-xs, ~1.5rem at text-sm
+    const lineHeight = textSize === "sm" ? 1.5 : 1.25;
+    style.maxHeight = `${lineClamp * lineHeight}rem`;
+    style.overflow = "hidden";
+  } else if (maxHeight) {
+    containerClass += ` ${maxHeight} overflow-auto`;
+  }
+
+  return (
+    <div className={containerClass} style={style}>
+      {rendered}
+    </div>
+  );
+}
+
+/** Format inline **bold** and `code` spans */
+function formatInline(text: string): ReactNode {
+  // Split on **bold** and `code` patterns
+  const parts: ReactNode[] = [];
+  const regex = /(\*\*(.+?)\*\*|`([^`]+)`)/g;
+  let lastIndex = 0;
+  let match: RegExpExecArray | null;
+
+  while ((match = regex.exec(text)) !== null) {
+    // Text before the match
+    if (match.index > lastIndex) {
+      parts.push(text.slice(lastIndex, match.index));
+    }
+
+    if (match[2]) {
+      // **bold**
+      parts.push(
+        <strong key={match.index} className="font-semibold text-foreground">
+          {match[2]}
+        </strong>
+      );
+    } else if (match[3]) {
+      // `code`
+      parts.push(
+        <code
+          key={match.index}
+          className="rounded bg-muted px-1 py-0.5 font-mono text-[0.85em]"
+        >
+          {match[3]}
+        </code>
+      );
+    }
+
+    lastIndex = match.index + match[0].length;
+  }
+
+  // Remaining text
+  if (lastIndex < text.length) {
+    parts.push(text.slice(lastIndex));
+  }
+
+  return parts.length === 1 ? parts[0] : parts;
+}

package/src/components/workflows/loop-status-view.tsx

@@ -3,6 +3,7 @@
 import { useState } from "react";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
+import { LightMarkdown } from "@/components/shared/light-markdown";
 import {
   CheckCircle,
   Circle,
@@ -233,10 +234,13 @@ export function LoopStatusView({
                         <p className="text-xs text-destructive">{iter.error}</p>
                       )}
                       {iter.result && (
-                        <p className="text-xs text-muted-foreground whitespace-pre-wrap line-clamp-6">
-                          {iter.result.slice(0, 1000)}
-                          {iter.result.length > 1000 ? "..." : ""}
-                        </p>
+                        <LightMarkdown
+                          content={
+                            iter.result.slice(0, 1000) +
+                            (iter.result.length > 1000 ? "..." : "")
+                          }
+                          lineClamp={6}
+                        />
                       )}
                       {iter.taskId && (
                         <a

package/src/components/workflows/workflow-status-view.tsx

@@ -25,6 +25,7 @@ import { toast } from "sonner";
 import { workflowStatusVariant, patternLabels } from "@/lib/constants/status-colors";
 import { LoopStatusView } from "./loop-status-view";
 import { ConfirmDialog } from "@/components/shared/confirm-dialog";
+import { LightMarkdown } from "@/components/shared/light-markdown";
 import { SwarmDashboard } from "./swarm-dashboard";
 import type { LoopState, LoopConfig, SwarmConfig } from "@/lib/workflows/types";
 
@@ -363,9 +364,11 @@ export function WorkflowStatusView({ workflowId }: WorkflowStatusViewProps) {
                                 </p>
                               )}
                               {step.state.result && step.state.status === "completed" && (
-                                <p className="mt-2 text-xs text-muted-foreground line-clamp-4">
-                                  {step.state.result.slice(0, 260)}
-                                </p>
+                                <LightMarkdown
+                                  content={step.state.result.slice(0, 500)}
+                                  lineClamp={4}
+                                  className="mt-2"
+                                />
                               )}
                             </div>
                           </div>
@@ -409,9 +412,11 @@ export function WorkflowStatusView({ workflowId }: WorkflowStatusViewProps) {
                             )}
                             {synthesisStep.state.result &&
                               synthesisStep.state.status === "completed" && (
-                                <p className="mt-2 text-xs text-muted-foreground line-clamp-4">
-                                  {synthesisStep.state.result.slice(0, 260)}
-                                </p>
+                                <LightMarkdown
+                                  content={synthesisStep.state.result.slice(0, 500)}
+                                  lineClamp={4}
+                                  className="mt-2"
+                                />
                               )}
                           </div>
                         </div>
@@ -448,9 +453,11 @@ export function WorkflowStatusView({ workflowId }: WorkflowStatusViewProps) {
                           </p>
                         )}
                         {step.state.result && step.state.status === "completed" && (
-                          <p className="text-xs text-muted-foreground mt-1 line-clamp-2">
-                            {step.state.result.slice(0, 200)}
-                          </p>
+                          <LightMarkdown
+                            content={step.state.result.slice(0, 500)}
+                            lineClamp={2}
+                            className="mt-1"
+                          />
                         )}
                       </div>
                     </div>

package/src/lib/agents/learned-context.ts

@@ -58,14 +58,24 @@ function getNextVersion(profileId: string): number {
 // Proposal flow
 // ---------------------------------------------------------------------------
 
-/** Insert a context proposal and create a notification for human review */
+/**
+ * Insert a context proposal and optionally create a notification for human review.
+ *
+ * When `options.silent` is true, the proposal row is created but no notification
+ * is generated. This is used by the learning session system to buffer proposals
+ * during workflow execution — a batch notification is created when the session closes.
+ *
+ * Returns the learned_context row ID (not the notification ID) so callers can
+ * reference the proposal regardless of whether a notification was created.
+ */
 export async function proposeContextAddition(
   profileId: string,
   taskId: string,
-  additions: string
+  additions: string,
+  options?: { silent?: boolean }
 ): Promise<string> {
   const version = getNextVersion(profileId);
-  const notificationId = crypto.randomUUID();
+  const notificationId = options?.silent ? null : crypto.randomUUID();
   const rowId = crypto.randomUUID();
   const now = new Date();
 
@@ -83,19 +93,21 @@ export async function proposeContextAddition(
     createdAt: now,
   });
 
-  // Create notification for human review
-  await db.insert(notifications).values({
-    id: notificationId,
-    taskId,
-    type: "context_proposal",
-    title: `Context proposal for ${profileId}`,
-    body: additions.slice(0, 500),
-    toolName: profileId,
-    toolInput: JSON.stringify({ profileId, additions, learnedContextId: rowId }),
-    createdAt: now,
-  });
+  // Create notification for human review (unless silent)
+  if (notificationId) {
+    await db.insert(notifications).values({
+      id: notificationId,
+      taskId,
+      type: "context_proposal",
+      title: `Context proposal for ${profileId}`,
+      body: additions.slice(0, 500),
+      toolName: profileId,
+      toolInput: JSON.stringify({ profileId, additions, learnedContextId: rowId }),
+      createdAt: now,
+    });
+  }
 
-  return notificationId;
+  return rowId;
 }
 
 // ---------------------------------------------------------------------------

package/src/lib/agents/learning-session.ts

@@ -0,0 +1,234 @@
+/**
+ * Learning Session — buffers context proposals during workflow execution.
+ *
+ * When a workflow starts, a session is opened. All context proposals generated
+ * by tasks within that workflow are buffered instead of creating individual
+ * notifications. When the workflow completes (or fails), the session is closed
+ * and a single batch notification is created for all buffered proposals.
+ */
+
+import { db } from "@/lib/db";
+import { learnedContext, notifications, tasks } from "@/lib/db/schema";
+import { eq, and } from "drizzle-orm";
+
+// ---------------------------------------------------------------------------
+// In-memory session registry
+// ---------------------------------------------------------------------------
+
+/**
+ * Active learning sessions, keyed by workflowId.
+ * Each session accumulates proposal IDs (learnedContext row IDs) until closed.
+ */
+const activeSessions = new Map<
+  string,
+  {
+    workflowId: string;
+    proposalIds: string[];
+    openedAt: Date;
+  }
+>();
+
+// ---------------------------------------------------------------------------
+// Session lifecycle
+// ---------------------------------------------------------------------------
+
+/**
+ * Open a learning session for a workflow. All proposals created during this
+ * session will be buffered instead of generating individual notifications.
+ */
+export function openLearningSession(workflowId: string): void {
+  activeSessions.set(workflowId, {
+    workflowId,
+    proposalIds: [],
+    openedAt: new Date(),
+  });
+}
+
+/**
+ * Check if a learning session is active for a workflow.
+ */
+export function hasLearningSession(workflowId: string): boolean {
+  return activeSessions.has(workflowId);
+}
+
+/**
+ * Get the active session for a workflow (or null if none).
+ */
+export function getLearningSession(workflowId: string) {
+  return activeSessions.get(workflowId) ?? null;
+}
+
+/**
+ * Buffer a proposal ID into the active session.
+ * Called by proposeContextAddition when it detects a workflow session.
+ */
+export function bufferProposal(
+  workflowId: string,
+  proposalRowId: string
+): void {
+  const session = activeSessions.get(workflowId);
+  if (session) {
+    session.proposalIds.push(proposalRowId);
+  }
+}
+
+/**
+ * Close the learning session and create a single batch notification
+ * for all buffered proposals. Returns the batch notification ID,
+ * or null if there were no proposals.
+ */
+export async function closeLearningSession(
+  workflowId: string
+): Promise<string | null> {
+  const session = activeSessions.get(workflowId);
+  activeSessions.delete(workflowId);
+
+  if (!session || session.proposalIds.length === 0) {
+    return null;
+  }
+
+  // Load all buffered proposal rows
+  const proposals = [];
+  for (const id of session.proposalIds) {
+    const [row] = db
+      .select()
+      .from(learnedContext)
+      .where(eq(learnedContext.id, id))
+      .all();
+    if (row) {
+      proposals.push(row);
+    }
+  }
+
+  if (proposals.length === 0) return null;
+
+  // Group by profile for the notification body
+  const byProfile = new Map<string, typeof proposals>();
+  for (const p of proposals) {
+    const group = byProfile.get(p.profileId) ?? [];
+    group.push(p);
+    byProfile.set(p.profileId, group);
+  }
+
+  // Build summary body
+  const bodyLines: string[] = [];
+  for (const [profileId, group] of byProfile) {
+    bodyLines.push(`**${profileId}** (${group.length} proposal${group.length > 1 ? "s" : ""}):`);
+    for (const p of group) {
+      const preview = (p.proposedAdditions ?? p.diff ?? "").slice(0, 150);
+      bodyLines.push(`  - ${preview}${preview.length >= 150 ? "..." : ""}`);
+    }
+  }
+
+  const notificationId = crypto.randomUUID();
+
+  await db.insert(notifications).values({
+    id: notificationId,
+    taskId: null,
+    type: "context_proposal_batch",
+    title: `Workflow learning: ${proposals.length} context proposal${proposals.length > 1 ? "s" : ""}`,
+    body: bodyLines.join("\n").slice(0, 1000),
+    toolName: "workflow-context-batch",
+    toolInput: JSON.stringify({
+      workflowId,
+      proposalIds: session.proposalIds,
+      profileIds: [...byProfile.keys()],
+    }),
+    createdAt: new Date(),
+  });
+
+  return notificationId;
+}
+
+// ---------------------------------------------------------------------------
+// Task → Workflow mapping
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the workflowId for a given task. Returns null if the task is
+ * not part of a workflow or the task doesn't exist.
+ */
+export function getTaskWorkflowId(taskId: string): string | null {
+  try {
+    const [row] = db
+      .select({ workflowId: tasks.workflowId })
+      .from(tasks)
+      .where(eq(tasks.id, taskId))
+      .all();
+
+    return row?.workflowId ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Batch operations
+// ---------------------------------------------------------------------------
+
+/**
+ * Approve all proposals in a batch by their IDs.
+ */
+export async function batchApproveProposals(
+  proposalRowIds: string[]
+): Promise<number> {
+  // Import inline to avoid circular dependency
+  const { approveProposal } = await import("./learned-context");
+
+  let approved = 0;
+  for (const rowId of proposalRowIds) {
+    const [row] = db
+      .select()
+      .from(learnedContext)
+      .where(
+        and(
+          eq(learnedContext.id, rowId),
+          eq(learnedContext.changeType, "proposal")
+        )
+      )
+      .all();
+
+    if (row?.proposalNotificationId) {
+      try {
+        await approveProposal(row.proposalNotificationId);
+        approved++;
+      } catch {
+        // Skip if already approved/rejected
+      }
+    }
+  }
+  return approved;
+}
+
+/**
+ * Reject all proposals in a batch by their IDs.
+ */
+export async function batchRejectProposals(
+  proposalRowIds: string[]
+): Promise<number> {
+  const { rejectProposal } = await import("./learned-context");
+
+  let rejected = 0;
+  for (const rowId of proposalRowIds) {
+    const [row] = db
+      .select()
+      .from(learnedContext)
+      .where(
+        and(
+          eq(learnedContext.id, rowId),
+          eq(learnedContext.changeType, "proposal")
+        )
+      )
+      .all();
+
+    if (row?.proposalNotificationId) {
+      try {
+        await rejectProposal(row.proposalNotificationId);
+        rejected++;
+      } catch {
+        // Skip if already approved/rejected
+      }
+    }
+  }
+  return rejected;
+}

package/src/lib/agents/pattern-extractor.ts

@@ -6,6 +6,11 @@ import {
   proposeContextAddition,
 } from "./learned-context";
 import { runMetaCompletion } from "./runtime/claude";
+import {
+  getTaskWorkflowId,
+  hasLearningSession,
+  bufferProposal,
+} from "./learning-session";
 
 export interface PatternEntry {
   title: string;
@@ -97,5 +102,19 @@ Extract ONLY genuinely useful patterns — things that would help this profile a
     )
     .join("\n\n");
 
+  // Check if this task is part of a workflow with an active learning session.
+  // If so, buffer the proposal instead of creating an individual notification.
+  const workflowId = getTaskWorkflowId(taskId);
+  if (workflowId && hasLearningSession(workflowId)) {
+    const rowId = await proposeContextAddition(
+      profileId,
+      taskId,
+      formattedAdditions,
+      { silent: true }
+    );
+    bufferProposal(workflowId, rowId);
+    return rowId;
+  }
+
   return proposeContextAddition(profileId, taskId, formattedAdditions);
 }

package/src/lib/agents/profiles/__tests__/sort.test.ts

@@ -0,0 +1,42 @@
+import type { AgentProfile } from "../types";
+
+import { sortProfilesByName } from "../sort";
+
+function makeProfile(id: string, name: string): AgentProfile {
+  return {
+    id,
+    name,
+    description: `${name} description`,
+    domain: "work",
+    tags: [],
+    systemPrompt: "",
+    skillMd: "",
+    allowedTools: [],
+    mcpServers: {},
+    canUseToolPolicy: false,
+    maxTurns: 20,
+    outputFormat: "text",
+    version: "1.0.0",
+    author: "test",
+    source: "test",
+    tests: [],
+    supportedRuntimes: ["claude-code"],
+    runtimeOverrides: {},
+  };
+}
+
+describe("sortProfilesByName", () => {
+  it("sorts profiles alphabetically so sweep remains discoverable", () => {
+    const sorted = sortProfilesByName([
+      makeProfile("sweep", "Sweep"),
+      makeProfile("general", "General"),
+      makeProfile("api-tester", "API Tester"),
+    ]);
+
+    expect(sorted.map((profile) => profile.id)).toEqual([
+      "api-tester",
+      "general",
+      "sweep",
+    ]);
+  });
+});

package/src/lib/agents/profiles/sort.ts

@@ -0,0 +1,7 @@
+export function sortProfilesByName<T extends { name: string }>(
+  profiles: T[]
+): T[] {
+  return [...profiles].sort((a, b) =>
+    a.name.localeCompare(b.name, undefined, { sensitivity: "base" })
+  );
+}

package/src/lib/constants/settings.ts

@@ -7,6 +7,7 @@ export const SETTINGS_KEYS = {
   PERMISSIONS_ALLOW: "permissions.allow",
   BUDGET_POLICY: "usage.budgetPolicy",
   BUDGET_WARNING_STATE: "usage.budgetWarningState",
+  PRICING_REGISTRY: "usage.pricingRegistry",
 } as const;
 
 export type AuthMethod = "api_key" | "oauth";

package/src/lib/db/schema.ts

@@ -88,6 +88,7 @@ export const notifications = sqliteTable(
         "agent_message",
         "budget_alert",
         "context_proposal",
+        "context_proposal_batch",
       ],
     }).notNull(),
     title: text("title").notNull(),
@@ -223,6 +224,8 @@ export const usageLedger = sqliteTable(
         "scheduled_firing",
         "task_assist",
         "profile_test",
+        "pattern_extraction",
+        "context_summarization",
       ],
     }).notNull(),
     runtimeId: text("runtime_id").notNull(),