stagent 0.10.0 → 0.11.1

package/src/hooks/use-saved-searches.ts

@@ -0,0 +1,142 @@
+"use client";
+
+/**
+ * `useSavedSearches` — client-side store for saved filter combinations
+ * surfaced in the chat mention popover and `⌘K` palette.
+ *
+ * Mirrors `use-pinned-entries.ts`: fetches once on mount, keeps an
+ * in-memory list, and writes back via PUT on every mutation (full-list
+ * replacement — see `src/app/api/settings/chat/saved-searches/route.ts`
+ * for design rationale).
+ */
+
+import { useCallback, useEffect, useState } from "react";
+
+export type SavedSearchSurface =
+  | "task"
+  | "project"
+  | "workflow"
+  | "document"
+  | "skill"
+  | "profile";
+
+export interface SavedSearch {
+  id: string;
+  surface: SavedSearchSurface;
+  label: string;
+  filterInput: string;
+  createdAt: string;
+}
+
+interface UseSavedSearchesReturn {
+  searches: SavedSearch[];
+  loading: boolean;
+  save: (entry: Omit<SavedSearch, "id" | "createdAt">) => SavedSearch;
+  remove: (id: string) => void;
+  forSurface: (surface: SavedSearchSurface) => SavedSearch[];
+  /**
+   * Re-fetch from the server. Each `useSavedSearches()` consumer holds
+   * its own state — the chat popover and the ⌘K palette do not share a
+   * cache. Components that need to see edits made elsewhere (e.g. the
+   * palette opening after a save in the popover) call `refetch()` at
+   * the right moment to revalidate.
+   *
+   * See features/saved-search-polish-v1.md for the bug history.
+   */
+  refetch: () => Promise<void>;
+  rename: (id: string, label: string) => void;
+}
+
+export function useSavedSearches(): UseSavedSearchesReturn {
+  const [searches, setSearches] = useState<SavedSearch[]>([]);
+  const [loading, setLoading] = useState(true);
+
+  // Single fetch helper used by both the mount effect and `refetch`.
+  // Returns void so consumers can `await` revalidation if they want
+  // to wait for fresh data before continuing.
+  const fetchSearches = useCallback(async (): Promise<void> => {
+    try {
+      const r = await fetch("/api/settings/chat/saved-searches");
+      const data: { searches?: SavedSearch[] } = r.ok
+        ? await r.json()
+        : { searches: [] };
+      setSearches(data.searches ?? []);
+    } catch {
+      setSearches([]);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    void fetchSearches();
+  }, [fetchSearches]);
+
+  const persist = useCallback(async (next: SavedSearch[]) => {
+    try {
+      await fetch("/api/settings/chat/saved-searches", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ searches: next }),
+      });
+    } catch {
+      // Optimistic update already applied; server-sync failure silently
+      // swallowed. Matches the pins-hook contract.
+    }
+  }, []);
+
+  const save = useCallback(
+    (entry: Omit<SavedSearch, "id" | "createdAt">): SavedSearch => {
+      const full: SavedSearch = {
+        ...entry,
+        id:
+          typeof crypto !== "undefined" && "randomUUID" in crypto
+            ? crypto.randomUUID()
+            : `ss-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        createdAt: new Date().toISOString(),
+      };
+      setSearches((prev) => {
+        const next = [...prev, full];
+        void persist(next);
+        return next;
+      });
+      return full;
+    },
+    [persist]
+  );
+
+  const remove = useCallback(
+    (id: string) => {
+      setSearches((prev) => {
+        const next = prev.filter((s) => s.id !== id);
+        void persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+
+  const forSurface = useCallback(
+    (surface: SavedSearchSurface) =>
+      searches.filter((s) => s.surface === surface),
+    [searches]
+  );
+
+  const refetch = useCallback(() => fetchSearches(), [fetchSearches]);
+
+  const rename = useCallback(
+    (id: string, label: string) => {
+      setSearches((prev) => {
+        const idx = prev.findIndex((s) => s.id === id);
+        if (idx === -1) return prev;
+        const next = prev.slice();
+        next[idx] = { ...next[idx], label };
+        void persist(next);
+        return next;
+      });
+    },
+    [persist]
+  );
+
+  return { searches, loading, save, remove, forSurface, refetch, rename };
+}

package/src/lib/agents/__tests__/claude-agent-sdk-options.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+
+describe("claude-agent.ts SDK options parity with chat engine", () => {
+  const agentSource = fs.readFileSync(
+    path.resolve(__dirname, "../claude-agent.ts"),
+    "utf8",
+  );
+
+  // Split the source at the resumeClaudeTask function boundary. The first
+  // half contains executeClaudeTask's query() block; the second half contains
+  // resumeClaudeTask's query() block. This is more robust than a single
+  // regex over the whole file — a future edit that adds a stray `canUseTool`
+  // reference above either function won't cause a parity test to match the
+  // wrong query() call.
+  const resumeMarker = "export async function resumeClaudeTask";
+  const splitIndex = agentSource.indexOf(resumeMarker);
+  if (splitIndex === -1) {
+    throw new Error(
+      "claude-agent-sdk-options.test.ts: could not find `" + resumeMarker +
+      "` in claude-agent.ts — rename or refactor broke this test's assumptions",
+    );
+  }
+  const executeSection = agentSource.slice(0, splitIndex);
+  const resumeSection = agentSource.slice(splitIndex);
+
+  it("imports CLAUDE_SDK_ALLOWED_TOOLS from runtime/claude-sdk", () => {
+    expect(agentSource).toMatch(/CLAUDE_SDK_ALLOWED_TOOLS[\s\S]*runtime\/claude-sdk/);
+  });
+
+  it("imports CLAUDE_SDK_SETTING_SOURCES from runtime/claude-sdk", () => {
+    expect(agentSource).toMatch(/CLAUDE_SDK_SETTING_SOURCES[\s\S]*runtime\/claude-sdk/);
+  });
+
+  it("imports getFeaturesForModel to gate native-skill options", () => {
+    expect(agentSource).toMatch(/getFeaturesForModel/);
+  });
+
+  it("passes settingSources inside executeClaudeTask query() options", () => {
+    // The execute section must contain a query( call AND settingSources.
+    expect(executeSection).toMatch(/query\(/);
+    expect(executeSection).toContain("settingSources");
+  });
+
+  it("passes settingSources inside resumeClaudeTask query() options", () => {
+    expect(resumeSection).toMatch(/query\(/);
+    expect(resumeSection).toContain("settingSources");
+  });
+
+  it("hooks field is NOT present in either query() options block", () => {
+    for (const section of [executeSection, resumeSection]) {
+      expect(section).not.toMatch(/\bhooks\s*:/);
+    }
+  });
+});

package/src/lib/agents/__tests__/claude-agent.test.ts

@@ -292,10 +292,12 @@ describe("executeClaudeTask", () => {
     expect(stagentCount).toBe(1);
   });
 
-  it("A-stagent-3: omits allowedTools when profile has none (preset defaults preserved)", async () => {
+  it("A-stagent-3: falls back to CLAUDE_SDK_ALLOWED_TOOLS when profile has none and runtime has native skills", async () => {
     mockWhere.mockResolvedValueOnce([makeTask({ projectId: "proj-7" })]);
-    // Default mockGetProfile returns allowedTools: undefined, so ctx.payload.allowedTools
-    // will also be undefined — the query() call should NOT include an allowedTools option.
+    // Default mockGetProfile returns allowedTools: undefined. Task-runtime-skill-parity
+    // (Task 3) changed withStagentAllowedTools so the Phase 1a tool set (Skill,
+    // Read/Grep/Glob, Edit/Write/Bash, TodoWrite) is passed alongside mcp__stagent__*
+    // when the runtime has hasNativeSkills=true — which is the claude-code default.
     mockQuery.mockReturnValue(
       createMockStream([
         { type: "result", result: "done" },
@@ -307,7 +309,18 @@ describe("executeClaudeTask", () => {
     const queryCall = mockQuery.mock.calls[0][0] as {
       options: { allowedTools?: string[] };
     };
-    expect(queryCall.options.allowedTools).toBeUndefined();
+    expect(queryCall.options.allowedTools).toBeDefined();
+    expect(queryCall.options.allowedTools).toEqual([
+      "mcp__stagent__*",
+      "Skill",
+      "Read",
+      "Grep",
+      "Glob",
+      "Edit",
+      "Write",
+      "Bash",
+      "TodoWrite",
+    ]);
   });
 
   it("A3: captures sessionId from init message and re-calls setExecution", async () => {

package/src/lib/agents/__tests__/task-dispatch.test.ts

@@ -0,0 +1,166 @@
+import { randomUUID } from "crypto";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { eq } from "drizzle-orm";
+import { db } from "@/lib/db";
+import { agentLogs, notifications, tasks } from "@/lib/db/schema";
+import { RetryableRuntimeLaunchError } from "@/lib/agents/runtime/launch-failure";
+
+const {
+  mockExecuteTaskWithRuntime,
+  mockResumeTaskWithRuntime,
+  mockResolveTaskExecutionTarget,
+  mockResolveResumeExecutionTarget,
+} = vi.hoisted(() => ({
+  mockExecuteTaskWithRuntime: vi.fn(),
+  mockResumeTaskWithRuntime: vi.fn(),
+  mockResolveTaskExecutionTarget: vi.fn(),
+  mockResolveResumeExecutionTarget: vi.fn(),
+}));
+
+vi.mock("@/lib/agents/runtime", () => ({
+  executeTaskWithRuntime: mockExecuteTaskWithRuntime,
+  resumeTaskWithRuntime: mockResumeTaskWithRuntime,
+}));
+
+vi.mock("@/lib/agents/runtime/execution-target", () => ({
+  resolveTaskExecutionTarget: mockResolveTaskExecutionTarget,
+  resolveResumeExecutionTarget: mockResolveResumeExecutionTarget,
+}));
+
+import { startTaskExecution } from "../task-dispatch";
+
+function seedTask() {
+  const id = randomUUID();
+  const now = new Date();
+  db.insert(tasks)
+    .values({
+      id,
+      title: "Upgrade local clone",
+      description: "Merge upstream changes safely",
+      status: "queued",
+      assignedAgent: "claude-code",
+      agentProfile: "upgrade-assistant",
+      priority: 2,
+      resumeCount: 0,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+  return id;
+}
+
+describe("startTaskExecution", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    db.delete(notifications).run();
+    db.delete(agentLogs).run();
+    db.delete(tasks).run();
+  });
+
+  it("retries once on a retryable launch failure and persists the fallback runtime", async () => {
+    const taskId = seedTask();
+
+    mockResolveTaskExecutionTarget
+      .mockResolvedValueOnce({
+        requestedRuntimeId: "claude-code",
+        effectiveRuntimeId: "claude-code",
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      })
+      .mockResolvedValueOnce({
+        requestedRuntimeId: "claude-code",
+        effectiveRuntimeId: "openai-codex-app-server",
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      });
+
+    mockExecuteTaskWithRuntime
+      .mockRejectedValueOnce(
+        new RetryableRuntimeLaunchError({
+          runtimeId: "claude-code",
+          message:
+            "Claude Code failed to launch before task execution started: Claude Code process exited with code 1",
+          cause: new Error("Claude Code process exited with code 1"),
+        })
+      )
+      .mockResolvedValueOnce(undefined);
+
+    await startTaskExecution(taskId, { requestedRuntimeId: "claude-code" });
+
+    expect(mockExecuteTaskWithRuntime).toHaveBeenNthCalledWith(1, taskId, "claude-code");
+    expect(mockExecuteTaskWithRuntime).toHaveBeenNthCalledWith(
+      2,
+      taskId,
+      "openai-codex-app-server"
+    );
+    expect(mockResolveTaskExecutionTarget).toHaveBeenNthCalledWith(2, {
+      title: "Upgrade local clone",
+      description: "Merge upstream changes safely",
+      requestedRuntimeId: "claude-code",
+      profileId: "upgrade-assistant",
+      unavailableRuntimeIds: ["claude-code"],
+      unavailableReasons: {
+        "claude-code":
+          "Claude Code failed to launch before task execution started: Claude Code process exited with code 1",
+      },
+    });
+
+    const row = db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+    expect(row?.status).toBe("running");
+    expect(row?.effectiveRuntimeId).toBe("openai-codex-app-server");
+    expect(row?.runtimeFallbackReason).toContain("Fell back to OpenAI Codex App Server.");
+
+    const logs = db
+      .select({ event: agentLogs.event, payload: agentLogs.payload })
+      .from(agentLogs)
+      .where(eq(agentLogs.taskId, taskId))
+      .all();
+    expect(logs.map((log) => log.event)).toContain("runtime_launch_failed");
+    expect(logs.map((log) => log.event)).toContain("runtime_fallback");
+  });
+
+  it("marks the task failed when a retryable launch failure has no compatible alternate", async () => {
+    const taskId = seedTask();
+
+    mockResolveTaskExecutionTarget
+      .mockResolvedValueOnce({
+        requestedRuntimeId: "claude-code",
+        effectiveRuntimeId: "claude-code",
+        requestedModelId: null,
+        effectiveModelId: null,
+        fallbackApplied: false,
+        fallbackReason: null,
+      })
+      .mockRejectedValueOnce(
+        new Error("No compatible configured runtime is available for this task.")
+      );
+
+    mockExecuteTaskWithRuntime.mockRejectedValueOnce(
+      new RetryableRuntimeLaunchError({
+        runtimeId: "claude-code",
+        message:
+          "Claude Code failed to launch before task execution started: Claude Code process exited with code 1",
+        cause: new Error("Claude Code process exited with code 1"),
+      })
+    );
+
+    await expect(
+      startTaskExecution(taskId, { requestedRuntimeId: "claude-code" })
+    ).rejects.toThrow("No compatible configured runtime is available for this task.");
+
+    const row = db.select().from(tasks).where(eq(tasks.id, taskId)).get();
+    expect(row?.status).toBe("failed");
+    expect(row?.result).toBe("No compatible configured runtime is available for this task.");
+
+    const taskNotifications = db
+      .select()
+      .from(notifications)
+      .where(eq(notifications.taskId, taskId))
+      .all();
+    expect(taskNotifications).toHaveLength(1);
+  });
+});

package/src/lib/agents/__tests__/tool-permissions.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    insert: vi.fn(() => ({ values: vi.fn().mockResolvedValue(undefined) })),
+    select: vi.fn(() => ({ from: vi.fn(() => ({ where: vi.fn().mockResolvedValue([]) })) })),
+  },
+}));
+
+vi.mock("@/lib/settings/permissions", () => ({
+  isToolAllowed: vi.fn().mockResolvedValue(false),
+}));
+
+import { handleToolPermission, clearPermissionCache } from "@/lib/agents/tool-permissions";
+
+describe("handleToolPermission — SDK filesystem and Skill auto-allow", () => {
+  beforeEach(() => {
+    clearPermissionCache("test-task");
+    clearPermissionCache("test-task-edit");
+  });
+
+  it("auto-allows Read without creating a notification", async () => {
+    const result = await handleToolPermission("test-task", "Read", { file_path: "/tmp/x" });
+    expect(result.behavior).toBe("allow");
+    expect(result.updatedInput).toEqual({ file_path: "/tmp/x" });
+  });
+
+  it("auto-allows Grep", async () => {
+    const result = await handleToolPermission("test-task", "Grep", { pattern: "foo" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Glob", async () => {
+    const result = await handleToolPermission("test-task", "Glob", { pattern: "**/*.ts" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Skill invocations", async () => {
+    const result = await handleToolPermission("test-task", "Skill", { skill: "code-reviewer" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("does NOT auto-allow Edit (must route through notification flow)", async () => {
+    const { db } = await import("@/lib/db");
+    const insertSpy = vi.spyOn(db, "insert");
+    handleToolPermission("test-task-edit", "Edit", { file_path: "/tmp/x", content: "y" });
+    await new Promise((r) => setTimeout(r, 10));
+    expect(insertSpy).toHaveBeenCalled();
+  });
+
+  it("profile autoDeny for Read wins over auto-allow", async () => {
+    const result = await handleToolPermission(
+      "test-task",
+      "Read",
+      { file_path: "/tmp/x" },
+      { autoApprove: [], autoDeny: ["Read"] },
+    );
+    expect(result.behavior).toBe("deny");
+  });
+});