stagent 0.1.11 → 0.1.12

package/src/lib/utils/__tests__/learned-context-history.test.ts

@@ -0,0 +1,171 @@
+import type { LearnedContextRow } from "@/lib/db/schema";
+
+import {
+  buildLearnedContextHistoryEntries,
+  buildUnifiedDiff,
+  hasMeaningfulDerivedDiff,
+} from "../learned-context-history";
+
+function makeRow(
+  overrides: Partial<LearnedContextRow> & {
+    id: string;
+    version: number;
+    changeType: LearnedContextRow["changeType"];
+  }
+): LearnedContextRow {
+  return {
+    id: overrides.id,
+    profileId: overrides.profileId ?? "general",
+    version: overrides.version,
+    content: overrides.content ?? null,
+    diff: overrides.diff ?? null,
+    changeType: overrides.changeType,
+    sourceTaskId: overrides.sourceTaskId ?? null,
+    proposalNotificationId: overrides.proposalNotificationId ?? null,
+    proposedAdditions: overrides.proposedAdditions ?? null,
+    approvedBy: overrides.approvedBy ?? null,
+    createdAt: overrides.createdAt ?? new Date("2026-03-17T12:00:00.000Z"),
+  };
+}
+
+describe("buildUnifiedDiff", () => {
+  it("treats the first version as all additions", () => {
+    expect(buildUnifiedDiff(null, "Alpha\nBeta")).toEqual([
+      { kind: "added", value: "Alpha" },
+      { kind: "added", value: "Beta" },
+    ]);
+  });
+
+  it("builds a unified diff for appended content", () => {
+    expect(buildUnifiedDiff("Alpha", "Alpha\nBeta")).toEqual([
+      { kind: "context", value: "Alpha" },
+      { kind: "added", value: "Beta" },
+    ]);
+  });
+});
+
+describe("buildLearnedContextHistoryEntries", () => {
+  it("derives rollback diffs from the previous snapshot version", () => {
+    const history = [
+      makeRow({
+        id: "v3",
+        version: 3,
+        changeType: "rollback",
+        content: "Alpha",
+        diff: "Rolled back to version 1",
+      }),
+      makeRow({
+        id: "v2",
+        version: 2,
+        changeType: "approved",
+        content: "Alpha\nBeta",
+        diff: "Beta",
+      }),
+      makeRow({
+        id: "v1",
+        version: 1,
+        changeType: "approved",
+        content: "Alpha",
+        diff: "Alpha",
+      }),
+    ];
+
+    const entries = buildLearnedContextHistoryEntries(history);
+    const rollbackEntry = entries[0];
+
+    expect(rollbackEntry.snapshotContent).toBe("Alpha");
+    expect(rollbackEntry.derivedDiff).toEqual({
+      previousVersion: 2,
+      lines: [
+        { kind: "context", value: "Alpha" },
+        { kind: "removed", value: "Beta" },
+      ],
+    });
+  });
+
+  it("derives summarization diffs from the previous snapshot version", () => {
+    const history = [
+      makeRow({
+        id: "v3",
+        version: 3,
+        changeType: "summarization",
+        content: "Alpha\nGamma",
+        diff: "Summarized from 14 to 11 chars",
+      }),
+      makeRow({
+        id: "v2",
+        version: 2,
+        changeType: "rejected",
+        content: "Alpha\nBeta",
+        diff: "Rejected addition",
+      }),
+      makeRow({
+        id: "v1",
+        version: 1,
+        changeType: "approved",
+        content: "Alpha\nBeta",
+        diff: "Alpha\nBeta",
+      }),
+    ];
+
+    const entries = buildLearnedContextHistoryEntries(history);
+    const summarizationEntry = entries[0];
+
+    expect(summarizationEntry.derivedDiff).toEqual({
+      previousVersion: 1,
+      lines: [
+        { kind: "context", value: "Alpha" },
+        { kind: "removed", value: "Beta" },
+        { kind: "added", value: "Gamma" },
+      ],
+    });
+  });
+
+  it("does not create derived diffs for proposal-only rows", () => {
+    const history = [
+      makeRow({
+        id: "proposal",
+        version: 2,
+        changeType: "proposal",
+        diff: "Add retries",
+      }),
+      makeRow({
+        id: "approved",
+        version: 1,
+        changeType: "approved",
+        content: "Validate inputs",
+        diff: "Validate inputs",
+      }),
+    ];
+
+    const entries = buildLearnedContextHistoryEntries(history);
+
+    expect(entries[0].snapshotContent).toBeNull();
+    expect(entries[0].derivedDiff).toBeNull();
+    expect(entries[1].derivedDiff?.previousVersion).toBeNull();
+  });
+});
+
+describe("hasMeaningfulDerivedDiff", () => {
+  it("detects when a derived diff contains additions or removals", () => {
+    expect(
+      hasMeaningfulDerivedDiff({
+        previousVersion: 1,
+        lines: [
+          { kind: "context", value: "Alpha" },
+          { kind: "added", value: "Beta" },
+        ],
+      })
+    ).toBe(true);
+  });
+
+  it("returns false for null or unchanged diffs", () => {
+    expect(hasMeaningfulDerivedDiff(null)).toBe(false);
+    expect(
+      hasMeaningfulDerivedDiff({
+        previousVersion: 1,
+        lines: [{ kind: "context", value: "Alpha" }],
+      })
+    ).toBe(false);
+  });
+});

package/src/lib/utils/learned-context-history.ts

@@ -0,0 +1,150 @@
+import type { LearnedContextRow } from "@/lib/db/schema";
+
+export type LearnedContextSnapshotType =
+  | "approved"
+  | "rollback"
+  | "summarization";
+
+export type LearnedContextDiffKind = "context" | "added" | "removed";
+
+export interface LearnedContextDiffLine {
+  kind: LearnedContextDiffKind;
+  value: string;
+}
+
+export interface LearnedContextDerivedDiff {
+  previousVersion: number | null;
+  lines: LearnedContextDiffLine[];
+}
+
+export interface LearnedContextHistoryEntry {
+  row: LearnedContextRow;
+  snapshotContent: string | null;
+  derivedDiff: LearnedContextDerivedDiff | null;
+}
+
+const SNAPSHOT_CHANGE_TYPES = new Set<LearnedContextSnapshotType>([
+  "approved",
+  "rollback",
+  "summarization",
+]);
+
+export function isSnapshotVersion(
+  row: LearnedContextRow
+): row is LearnedContextRow & {
+  changeType: LearnedContextSnapshotType;
+  content: string;
+} {
+  return (
+    SNAPSHOT_CHANGE_TYPES.has(row.changeType as LearnedContextSnapshotType) &&
+    typeof row.content === "string"
+  );
+}
+
+function normalizeLines(content: string | null): string[] {
+  if (!content) return [];
+  return content.replace(/\r\n/g, "\n").split("\n");
+}
+
+function buildLcsTable(previous: string[], next: string[]): number[][] {
+  const table = Array.from({ length: previous.length + 1 }, () =>
+    Array(next.length + 1).fill(0)
+  );
+
+  for (let i = previous.length - 1; i >= 0; i -= 1) {
+    for (let j = next.length - 1; j >= 0; j -= 1) {
+      if (previous[i] === next[j]) {
+        table[i][j] = table[i + 1][j + 1] + 1;
+      } else {
+        table[i][j] = Math.max(table[i + 1][j], table[i][j + 1]);
+      }
+    }
+  }
+
+  return table;
+}
+
+export function buildUnifiedDiff(
+  previousContent: string | null,
+  nextContent: string
+): LearnedContextDiffLine[] {
+  const previousLines = normalizeLines(previousContent);
+  const nextLines = normalizeLines(nextContent);
+
+  if (previousLines.length === 0) {
+    return nextLines.map((value) => ({ kind: "added", value }));
+  }
+
+  const table = buildLcsTable(previousLines, nextLines);
+  const lines: LearnedContextDiffLine[] = [];
+
+  let i = 0;
+  let j = 0;
+
+  while (i < previousLines.length && j < nextLines.length) {
+    if (previousLines[i] === nextLines[j]) {
+      lines.push({ kind: "context", value: previousLines[i] });
+      i += 1;
+      j += 1;
+      continue;
+    }
+
+    if (table[i + 1][j] >= table[i][j + 1]) {
+      lines.push({ kind: "removed", value: previousLines[i] });
+      i += 1;
+      continue;
+    }
+
+    lines.push({ kind: "added", value: nextLines[j] });
+    j += 1;
+  }
+
+  while (i < previousLines.length) {
+    lines.push({ kind: "removed", value: previousLines[i] });
+    i += 1;
+  }
+
+  while (j < nextLines.length) {
+    lines.push({ kind: "added", value: nextLines[j] });
+    j += 1;
+  }
+
+  return lines;
+}
+
+export function hasMeaningfulDerivedDiff(
+  diff: LearnedContextDerivedDiff | null
+): boolean {
+  return Boolean(
+    diff?.lines.some((line) => line.kind === "added" || line.kind === "removed")
+  );
+}
+
+export function buildLearnedContextHistoryEntries(
+  history: LearnedContextRow[]
+): LearnedContextHistoryEntry[] {
+  const derivedDiffById = new Map<string, LearnedContextDerivedDiff>();
+  let previousSnapshot: (LearnedContextRow & {
+    changeType: LearnedContextSnapshotType;
+    content: string;
+  }) | null = null;
+
+  const ascending = [...history].sort((a, b) => a.version - b.version);
+
+  for (const row of ascending) {
+    if (!isSnapshotVersion(row)) continue;
+
+    derivedDiffById.set(row.id, {
+      previousVersion: previousSnapshot?.version ?? null,
+      lines: buildUnifiedDiff(previousSnapshot?.content ?? null, row.content),
+    });
+
+    previousSnapshot = row;
+  }
+
+  return history.map((row) => ({
+    row,
+    snapshotContent: isSnapshotVersion(row) ? row.content : null,
+    derivedDiff: derivedDiffById.get(row.id) ?? null,
+  }));
+}

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

@@ -99,24 +99,18 @@ describe("updateOpenAISettingsSchema", () => {
 });
 
 describe("updateBudgetPolicySchema", () => {
-  it("accepts nullable budget caps for all windows", () => {
+  it("accepts a monthly-only budget payload", () => {
     const result = updateBudgetPolicySchema.safeParse({
       overall: {
-        dailySpendCapUsd: null,
         monthlySpendCapUsd: 50,
       },
       runtimes: {
         "claude-code": {
-          dailySpendCapUsd: 10,
           monthlySpendCapUsd: 100,
-          dailyTokenCap: 10000,
-          monthlyTokenCap: null,
+          claudeOAuthPlan: "max_5x",
         },
         "openai-codex-app-server": {
-          dailySpendCapUsd: null,
           monthlySpendCapUsd: null,
-          dailyTokenCap: null,
-          monthlyTokenCap: 50000,
         },
       },
     });
@@ -127,21 +121,34 @@ describe("updateBudgetPolicySchema", () => {
   it("rejects zero and negative values", () => {
     const result = updateBudgetPolicySchema.safeParse({
       overall: {
-        dailySpendCapUsd: 0,
         monthlySpendCapUsd: -1,
       },
       runtimes: {
         "claude-code": {
-          dailySpendCapUsd: null,
-          monthlySpendCapUsd: null,
-          dailyTokenCap: 0,
-          monthlyTokenCap: null,
+          monthlySpendCapUsd: 0,
+          claudeOAuthPlan: "pro",
         },
         "openai-codex-app-server": {
-          dailySpendCapUsd: null,
           monthlySpendCapUsd: null,
-          dailyTokenCap: null,
-          monthlyTokenCap: null,
+        },
+      },
+    });
+
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects invalid Claude OAuth plans", () => {
+    const result = updateBudgetPolicySchema.safeParse({
+      overall: {
+        monthlySpendCapUsd: 300,
+      },
+      runtimes: {
+        "claude-code": {
+          monthlySpendCapUsd: 150,
+          claudeOAuthPlan: "enterprise",
+        },
+        "openai-codex-app-server": {
+          monthlySpendCapUsd: 150,
         },
       },
     });

package/src/lib/validators/settings.ts

@@ -25,22 +25,15 @@ const nullablePositiveNumber = z.preprocess((value) => {
   return value;
 }, z.number().finite().positive().nullable());
 
-const nullablePositiveInteger = z.preprocess((value) => {
-  if (value === "" || value == null) return null;
-  if (typeof value === "string") return Number(value);
-  return value;
-}, z.number().int().positive().nullable());
+export const claudeOAuthPlanSchema = z.enum(["pro", "max_5x", "max_20x"]);
 
 export const runtimeBudgetPolicySchema = z.object({
-  dailySpendCapUsd: nullablePositiveNumber,
   monthlySpendCapUsd: nullablePositiveNumber,
-  dailyTokenCap: nullablePositiveInteger,
-  monthlyTokenCap: nullablePositiveInteger,
+  claudeOAuthPlan: claudeOAuthPlanSchema.optional(),
 });
 
 export const budgetPolicySchema = z.object({
   overall: z.object({
-    dailySpendCapUsd: nullablePositiveNumber,
     monthlySpendCapUsd: nullablePositiveNumber,
   }),
   runtimes: z.object(
@@ -55,3 +48,4 @@ export const updateBudgetPolicySchema = budgetPolicySchema;
 export type RuntimeBudgetPolicy = z.infer<typeof runtimeBudgetPolicySchema>;
 export type BudgetPolicy = z.infer<typeof budgetPolicySchema>;
 export type UpdateBudgetPolicyInput = z.infer<typeof updateBudgetPolicySchema>;
+export type ClaudeOAuthPlan = z.infer<typeof claudeOAuthPlanSchema>;

package/src/lib/workflows/engine.ts

@@ -16,6 +16,10 @@ import {
   buildSwarmWorkerPrompt,
   getSwarmWorkflowStructure,
 } from "./swarm";
+import {
+  openLearningSession,
+  closeLearningSession,
+} from "@/lib/agents/learning-session";
 
 /**
  * Execute a workflow by advancing through its steps according to the pattern.
@@ -43,6 +47,10 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
     timestamp: new Date(),
   });
 
+  // Open a learning session to buffer context proposals during execution.
+  // Proposals are collected and presented as a single batch at workflow end.
+  openLearningSession(workflowId);
+
   // Loop pattern manages its own lifecycle — delegate fully
   if (definition.pattern === "loop") {
     try {
@@ -72,6 +80,11 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
         }),
         timestamp: new Date(),
       });
+    } finally {
+      // Close learning session — flush buffered proposals as batch notification
+      await closeLearningSession(workflowId).catch((err) => {
+        console.error("[workflow-engine] Failed to close learning session:", err);
+      });
     }
     return;
   }
@@ -128,6 +141,11 @@ export async function executeWorkflow(workflowId: string): Promise<void> {
       }),
       timestamp: new Date(),
     });
+  } finally {
+    // Close learning session — flush buffered proposals as batch notification
+    await closeLearningSession(workflowId).catch((err) => {
+      console.error("[workflow-engine] Failed to close learning session:", err);
+    });
   }
 }