stagent 0.10.0 → 0.11.1

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;
+}

package/src/lib/chat/context-builder.ts

@@ -5,6 +5,8 @@ import { getMessages } from "@/lib/data/chat";
 import { getProfile } from "@/lib/agents/profiles/registry";
 import { STAGENT_SYSTEM_PROMPT } from "./system-prompt";
 import type { WorkspaceContext } from "@/lib/environment/workspace-context";
+import { expandFileMention } from "./files/expand-mention";
+import { conversations } from "@/lib/db/schema";
 
 // ── Token budget constants ─────────────────────────────────────────────
 
@@ -50,6 +52,121 @@ function buildTier0(
   return parts.join("\n");
 }
 
+// ── Active skill injection (Ollama-first, runtime-agnostic) ────────────
+
+/**
+ * Token budget for a conversation-bound skill's SKILL.md content.
+ *
+ * Per spec §7.1: 1000-4000 tokens typical, with 300 tokens of index/
+ * metadata on top. We cap at ~4000 tokens (≈16K chars) so a large skill
+ * can't blow out a small-context local model. Single-active-skill is
+ * enforced at the MCP-tool layer.
+ */
+const ACTIVE_SKILL_BUDGET = 4_000;
+
+interface ActiveSkillSection {
+  name: string;
+  text: string;
+}
+
+function renderActiveSkillSections(
+  kept: ActiveSkillSection[],
+  omitted: ActiveSkillSection[]
+): string {
+  if (kept.length === 0) return "";
+
+  const parts: string[] = [];
+  if (omitted.length > 0) {
+    const label = omitted.length === 1 ? "skill" : "skills";
+    parts.push(
+      `## Active Skill Note\nOmitted ${omitted.length} older active ${label} to fit the prompt budget: ${omitted
+        .map((section) => section.name)
+        .join(", ")}.`
+    );
+  }
+  parts.push(...kept.map((section) => section.text));
+  return parts.join("\n\n---\n\n");
+}
+
+/**
+ * Build the "Active Skill" section of the system prompt, if one is bound
+ * to the conversation via `conversations.active_skill_id`. Returns "" for
+ * conversations without an active skill.
+ *
+ * Primary use case: Ollama has no SDK-native skill support, so this is
+ * how SKILL.md reaches a local model. Claude and Codex runtimes can
+ * also bind a skill via this path alongside their native Skill tools.
+ *
+ * See `features/chat-ollama-native-skills.md`.
+ */
+async function buildActiveSkill(conversationId: string): Promise<string> {
+  const row = await db
+    .select({
+      activeSkillId: conversations.activeSkillId,
+      activeSkillIds: conversations.activeSkillIds,
+      runtimeId: conversations.runtimeId,
+    })
+    .from(conversations)
+    .where(eq(conversations.id, conversationId))
+    .get();
+
+  // Merge legacy single-active + new composed array. Dynamic import to
+  // avoid loading the chat tools module on the hot path / risk import
+  // cycles per the runtime-catalog smoke-test budget rule in MEMORY.md.
+  const { mergeActiveSkillIds } = await import("@/lib/chat/active-skills");
+  const merged = mergeActiveSkillIds(row?.activeSkillId, row?.activeSkillIds);
+  if (merged.length === 0) return "";
+
+  // Composition (any entry in the new activeSkillIds column) is an
+  // explicit user opt-in to override the SDK-native default. Without
+  // this carve-out, composed skills would silently no-op on Claude/
+  // Codex where stagentInjectsSkills=false. When only the legacy
+  // activeSkillId is set, fall back to the original capability gate
+  // (Ollama-only injection).
+  const isComposed = (row?.activeSkillIds?.length ?? 0) > 0;
+
+  if (!isComposed && row?.runtimeId) {
+    try {
+      const { getRuntimeFeatures } = await import("@/lib/agents/runtime/catalog");
+      const features = getRuntimeFeatures(
+        row.runtimeId as Parameters<typeof getRuntimeFeatures>[0]
+      );
+      if (!features.stagentInjectsSkills) return "";
+    } catch {
+      // Unknown runtime — fall through and inject (safer default than
+      // silently dropping the skill on an unrecognized runtime id).
+    }
+  }
+
+  // Dynamic import keeps the scanner + fs dependency off the hot path for
+  // conversations that don't have an active skill (the common case).
+  const { getSkill } = await import("@/lib/environment/list-skills");
+  const sections: ActiveSkillSection[] = [];
+  for (const id of merged) {
+    const skill = getSkill(id);
+    if (!skill) continue;
+    sections.push({
+      name: skill.name,
+      text: `## Active Skill: ${skill.name}\n\n${skill.content}`,
+    });
+  }
+  if (sections.length === 0) return "";
+
+  const kept = [...sections];
+  const omitted: ActiveSkillSection[] = [];
+  while (
+    kept.length > 1 &&
+    estimateTokens(renderActiveSkillSections(kept, omitted)) > ACTIVE_SKILL_BUDGET
+  ) {
+    const oldest = kept.shift();
+    if (oldest) omitted.push(oldest);
+  }
+
+  const combined = renderActiveSkillSections(kept, omitted);
+  if (estimateTokens(combined) <= ACTIVE_SKILL_BUDGET) return combined;
+  return truncateToTokenBudget(combined, ACTIVE_SKILL_BUDGET);
+}
+
 // ── Tier 1: Conversation history ───────────────────────────────────────
 
 interface HistoryMessage {
@@ -278,6 +395,23 @@ async function buildTier3(mentions: MentionReference[]): Promise<string> {
         }
         break;
       }
+      case "file": {
+        // `entityId` is a relative path scoped to the active project's
+        // workingDirectory (preferred) or the stagent launch cwd (fallback).
+        // Security is enforced inside expandFileMention — the caller cannot
+        // influence cwd.
+        const { getLaunchCwd } = await import("@/lib/environment/workspace-context");
+        let cwd = getLaunchCwd();
+        // If the mention has a known project context in scope, prefer the
+        // project's workingDirectory. We don't have it at this scope today,
+        // so launch cwd is the safe default — matches the API route.
+        // (Future: plumb projectId into buildTier3 so file expansion honors
+        // per-project cwds exactly the same way as the search API.)
+        void cwd;
+        cwd = getLaunchCwd();
+        parts.push(...expandFileMention(mention.entityId, cwd));
+        break;
+      }
     }
   }
 
@@ -304,16 +438,22 @@ export async function buildChatContext(opts: {
   workspace?: WorkspaceContext | null;
   mentions?: MentionReference[];
 }): Promise<ChatContext> {
-  const [history, tier2, tier3] = await Promise.all([
+  const [history, tier2, tier3, activeSkill] = await Promise.all([
     buildTier1(opts.conversationId),
     buildTier2(opts.projectId),
     buildTier3(opts.mentions ?? []),
+    buildActiveSkill(opts.conversationId),
   ]);
 
   const tier0 = buildTier0(opts.projectName, opts.workspace);
 
   const systemParts = [tier0];
 
+  // Active skill (from conversations.active_skill_id) sits right below
+  // Tier 0 so its instructions carry the most weight. Empty string when
+  // no skill is bound — common case.
+  if (activeSkill) systemParts.push(activeSkill);
+
   if (tier3) systemParts.push(tier3);
   if (tier2) systemParts.push(tier2);
 

package/src/lib/chat/dismissals.ts

@@ -0,0 +1,73 @@
+export const DISMISSAL_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+
+export interface DismissalStore {
+  read(): string | null;
+  write(value: string): void;
+}
+
+export type DismissalMap = Record<string, Record<string, number>>;
+
+export function loadDismissals(store: DismissalStore): DismissalMap {
+  const raw = store.read();
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") return parsed as DismissalMap;
+  } catch {
+    // corrupt — fall through
+  }
+  return {};
+}
+
+export function saveDismissal(
+  store: DismissalStore,
+  conversationId: string,
+  skillId: string,
+  nowMs: number = Date.now()
+): void {
+  const current = loadDismissals(store);
+  current[conversationId] = current[conversationId] ?? {};
+  current[conversationId][skillId] = nowMs;
+  try {
+    store.write(JSON.stringify(current));
+  } catch {
+    // silent — in-memory state won't persist
+  }
+}
+
+export function activeDismissedIds(
+  store: DismissalStore,
+  conversationId: string,
+  nowMs: number = Date.now()
+): Set<string> {
+  const all = loadDismissals(store);
+  const conv = all[conversationId];
+  if (!conv) return new Set();
+  const out = new Set<string>();
+  for (const [skillId, ts] of Object.entries(conv)) {
+    if (nowMs - ts < DISMISSAL_TTL_MS) out.add(skillId);
+  }
+  return out;
+}
+
+/** Browser store adapter around localStorage for a given key. */
+export function browserLocalStore(key: string): DismissalStore {
+  return {
+    read() {
+      if (typeof window === "undefined") return null;
+      try {
+        return window.localStorage.getItem(key);
+      } catch {
+        return null;
+      }
+    },
+    write(value) {
+      if (typeof window === "undefined") return;
+      try {
+        window.localStorage.setItem(key, value);
+      } catch {
+        // quota / disabled — silent
+      }
+    },
+  };
+}