stagent 0.1.0 → 0.1.1

package/src/lib/agents/__tests__/execution-manager.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  getExecution,
+  setExecution,
+  removeExecution,
+  getAllExecutions,
+} from "@/lib/agents/execution-manager";
+
+function makeExecution(taskId: string) {
+  return {
+    abortController: new AbortController(),
+    sessionId: `session-${taskId}`,
+    taskId,
+    startedAt: new Date(),
+  };
+}
+
+describe("execution-manager", () => {
+  beforeEach(() => {
+    // Clear all executions between tests
+    for (const key of getAllExecutions().keys()) {
+      removeExecution(key);
+    }
+  });
+
+  it("returns undefined for non-existent task", () => {
+    expect(getExecution("nonexistent")).toBeUndefined();
+  });
+
+  it("stores and retrieves an execution", () => {
+    const exec = makeExecution("task-1");
+    setExecution("task-1", exec);
+    expect(getExecution("task-1")).toBe(exec);
+  });
+
+  it("removes an execution", () => {
+    setExecution("task-1", makeExecution("task-1"));
+    removeExecution("task-1");
+    expect(getExecution("task-1")).toBeUndefined();
+  });
+
+  it("returns all executions", () => {
+    setExecution("task-1", makeExecution("task-1"));
+    setExecution("task-2", makeExecution("task-2"));
+    const all = getAllExecutions();
+    expect(all.size).toBe(2);
+    expect(all.has("task-1")).toBe(true);
+    expect(all.has("task-2")).toBe(true);
+  });
+
+  it("overwrites execution for same taskId", () => {
+    const exec1 = makeExecution("task-1");
+    const exec2 = makeExecution("task-1");
+    setExecution("task-1", exec1);
+    setExecution("task-1", exec2);
+    expect(getExecution("task-1")).toBe(exec2);
+    expect(getAllExecutions().size).toBe(1);
+  });
+
+  it("removing non-existent task does not throw", () => {
+    expect(() => removeExecution("nonexistent")).not.toThrow();
+  });
+});

package/src/lib/agents/__tests__/router.test.ts

@@ -0,0 +1,61 @@
+import { describe, it, expect, vi } from "vitest";
+import { executeTaskWithAgent, resumeTaskWithAgent } from "@/lib/agents/router";
+
+const throwIfUnknownRuntime = (agentType?: string | null) => {
+  if (agentType === "unknown-agent") {
+    throw new Error("Unknown agent type: unknown-agent");
+  }
+};
+
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: vi.fn().mockImplementation(
+    async (_taskId: string, agentType?: string | null) => {
+      throwIfUnknownRuntime(agentType);
+    }
+  ),
+  resumeTaskWithRuntime: vi.fn().mockImplementation(
+    async (_taskId: string, agentType?: string | null) => {
+      throwIfUnknownRuntime(agentType);
+    }
+  ),
+}));
+
+describe("executeTaskWithAgent", () => {
+  it("delegates to the runtime registry for claude-code agent", async () => {
+    const { executeTaskWithRuntime } = await import("@/lib/agents/runtime");
+    await executeTaskWithAgent("task-1", "claude-code");
+    expect(executeTaskWithRuntime).toHaveBeenCalledWith("task-1", "claude-code");
+  });
+
+  it("defaults to claude-code when no agent type specified", async () => {
+    const { executeTaskWithRuntime } = await import("@/lib/agents/runtime");
+    await executeTaskWithAgent("task-2");
+    expect(executeTaskWithRuntime).toHaveBeenCalledWith("task-2", "claude-code");
+  });
+
+  it("throws for unknown agent type", async () => {
+    await expect(
+      executeTaskWithAgent("task-1", "unknown-agent")
+    ).rejects.toThrow("Unknown agent type: unknown-agent");
+  });
+});
+
+describe("resumeTaskWithAgent", () => {
+  it("delegates to the runtime registry for claude-code agent", async () => {
+    const { resumeTaskWithRuntime } = await import("@/lib/agents/runtime");
+    await resumeTaskWithAgent("task-1", "claude-code");
+    expect(resumeTaskWithRuntime).toHaveBeenCalledWith("task-1", "claude-code");
+  });
+
+  it("defaults to claude-code when no agent type specified", async () => {
+    const { resumeTaskWithRuntime } = await import("@/lib/agents/runtime");
+    await resumeTaskWithAgent("task-2");
+    expect(resumeTaskWithRuntime).toHaveBeenCalledWith("task-2", "claude-code");
+  });
+
+  it("throws for unknown agent type", async () => {
+    await expect(
+      resumeTaskWithAgent("task-1", "unknown-agent")
+    ).rejects.toThrow("Unknown agent type: unknown-agent");
+  });
+});

package/src/lib/agents/claude-agent.ts

@@ -15,6 +15,9 @@ import { getProfile } from "./profiles/registry";
 import { resolveProfileRuntimePayload } from "./profiles/compatibility";
 import type { CanUseToolPolicy } from "./profiles/types";
 import { buildClaudeSdkEnv } from "./runtime/claude-sdk";
+import { getActiveLearnedContext } from "./learned-context";
+import { analyzeForLearnedPatterns } from "./pattern-extractor";
+import { processSweepResult } from "./sweep";
 import {
   extractUsageSnapshot,
   mergeUsageSnapshot,
@@ -319,6 +322,13 @@ async function processAgentStream(
         });
       }
 
+      // Fire-and-forget sweep result processing
+      if (agentProfileId === "sweep") {
+        processSweepResult(taskId).catch((err) => {
+          console.error("[sweep] result processing failed:", err);
+        });
+      }
+
       await finalizeTaskUsage(usageState, "completed");
     }
   }
@@ -354,6 +364,7 @@ export async function executeClaudeTask(taskId: string): Promise<void> {
   const usageState = createTaskUsageState(task);
 
   const abortController = new AbortController();
+  const agentProfileId = task.agentProfile ?? "general";
 
   setExecution(taskId, {
     abortController,
@@ -364,7 +375,7 @@ export async function executeClaudeTask(taskId: string): Promise<void> {
 
   try {
     await prepareTaskOutputDirectory(taskId, { clearExisting: true });
-    const profile = getProfile(task.agentProfile ?? "general");
+    const profile = getProfile(agentProfileId);
     const payload = profile
       ? resolveProfileRuntimePayload(profile, "claude-code")
       : null;
@@ -375,7 +386,11 @@ export async function executeClaudeTask(taskId: string): Promise<void> {
     const basePrompt = task.description || task.title;
     const docContext = await buildDocumentContext(taskId);
     const outputInstructions = buildTaskOutputInstructions(taskId);
-    const prompt = [systemPrompt, docContext, outputInstructions, basePrompt]
+    const learnedCtx = getActiveLearnedContext(agentProfileId);
+    const learnedCtxBlock = learnedCtx
+      ? `## Learned Context\nPatterns and insights learned from previous tasks:\n\n${learnedCtx}`
+      : "";
+    const prompt = [systemPrompt, learnedCtxBlock, docContext, outputInstructions, basePrompt]
       .filter(Boolean)
       .join("\n\n");
 
@@ -420,16 +435,21 @@ export async function executeClaudeTask(taskId: string): Promise<void> {
       task.title,
       response as AsyncIterable<Record<string, unknown>>,
       abortController,
-      task.agentProfile ?? "general",
+      agentProfileId,
       usageState
     );
+
+    // Fire-and-forget pattern extraction for self-improvement
+    analyzeForLearnedPatterns(taskId, agentProfileId).catch((err) => {
+      console.error("[self-improvement] pattern extraction failed:", err);
+    });
   } catch (error: unknown) {
     await handleExecutionError(
       taskId,
       task.title,
       error,
       abortController,
-      task.agentProfile ?? "general",
+      agentProfileId,
       usageState
     );
   } finally {
@@ -494,7 +514,11 @@ export async function resumeClaudeTask(taskId: string): Promise<void> {
     const basePrompt = task.description || task.title;
     const docContext = await buildDocumentContext(taskId);
     const outputInstructions = buildTaskOutputInstructions(taskId);
-    const prompt = [systemPrompt, docContext, outputInstructions, basePrompt]
+    const learnedCtx = getActiveLearnedContext(profileId);
+    const learnedCtxBlock = learnedCtx
+      ? `## Learned Context\nPatterns and insights learned from previous tasks:\n\n${learnedCtx}`
+      : "";
+    const prompt = [systemPrompt, learnedCtxBlock, docContext, outputInstructions, basePrompt]
       .filter(Boolean)
       .join("\n\n");
 
@@ -543,6 +567,11 @@ export async function resumeClaudeTask(taskId: string): Promise<void> {
       profileId,
       usageState
     );
+
+    // Fire-and-forget pattern extraction for self-improvement
+    analyzeForLearnedPatterns(taskId, profileId).catch((err) => {
+      console.error("[self-improvement] pattern extraction failed:", err);
+    });
   } catch (error: unknown) {
     const errorMessage =
       error instanceof Error ? error.message : String(error);

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

@@ -0,0 +1,322 @@
+import { db } from "@/lib/db";
+import { learnedContext, notifications } from "@/lib/db/schema";
+import { and, desc, eq } from "drizzle-orm";
+import type { LearnedContextRow } from "@/lib/db/schema";
+import Anthropic from "@anthropic-ai/sdk";
+
+const CONTEXT_CHAR_LIMIT = 8_000;
+const SUMMARIZATION_THRESHOLD = 6_000;
+
+// ---------------------------------------------------------------------------
+// Read helpers
+// ---------------------------------------------------------------------------
+
+/** Get the latest approved context for a profile (returns content string or null) */
+export function getActiveLearnedContext(profileId: string): string | null {
+  const [row] = db
+    .select({ content: learnedContext.content })
+    .from(learnedContext)
+    .where(
+      and(
+        eq(learnedContext.profileId, profileId),
+        eq(learnedContext.changeType, "approved")
+      )
+    )
+    .orderBy(desc(learnedContext.version))
+    .limit(1)
+    .all();
+
+  return row?.content ?? null;
+}
+
+/** Get full version history for a profile */
+export async function getContextHistory(
+  profileId: string
+): Promise<LearnedContextRow[]> {
+  return db
+    .select()
+    .from(learnedContext)
+    .where(eq(learnedContext.profileId, profileId))
+    .orderBy(desc(learnedContext.version))
+    .all();
+}
+
+/** Get the next version number for a profile */
+function getNextVersion(profileId: string): number {
+  const [row] = db
+    .select({ version: learnedContext.version })
+    .from(learnedContext)
+    .where(eq(learnedContext.profileId, profileId))
+    .orderBy(desc(learnedContext.version))
+    .limit(1)
+    .all();
+
+  return (row?.version ?? 0) + 1;
+}
+
+// ---------------------------------------------------------------------------
+// Proposal flow
+// ---------------------------------------------------------------------------
+
+/** Insert a context proposal and create a notification for human review */
+export async function proposeContextAddition(
+  profileId: string,
+  taskId: string,
+  additions: string
+): Promise<string> {
+  const version = getNextVersion(profileId);
+  const notificationId = crypto.randomUUID();
+  const rowId = crypto.randomUUID();
+  const now = new Date();
+
+  // Insert proposal row
+  await db.insert(learnedContext).values({
+    id: rowId,
+    profileId,
+    version,
+    content: null, // not yet approved
+    diff: additions,
+    changeType: "proposal",
+    sourceTaskId: taskId,
+    proposalNotificationId: notificationId,
+    proposedAdditions: additions,
+    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,
+  });
+
+  return notificationId;
+}
+
+// ---------------------------------------------------------------------------
+// Approval / Rejection / Rollback
+// ---------------------------------------------------------------------------
+
+/** Approve a proposal — merges additions into current context, creates approved version */
+export async function approveProposal(
+  notificationId: string,
+  editedContent?: string
+): Promise<void> {
+  // Find the proposal row by notification ID
+  const [proposal] = db
+    .select()
+    .from(learnedContext)
+    .where(eq(learnedContext.proposalNotificationId, notificationId))
+    .all();
+
+  if (!proposal) throw new Error("Proposal not found");
+
+  const currentContent = getActiveLearnedContext(proposal.profileId) ?? "";
+  const additions = editedContent ?? proposal.proposedAdditions ?? "";
+  const mergedContent = currentContent
+    ? `${currentContent}\n\n${additions}`
+    : additions;
+
+  const version = getNextVersion(proposal.profileId);
+
+  await db.insert(learnedContext).values({
+    id: crypto.randomUUID(),
+    profileId: proposal.profileId,
+    version,
+    content: mergedContent,
+    diff: additions,
+    changeType: "approved",
+    sourceTaskId: proposal.sourceTaskId,
+    proposalNotificationId: notificationId,
+    proposedAdditions: additions,
+    approvedBy: "human",
+    createdAt: new Date(),
+  });
+
+  // Mark notification as responded
+  await db
+    .update(notifications)
+    .set({
+      response: JSON.stringify({ action: "approved" }),
+      respondedAt: new Date(),
+    })
+    .where(eq(notifications.id, notificationId));
+
+  // Check if we need to auto-summarize
+  const sizeInfo = checkContextSize(proposal.profileId);
+  if (sizeInfo.needsSummarization) {
+    await summarizeContext(proposal.profileId);
+  }
+}
+
+/** Reject a proposal */
+export async function rejectProposal(notificationId: string): Promise<void> {
+  const [proposal] = db
+    .select()
+    .from(learnedContext)
+    .where(eq(learnedContext.proposalNotificationId, notificationId))
+    .all();
+
+  if (!proposal) throw new Error("Proposal not found");
+
+  const version = getNextVersion(proposal.profileId);
+
+  await db.insert(learnedContext).values({
+    id: crypto.randomUUID(),
+    profileId: proposal.profileId,
+    version,
+    content: getActiveLearnedContext(proposal.profileId),
+    diff: proposal.proposedAdditions,
+    changeType: "rejected",
+    sourceTaskId: proposal.sourceTaskId,
+    proposalNotificationId: notificationId,
+    proposedAdditions: proposal.proposedAdditions,
+    createdAt: new Date(),
+  });
+
+  // Mark notification as responded
+  await db
+    .update(notifications)
+    .set({
+      response: JSON.stringify({ action: "rejected" }),
+      respondedAt: new Date(),
+    })
+    .where(eq(notifications.id, notificationId));
+}
+
+/** Rollback to a specific version — creates a new version with that version's content */
+export async function rollbackToVersion(
+  profileId: string,
+  targetVersion: number
+): Promise<void> {
+  const [target] = db
+    .select()
+    .from(learnedContext)
+    .where(
+      and(
+        eq(learnedContext.profileId, profileId),
+        eq(learnedContext.version, targetVersion)
+      )
+    )
+    .all();
+
+  if (!target) throw new Error(`Version ${targetVersion} not found`);
+
+  const version = getNextVersion(profileId);
+
+  await db.insert(learnedContext).values({
+    id: crypto.randomUUID(),
+    profileId,
+    version,
+    content: target.content,
+    diff: `Rolled back to version ${targetVersion}`,
+    changeType: "rollback",
+    createdAt: new Date(),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Context size management
+// ---------------------------------------------------------------------------
+
+export function checkContextSize(profileId: string): {
+  currentSize: number;
+  limit: number;
+  needsSummarization: boolean;
+} {
+  const content = getActiveLearnedContext(profileId);
+  const currentSize = content?.length ?? 0;
+  return {
+    currentSize,
+    limit: CONTEXT_CHAR_LIMIT,
+    needsSummarization: currentSize > SUMMARIZATION_THRESHOLD,
+  };
+}
+
+/** Auto-condense context via LLM when it grows too large */
+export async function summarizeContext(profileId: string): Promise<void> {
+  const content = getActiveLearnedContext(profileId);
+  if (!content || content.length <= SUMMARIZATION_THRESHOLD) return;
+
+  const client = new Anthropic();
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 2048,
+    messages: [
+      {
+        role: "user",
+        content: `You are condensing learned context for an AI agent profile "${profileId}".
+The current context has grown to ${content.length} characters and needs to be summarized to under ${SUMMARIZATION_THRESHOLD} characters while preserving all key patterns, best practices, and important insights.
+
+Current learned context:
+---
+${content}
+---
+
+Produce a condensed version that:
+1. Preserves all actionable patterns and best practices
+2. Merges related patterns into combined entries
+3. Removes redundant or superseded information
+4. Keeps the same format (bullet points or sections)
+5. Stays under ${SUMMARIZATION_THRESHOLD} characters
+
+Output ONLY the condensed context, no preamble.`,
+      },
+    ],
+  });
+
+  const summarized =
+    response.content[0].type === "text" ? response.content[0].text : "";
+
+  if (!summarized || summarized.length >= content.length) return;
+
+  const version = getNextVersion(profileId);
+
+  await db.insert(learnedContext).values({
+    id: crypto.randomUUID(),
+    profileId,
+    version,
+    content: summarized,
+    diff: `Summarized from ${content.length} to ${summarized.length} chars`,
+    changeType: "summarization",
+    createdAt: new Date(),
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Manual addition (direct approve, no LLM extraction)
+// ---------------------------------------------------------------------------
+
+/** Add context directly without going through the proposal flow */
+export async function addDirectContext(
+  profileId: string,
+  additions: string
+): Promise<void> {
+  const currentContent = getActiveLearnedContext(profileId) ?? "";
+  const mergedContent = currentContent
+    ? `${currentContent}\n\n${additions}`
+    : additions;
+
+  const version = getNextVersion(profileId);
+
+  await db.insert(learnedContext).values({
+    id: crypto.randomUUID(),
+    profileId,
+    version,
+    content: mergedContent,
+    diff: additions,
+    changeType: "approved",
+    approvedBy: "human",
+    createdAt: new Date(),
+  });
+
+  const sizeInfo = checkContextSize(profileId);
+  if (sizeInfo.needsSummarization) {
+    await summarizeContext(profileId);
+  }
+}

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

@@ -0,0 +1,150 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { db } from "@/lib/db";
+import { tasks, agentLogs } from "@/lib/db/schema";
+import { eq, desc } from "drizzle-orm";
+import {
+  getActiveLearnedContext,
+  proposeContextAddition,
+} from "./learned-context";
+
+export interface PatternEntry {
+  title: string;
+  description: string;
+  category: "error_resolution" | "best_practice" | "shortcut" | "preference";
+}
+
+export interface PatternProposal {
+  patterns: PatternEntry[];
+}
+
+const PATTERN_TOOL: Anthropic.Messages.Tool = {
+  name: "propose_learned_patterns",
+  description:
+    "Propose patterns learned from this task execution that should be remembered for future tasks with this profile.",
+  input_schema: {
+    type: "object" as const,
+    properties: {
+      patterns: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            title: {
+              type: "string",
+              description: "Short pattern name (2-6 words)",
+            },
+            description: {
+              type: "string",
+              description:
+                "Concise description of the pattern or lesson (1-2 sentences)",
+            },
+            category: {
+              type: "string",
+              enum: [
+                "error_resolution",
+                "best_practice",
+                "shortcut",
+                "preference",
+              ],
+            },
+          },
+          required: ["title", "description", "category"],
+        },
+        description:
+          "Patterns worth remembering. Return empty array if nothing notable.",
+      },
+    },
+    required: ["patterns"],
+  },
+};
+
+/**
+ * Analyze a completed task for patterns worth learning.
+ * Makes a focused Claude API call, then proposes additions if patterns found.
+ * Returns the notification ID if a proposal was created, null otherwise.
+ */
+export async function analyzeForLearnedPatterns(
+  taskId: string,
+  profileId: string
+): Promise<string | null> {
+  // Gather task data
+  const [task] = await db
+    .select({
+      title: tasks.title,
+      description: tasks.description,
+      result: tasks.result,
+    })
+    .from(tasks)
+    .where(eq(tasks.id, taskId));
+
+  if (!task) return null;
+
+  // Get recent agent logs for this task (last 20)
+  const logs = await db
+    .select({ event: agentLogs.event, payload: agentLogs.payload })
+    .from(agentLogs)
+    .where(eq(agentLogs.taskId, taskId))
+    .orderBy(desc(agentLogs.timestamp))
+    .limit(20);
+
+  const currentContext = getActiveLearnedContext(profileId);
+
+  // Build a compact representation of logs
+  const logSummary = logs
+    .map((log) => {
+      const payload = log.payload
+        ? JSON.stringify(JSON.parse(log.payload)).slice(0, 200)
+        : "";
+      return `[${log.event}] ${payload}`;
+    })
+    .join("\n");
+
+  const client = new Anthropic();
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 1024,
+    tools: [PATTERN_TOOL],
+    tool_choice: { type: "tool", name: "propose_learned_patterns" },
+    messages: [
+      {
+        role: "user",
+        content: `Analyze this completed task for patterns worth learning for the "${profileId}" agent profile.
+
+## Task
+Title: ${task.title}
+Description: ${(task.description ?? "").slice(0, 500)}
+
+## Result (truncated)
+${(task.result ?? "No result").slice(0, 1500)}
+
+## Recent Agent Logs
+${logSummary.slice(0, 2000)}
+
+## Currently Learned Context
+${currentContext ?? "(none yet)"}
+
+Extract ONLY genuinely useful patterns — things that would help this profile avoid mistakes or work more efficiently on similar future tasks. If this task was routine with nothing notable, return an empty patterns array. Do NOT repeat patterns already in the learned context.`,
+      },
+    ],
+  });
+
+  // Extract the tool use result
+  const toolBlock = response.content.find(
+    (block) => block.type === "tool_use" && block.name === "propose_learned_patterns"
+  );
+
+  if (!toolBlock || toolBlock.type !== "tool_use") return null;
+
+  const proposal = toolBlock.input as PatternProposal;
+  if (!proposal.patterns || proposal.patterns.length === 0) return null;
+
+  // Format patterns as text for the proposal
+  const formattedAdditions = proposal.patterns
+    .map(
+      (p) =>
+        `### ${p.title} [${p.category}]\n${p.description}`
+    )
+    .join("\n\n");
+
+  return proposeContextAddition(profileId, taskId, formattedAdditions);
+}