stagent 0.1.10 → 0.1.12

package/src/__tests__/e2e/single-task.test.ts

@@ -0,0 +1,170 @@
+/**
+ * E2E: Single task execution across profiles and runtimes.
+ *
+ * Tests that individual tasks execute and produce results via both
+ * Claude Code and Codex runtimes with different agent profiles.
+ */
+
+import {
+  setupE2E,
+  teardownE2E,
+  testProjectId,
+  claudeAvailable,
+  codexAvailable,
+} from "./setup";
+import {
+  createTask,
+  executeTask,
+  pollTaskUntilDone,
+  updateTask,
+} from "./helpers";
+
+beforeAll(async () => {
+  await setupE2E();
+});
+
+afterAll(async () => {
+  await teardownE2E();
+});
+
+// ---------------------------------------------------------------------------
+// Claude Code runtime
+// ---------------------------------------------------------------------------
+
+describe("Single Task — Claude Code", () => {
+  beforeAll(() => {
+    if (!claudeAvailable) {
+      console.warn("Skipping Claude Code tests — runtime not available");
+    }
+  });
+
+  it.skipIf(!claudeAvailable)(
+    "general profile describes code",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Describe the TypeScript code in src/",
+        description:
+          "Read the TypeScript files in the project and describe what the code does.",
+        projectId: testProjectId,
+        agentProfile: "general",
+      });
+      expect(ok).toBe(true);
+
+      // Queue → execute
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      // Poll until done
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+      expect(result.result!.length).toBeGreaterThan(50);
+    }
+  );
+
+  it.skipIf(!claudeAvailable)(
+    "code-reviewer profile finds bugs",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Review code for bugs",
+        description:
+          "Review all TypeScript files in the project. Find bugs and report them with severity levels.",
+        projectId: testProjectId,
+        agentProfile: "code-reviewer",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+      // Code reviewer should find at least some issues
+      expect(result.result!.length).toBeGreaterThan(100);
+    }
+  );
+
+  it.skipIf(!claudeAvailable)(
+    "document-writer profile generates overview",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Write a technical overview document",
+        description:
+          "Generate a technical overview of this project including structure, modules, and dependencies.",
+        projectId: testProjectId,
+        agentProfile: "document-writer",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+    }
+  );
+});
+
+// ---------------------------------------------------------------------------
+// Codex runtime
+// ---------------------------------------------------------------------------
+
+describe("Single Task — Codex", () => {
+  beforeAll(() => {
+    if (!codexAvailable) {
+      console.warn("Skipping Codex tests — runtime not available");
+    }
+  });
+
+  it.skipIf(!codexAvailable)(
+    "general profile describes code via Codex",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Describe the TypeScript code in src/",
+        description:
+          "Read the TypeScript files in the project and describe what the code does.",
+        projectId: testProjectId,
+        assignedAgent: "codex",
+        agentProfile: "general",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+      expect(result.result!.length).toBeGreaterThan(50);
+    }
+  );
+
+  it.skipIf(!codexAvailable)(
+    "code-reviewer profile finds bugs via Codex",
+    async () => {
+      const { ok, data: task } = await createTask({
+        title: "Review code for bugs",
+        description:
+          "Review all TypeScript files in the project. Find bugs and report them with severity levels.",
+        projectId: testProjectId,
+        assignedAgent: "codex",
+        agentProfile: "code-reviewer",
+      });
+      expect(ok).toBe(true);
+
+      await updateTask(task!.id, { status: "queued" });
+      const exec = await executeTask(task!.id);
+      expect(exec.status).toBe(202);
+
+      const result = await pollTaskUntilDone(task!.id);
+      expect(result.status).toBe("completed");
+      expect(result.result).toBeTruthy();
+    }
+  );
+});

package/src/app/api/command-palette/recent/route.ts

@@ -2,30 +2,53 @@ import { NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { projects, tasks } from "@/lib/db/schema";
 import { desc } from "drizzle-orm";
+import { getManifest } from "@/lib/docs/reader";
 
 export async function GET() {
-  const recentProjects = await db
-    .select({
-      id: projects.id,
-      name: projects.name,
-      status: projects.status,
-    })
-    .from(projects)
-    .orderBy(desc(projects.updatedAt))
-    .limit(5);
+  const [recentProjects, recentTasks] = await Promise.all([
+    db
+      .select({
+        id: projects.id,
+        name: projects.name,
+        status: projects.status,
+      })
+      .from(projects)
+      .orderBy(desc(projects.updatedAt))
+      .limit(5),
+    db
+      .select({
+        id: tasks.id,
+        title: tasks.title,
+        status: tasks.status,
+      })
+      .from(tasks)
+      .orderBy(desc(tasks.updatedAt))
+      .limit(5),
+  ]);
 
-  const recentTasks = await db
-    .select({
-      id: tasks.id,
-      title: tasks.title,
-      status: tasks.status,
-    })
-    .from(tasks)
-    .orderBy(desc(tasks.updatedAt))
-    .limit(5);
+  // Read playbook items from manifest
+  let playbook: { slug: string; title: string; tags: string[] }[] = [];
+  try {
+    const manifest = getManifest();
+    playbook = [
+      ...manifest.sections.map((s) => ({
+        slug: s.slug,
+        title: s.title,
+        tags: s.tags,
+      })),
+      ...manifest.journeys.map((j) => ({
+        slug: j.slug,
+        title: j.title,
+        tags: [j.persona, j.difficulty],
+      })),
+    ];
+  } catch {
+    // docs/manifest.json may not exist — graceful fallback
+  }
 
   return NextResponse.json({
     projects: recentProjects,
     tasks: recentTasks,
+    playbook,
   });
 }

package/src/app/api/context/batch/route.ts

@@ -0,0 +1,44 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  batchApproveProposals,
+  batchRejectProposals,
+} from "@/lib/agents/learning-session";
+
+const batchSchema = z.object({
+  proposalIds: z.array(z.string().min(1)).min(1),
+  action: z.enum(["approve", "reject"]),
+});
+
+/**
+ * POST /api/context/batch — batch approve or reject context proposals.
+ *
+ * Used by the batch proposal review UI after workflow completion.
+ * Accepts an array of learned_context row IDs and an action.
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const parsed = batchSchema.safeParse(body);
+
+    if (!parsed.success) {
+      return NextResponse.json(
+        { error: "proposalIds (string[]) and action ('approve'|'reject') are required" },
+        { status: 400 }
+      );
+    }
+
+    const { proposalIds, action } = parsed.data;
+
+    const count =
+      action === "approve"
+        ? await batchApproveProposals(proposalIds)
+        : await batchRejectProposals(proposalIds);
+
+    return NextResponse.json({ success: true, action, count });
+  } catch (err: unknown) {
+    const message =
+      err instanceof Error ? err.message : "Batch operation failed";
+    return NextResponse.json({ error: message }, { status: 500 });
+  }
+}

package/src/app/api/permissions/presets/route.ts

@@ -0,0 +1,80 @@
+import { NextRequest, NextResponse } from "next/server";
+import { z } from "zod";
+import {
+  getPreset,
+  getActivePresets,
+  applyPreset,
+  removePreset,
+  PRESETS,
+} from "@/lib/settings/permission-presets";
+
+const presetSchema = z.object({
+  presetId: z.string().min(1),
+});
+
+/**
+ * GET /api/permissions/presets — list all presets with their active status.
+ */
+export async function GET() {
+  const activeIds = await getActivePresets();
+  const activeSet = new Set(activeIds);
+
+  const presets = PRESETS.map((p) => ({
+    ...p,
+    active: activeSet.has(p.id),
+  }));
+
+  return NextResponse.json({ presets });
+}
+
+/**
+ * POST /api/permissions/presets — enable a preset (adds all its patterns).
+ */
+export async function POST(req: NextRequest) {
+  const body = await req.json();
+  const parsed = presetSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "presetId (string) is required" },
+      { status: 400 }
+    );
+  }
+
+  const preset = getPreset(parsed.data.presetId);
+  if (!preset) {
+    return NextResponse.json(
+      { error: `Unknown preset: ${parsed.data.presetId}` },
+      { status: 404 }
+    );
+  }
+
+  await applyPreset(parsed.data.presetId);
+  return NextResponse.json({ success: true });
+}
+
+/**
+ * DELETE /api/permissions/presets — disable a preset (removes unique patterns).
+ */
+export async function DELETE(req: NextRequest) {
+  const body = await req.json();
+  const parsed = presetSchema.safeParse(body);
+
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "presetId (string) is required" },
+      { status: 400 }
+    );
+  }
+
+  const preset = getPreset(parsed.data.presetId);
+  if (!preset) {
+    return NextResponse.json(
+      { error: `Unknown preset: ${parsed.data.presetId}` },
+      { status: 404 }
+    );
+  }
+
+  await removePreset(parsed.data.presetId);
+  return NextResponse.json({ success: true });
+}

package/src/app/api/playbook/status/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import { getDocsLastGenerated } from "@/lib/docs/reader";
+import { getSetting } from "@/lib/settings/helpers";
+
+export async function GET() {
+  const lastGenerated = getDocsLastGenerated();
+  const lastVisit = await getSetting("lastPlaybookVisit");
+
+  const hasUpdates =
+    lastGenerated != null &&
+    lastVisit != null &&
+    new Date(lastGenerated) > new Date(lastVisit);
+
+  return NextResponse.json({ hasUpdates });
+}

package/src/app/api/profiles/route.ts

@@ -1,29 +1,31 @@
 import { NextRequest, NextResponse } from "next/server";
 import { listProfiles, createProfile, isBuiltin } from "@/lib/agents/profiles/registry";
+import { sortProfilesByName } from "@/lib/agents/profiles/sort";
 import { ProfileConfigSchema } from "@/lib/validators/profile";
 
 export async function GET() {
-  const profiles = listProfiles().map((p) => ({
-    id: p.id,
-    name: p.name,
-    description: p.description,
-    domain: p.domain,
-    tags: p.tags,
-    skillMd: p.skillMd,
-    allowedTools: p.allowedTools,
-    mcpServers: p.mcpServers,
-    canUseToolPolicy: p.canUseToolPolicy,
-    temperature: p.temperature,
-    maxTurns: p.maxTurns,
-    outputFormat: p.outputFormat,
-    version: p.version,
-    author: p.author,
-    source: p.source,
-    tests: p.tests,
-    supportedRuntimes: p.supportedRuntimes,
-    runtimeOverrides: p.runtimeOverrides,
-    isBuiltin: isBuiltin(p.id),
-  }));
+  const profiles = sortProfilesByName(
+    listProfiles().map((p) => ({
+      id: p.id,
+      name: p.name,
+      description: p.description,
+      domain: p.domain,
+      tags: p.tags,
+      skillMd: p.skillMd,
+      allowedTools: p.allowedTools,
+      mcpServers: p.mcpServers,
+      canUseToolPolicy: p.canUseToolPolicy,
+      maxTurns: p.maxTurns,
+      outputFormat: p.outputFormat,
+      version: p.version,
+      author: p.author,
+      source: p.source,
+      tests: p.tests,
+      supportedRuntimes: p.supportedRuntimes,
+      runtimeOverrides: p.runtimeOverrides,
+      isBuiltin: isBuiltin(p.id),
+    }))
+  );
 
   return NextResponse.json(profiles);
 }

package/src/app/api/settings/pricing/route.ts

@@ -0,0 +1,15 @@
+import { NextResponse } from "next/server";
+import {
+  getPricingRegistrySnapshot,
+  refreshPricingRegistry,
+} from "@/lib/usage/pricing-registry";
+
+export async function GET() {
+  const snapshot = await getPricingRegistrySnapshot();
+  return NextResponse.json(snapshot);
+}
+
+export async function POST() {
+  const snapshot = await refreshPricingRegistry();
+  return NextResponse.json(snapshot);
+}

package/src/app/costs/page.tsx

@@ -1,4 +1,3 @@
-import { listRuntimeCatalog } from "@/lib/agents/runtime/catalog";
 import { CostDashboard } from "@/components/costs/cost-dashboard";
 import { getBudgetGuardrailSnapshot } from "@/lib/settings/budget-guardrails";
 import {
@@ -13,8 +12,6 @@ import {
 
 export const dynamic = "force-dynamic";
 
-const runtimeCatalog = listRuntimeCatalog();
-const validRuntimeIds = new Set<string>(runtimeCatalog.map((runtime) => runtime.id));
 const validDateRanges = new Set(["7d", "30d", "90d", "all"]);
 const validStatuses = new Set<UsageLedgerStatus>([
   "completed",
@@ -40,10 +37,6 @@ function resolveDateRange(value: string | undefined) {
   return value && validDateRanges.has(value) ? value : "30d";
 }
 
-function resolveRuntime(value: string | undefined) {
-  return value && validRuntimeIds.has(value) ? value : "all";
-}
-
 function resolveStatus(value: string | undefined) {
   return value && validStatuses.has(value as UsageLedgerStatus) ? value : "all";
 }
@@ -102,25 +95,6 @@ function fillSeries<T extends { day: string }>(
   return keys.map((key) => values.get(key) ?? 0);
 }
 
-function findOverallSpend(
-  statuses: Array<{
-    scopeId: string;
-    window: string;
-    metric: string;
-    currentValue: number;
-  }>,
-  window: "daily" | "monthly"
-) {
-  return (
-    statuses.find(
-      (status) =>
-        status.scopeId === "overall" &&
-        status.window === window &&
-        status.metric === "spend"
-    )?.currentValue ?? 0
-  );
-}
-
 function buildRuntimeBreakdown(
   rows: ProviderModelBreakdownEntry[]
 ): Array<{
@@ -149,9 +123,7 @@ function buildRuntimeBreakdown(
   for (const row of rows) {
     const current = totals.get(row.runtimeId) ?? {
       runtimeId: row.runtimeId,
-      label:
-        runtimeCatalog.find((runtime) => runtime.id === row.runtimeId)?.label ??
-        row.runtimeId,
+      label: row.runtimeId,
       providerId: row.providerId,
       costMicros: 0,
       totalTokens: 0,
@@ -191,22 +163,34 @@ export default async function CostsPage({
 }) {
   const params = await searchParams;
   const dateRange = resolveDateRange(toScalar(params.range));
-  const runtimeId = resolveRuntime(toScalar(params.runtime));
   const status = resolveStatus(toScalar(params.status));
   const activityType = resolveActivityType(toScalar(params.activity));
-
   const rangeStart = getRangeStart(dateRange);
-  const [spendRows30, tokenRows30, monthBreakdown, filteredBreakdown, auditEntries, budgetSnapshot] =
+
+  const budgetSnapshot = await getBudgetGuardrailSnapshot();
+  const configuredRuntimeIds = Object.values(budgetSnapshot.runtimeStates)
+    .filter((runtime) => runtime.configured)
+    .map((runtime) => runtime.runtimeId);
+  const requestedRuntime = toScalar(params.runtime);
+  const runtimeId =
+    requestedRuntime && configuredRuntimeIds.includes(requestedRuntime as never)
+      ? requestedRuntime
+      : "all";
+
+  const [spendRows30, tokenRows30, monthBreakdown, filteredBreakdown, auditEntries] =
     await Promise.all([
       getDailySpendTotals(30),
       getDailyTokenTotals(30),
       getProviderModelBreakdown({ startedAt: startOfCurrentMonth() }),
-      getProviderModelBreakdown(
-        rangeStart ? { startedAt: rangeStart } : undefined
-      ),
+      getProviderModelBreakdown(rangeStart ? { startedAt: rangeStart } : undefined),
       listUsageAuditEntries({
         limit: 100,
-        runtimeIds: runtimeId === "all" ? undefined : [runtimeId],
+        runtimeIds:
+          runtimeId === "all"
+            ? configuredRuntimeIds.length > 0
+              ? configuredRuntimeIds
+              : undefined
+            : [runtimeId],
         statuses: status === "all" ? undefined : [status as UsageLedgerStatus],
         activityTypes:
           activityType === "all"
@@ -214,17 +198,38 @@ export default async function CostsPage({
             : [activityType as UsageActivityType],
         startedAt: rangeStart,
       }),
-      getBudgetGuardrailSnapshot(),
     ]);
 
+  const configuredBreakdown = filteredBreakdown.filter((row) =>
+    configuredRuntimeIds.length > 0
+      ? configuredRuntimeIds.includes(row.runtimeId as never)
+      : true
+  );
+  const configuredMonthBreakdown = monthBreakdown.filter((row) =>
+    configuredRuntimeIds.length > 0
+      ? configuredRuntimeIds.includes(row.runtimeId as never)
+      : true
+  );
+
   const spendSeries30 = fillSeries(30, spendRows30, (row) => row.costMicros);
   const tokenSeries30 = fillSeries(30, tokenRows30, (row) => row.totalTokens);
-  const runtimeBreakdown = buildRuntimeBreakdown(filteredBreakdown);
-  const monthTokens = monthBreakdown.reduce(
+  const runtimeBreakdown = buildRuntimeBreakdown(configuredBreakdown).map((row) => ({
+    ...row,
+    label: budgetSnapshot.runtimeStates[row.runtimeId as keyof typeof budgetSnapshot.runtimeStates]
+      ?.label ?? row.runtimeId,
+  }));
+  const monthTokens = configuredMonthBreakdown.reduce(
     (sum, row) => sum + row.totalTokens,
     0
   );
 
+  const overallDaily = budgetSnapshot.statuses.find(
+    (status) => status.scopeId === "overall" && status.window === "daily"
+  );
+  const overallMonthly = budgetSnapshot.statuses.find(
+    (status) => status.scopeId === "overall" && status.window === "monthly"
+  );
+
   return (
     <div className="gradient-neutral min-h-screen p-6">
       <CostDashboard
@@ -235,9 +240,12 @@ export default async function CostsPage({
           activityType,
         }}
         summary={{
-          todaySpendMicros: findOverallSpend(budgetSnapshot.statuses, "daily"),
-          monthSpendMicros: findOverallSpend(budgetSnapshot.statuses, "monthly"),
-          todayTokens: tokenSeries30[tokenSeries30.length - 1] ?? 0,
+          monthSpendMicros: overallMonthly?.currentValue ?? 0,
+          derivedDailyBudgetMicros: overallDaily?.limitValue ?? 0,
+          remainingMonthlyHeadroomMicros: Math.max(
+            (overallMonthly?.limitValue ?? 0) - (overallMonthly?.currentValue ?? 0),
+            0
+          ),
           monthTokens,
         }}
         trendSeries={{
@@ -247,8 +255,10 @@ export default async function CostsPage({
           tokens30: tokenSeries30,
         }}
         budgetStatuses={budgetSnapshot.statuses}
+        runtimeStates={budgetSnapshot.runtimeStates}
+        pricing={budgetSnapshot.pricing}
         runtimeBreakdown={runtimeBreakdown}
-        modelBreakdown={filteredBreakdown}
+        modelBreakdown={configuredBreakdown}
         auditEntries={auditEntries}
       />
     </div>

package/src/app/globals.css

@@ -446,11 +446,6 @@
   box-shadow: var(--glass-shadow-sm);
 }
 
-/* Temperature slider gradient track */
-.slider-temperature [data-slot="slider-range"] {
-  background: linear-gradient(90deg, oklch(0.6 0.18 260), oklch(0.7 0.15 55));
-}
-
 [data-slot="popover-content"],
 [data-slot="dropdown-menu-content"],
 [data-slot="select-content"] {