stagent 0.10.0 → 0.11.1

package/src/app/api/tasks/[id]/respond/route.ts

@@ -43,25 +43,41 @@ export async function POST(
     return NextResponse.json({ error: "Already responded" }, { status: 409 });
   }
 
-  // Validate updatedInput keys against the original tool input to prevent injection
+  // Validate updatedInput keys against the original tool input to prevent injection.
+  // AskUserQuestion is a special case: the original toolInput describes the question
+  // (`question`, `options?`) but the response carries the user's `answer` — a key not
+  // present in the original. Allow a tightly-scoped `{answer: string}` shape.
   let sanitizedUpdatedInput = updatedInput;
+  const isQuestion = notification.toolName === "AskUserQuestion";
   if (updatedInput !== undefined && updatedInput !== null && typeof updatedInput === "object" && !Array.isArray(updatedInput)) {
-    try {
-      const originalToolInput = typeof notification.toolInput === "string" ? JSON.parse(notification.toolInput) : (notification.toolInput ?? {});
-      if (typeof originalToolInput === "object" && originalToolInput !== null) {
-        const allowedKeys = new Set(Object.keys(originalToolInput));
-        const inputRecord = updatedInput as Record<string, unknown>;
-        const extraKeys = Object.keys(inputRecord).filter((k) => !allowedKeys.has(k));
-        if (extraKeys.length > 0) {
-          return NextResponse.json(
-            { error: `updatedInput contains disallowed keys: ${extraKeys.join(", ")}` },
-            { status: 400 }
-          );
+    if (isQuestion) {
+      const inputRecord = updatedInput as Record<string, unknown>;
+      const keys = Object.keys(inputRecord);
+      const extraKeys = keys.filter((k) => k !== "answer");
+      if (extraKeys.length > 0 || typeof inputRecord.answer !== "string") {
+        return NextResponse.json(
+          { error: "AskUserQuestion response must be { answer: string }" },
+          { status: 400 }
+        );
+      }
+    } else {
+      try {
+        const originalToolInput = typeof notification.toolInput === "string" ? JSON.parse(notification.toolInput) : (notification.toolInput ?? {});
+        if (typeof originalToolInput === "object" && originalToolInput !== null) {
+          const allowedKeys = new Set(Object.keys(originalToolInput));
+          const inputRecord = updatedInput as Record<string, unknown>;
+          const extraKeys = Object.keys(inputRecord).filter((k) => !allowedKeys.has(k));
+          if (extraKeys.length > 0) {
+            return NextResponse.json(
+              { error: `updatedInput contains disallowed keys: ${extraKeys.join(", ")}` },
+              { status: 400 }
+            );
+          }
         }
+      } catch {
+        // If we can't parse the original notification data, reject updatedInput entirely
+        sanitizedUpdatedInput = undefined;
       }
-    } catch {
-      // If we can't parse the original notification data, reject updatedInput entirely
-      sanitizedUpdatedInput = undefined;
     }
   }
 

package/src/app/api/tasks/[id]/resume/route.ts

@@ -2,13 +2,13 @@ import { NextRequest, NextResponse } from "next/server";
 import { db } from "@/lib/db";
 import { tasks } from "@/lib/db/schema";
 import { eq, and, inArray } from "drizzle-orm";
-import { resumeTaskWithAgent } from "@/lib/agents/router";
 import { MAX_RESUME_COUNT } from "@/lib/constants/task-status";
-import { DEFAULT_AGENT_RUNTIME } from "@/lib/agents/runtime/catalog";
 import {
   BudgetLimitExceededError,
   enforceTaskBudgetGuardrails,
 } from "@/lib/settings/budget-guardrails";
+import { resolveResumeExecutionTarget } from "@/lib/agents/runtime/execution-target";
+import { resumeTaskExecution } from "@/lib/agents/task-dispatch";
 
 export async function POST(
   _req: NextRequest,
@@ -67,8 +67,29 @@ export async function POST(
     );
   }
 
+  try {
+    await resolveResumeExecutionTarget({
+      requestedRuntimeId: task.assignedAgent,
+      effectiveRuntimeId: task.effectiveRuntimeId,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    db.update(tasks)
+      .set({
+        status: "failed",
+        result: message,
+        updatedAt: new Date(),
+      })
+      .where(eq(tasks.id, id))
+      .run();
+    return NextResponse.json({ error: message }, { status: 400 });
+  }
+
   // Fire-and-forget
-  resumeTaskWithAgent(id, task.assignedAgent ?? DEFAULT_AGENT_RUNTIME).catch((err) =>
+  resumeTaskExecution(id, {
+    requestedRuntimeId: task.assignedAgent,
+    effectiveRuntimeId: task.effectiveRuntimeId,
+  }).catch((err) =>
     console.error(`Task ${id} resume error:`, err)
   );
 

package/src/app/documents/page.tsx

@@ -1,3 +1,4 @@
+import { Suspense } from "react";
 import { db } from "@/lib/db";
 import { documents, tasks, projects, workflows } from "@/lib/db/schema";
 import { desc, eq } from "drizzle-orm";
@@ -47,7 +48,9 @@ export default async function DocumentsPage() {
 
   return (
     <PageShell title="Documents">
-      <DocumentBrowser initialDocuments={docs} projects={projectList} />
+      <Suspense fallback={null}>
+        <DocumentBrowser initialDocuments={docs} projects={projectList} />
+      </Suspense>
     </PageShell>
   );
 }

package/src/app/settings/page.tsx

@@ -7,6 +7,7 @@ import { ChatSettingsSection } from "@/components/settings/chat-settings-section
 import { RuntimeTimeoutSection } from "@/components/settings/runtime-timeout-section";
 import { BrowserToolsSection } from "@/components/settings/browser-tools-section";
 import { WebSearchSection } from "@/components/settings/web-search-section";
+import { EnvironmentSection } from "@/components/settings/environment-section";
 import { LearningContextSection } from "@/components/settings/learning-context-section";
 import { OllamaSection } from "@/components/settings/ollama-section";
 import { ChannelsSection } from "@/components/settings/channels-section";
@@ -29,6 +30,7 @@ export default function SettingsPage() {
         <RuntimeTimeoutSection />
         <LearningContextSection />
         <WebSearchSection />
+        <EnvironmentSection />
         <BrowserToolsSection />
         <ChannelsSection />
         <BudgetGuardrailsSection />

package/src/components/book/content-blocks.tsx

@@ -143,7 +143,7 @@ function CodeBlockView({
 
 /* ─── ImageBlock ─── */
 
-const BOOK_IMAGE_BASE = "https://raw.githubusercontent.com/navam-io/stagent/main/book/images";
+const BOOK_IMAGE_BASE = "https://raw.githubusercontent.com/manavsehgal/stagent/main/book/images";
 
 function ImageBlockView({
   src,

package/src/components/chat/__tests__/capability-banner.test.tsx

@@ -0,0 +1,38 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
+import { CapabilityBanner } from "../capability-banner";
+
+describe("CapabilityBanner", () => {
+  beforeEach(() => {
+    sessionStorage.clear();
+  });
+
+  it("is hidden on claude-code runtime", () => {
+    render(<CapabilityBanner runtimeId="claude-code" />);
+    expect(screen.queryByRole("status")).toBeNull();
+  });
+
+  it("is hidden on openai-codex-app-server runtime", () => {
+    render(<CapabilityBanner runtimeId="openai-codex-app-server" />);
+    expect(screen.queryByRole("status")).toBeNull();
+  });
+
+  it("is visible on ollama runtime with capability message", () => {
+    render(<CapabilityBanner runtimeId="ollama" />);
+    const status = screen.getByRole("status");
+    expect(status.textContent).toContain("file read/write");
+  });
+
+  it("hides on dismiss and persists to sessionStorage", () => {
+    render(<CapabilityBanner runtimeId="ollama" />);
+    fireEvent.click(screen.getByRole("button", { name: /dismiss/i }));
+    expect(screen.queryByRole("status")).toBeNull();
+    expect(sessionStorage.getItem("stagent.capability-banner.dismissed.ollama")).toBe("1");
+  });
+
+  it("stays dismissed on remount if sessionStorage flag set", () => {
+    sessionStorage.setItem("stagent.capability-banner.dismissed.ollama", "1");
+    render(<CapabilityBanner runtimeId="ollama" />);
+    expect(screen.queryByRole("status")).toBeNull();
+  });
+});

package/src/components/chat/__tests__/chat-session-provider.test.tsx

@@ -1,6 +1,6 @@
 import { act, render, screen, waitFor } from "@testing-library/react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import type { ChatMessageRow } from "@/lib/db/schema";
 import {
@@ -405,4 +405,169 @@ describe("ChatSessionProvider", () => {
       expect(screen.getByTestId("c-isStreaming").textContent).toBe("false");
     });
   });
+
+  it("view-remount telemetry pattern logs on unmount when streaming", async () => {
+    // Contract test for the `client.stream.view-remount` telemetry code.
+    // Mirrors the pattern ChatShell implements: track isStreaming in a ref,
+    // then log on unmount iff the ref was true. The ref is necessary because
+    // a stale closure would see isStreaming at effect-setup time, not at
+    // unmount time.
+    const consoleInfoSpy = vi
+      .spyOn(console, "info")
+      .mockImplementation(() => {});
+
+    function ViewRemountConsumer() {
+      const { isStreaming, activeId, sendMessage } = useChatSession();
+      const isStreamingRef = useRef(isStreaming);
+      const activeIdRef = useRef(activeId);
+      useEffect(() => {
+        isStreamingRef.current = isStreaming;
+      }, [isStreaming]);
+      useEffect(() => {
+        activeIdRef.current = activeId;
+      }, [activeId]);
+      useEffect(() => {
+        return () => {
+          if (isStreamingRef.current) {
+            // eslint-disable-next-line no-console
+            console.info("[chat-stream] client.stream.view-remount", {
+              conversationId: activeIdRef.current,
+            });
+          }
+        };
+        // Empty deps: run-once cleanup on unmount.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, []);
+      return (
+        <div>
+          <div data-testid="vr-isStreaming">{String(isStreaming)}</div>
+          <button
+            data-testid="vr-send"
+            onClick={() => void sendMessage("hello")}
+          >
+            send
+          </button>
+        </div>
+      );
+    }
+
+    function ViewRemountWrapper() {
+      const [mounted, setMounted] = useState(true);
+      return (
+        <ChatSessionProvider>
+          <button data-testid="vr-unmount" onClick={() => setMounted(false)}>
+            unmount
+          </button>
+          {mounted && <ViewRemountConsumer />}
+        </ChatSessionProvider>
+      );
+    }
+
+    const fetchMock = vi.fn(async (url: RequestInfo | URL, init?: RequestInit) => {
+      const u = url.toString();
+      if (u.startsWith("/api/settings/chat")) return new Response(null, { status: 204 });
+      if (u.startsWith("/api/chat/models")) return new Response(null, { status: 204 });
+      if (u === "/api/chat/conversations" || u.endsWith("/api/chat/conversations")) {
+        return new Response(
+          JSON.stringify({
+            id: "conv-vr",
+            projectId: null,
+            title: "T",
+            status: "active",
+            runtimeId: "claude-code",
+            modelId: "haiku",
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          }),
+          { status: 200 }
+        );
+      }
+      if (u.match(/\/api\/chat\/conversations\/conv-vr\/messages$/)) {
+        const signal = init?.signal as AbortSignal;
+        return new Response(makeHangingStream(signal), { status: 200 });
+      }
+      return new Response(null, { status: 404 });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    render(<ViewRemountWrapper />);
+
+    await act(async () => {
+      screen.getByTestId("vr-send").click();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId("vr-isStreaming").textContent).toBe("true");
+    });
+
+    // Unmount the consumer while streaming is in flight.
+    await act(async () => {
+      screen.getByTestId("vr-unmount").click();
+    });
+
+    expect(consoleInfoSpy).toHaveBeenCalledWith(
+      "[chat-stream] client.stream.view-remount",
+      expect.objectContaining({ conversationId: "conv-vr" })
+    );
+
+    consoleInfoSpy.mockRestore();
+  });
+
+  it("view-remount telemetry pattern does NOT log when not streaming", async () => {
+    // Guard case: unmounting without an active stream must not emit.
+    const consoleInfoSpy = vi
+      .spyOn(console, "info")
+      .mockImplementation(() => {});
+
+    function ViewRemountConsumer() {
+      const { isStreaming } = useChatSession();
+      const isStreamingRef = useRef(isStreaming);
+      useEffect(() => {
+        isStreamingRef.current = isStreaming;
+      }, [isStreaming]);
+      useEffect(() => {
+        return () => {
+          if (isStreamingRef.current) {
+            // eslint-disable-next-line no-console
+            console.info("[chat-stream] client.stream.view-remount", {
+              conversationId: null,
+            });
+          }
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, []);
+      return <div />;
+    }
+
+    function Wrapper() {
+      const [mounted, setMounted] = useState(true);
+      return (
+        <ChatSessionProvider>
+          <button data-testid="toggle" onClick={() => setMounted(false)}>
+            toggle
+          </button>
+          {mounted && <ViewRemountConsumer />}
+        </ChatSessionProvider>
+      );
+    }
+
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () => new Response(null, { status: 204 }))
+    );
+
+    render(<Wrapper />);
+
+    await act(async () => {
+      screen.getByTestId("toggle").click();
+    });
+
+    const viewRemountCalls = consoleInfoSpy.mock.calls.filter(
+      ([msg]) =>
+        typeof msg === "string" && msg.includes("client.stream.view-remount")
+    );
+    expect(viewRemountCalls).toHaveLength(0);
+
+    consoleInfoSpy.mockRestore();
+  });
 });

package/src/components/chat/__tests__/skill-row.test.tsx

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
+import { Command, CommandList } from "@/components/ui/command";
+import { SkillRow } from "../skill-row";
+import type { EnrichedSkill } from "@/lib/environment/skill-enrichment";
+
+const base: EnrichedSkill = {
+  id: "code-reviewer",
+  name: "code-reviewer",
+  tool: "claude-code",
+  scope: "user",
+  preview: "Review PRs for security",
+  sizeBytes: 100,
+  absPath: "/p",
+  absPaths: ["/p"],
+  healthScore: "healthy",
+  syncStatus: "synced",
+  linkedProfileId: "code-reviewer-profile",
+};
+
+// SkillRow uses CommandItem, which must live inside a cmdk Command/CommandList
+function renderRow(skill: EnrichedSkill, recommended = false) {
+  return render(
+    <Command>
+      <CommandList>
+        <SkillRow skill={skill} recommended={recommended} onSelect={() => {}} />
+      </CommandList>
+    </Command>
+  );
+}
+
+describe("SkillRow", () => {
+  it("renders skill name and description", () => {
+    renderRow(base);
+    expect(screen.getByText("code-reviewer")).toBeInTheDocument();
+    expect(screen.getByText(/Review PRs/)).toBeInTheDocument();
+  });
+
+  it("shows synced badge when syncStatus is synced", () => {
+    renderRow(base);
+    expect(screen.getByText(/synced/i)).toBeInTheDocument();
+  });
+
+  it("shows profile linkage badge", () => {
+    renderRow(base);
+    expect(screen.getByText(/code-reviewer-profile/)).toBeInTheDocument();
+  });
+
+  it("shows 'stale' badge for stale health", () => {
+    renderRow({ ...base, healthScore: "stale" });
+    expect(screen.getByText(/stale/i)).toBeInTheDocument();
+  });
+
+  it("shows a recommended indicator when recommended=true", () => {
+    renderRow(base, true);
+    expect(screen.getByLabelText(/recommended/i)).toBeInTheDocument();
+  });
+
+  it("calls onDismissRecommendation when X is clicked", () => {
+    const onDismiss = vi.fn();
+    render(
+      <Command>
+        <CommandList>
+          <SkillRow
+            skill={base}
+            recommended
+            onSelect={() => {}}
+            onDismissRecommendation={onDismiss}
+          />
+        </CommandList>
+      </Command>
+    );
+    fireEvent.click(screen.getByLabelText("Dismiss recommendation"));
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not render dismiss button when not recommended", () => {
+    render(
+      <Command>
+        <CommandList>
+          <SkillRow
+            skill={base}
+            onSelect={() => {}}
+            onDismissRecommendation={() => {}}
+          />
+        </CommandList>
+      </Command>
+    );
+    expect(screen.queryByLabelText("Dismiss recommendation")).toBeNull();
+  });
+});

package/src/components/chat/capability-banner.tsx

@@ -0,0 +1,68 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { X } from "lucide-react";
+import { getRuntimeFeatures, type AgentRuntimeId } from "@/lib/agents/runtime/catalog";
+import { cn } from "@/lib/utils";
+
+interface CapabilityBannerProps {
+  runtimeId: AgentRuntimeId;
+  className?: string;
+}
+
+function dismissKey(runtimeId: string): string {
+  return `stagent.capability-banner.dismissed.${runtimeId}`;
+}
+
+function readDismissed(runtimeId: string): boolean {
+  if (typeof window === "undefined") return false;
+  try {
+    return window.sessionStorage.getItem(dismissKey(runtimeId)) === "1";
+  } catch {
+    return false;
+  }
+}
+
+export function CapabilityBanner({ runtimeId, className }: CapabilityBannerProps) {
+  const [dismissed, setDismissed] = useState<boolean>(() => readDismissed(runtimeId));
+
+  useEffect(() => {
+    setDismissed(readDismissed(runtimeId));
+  }, [runtimeId]);
+
+  const features = getRuntimeFeatures(runtimeId);
+  const limited = !features.hasFilesystemTools && !features.hasBash;
+
+  if (!limited || dismissed) return null;
+
+  const handleDismiss = () => {
+    setDismissed(true);
+    try {
+      window.sessionStorage.setItem(dismissKey(runtimeId), "1");
+    } catch {
+      // ignore
+    }
+  };
+
+  return (
+    <div
+      role="status"
+      className={cn(
+        "flex items-start gap-2 px-4 py-1.5 text-xs text-muted-foreground animate-in fade-in-0",
+        className
+      )}
+    >
+      <span className="flex-1">
+        Features like file read/write, Bash, and hooks are not available on this runtime. Switch models to use them.
+      </span>
+      <button
+        type="button"
+        aria-label="Dismiss capability notice"
+        onClick={handleDismiss}
+        className="shrink-0 rounded p-0.5 hover:bg-muted focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+      >
+        <X className="h-3 w-3" />
+      </button>
+    </div>
+  );
+}