stagent 0.1.9 → 0.1.11

package/src/lib/data/seed-data/profiles.ts

@@ -34,7 +34,6 @@ export function getSampleProfiles(): SampleProfileSeed[] {
         canUseToolPolicy: {
           autoApprove: ["Read", "Grep"],
         },
-        temperature: 0.3,
         maxTurns: 18,
         outputFormat: "Weekly operating note with metrics, risks, and next actions.",
         author: SAMPLE_PROFILE_AUTHOR,
@@ -73,7 +72,6 @@ You review pipeline movement, funnel risk, and rep follow-ups with a bias toward
         canUseToolPolicy: {
           autoApprove: ["Read"],
         },
-        temperature: 0.6,
         maxTurns: 16,
         outputFormat: "Experiment summary with winning message angles and next tests.",
         author: SAMPLE_PROFILE_AUTHOR,
@@ -109,7 +107,6 @@ You turn campaign performance and research inputs into sharper launch messaging.
         domain: "personal",
         tags: ["investing", "portfolio", "risk", "habits"],
         allowedTools: ["Read", "Write"],
-        temperature: 0.25,
         maxTurns: 14,
         outputFormat: "Short investor brief with posture, risk notes, and watchlist changes.",
         author: SAMPLE_PROFILE_AUTHOR,

package/src/lib/notifications/permissions.ts

@@ -149,6 +149,11 @@ export function getPermissionDetailEntries(
 export function getPermissionResponseLabel(response: string | null): string | null {
   if (!response) return null;
 
+  // Handle legacy plain-string responses (pre-JSON format)
+  const legacy = response.toLowerCase();
+  if (legacy === "approved" || legacy === "allowed") return "Allowed";
+  if (legacy === "denied" || legacy === "rejected") return "Denied";
+
   try {
     const parsed = JSON.parse(response) as {
       behavior?: "allow" | "deny";
@@ -164,8 +169,7 @@ export function getPermissionResponseLabel(response: string | null): string | nu
     }
 
     return null;
-  } catch (err) {
-    console.error("[permissions] Failed to parse permission response:", err);
+  } catch {
     return null;
   }
 }

package/src/lib/usage/__tests__/ledger.test.ts

@@ -33,9 +33,10 @@ function formatLocalDay(date: Date) {
 }
 
 describe("usage ledger", () => {
-  it("records normalized ledger rows with derived and unknown pricing states", async () => {
+  it("records normalized ledger rows with derived, fallback, and unknown pricing states", async () => {
     const { db, usageLedger, recordUsageLedgerEntry } = await loadUsageModules();
 
+    // Known model — gets specific pricing rule
     await recordUsageLedgerEntry({
       activityType: "task_assist",
       runtimeId: "claude-code",
@@ -49,6 +50,7 @@ describe("usage ledger", () => {
       finishedAt: new Date("2026-03-10T08:01:00.000Z"),
     });
 
+    // Unknown model — hits catch-all fallback pricing (conservative estimate)
     await recordUsageLedgerEntry({
       activityType: "task_assist",
       runtimeId: "openai-codex-app-server",
@@ -62,15 +64,37 @@ describe("usage ledger", () => {
       finishedAt: new Date("2026-03-10T09:01:00.000Z"),
     });
 
+    // Null modelId — gets unknown_pricing (no model to match)
+    await recordUsageLedgerEntry({
+      activityType: "task_run",
+      runtimeId: "claude-code",
+      providerId: "anthropic",
+      modelId: null,
+      inputTokens: 100,
+      outputTokens: 50,
+      totalTokens: 150,
+      status: "completed",
+      startedAt: new Date("2026-03-10T10:00:00.000Z"),
+      finishedAt: new Date("2026-03-10T10:01:00.000Z"),
+    });
+
     const rows = await db.select().from(usageLedger);
-    expect(rows).toHaveLength(2);
+    expect(rows).toHaveLength(3);
 
-    const priced = rows.find((row) => row.providerId === "anthropic");
+    // Known: specific pricing
+    const priced = rows.find((row) => row.modelId === "claude-sonnet-4-20250514");
     expect(priced?.costMicros).toBe(10_500);
     expect(priced?.status).toBe("completed");
-    expect(priced?.pricingVersion).toBe("registry-2026-03-12");
+    expect(priced?.pricingVersion).toBe("registry-2026-03-15");
+
+    // Unknown model: fallback pricing (conservative Opus-tier for OpenAI: $10/$30)
+    const fallback = rows.find((row) => row.modelId === "codex-unknown");
+    expect(fallback?.costMicros).toBeGreaterThan(0);
+    expect(fallback?.status).toBe("completed");
+    expect(fallback?.pricingVersion).toBe("registry-2026-03-15-fallback");
 
-    const unknown = rows.find((row) => row.providerId === "openai");
+    // Null modelId: truly unknown
+    const unknown = rows.find((row) => row.modelId === null);
     expect(unknown?.costMicros).toBeNull();
     expect(unknown?.status).toBe("unknown_pricing");
     expect(unknown?.pricingVersion).toBeNull();

package/src/lib/usage/ledger.ts

@@ -15,7 +15,9 @@ export type UsageActivityType =
   | "workflow_step"
   | "scheduled_firing"
   | "task_assist"
-  | "profile_test";
+  | "profile_test"
+  | "pattern_extraction"
+  | "context_summarization";
 
 export type UsageLedgerStatus =
   | "completed"

package/src/lib/usage/pricing.ts

@@ -7,25 +7,79 @@ export interface PricingRule {
 }
 
 const PRICING_RULES: PricingRule[] = [
+  // ── Anthropic ──────────────────────────────────────────────────────
   {
     providerId: "anthropic",
-    pricingVersion: "registry-2026-03-12",
+    pricingVersion: "registry-2026-03-15",
+    inputCostPerMillionMicros: 15_000_000,
+    outputCostPerMillionMicros: 75_000_000,
+    matchesModel(modelId) {
+      return modelId.startsWith("claude-opus");
+    },
+  },
+  {
+    providerId: "anthropic",
+    pricingVersion: "registry-2026-03-15",
     inputCostPerMillionMicros: 3_000_000,
     outputCostPerMillionMicros: 15_000_000,
     matchesModel(modelId) {
-      return (
-        modelId === "claude-sonnet-4-20250514" ||
-        modelId.startsWith("claude-sonnet-4")
-      );
+      return modelId.startsWith("claude-sonnet");
+    },
+  },
+  {
+    providerId: "anthropic",
+    pricingVersion: "registry-2026-03-15",
+    inputCostPerMillionMicros: 800_000,
+    outputCostPerMillionMicros: 4_000_000,
+    matchesModel(modelId) {
+      return modelId.startsWith("claude-haiku");
     },
   },
+  // ── OpenAI ─────────────────────────────────────────────────────────
   {
     providerId: "openai",
-    pricingVersion: "registry-2026-03-12",
+    pricingVersion: "registry-2026-03-15",
     inputCostPerMillionMicros: 1_500_000,
     outputCostPerMillionMicros: 6_000_000,
     matchesModel(modelId) {
-      return modelId === "codex-mini-latest" || modelId.startsWith("codex-mini");
+      return modelId.startsWith("codex-mini") || modelId === "codex-mini-latest";
+    },
+  },
+  {
+    providerId: "openai",
+    pricingVersion: "registry-2026-03-15",
+    inputCostPerMillionMicros: 2_500_000,
+    outputCostPerMillionMicros: 10_000_000,
+    matchesModel(modelId) {
+      return modelId.startsWith("gpt-4o");
+    },
+  },
+  {
+    providerId: "openai",
+    pricingVersion: "registry-2026-03-15",
+    inputCostPerMillionMicros: 10_000_000,
+    outputCostPerMillionMicros: 30_000_000,
+    matchesModel(modelId) {
+      return modelId.startsWith("gpt-5") || modelId.startsWith("o3") || modelId.startsWith("o4");
+    },
+  },
+  // ── Catch-all (conservative estimate to prevent null costs) ────────
+  {
+    providerId: "anthropic",
+    pricingVersion: "registry-2026-03-15-fallback",
+    inputCostPerMillionMicros: 15_000_000,
+    outputCostPerMillionMicros: 75_000_000,
+    matchesModel() {
+      return true;
+    },
+  },
+  {
+    providerId: "openai",
+    pricingVersion: "registry-2026-03-15-fallback",
+    inputCostPerMillionMicros: 10_000_000,
+    outputCostPerMillionMicros: 30_000_000,
+    matchesModel() {
+      return true;
     },
   },
 ];

package/src/lib/validators/__tests__/profile.test.ts

@@ -28,7 +28,6 @@ describe("ProfileConfigSchema", () => {
         preToolCall: ["echo pre"],
         postToolCall: ["echo post"],
       },
-      temperature: 0.5,
       maxTurns: 20,
       outputFormat: "markdown",
       author: "stagent",
@@ -77,20 +76,6 @@ describe("ProfileConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
-  it("rejects temperature out of range", () => {
-    const tooHigh = ProfileConfigSchema.safeParse({
-      ...validProfile,
-      temperature: 1.5,
-    });
-    expect(tooHigh.success).toBe(false);
-
-    const tooLow = ProfileConfigSchema.safeParse({
-      ...validProfile,
-      temperature: -0.1,
-    });
-    expect(tooLow.success).toBe(false);
-  });
-
   it("rejects invalid source URL", () => {
     const result = ProfileConfigSchema.safeParse({
       ...validProfile,

package/src/lib/validators/profile.ts

@@ -38,7 +38,6 @@ export const ProfileConfigSchema = z.object({
       postToolCall: z.array(z.string()).optional(),
     })
     .optional(),
-  temperature: z.number().min(0).max(1).optional(),
   maxTurns: z.number().positive().optional(),
   outputFormat: z.string().optional(),
   author: z.string().optional(),

package/src/lib/workflows/__tests__/assist-builder.test.ts

@@ -0,0 +1,255 @@
+import { describe, it, expect } from "vitest";
+import { buildWorkflowDefinitionFromAssist } from "../assist-builder";
+import type { TaskAssistResponse } from "@/lib/agents/runtime/task-assist-types";
+
+const MAIN_TASK = {
+  title: "Build Auth System",
+  description: "Implement authentication with OAuth2",
+  agentProfile: "general",
+};
+
+function makeAssistResponse(
+  overrides: Partial<TaskAssistResponse> = {}
+): TaskAssistResponse {
+  return {
+    improvedDescription: "Build a complete auth system",
+    breakdown: [
+      { title: "Set up middleware", description: "Create auth middleware" },
+      { title: "Create endpoints", description: "Build user API endpoints" },
+      { title: "Write tests", description: "Integration tests for auth" },
+    ],
+    recommendedPattern: "sequence",
+    complexity: "complex",
+    needsCheckpoint: false,
+    reasoning: "Multi-step ordered work",
+    ...overrides,
+  };
+}
+
+describe("buildWorkflowDefinitionFromAssist", () => {
+  describe("sequence pattern", () => {
+    it("creates a sequence workflow with main task as step 1", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse(),
+      });
+
+      expect(result.pattern).toBe("sequence");
+      expect(result.steps).toHaveLength(4); // main + 3 breakdown
+      expect(result.steps[0].name).toBe("Build Auth System");
+      expect(result.steps[1].name).toBe("Set up middleware");
+      expect(result.steps[3].name).toBe("Write tests");
+    });
+
+    it("assigns profiles from main task and suggestions", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          breakdown: [
+            { title: "Research", description: "Research patterns", suggestedProfile: "researcher" },
+            { title: "Code", description: "Write code" },
+          ],
+        }),
+      });
+
+      expect(result.steps[0].agentProfile).toBe("general"); // from mainTask
+      expect(result.steps[1].agentProfile).toBe("researcher"); // from suggestion
+      expect(result.steps[2].agentProfile).toBeUndefined(); // no suggestion = undefined
+    });
+  });
+
+  describe("checkpoint pattern", () => {
+    it("preserves requiresApproval on steps", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "checkpoint",
+          breakdown: [
+            { title: "Plan", description: "Plan deployment", requiresApproval: true },
+            { title: "Deploy", description: "Execute deployment" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("checkpoint");
+      expect(result.steps[1].requiresApproval).toBe(true);
+      expect(result.steps[2].requiresApproval).toBeUndefined();
+    });
+  });
+
+  describe("parallel pattern", () => {
+    it("auto-generates synthesis step when none provided", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "parallel",
+          breakdown: [
+            { title: "Branch A", description: "Research area A" },
+            { title: "Branch B", description: "Research area B" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("parallel");
+      // main + 2 branches + auto-synthesis = 4
+      expect(result.steps).toHaveLength(4);
+      expect(result.steps[3].name).toBe("Synthesize results");
+      expect(result.steps[3].dependsOn).toEqual(["step_1", "step_2", "step_3"]);
+    });
+
+    it("preserves explicit synthesis step with dependsOn", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "parallel",
+          breakdown: [
+            { title: "Branch A", description: "Research A" },
+            { title: "Merge", description: "Merge results", dependsOn: [0, 1] },
+          ],
+        }),
+      });
+
+      // main + Branch A + Merge = 3 (no auto-synthesis because dependsOn exists)
+      expect(result.steps).toHaveLength(3);
+      expect(result.steps[2].dependsOn).toEqual(["step_1", "step_2"]);
+    });
+  });
+
+  describe("loop pattern", () => {
+    it("creates single-step loop with config", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "loop",
+          suggestedLoopConfig: { maxIterations: 3, timeBudgetMs: 60000 },
+        }),
+      });
+
+      expect(result.pattern).toBe("loop");
+      expect(result.steps).toHaveLength(1);
+      expect(result.loopConfig?.maxIterations).toBe(3);
+      expect(result.loopConfig?.timeBudgetMs).toBe(60000);
+    });
+
+    it("defaults to 5 iterations", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({ recommendedPattern: "loop" }),
+      });
+
+      expect(result.loopConfig?.maxIterations).toBe(5);
+    });
+
+    it("applies loop config overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "loop",
+          suggestedLoopConfig: { maxIterations: 3 },
+        }),
+        overrides: { loopConfig: { maxIterations: 10 } },
+      });
+
+      expect(result.loopConfig?.maxIterations).toBe(10);
+    });
+  });
+
+  describe("swarm pattern", () => {
+    it("creates mayor/workers/refinery structure", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "swarm",
+          breakdown: [
+            { title: "Worker 1", description: "Task 1" },
+            { title: "Worker 2", description: "Task 2" },
+          ],
+        }),
+      });
+
+      expect(result.pattern).toBe("swarm");
+      // mayor + 2 workers + refinery = 4
+      expect(result.steps).toHaveLength(4);
+      expect(result.steps[0].name).toBe("Build Auth System"); // mayor
+      expect(result.steps[3].name).toBe("Refine and merge results"); // refinery
+      expect(result.swarmConfig?.workerConcurrencyLimit).toBe(2);
+    });
+
+    it("applies swarm config overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({
+          recommendedPattern: "swarm",
+          breakdown: [
+            { title: "W1", description: "T1" },
+            { title: "W2", description: "T2" },
+          ],
+          suggestedSwarmConfig: { workerConcurrencyLimit: 1 },
+        }),
+        overrides: { swarmConfig: { workerConcurrencyLimit: 2 } },
+      });
+
+      expect(result.swarmConfig?.workerConcurrencyLimit).toBe(2);
+    });
+  });
+
+  describe("pattern override", () => {
+    it("overrides AI-recommended pattern", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse({ recommendedPattern: "sequence" }),
+        overrides: { pattern: "checkpoint" },
+      });
+
+      expect(result.pattern).toBe("checkpoint");
+    });
+  });
+
+  describe("step overrides", () => {
+    it("applies partial step overrides", () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: MAIN_TASK,
+        assistResponse: makeAssistResponse(),
+        overrides: {
+          steps: [
+            undefined,
+            { agentProfile: "code-reviewer" },
+          ] as Partial<import("../types").WorkflowStep>[],
+        },
+      });
+
+      expect(result.steps[1].agentProfile).toBe("code-reviewer");
+    });
+  });
+
+  describe("validation", () => {
+    it("throws on invalid definition", () => {
+      expect(() =>
+        buildWorkflowDefinitionFromAssist({
+          mainTask: MAIN_TASK,
+          assistResponse: makeAssistResponse({
+            recommendedPattern: "loop",
+            // Missing loopConfig
+          }),
+          overrides: { loopConfig: { maxIterations: 0 } },
+        })
+      ).toThrow("Invalid workflow definition");
+    });
+  });
+
+  describe("auto profile handling", () => {
+    it('treats "auto" suggestedProfile as undefined', () => {
+      const result = buildWorkflowDefinitionFromAssist({
+        mainTask: { ...MAIN_TASK, agentProfile: undefined },
+        assistResponse: makeAssistResponse({
+          breakdown: [
+            { title: "Step", description: "Do thing", suggestedProfile: "auto" },
+          ],
+        }),
+      });
+
+      expect(result.steps[0].agentProfile).toBeUndefined();
+      expect(result.steps[1].agentProfile).toBeUndefined();
+    });
+  });
+});

package/src/lib/workflows/__tests__/engine.test.ts

@@ -103,6 +103,8 @@ describe("executeWorkflow", () => {
       .mockResolvedValueOnce([workflow])
       .mockResolvedValueOnce([failedTask])
       .mockResolvedValueOnce([workflow])
+      .mockResolvedValueOnce([workflow])
+      // syncSourceTaskStatus reads the workflow to find sourceTaskId
       .mockResolvedValueOnce([workflow]);
 
     const { executeWorkflow } = await import("../engine");