stagent 0.1.9 → 0.1.11

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

@@ -2,7 +2,7 @@ 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";
+import { runMetaCompletion } from "./runtime/claude";
 
 const CONTEXT_CHAR_LIMIT = 8_000;
 const SUMMARIZATION_THRESHOLD = 6_000;
@@ -243,14 +243,8 @@ 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}".
+  const { text } = await runMetaCompletion({
+    prompt: `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:
@@ -266,12 +260,10 @@ Produce a condensed version that:
 5. Stays under ${SUMMARIZATION_THRESHOLD} characters
 
 Output ONLY the condensed context, no preamble.`,
-      },
-    ],
+    activityType: "context_summarization",
   });
 
-  const summarized =
-    response.content[0].type === "text" ? response.content[0].text : "";
+  const summarized = text.trim();
 
   if (!summarized || summarized.length >= content.length) return;
 

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

@@ -1,4 +1,3 @@
-import Anthropic from "@anthropic-ai/sdk";
 import { db } from "@/lib/db";
 import { tasks, agentLogs } from "@/lib/db/schema";
 import { eq, desc } from "drizzle-orm";
@@ -6,6 +5,7 @@ import {
   getActiveLearnedContext,
   proposeContextAddition,
 } from "./learned-context";
+import { runMetaCompletion } from "./runtime/claude";
 
 export interface PatternEntry {
   title: string;
@@ -17,50 +17,9 @@ 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.
+ * Routes through the Claude Agent SDK runtime (no direct Anthropic SDK usage).
  * Returns the notification ID if a proposal was created, null otherwise.
  */
 export async function analyzeForLearnedPatterns(
@@ -99,16 +58,13 @@ export async function analyzeForLearnedPatterns(
     })
     .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.
+  const { text } = await runMetaCompletion({
+    prompt: `Analyze this completed task for patterns worth learning for the "${profileId}" agent profile.
+
+Return ONLY a JSON array (no markdown, no code fences):
+[{"title": "...", "description": "...", "category": "error_resolution|best_practice|shortcut|preference"}]
+
+Return an empty array [] if no noteworthy patterns.
 
 ## Task
 Title: ${task.title}
@@ -124,22 +80,17 @@ ${logSummary.slice(0, 2000)}
 ${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.`,
-      },
-    ],
+    activityType: "pattern_extraction",
   });
 
-  // 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;
+  // Parse JSON array from response text
+  const jsonMatch = text.match(/\[[\s\S]*\]/);
+  const patterns: PatternEntry[] = jsonMatch ? JSON.parse(jsonMatch[0]) : [];
 
-  const proposal = toolBlock.input as PatternProposal;
-  if (!proposal.patterns || proposal.patterns.length === 0) return null;
+  if (patterns.length === 0) return null;
 
   // Format patterns as text for the proposal
-  const formattedAdditions = proposal.patterns
+  const formattedAdditions = patterns
     .map(
       (p) =>
         `### ${p.title} [${p.category}]\n${p.description}`

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

@@ -0,0 +1,67 @@
+import { describe, it, expect } from "vitest";
+import { suggestProfileForStep } from "../suggest";
+
+const ALL_PROFILES = [
+  "general",
+  "researcher",
+  "code-reviewer",
+  "document-writer",
+  "devops-engineer",
+  "data-analyst",
+];
+
+describe("suggestProfileForStep", () => {
+  it("suggests researcher for research-related tasks", () => {
+    expect(
+      suggestProfileForStep("Research API patterns", "Investigate best practices", ALL_PROFILES)
+    ).toBe("researcher");
+  });
+
+  it("suggests code-reviewer for review tasks", () => {
+    expect(
+      suggestProfileForStep("Security audit", "Review code for vulnerabilities", ALL_PROFILES)
+    ).toBe("code-reviewer");
+  });
+
+  it("suggests document-writer for writing tasks", () => {
+    expect(
+      suggestProfileForStep("Write documentation", "Document the API endpoints", ALL_PROFILES)
+    ).toBe("document-writer");
+  });
+
+  it("suggests devops-engineer for deployment tasks", () => {
+    expect(
+      suggestProfileForStep("Deploy to production", "Set up CI pipeline and infrastructure", ALL_PROFILES)
+    ).toBe("devops-engineer");
+  });
+
+  it("suggests data-analyst for data tasks", () => {
+    expect(
+      suggestProfileForStep("Analyze metrics", "Aggregate data and create statistics", ALL_PROFILES)
+    ).toBe("data-analyst");
+  });
+
+  it('returns "auto" when no keywords match', () => {
+    expect(
+      suggestProfileForStep("Fix the thing", "Make it work", ALL_PROFILES)
+    ).toBe("auto");
+  });
+
+  it("only suggests from available profiles", () => {
+    expect(
+      suggestProfileForStep("Research API patterns", "Investigate", ["general"])
+    ).toBe("auto");
+  });
+
+  it("picks highest-scoring profile when multiple match", () => {
+    // "review" + "security" + "vulnerability" = 3 hits for code-reviewer
+    // "investigate" = 1 hit for researcher
+    expect(
+      suggestProfileForStep(
+        "Security review",
+        "Investigate vulnerability audit",
+        ALL_PROFILES
+      )
+    ).toBe("code-reviewer");
+  });
+});

package/src/lib/agents/profiles/builtins/code-reviewer/profile.yaml

@@ -15,7 +15,6 @@ canUseToolPolicy:
   autoApprove: [Read, Grep, Glob]
   autoDeny: []
 
-temperature: 0.3
 maxTurns: 20
 outputFormat: structured-findings
 

package/src/lib/agents/profiles/builtins/data-analyst/profile.yaml

@@ -15,7 +15,6 @@ canUseToolPolicy:
   autoApprove: [Read, Grep, Glob]
   autoDeny: []
 
-temperature: 0.3
 maxTurns: 30
 
 author: stagent

package/src/lib/agents/profiles/builtins/devops-engineer/profile.yaml

@@ -15,7 +15,6 @@ canUseToolPolicy:
   autoApprove: [Read, Grep, Glob]
   autoDeny: []
 
-temperature: 0.3
 maxTurns: 30
 
 author: stagent

package/src/lib/agents/profiles/builtins/document-writer/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [Read]
   autoDeny: []
 
-temperature: 0.5
 maxTurns: 20
 outputFormat: markdown-document
 

package/src/lib/agents/profiles/builtins/general/profile.yaml

@@ -12,7 +12,6 @@ runtimeOverrides:
       Stay pragmatic, execute the requested work directly, and prefer concise operational updates.
       Keep outputs grounded in the current workspace and call out blocked actions explicitly.
 
-temperature: 0.5
 maxTurns: 30
 
 author: stagent

package/src/lib/agents/profiles/builtins/health-fitness-coach/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [WebSearch, WebFetch, Read]
   autoDeny: [Bash, Write, Edit]
 
-temperature: 0.6
 maxTurns: 20
 
 author: stagent

package/src/lib/agents/profiles/builtins/learning-coach/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [WebSearch, WebFetch, Read]
   autoDeny: [Bash, Write, Edit]
 
-temperature: 0.5
 maxTurns: 25
 
 author: stagent

package/src/lib/agents/profiles/builtins/project-manager/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [Read, Grep, Glob]
   autoDeny: []
 
-temperature: 0.4
 maxTurns: 25
 
 author: stagent

package/src/lib/agents/profiles/builtins/researcher/profile.yaml

@@ -15,7 +15,6 @@ canUseToolPolicy:
   autoApprove: [WebSearch, WebFetch, Read]
   autoDeny: []
 
-temperature: 0.4
 maxTurns: 25
 
 author: stagent

package/src/lib/agents/profiles/builtins/shopping-assistant/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [WebSearch, WebFetch, Read]
   autoDeny: [Bash, Write, Edit]
 
-temperature: 0.5
 maxTurns: 20
 
 author: stagent

package/src/lib/agents/profiles/builtins/sweep/profile.yaml

@@ -5,7 +5,6 @@ domain: work
 tags: [sweep, audit, improvement, maintenance]
 supportedRuntimes: [claude-code]
 
-temperature: 0.3
 maxTurns: 50
 outputFormat: json
 

package/src/lib/agents/profiles/builtins/technical-writer/profile.yaml

@@ -16,7 +16,6 @@ canUseToolPolicy:
   autoApprove: [Read, Grep, Glob]
   autoDeny: []
 
-temperature: 0.4
 maxTurns: 20
 outputFormat: markdown
 

package/src/lib/agents/profiles/builtins/travel-planner/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [WebSearch, WebFetch, Read]
   autoDeny: [Bash, Write, Edit]
 
-temperature: 0.6
 maxTurns: 25
 
 author: stagent

package/src/lib/agents/profiles/builtins/wealth-manager/profile.yaml

@@ -14,7 +14,6 @@ canUseToolPolicy:
   autoApprove: [Read]
   autoDeny: [Bash, Write, Edit]
 
-temperature: 0.3
 maxTurns: 20
 
 author: stagent

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

@@ -174,7 +174,6 @@ function scanProfiles(): Map<string, AgentProfile> {
         allowedTools: config.allowedTools,
         mcpServers: config.mcpServers as Record<string, unknown>,
         canUseToolPolicy: config.canUseToolPolicy,
-        temperature: config.temperature,
         maxTurns: config.maxTurns,
         outputFormat: config.outputFormat,
         version: config.version,

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

@@ -0,0 +1,36 @@
+/**
+ * Lightweight keyword-based profile suggestion.
+ * Used as fallback when AI doesn't suggest a profile for a step.
+ */
+
+const KEYWORD_MAP: Record<string, string[]> = {
+  researcher: ["research", "search", "investigate", "explore", "find", "discover", "analyze data", "survey"],
+  "code-reviewer": ["review", "audit", "security", "vulnerability", "lint", "inspect", "code quality"],
+  "document-writer": ["write", "document", "report", "summarize", "draft", "compose", "blog", "article"],
+  "devops-engineer": ["deploy", "ci", "infrastructure", "pipeline", "docker", "kubernetes", "terraform", "monitor"],
+  "data-analyst": ["analyze", "data", "statistics", "metrics", "chart", "visualization", "dashboard", "aggregate"],
+};
+
+export function suggestProfileForStep(
+  title: string,
+  description: string,
+  availableProfileIds: string[]
+): string {
+  const text = `${title} ${description}`.toLowerCase();
+  let bestProfile = "auto";
+  let bestScore = 0;
+
+  for (const [profileId, keywords] of Object.entries(KEYWORD_MAP)) {
+    if (!availableProfileIds.includes(profileId)) continue;
+    let score = 0;
+    for (const keyword of keywords) {
+      if (text.includes(keyword)) score++;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestProfile = profileId;
+    }
+  }
+
+  return bestScore >= 1 ? bestProfile : "auto";
+}

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

@@ -31,7 +31,6 @@ export interface AgentProfile {
   allowedTools?: string[];
   mcpServers?: Record<string, unknown>;
   canUseToolPolicy?: CanUseToolPolicy;
-  temperature?: number;
   maxTurns?: number;
   outputFormat?: string;
   version?: string;

package/src/lib/agents/runtime/catalog.ts

@@ -50,7 +50,7 @@ const RUNTIME_CATALOG: Record<AgentRuntimeId, RuntimeCatalogEntry> = {
       resume: true,
       cancel: true,
       approvals: true,
-      mcpServers: true,
+      mcpServers: false, // Not yet wired — configs not passed to codex subprocess
       profileTests: false,
       taskAssist: true,
       authHealthCheck: true,

package/src/lib/agents/runtime/claude.ts

@@ -4,7 +4,7 @@ import { tasks } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import { updateAuthStatus, getAuthEnv } from "@/lib/settings/auth";
 import { getExecution, removeExecution } from "@/lib/agents/execution-manager";
-import { getProfile } from "@/lib/agents/profiles/registry";
+import { getProfile, listProfiles } from "@/lib/agents/profiles/registry";
 import { resolveProfileRuntimePayload } from "@/lib/agents/profiles/compatibility";
 import { executeClaudeTask, resumeClaudeTask } from "@/lib/agents/claude-agent";
 import { getRuntimeCapabilities, getRuntimeCatalogEntry } from "./catalog";
@@ -23,13 +23,41 @@ import {
   type UsageSnapshot,
 } from "@/lib/usage/ledger";
 
-const TASK_ASSIST_SYSTEM_PROMPT = `You are an AI task definition assistant. Analyze the given task and return ONLY a JSON object (no markdown, no code fences) with:
+function buildTaskAssistSystemPrompt(profileIds: string[]): string {
+  const profileList = profileIds.length > 0
+    ? `Available agent profiles: ${profileIds.join(", ")}\nUse "auto" if unsure which profile fits a step.`
+    : `No explicit profiles available. Use "auto" for suggestedProfile.`;
+
+  return `You are an AI task definition assistant. Analyze the given task and return ONLY a JSON object (no markdown, no code fences) with:
 - "improvedDescription": A clearer version of the task for an AI agent to execute
-- "breakdown": Array of {title, description} sub-tasks if complex (empty array if simple)
-- "recommendedPattern": "single", "sequence", "planner-executor", or "checkpoint"
+- "breakdown": Array of step objects if complex (empty array if simple). Each step: {title, description, suggestedProfile?, requiresApproval?, dependsOn?}
+  - "suggestedProfile": one of the available profile IDs or "auto"
+  - "requiresApproval": true if the step involves irreversible actions needing human review
+  - "dependsOn": array of step indices (0-based) this step depends on (for parallel/swarm patterns)
+- "recommendedPattern": one of "single", "sequence", "planner-executor", "checkpoint", "parallel", "loop", "swarm"
+  - "sequence": steps run one after another in order
+  - "planner-executor": first step plans, remaining steps execute the plan
+  - "checkpoint": like sequence but certain steps pause for human approval
+  - "parallel": independent steps run concurrently, a final synthesis step merges results (use dependsOn to mark the synthesis step)
+  - "loop": a single step repeats iteratively until a goal is met (include suggestedLoopConfig)
+  - "swarm": first step is the mayor (coordinator), middle steps are workers (run in parallel), last step is the refinery (merges results)
 - "complexity": "simple", "moderate", or "complex"
 - "needsCheckpoint": true if irreversible actions or needs human review
-- "reasoning": Brief explanation`;
+- "reasoning": Brief explanation of why you chose this pattern
+- "suggestedLoopConfig": {maxIterations, timeBudgetMs?} — only for loop pattern
+- "suggestedSwarmConfig": {workerConcurrencyLimit?} — only for swarm pattern
+
+${profileList}
+
+Pattern selection guide:
+- Use "single" for simple, atomic tasks
+- Use "sequence" for ordered multi-step work where each step builds on the previous
+- Use "planner-executor" when the task needs analysis before action
+- Use "checkpoint" when steps involve deployments, deletions, or other irreversible actions
+- Use "parallel" when sub-tasks are independent and can run concurrently (research, analysis)
+- Use "loop" for iterative refinement (code review cycles, optimization passes)
+- Use "swarm" for complex tasks needing multiple specialized agents coordinated by a lead`;
+}
 
 async function collectResultText(
   response: AsyncIterable<Record<string, unknown>>
@@ -224,6 +252,71 @@ async function runClaudeProfileTests(profileId: string): Promise<ProfileTestRepo
   };
 }
 
+// ---------------------------------------------------------------------------
+// Lightweight meta-completion (pattern extraction, context summarization, etc.)
+// ---------------------------------------------------------------------------
+
+export async function runMetaCompletion(input: {
+  prompt: string;
+  activityType: string;
+}): Promise<{ text: string; usage: UsageSnapshot }> {
+  const authEnv = await getAuthEnv();
+  const startedAt = new Date();
+  let usage: UsageSnapshot = {};
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => abortController.abort(), 60_000);
+
+  try {
+    const response = query({
+      prompt: input.prompt,
+      options: {
+        abortController,
+        includePartialMessages: true,
+        cwd: process.cwd(),
+        env: buildClaudeSdkEnv(authEnv),
+        allowedTools: [],
+        maxTurns: 1,
+      },
+    });
+
+    const collected = await collectResultText(
+      response as AsyncIterable<Record<string, unknown>>
+    );
+    usage = collected.usage;
+
+    await recordUsageLedgerEntry({
+      activityType: input.activityType as import("@/lib/usage/ledger").UsageActivityType,
+      runtimeId: "claude-code",
+      providerId: "anthropic",
+      modelId: usage.modelId ?? null,
+      inputTokens: usage.inputTokens ?? null,
+      outputTokens: usage.outputTokens ?? null,
+      totalTokens: usage.totalTokens ?? null,
+      status: "completed",
+      startedAt,
+      finishedAt: new Date(),
+    });
+
+    return { text: collected.resultText, usage };
+  } catch (error) {
+    await recordUsageLedgerEntry({
+      activityType: input.activityType as import("@/lib/usage/ledger").UsageActivityType,
+      runtimeId: "claude-code",
+      providerId: "anthropic",
+      modelId: usage.modelId ?? null,
+      inputTokens: usage.inputTokens ?? null,
+      outputTokens: usage.outputTokens ?? null,
+      totalTokens: usage.totalTokens ?? null,
+      status: "failed",
+      startedAt,
+      finishedAt: new Date(),
+    });
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 async function runClaudeTaskAssist(
   input: TaskAssistInput
 ): Promise<TaskAssistResponse> {
@@ -235,7 +328,9 @@ async function runClaudeTaskAssist(
     .join("\n");
 
   const authEnv = await getAuthEnv();
-  const prompt = `${TASK_ASSIST_SYSTEM_PROMPT}\n\n${userMessage}`;
+  const profileIds = listProfiles().map((p) => p.id);
+  const systemPrompt = buildTaskAssistSystemPrompt(profileIds);
+  const prompt = `${systemPrompt}\n\n${userMessage}`;
   const startedAt = new Date();
   let usage: UsageSnapshot = {};
 
@@ -315,6 +410,7 @@ async function testClaudeConnection(): Promise<RuntimeConnectionResult> {
       options: {
         abortController,
         maxTurns: 1,
+        includePartialMessages: false,
         cwd: process.cwd(),
         env: buildClaudeSdkEnv(authEnv),
       },

package/src/lib/agents/runtime/task-assist-types.ts

@@ -1,8 +1,18 @@
+export interface TaskAssistBreakdownStep {
+  title: string;
+  description: string;
+  suggestedProfile?: string;
+  requiresApproval?: boolean;
+  dependsOn?: number[];
+}
+
 export interface TaskAssistResponse {
   improvedDescription: string;
-  breakdown: { title: string; description: string }[];
-  recommendedPattern: "single" | "sequence" | "planner-executor" | "checkpoint";
+  breakdown: TaskAssistBreakdownStep[];
+  recommendedPattern: "single" | "sequence" | "planner-executor" | "checkpoint" | "parallel" | "loop" | "swarm";
   complexity: "simple" | "moderate" | "complex";
   needsCheckpoint: boolean;
   reasoning: string;
+  suggestedLoopConfig?: { maxIterations: number; timeBudgetMs?: number };
+  suggestedSwarmConfig?: { workerConcurrencyLimit?: number };
 }

package/src/lib/constants/task-status.ts

@@ -47,3 +47,9 @@ export function isValidDragTransition(from: TaskStatus, to: TaskStatus): boolean
 
 /** Maximum number of times a task can be resumed before requiring a fresh start */
 export const MAX_RESUME_COUNT = 3;
+
+/** Default max turns for agent task execution (safety net) */
+export const DEFAULT_MAX_TURNS = 50;
+
+/** Default per-execution budget cap in USD */
+export const DEFAULT_MAX_BUDGET_USD = 2.0;

package/src/lib/data/__tests__/clear.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "fs";
+import { join } from "path";
+import * as schema from "@/lib/db/schema";
+
+/**
+ * Safety-net test: every table exported from schema.ts must appear in clear.ts
+ * (except `settings`, which is intentionally preserved across clears).
+ *
+ * When you add a new table to schema.ts, this test will fail until you add a
+ * corresponding db.delete() call to clear.ts in the correct FK-safe order.
+ */
+describe("clearAllData coverage", () => {
+  const INTENTIONALLY_PRESERVED = ["settings"];
+
+  it("deletes every schema table (except settings)", () => {
+    const clearSource = readFileSync(
+      join(__dirname, "..", "clear.ts"),
+      "utf-8"
+    );
+
+    // Collect all sqliteTable exports from schema
+    const tableExports = Object.entries(schema)
+      .filter(
+        ([, value]) =>
+          value != null &&
+          typeof value === "object" &&
+          "getSQL" in (value as Record<string, unknown>)
+      )
+      .map(([name]) => name);
+
+    expect(tableExports.length).toBeGreaterThan(0);
+
+    const missing = tableExports.filter(
+      (name) =>
+        !INTENTIONALLY_PRESERVED.includes(name) &&
+        !clearSource.includes(`db.delete(${name})`)
+    );
+
+    expect(missing, `Tables missing from clear.ts: ${missing.join(", ")}`).toEqual([]);
+  });
+});

package/src/lib/data/clear.ts

@@ -3,6 +3,7 @@ import {
   agentLogs,
   notifications,
   documents,
+  learnedContext,
   tasks,
   workflows,
   schedules,
@@ -31,6 +32,7 @@ export function clearAllData() {
   const logsDeleted = db.delete(agentLogs).run().changes;
   const notificationsDeleted = db.delete(notifications).run().changes;
   const documentsDeleted = db.delete(documents).run().changes;
+  const learnedContextDeleted = db.delete(learnedContext).run().changes;
   const tasksDeleted = db.delete(tasks).run().changes;
   const workflowsDeleted = db.delete(workflows).run().changes;
   const schedulesDeleted = db.delete(schedules).run().changes;
@@ -58,6 +60,7 @@ export function clearAllData() {
     agentLogs: logsDeleted,
     notifications: notificationsDeleted,
     documents: documentsDeleted,
+    learnedContext: learnedContextDeleted,
     files: filesDeleted,
   };
 }