stagent 0.10.0 → 0.11.0

package/src/lib/chat/__tests__/context-builder-files.test.ts

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockFs } = vi.hoisted(() => ({
+  mockFs: {
+    realpathMap: new Map<string, string>(),
+    files: new Map<string, string>(),
+    statMap: new Map<string, { size: number }>(),
+  },
+}));
+
+vi.mock("node:fs", () => {
+  const realpathSync = (p: string) => {
+    const real = mockFs.realpathMap.get(p);
+    if (real === undefined) throw new Error(`ENOENT: realpath ${p}`);
+    return real;
+  };
+  const statSync = (p: string) => {
+    const s = mockFs.statMap.get(p);
+    if (!s) throw new Error(`ENOENT: stat ${p}`);
+    return s;
+  };
+  const readFileSync = (p: string) => {
+    const content = mockFs.files.get(p);
+    if (content === undefined) throw new Error(`ENOENT: read ${p}`);
+    return content;
+  };
+  return {
+    default: { realpathSync, statSync, readFileSync },
+    realpathSync,
+    statSync,
+    readFileSync,
+  };
+});
+
+import { expandFileMention } from "../files/expand-mention";
+
+const CWD = "/repo";
+
+beforeEach(() => {
+  mockFs.realpathMap.clear();
+  mockFs.files.clear();
+  mockFs.statMap.clear();
+  mockFs.realpathMap.set(CWD, CWD);
+});
+
+function registerFile(relPath: string, content: string) {
+  const abs = `${CWD}/${relPath}`;
+  mockFs.files.set(abs, content);
+  mockFs.statMap.set(abs, { size: Buffer.byteLength(content, "utf8") });
+}
+
+describe("expandFileMention", () => {
+  it("inlines files under 8 KB with a path header and fenced code block", () => {
+    registerFile("src/a.ts", "export const x = 1;\n");
+    const out = expandFileMention("src/a.ts", CWD).join("\n");
+    expect(out).toContain("### File: src/a.ts");
+    expect(out).toContain("```ts");
+    expect(out).toContain("export const x = 1;");
+    expect(out).toContain("```");
+  });
+
+  it("references files >= 8 KB without inlining their content", () => {
+    const big = "A".repeat(10 * 1024);
+    registerFile("docs/large.md", big);
+    const out = expandFileMention("docs/large.md", CWD).join("\n");
+    expect(out).toContain("File (by reference): docs/large.md");
+    expect(out).toContain("KB)"); // size hint
+    expect(out).toContain("Use the Read tool");
+    expect(out).not.toContain(big); // content not inlined
+  });
+
+  it("emits a not-found note when the file no longer exists", () => {
+    const out = expandFileMention("src/gone.ts", CWD).join("\n");
+    expect(out).toContain("### File: src/gone.ts");
+    expect(out).toContain("(file not found at context-build time)");
+  });
+
+  it("rejects paths that resolve outside cwd (security guardrail)", () => {
+    const out = expandFileMention("../escape.ts", CWD).join("\n");
+    expect(out).toContain("(invalid path — escapes working directory)");
+    expect(out).not.toContain("(file not found"); // did not even try to read
+  });
+
+  it("skips pathological files >= 50 MB silently (returns empty)", () => {
+    const abs = `${CWD}/huge.bin`;
+    mockFs.statMap.set(abs, { size: 60 * 1024 * 1024 });
+    // readFileSync is never reached
+    const out = expandFileMention("huge.bin", CWD);
+    expect(out).toEqual([]);
+  });
+
+  it("picks an 'unknown' code-fence language for files without an extension", () => {
+    const abs = `${CWD}/Makefile`;
+    mockFs.files.set(abs, "all:\n\techo ok\n");
+    mockFs.statMap.set(abs, { size: 16 });
+    const out = expandFileMention("Makefile", CWD).join("\n");
+    // .split(".").pop() on a name with no dot returns the whole name,
+    // which is the best we can do without a language map. We just
+    // assert a header + a closing fence are present.
+    expect(out).toContain("### File: Makefile");
+    expect(out).toMatch(/```[\w]*/);
+    expect(out).toContain("all:");
+  });
+
+  it("emits a read-failure note if the file stats OK but reads throw", () => {
+    const abs = `${CWD}/src/binary.ico`;
+    mockFs.statMap.set(abs, { size: 100 });
+    // Do NOT register contents — readFileSync will throw
+    const out = expandFileMention("src/binary.ico", CWD).join("\n");
+    expect(out).toContain("(file could not be read as UTF-8)");
+  });
+});

package/src/lib/chat/__tests__/dismissals.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from "vitest";
+import {
+  loadDismissals,
+  saveDismissal,
+  activeDismissedIds,
+  DISMISSAL_TTL_MS,
+} from "../dismissals";
+
+type Store = { read: () => string | null; write: (v: string) => void };
+
+function mockStore(initial: string | null = null): Store {
+  let v = initial;
+  return {
+    read: () => v,
+    write: (next) => {
+      v = next;
+    },
+  };
+}
+
+describe("dismissals", () => {
+  const NOW = 1_700_000_000_000;
+
+  it("returns empty when store is null", () => {
+    const store = mockStore();
+    const all = loadDismissals(store);
+    expect(all).toEqual({});
+  });
+
+  it("saves dismissals keyed by conversation + skill", () => {
+    const store = mockStore();
+    saveDismissal(store, "conv-1", "skill-a", NOW);
+    const all = loadDismissals(store);
+    expect(all["conv-1"]["skill-a"]).toBe(NOW);
+  });
+
+  it("activeDismissedIds excludes expired entries", () => {
+    const store = mockStore();
+    saveDismissal(store, "c1", "fresh", NOW);
+    saveDismissal(store, "c1", "old", NOW - DISMISSAL_TTL_MS - 1000);
+    const ids = activeDismissedIds(store, "c1", NOW);
+    expect(ids.has("fresh")).toBe(true);
+    expect(ids.has("old")).toBe(false);
+  });
+
+  it("returns empty set when conversation has no dismissals", () => {
+    const store = mockStore();
+    expect(activeDismissedIds(store, "never-seen", NOW).size).toBe(0);
+  });
+
+  it("silently tolerates store write errors", () => {
+    const store: Store = {
+      read: () => null,
+      write: () => {
+        throw new Error("quota");
+      },
+    };
+    expect(() => saveDismissal(store, "c1", "s1", NOW)).not.toThrow();
+  });
+
+  it("silently tolerates corrupt JSON on read", () => {
+    const store = mockStore("not-json");
+    expect(loadDismissals(store)).toEqual({});
+  });
+});

package/src/lib/chat/__tests__/engine-sdk-options.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vitest";
+import {
+  CLAUDE_SDK_ALLOWED_TOOLS,
+  CLAUDE_SDK_SETTING_SOURCES,
+  CLAUDE_SDK_READ_ONLY_FS_TOOLS,
+} from "@/lib/chat/engine";
+
+describe("Claude SDK options (Phase 1a)", () => {
+  it("declares settingSources loading user and project config", () => {
+    expect(CLAUDE_SDK_SETTING_SOURCES).toEqual(["user", "project"]);
+  });
+
+  it("includes Skill, filesystem tools, Bash, and TodoWrite in allowedTools", () => {
+    expect(CLAUDE_SDK_ALLOWED_TOOLS).toEqual(
+      expect.arrayContaining([
+        "Skill",
+        "Read",
+        "Grep",
+        "Glob",
+        "Edit",
+        "Write",
+        "Bash",
+        "TodoWrite",
+      ])
+    );
+  });
+
+  it("does NOT include Task (subagent delegation replaced by Stagent primitives)", () => {
+    expect(CLAUDE_SDK_ALLOWED_TOOLS).not.toContain("Task");
+  });
+
+  it("declares Read, Grep, Glob as read-only filesystem tools", () => {
+    expect(CLAUDE_SDK_READ_ONLY_FS_TOOLS).toEqual(
+      new Set(["Read", "Grep", "Glob"])
+    );
+  });
+
+  it("does NOT treat Edit, Write, Bash, or TodoWrite as read-only", () => {
+    for (const tool of ["Edit", "Write", "Bash", "TodoWrite"]) {
+      expect(CLAUDE_SDK_READ_ONLY_FS_TOOLS.has(tool)).toBe(false);
+    }
+  });
+});
+
+import { canUseToolForTest } from "@/lib/chat/engine";
+
+describe("canUseTool auto-allow policy for SDK filesystem tools", () => {
+  it("auto-allows Read without a permission request", async () => {
+    const result = await canUseToolForTest("Read", { file_path: "/tmp/x" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Grep without a permission request", async () => {
+    const result = await canUseToolForTest("Grep", { pattern: "foo" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Glob without a permission request", async () => {
+    const result = await canUseToolForTest("Glob", { pattern: "**/*.ts" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("auto-allows Skill tool invocation", async () => {
+    const result = await canUseToolForTest("Skill", { skill: "code-reviewer" });
+    expect(result.behavior).toBe("allow");
+  });
+
+  it("does NOT auto-allow Edit (must go through permission flow)", async () => {
+    const result = await canUseToolForTest("Edit", { file_path: "/tmp/x", content: "y" });
+    expect(result.behavior).not.toBe("allow");
+  });
+
+  it("does NOT auto-allow Bash", async () => {
+    const result = await canUseToolForTest("Bash", { command: "ls" });
+    expect(result.behavior).not.toBe("allow");
+  });
+});
+
+describe("hooks excluded per Q2", () => {
+  it("does not declare a hooks field alongside settingSources", async () => {
+    const fs = await import("fs");
+    const path = await import("path");
+    const enginePath = path.resolve(__dirname, "../engine.ts");
+    const source = fs.readFileSync(enginePath, "utf8");
+    // Assert that within the query() options block, there is no `hooks:` field.
+    // This is a regex-level check because the options object is inline literals.
+    const optionsBlock = source.match(/query\(\s*\{[\s\S]*?\}\s*\)/)?.[0] ?? "";
+    expect(optionsBlock).toContain("settingSources");
+    expect(optionsBlock).not.toMatch(/\bhooks\s*:/);
+  });
+});
+
+describe("CLAUDE_SDK_* constants source-of-truth", () => {
+  it("exports CLAUDE_SDK_ALLOWED_TOOLS from runtime/claude-sdk", async () => {
+    const mod = await import("@/lib/agents/runtime/claude-sdk");
+    expect(mod.CLAUDE_SDK_ALLOWED_TOOLS).toEqual([
+      "Skill",
+      "Read",
+      "Grep",
+      "Glob",
+      "Edit",
+      "Write",
+      "Bash",
+      "TodoWrite",
+    ]);
+  });
+
+  it("exports CLAUDE_SDK_SETTING_SOURCES from runtime/claude-sdk", async () => {
+    const mod = await import("@/lib/agents/runtime/claude-sdk");
+    expect(mod.CLAUDE_SDK_SETTING_SOURCES).toEqual(["user", "project"]);
+  });
+
+  it("exports CLAUDE_SDK_READ_ONLY_FS_TOOLS from runtime/claude-sdk", async () => {
+    const mod = await import("@/lib/agents/runtime/claude-sdk");
+    expect(mod.CLAUDE_SDK_READ_ONLY_FS_TOOLS).toEqual(new Set(["Read", "Grep", "Glob"]));
+  });
+});

package/src/lib/chat/__tests__/skill-conflict.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from "vitest";
+import { detectSkillConflicts } from "../skill-conflict";
+
+describe("detectSkillConflicts", () => {
+  it("returns no conflicts for two unrelated skills", () => {
+    const a = { id: "a", name: "code-reviewer", content: "Always run ESLint before reviewing code." };
+    const b = { id: "b", name: "haiku-poet", content: "Use 5-7-5 syllable structure." };
+    expect(detectSkillConflicts(a, b)).toEqual([]);
+  });
+
+  it("flags directive divergence on a shared topic", () => {
+    const a = { id: "a", name: "tdd", content: "Always write the test first. Never write production code without a failing test." };
+    const b = { id: "b", name: "spike", content: "Never write tests during a spike. Prefer exploratory code." };
+    const conflicts = detectSkillConflicts(a, b);
+    expect(conflicts.length).toBeGreaterThan(0);
+    expect(conflicts[0]).toMatchObject({
+      skillA: "tdd",
+      skillB: "spike",
+    });
+    expect(conflicts[0].excerptA).toMatch(/test/i);
+    expect(conflicts[0].excerptB).toMatch(/test/i);
+  });
+
+  it("returns no conflicts when both skills agree on a topic", () => {
+    const a = { id: "a", name: "tdd", content: "Always write tests first." };
+    const b = { id: "b", name: "qa-strict", content: "Always write tests first and add coverage gates." };
+    expect(detectSkillConflicts(a, b)).toEqual([]);
+  });
+
+  it("ignores non-directive lines", () => {
+    const a = { id: "a", name: "x", content: "This skill is for documentation tasks." };
+    const b = { id: "b", name: "y", content: "Documentation is important context." };
+    expect(detectSkillConflicts(a, b)).toEqual([]);
+  });
+});

package/src/lib/chat/__tests__/types.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { getFeaturesForModel, getRuntimeForModel } from "@/lib/chat/types";
+
+describe("getFeaturesForModel", () => {
+  it("returns Claude features for a Claude model id", () => {
+    const features = getFeaturesForModel("sonnet");
+    expect(features.hasNativeSkills).toBe(true);
+    expect(features.autoLoadsInstructions).toBe("CLAUDE.md");
+  });
+
+  it("returns Ollama features for an ollama-prefixed model id", () => {
+    const features = getFeaturesForModel("ollama:llama3");
+    expect(features.stagentInjectsSkills).toBe(true);
+    expect(features.hasNativeSkills).toBe(false);
+  });
+
+  it("returns Codex features for a GPT model id", () => {
+    const features = getFeaturesForModel("gpt-5.4");
+    expect(features.autoLoadsInstructions).toBe("AGENTS.md");
+  });
+
+  it("falls back to claude-code features for an unknown model id", () => {
+    // getRuntimeForModel's fallback chain lands on claude-code for unknown ids.
+    const features = getFeaturesForModel("totally-made-up-model");
+    expect(features.hasNativeSkills).toBe(true);
+    expect(getRuntimeForModel("totally-made-up-model")).toBe("claude-code");
+  });
+});

package/src/lib/chat/active-skills.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure helper for combining the legacy `conversations.active_skill_id`
+ * column with the new `conversations.active_skill_ids` JSON array
+ * (`features/chat-skill-composition.md`).
+ *
+ * Lives in its own module (no DB imports) so client components can use
+ * it without pulling server-only code into the bundle. The original
+ * lived alongside the chat-tool definition in `tools/skill-tools.ts`,
+ * which can only run server-side.
+ */
+
+export function mergeActiveSkillIds(
+  legacyId: string | null | undefined,
+  composed: string[] | null | undefined
+): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  if (legacyId) {
+    out.push(legacyId);
+    seen.add(legacyId);
+  }
+  if (composed) {
+    for (const id of composed) {
+      if (id && !seen.has(id)) {
+        out.push(id);
+        seen.add(id);
+      }
+    }
+  }
+  return out;
+}

package/src/lib/chat/clean-filter-input.ts

@@ -0,0 +1,30 @@
+/**
+ * Sanitize the filterInput we persist for a saved search.
+ *
+ * The chat popover input may include the mention trigger prefix
+ * (e.g. `@task: ` or `task: ` depending on what the trigger regex
+ * stripped). When the user "Saves this view", we want the persisted
+ * filterInput to contain ONLY the meaningful filter expression —
+ * `#key:value` clauses plus any free-text search the user typed —
+ * not the trigger residue.
+ *
+ * Pure function. Tested in isolation; called from
+ * `chat-command-popover.tsx` at the SaveViewFooter call site.
+ *
+ * See `features/saved-search-polish-v1.md` for the bug history.
+ */
+
+import type { FilterClause } from "@/lib/filters/parse";
+
+const TRIGGER_RESIDUE = /^@?[a-z]+:\s*/i;
+
+export function cleanFilterInput(
+  clauses: FilterClause[],
+  rawQuery: string
+): string {
+  const cleanRawQuery = rawQuery.replace(TRIGGER_RESIDUE, "").trim();
+  return [
+    ...clauses.map((c) => `#${c.key}:${c.value}`),
+    ...(cleanRawQuery ? [cleanRawQuery] : []),
+  ].join(" ");
+}

package/src/lib/chat/codex-engine.ts

@@ -34,6 +34,7 @@ import {
   cleanupConversation,
 } from "./permission-bridge";
 import { getWorkspaceContext } from "@/lib/environment/workspace-context";
+import type { ResolvedExecutionTarget } from "@/lib/agents/runtime/execution-target";
 
 // ── Helpers ──────────────────────────────────────────────────────────────
 
@@ -57,7 +58,8 @@ function asString(v: unknown): string | null {
 export async function* sendCodexMessage(
   conversationId: string,
   userContent: string,
-  signal?: AbortSignal
+  signal?: AbortSignal,
+  targetOverride?: ResolvedExecutionTarget
 ): AsyncGenerator<ChatStreamEvent> {
   const conversation = await getConversation(conversationId);
   if (!conversation) {
@@ -65,7 +67,7 @@ export async function* sendCodexMessage(
     return;
   }
 
-  const runtimeId = conversation.runtimeId;
+  const runtimeId = targetOverride?.effectiveRuntimeId ?? conversation.runtimeId;
   const providerId = getProviderForRuntime(runtimeId);
 
   // Enforce budget
@@ -187,8 +189,10 @@ export async function* sendCodexMessage(
       const availableIds = new Set(
         (modelResponse.models ?? []).map((m: { id: string }) => m.id)
       );
-      if (conversation.modelId && availableIds.has(conversation.modelId)) {
-        validatedModel = conversation.modelId;
+      const requestedModelId =
+        targetOverride?.effectiveModelId ?? conversation.modelId;
+      if (requestedModelId && availableIds.has(requestedModelId)) {
+        validatedModel = requestedModelId;
       }
       // If not available, validatedModel stays undefined → Codex uses its default
     } catch {
@@ -376,7 +380,18 @@ export async function* sendCodexMessage(
 
     // Save usage metadata
     const metadata = JSON.stringify({
-      modelId: usage.modelId ?? conversation.modelId,
+      modelId:
+        usage.modelId ??
+        targetOverride?.effectiveModelId ??
+        conversation.modelId,
+      runtimeId,
+      requestedRuntimeId:
+        targetOverride?.requestedRuntimeId ?? conversation.runtimeId,
+      requestedModelId:
+        targetOverride?.requestedModelId ?? conversation.modelId,
+      ...(targetOverride?.fallbackReason
+        ? { fallbackReason: targetOverride.fallbackReason }
+        : {}),
       inputTokens: usage.inputTokens,
       outputTokens: usage.outputTokens,
       ...(quickAccess.length > 0 ? { quickAccess } : {}),
@@ -393,7 +408,11 @@ export async function* sendCodexMessage(
       activityType: "chat_turn",
       runtimeId,
       providerId,
-      modelId: usage.modelId ?? conversation.modelId ?? null,
+      modelId:
+        usage.modelId ??
+        targetOverride?.effectiveModelId ??
+        conversation.modelId ??
+        null,
       inputTokens: usage.inputTokens ?? null,
       outputTokens: usage.outputTokens ?? null,
       totalTokens: usage.totalTokens ?? null,
@@ -413,7 +432,11 @@ export async function* sendCodexMessage(
       activityType: "chat_turn",
       runtimeId,
       providerId,
-      modelId: usage.modelId ?? conversation.modelId ?? null,
+      modelId:
+        usage.modelId ??
+        targetOverride?.effectiveModelId ??
+        conversation.modelId ??
+        null,
       inputTokens: usage.inputTokens ?? null,
       outputTokens: usage.outputTokens ?? null,
       totalTokens: usage.totalTokens ?? null,

package/src/lib/chat/command-tabs.ts

@@ -0,0 +1,61 @@
+import type { ToolCatalogEntry, ToolGroup } from "./tool-catalog";
+
+export const COMMAND_TAB_IDS = ["actions", "skills", "tools", "entities"] as const;
+export type CommandTabId = (typeof COMMAND_TAB_IDS)[number];
+
+export interface CommandTab {
+  id: CommandTabId;
+  label: string;
+  shortcut: string; // ⌘1..⌘4
+}
+
+export const COMMAND_TABS: CommandTab[] = [
+  { id: "actions", label: "Actions", shortcut: "⌘1" },
+  { id: "skills", label: "Skills", shortcut: "⌘2" },
+  { id: "tools", label: "Tools", shortcut: "⌘3" },
+  { id: "entities", label: "Entities", shortcut: "⌘4" },
+];
+
+export const DEFAULT_COMMAND_TAB: CommandTabId = "actions";
+
+export const GROUP_TO_TAB = {
+  // Stagent actions / session primitives
+  Session: "actions",
+  Tasks: "actions",
+  Projects: "actions",
+  Workflows: "actions",
+  Schedules: "actions",
+  Documents: "actions",
+  Tables: "actions",
+  Notifications: "actions",
+  Profiles: "actions",
+  Usage: "actions",
+  Settings: "actions",
+  Chat: "actions",
+  // Skills
+  Skills: "skills",
+  // Tools (filesystem / system / utility)
+  Browser: "tools",
+  Utility: "tools",
+} satisfies Record<ToolGroup, CommandTabId>;
+
+export function isCommandTabId(value: string): value is CommandTabId {
+  return (COMMAND_TAB_IDS as readonly string[]).includes(value);
+}
+
+export interface PartitionedCatalog {
+  actions: ToolCatalogEntry[];
+  skills: ToolCatalogEntry[];
+  tools: ToolCatalogEntry[];
+  entities: ToolCatalogEntry[];
+}
+
+export function partitionCatalogByTab(
+  catalog: ToolCatalogEntry[]
+): PartitionedCatalog {
+  const out: PartitionedCatalog = { actions: [], skills: [], tools: [], entities: [] };
+  for (const entry of catalog) {
+    out[GROUP_TO_TAB[entry.group]].push(entry);
+  }
+  return out;
+}