stagent 0.10.0 → 0.11.0

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

@@ -0,0 +1,220 @@
+import { db } from "@/lib/db";
+import { agentLogs, notifications, tasks } from "@/lib/db/schema";
+import { eq } from "drizzle-orm";
+import { executeTaskWithRuntime, resumeTaskWithRuntime } from "@/lib/agents/runtime";
+import {
+  resolveResumeExecutionTarget,
+  resolveTaskExecutionTarget,
+  type ResolvedExecutionTarget,
+} from "@/lib/agents/runtime/execution-target";
+import {
+  classifyTaskFailureReason,
+  RetryableRuntimeLaunchError,
+} from "@/lib/agents/runtime/launch-failure";
+import { getRuntimeCatalogEntry } from "@/lib/agents/runtime/catalog";
+
+async function persistExecutionTarget(
+  taskId: string,
+  target: ResolvedExecutionTarget
+) {
+  await db
+    .update(tasks)
+    .set({
+      effectiveRuntimeId: target.effectiveRuntimeId,
+      effectiveModelId: target.effectiveModelId,
+      runtimeFallbackReason: target.fallbackReason,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, taskId));
+
+  if (target.fallbackApplied && target.fallbackReason) {
+    await db.insert(agentLogs).values({
+      id: crypto.randomUUID(),
+      taskId,
+      agentType: "runtime-router",
+      event: "runtime_fallback",
+      payload: JSON.stringify({
+        requestedRuntimeId: target.requestedRuntimeId,
+        effectiveRuntimeId: target.effectiveRuntimeId,
+        reason: target.fallbackReason,
+      }),
+      timestamp: new Date(),
+    });
+  }
+}
+
+async function logRuntimeLaunchFailure(
+  taskId: string,
+  error: RetryableRuntimeLaunchError
+) {
+  await db.insert(agentLogs).values({
+    id: crypto.randomUUID(),
+    taskId,
+    agentType: "runtime-router",
+    event: "runtime_launch_failed",
+    payload: JSON.stringify({
+      runtimeId: error.runtimeId,
+      error: error.message,
+    }),
+    timestamp: new Date(),
+  });
+}
+
+async function markTaskLaunchFailed(
+  taskId: string,
+  taskTitle: string,
+  error: unknown
+) {
+  const message = error instanceof Error ? error.message : String(error);
+  await db
+    .update(tasks)
+    .set({
+      status: "failed",
+      result: message,
+      failureReason: classifyTaskFailureReason(
+        error instanceof Error ? error : new Error(message)
+      ),
+      sessionId: null,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, taskId));
+
+  await db.insert(notifications).values({
+    id: crypto.randomUUID(),
+    taskId,
+    type: "task_failed",
+    title: `Task failed: ${taskTitle}`,
+    body: message.slice(0, 500),
+    createdAt: new Date(),
+  });
+}
+
+function buildLaunchFallbackTarget(input: {
+  originalTarget: ResolvedExecutionTarget;
+  retryTarget: ResolvedExecutionTarget;
+  launchError: RetryableRuntimeLaunchError;
+}): ResolvedExecutionTarget {
+  const effectiveLabel = getRuntimeCatalogEntry(
+    input.retryTarget.effectiveRuntimeId
+  ).label;
+
+  return {
+    ...input.retryTarget,
+    fallbackApplied: true,
+    fallbackReason: `${input.launchError.message}. Fell back to ${effectiveLabel}.`,
+    requestedRuntimeId:
+      input.retryTarget.requestedRuntimeId ?? input.originalTarget.requestedRuntimeId,
+    requestedModelId:
+      input.retryTarget.requestedModelId ?? input.originalTarget.requestedModelId,
+    effectiveModelId: input.retryTarget.effectiveModelId,
+    effectiveRuntimeId: input.retryTarget.effectiveRuntimeId,
+  };
+}
+
+async function retryTaskWithFallback(
+  task: typeof tasks.$inferSelect,
+  originalTarget: ResolvedExecutionTarget,
+  launchError: RetryableRuntimeLaunchError
+) {
+  await logRuntimeLaunchFailure(task.id, launchError);
+
+  let retryTarget: ResolvedExecutionTarget;
+  try {
+    retryTarget = await resolveTaskExecutionTarget({
+      title: task.title,
+      description: task.description,
+      requestedRuntimeId: originalTarget.requestedRuntimeId ?? task.assignedAgent,
+      profileId: task.agentProfile,
+      unavailableRuntimeIds: [launchError.runtimeId],
+      unavailableReasons: {
+        [launchError.runtimeId]: launchError.message,
+      },
+    });
+  } catch (error) {
+    await markTaskLaunchFailed(task.id, task.title, error);
+    throw error;
+  }
+
+  const fallbackTarget = buildLaunchFallbackTarget({
+    originalTarget,
+    retryTarget,
+    launchError,
+  });
+
+  await db
+    .update(tasks)
+    .set({
+      status: "running",
+      result: null,
+      failureReason: null,
+      sessionId: null,
+      updatedAt: new Date(),
+    })
+    .where(eq(tasks.id, task.id));
+
+  await persistExecutionTarget(task.id, fallbackTarget);
+  try {
+    return await executeTaskWithRuntime(task.id, fallbackTarget.effectiveRuntimeId);
+  } catch (error) {
+    if (error instanceof RetryableRuntimeLaunchError) {
+      await markTaskLaunchFailed(task.id, task.title, error);
+    }
+    throw error;
+  }
+}
+
+export async function startTaskExecution(
+  taskId: string,
+  options?: { requestedRuntimeId?: string | null }
+) {
+  const [task] = await db.select().from(tasks).where(eq(tasks.id, taskId));
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const target = await resolveTaskExecutionTarget({
+    title: task.title,
+    description: task.description,
+    requestedRuntimeId: options?.requestedRuntimeId ?? task.assignedAgent,
+    profileId: task.agentProfile,
+  });
+
+  await db
+    .update(tasks)
+    .set({ status: "running", updatedAt: new Date() })
+    .where(eq(tasks.id, taskId));
+  await persistExecutionTarget(taskId, target);
+  try {
+    return await executeTaskWithRuntime(taskId, target.effectiveRuntimeId);
+  } catch (error) {
+    if (error instanceof RetryableRuntimeLaunchError) {
+      return retryTaskWithFallback(task, target, error);
+    }
+    throw error;
+  }
+}
+
+export async function resumeTaskExecution(
+  taskId: string,
+  options?: {
+    requestedRuntimeId?: string | null;
+    effectiveRuntimeId?: string | null;
+  }
+) {
+  const [task] = await db.select().from(tasks).where(eq(tasks.id, taskId));
+  if (!task) {
+    throw new Error(`Task ${taskId} not found`);
+  }
+
+  const target = await resolveResumeExecutionTarget({
+    requestedRuntimeId: options?.requestedRuntimeId ?? task.assignedAgent,
+    effectiveRuntimeId: options?.effectiveRuntimeId ?? task.effectiveRuntimeId,
+  });
+
+  await db
+    .update(tasks)
+    .set({ status: "running", updatedAt: new Date() })
+    .where(eq(tasks.id, taskId));
+  await persistExecutionTarget(taskId, target);
+  return resumeTaskWithRuntime(taskId, target.effectiveRuntimeId);
+}

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

@@ -12,6 +12,7 @@ import { notifications } from "@/lib/db/schema";
 import { eq } from "drizzle-orm";
 import type { CanUseToolPolicy } from "./profiles/types";
 import { isExaTool, isExaReadOnly } from "./browser-mcp";
+import { CLAUDE_SDK_READ_ONLY_FS_TOOLS } from "./runtime/claude-sdk";
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -120,7 +121,10 @@ export async function handleToolPermission(
 ): Promise<ToolPermissionResponse> {
   const isQuestion = toolName === "AskUserQuestion";
 
-  // Layer 1: Profile-level canUseToolPolicy — fastest check, no I/O
+  // Layer 1: Profile-level canUseToolPolicy — fastest check, no I/O.
+  // Runs BEFORE Layer 1.75's SDK filesystem auto-allow so `autoDeny: ["Read"]`
+  // still denies; `autoApprove` for Read/Grep/Glob is redundant (Layer 1.75
+  // would also allow) but harmless.
   if (!isQuestion && canUseToolPolicy) {
     if (canUseToolPolicy.autoApprove?.includes(toolName)) {
       return buildAllowedToolPermissionResponse(input);
@@ -135,6 +139,17 @@ export async function handleToolPermission(
     return buildAllowedToolPermissionResponse(input);
   }
 
+  // Layer 1.75: SDK filesystem read-only tools and Skill invocations —
+  // auto-approve without I/O. Mirrors the chat-side Phase 1a policy
+  // (src/lib/chat/engine.ts canUseTool). Read/Grep/Glob are non-destructive;
+  // Skill load is equivalent to using `claude` CLI directly — any tool the
+  // loaded skill subsequently invokes (Bash, Edit, etc.) goes through this
+  // same canUseTool check. See features/chat-claude-sdk-skills.md Error
+  // & Rescue Registry row "settingSources loads hostile skill."
+  if (!isQuestion && (CLAUDE_SDK_READ_ONLY_FS_TOOLS.has(toolName) || toolName === "Skill")) {
+    return buildAllowedToolPermissionResponse(input);
+  }
+
   // Layer 2: Saved user permissions — skip notification for pre-approved tools
   if (!isQuestion) {
     const { isToolAllowed } = await import("@/lib/settings/permissions");

package/src/lib/chat/__tests__/active-skill-injection.test.ts

@@ -0,0 +1,261 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const { mockState } = vi.hoisted(() => ({
+  mockState: {
+    activeSkillId: null as string | null,
+    activeSkillIds: [] as string[],
+    skills: {} as Record<string, { name: string; content: string }>,
+    runtimeId: "ollama" as string, // default: Ollama (stagentInjectsSkills: true)
+  },
+}));
+
+// ── Mocks ──────────────────────────────────────────────────────────────
+
+vi.mock("@/lib/db", () => ({
+  db: {
+    select: () => ({
+      from() {
+        return this;
+      },
+      where() {
+        return this;
+      },
+      get() {
+        return Promise.resolve({
+          activeSkillId: mockState.activeSkillId,
+          activeSkillIds: mockState.activeSkillIds,
+          runtimeId: mockState.runtimeId,
+        });
+      },
+    }),
+  },
+}));
+
+vi.mock("@/lib/db/schema", () => ({
+  conversations: {
+    id: "id",
+    activeSkillId: "activeSkillId",
+    activeSkillIds: "activeSkillIds",
+    runtimeId: "runtimeId",
+  },
+  projects: { id: "id" },
+  tasks: { id: "id" },
+  workflows: { id: "id" },
+  documents: { id: "id" },
+  schedules: { id: "id" },
+}));
+
+vi.mock("drizzle-orm", () => ({
+  eq: () => ({}),
+  desc: () => ({}),
+  and: () => ({}),
+}));
+
+vi.mock("@/lib/data/chat", () => ({
+  getMessages: async () => [],
+}));
+
+vi.mock("@/lib/agents/profiles/registry", () => ({
+  getProfile: () => null,
+}));
+
+vi.mock("@/lib/environment/list-skills", () => ({
+  getSkill: (id: string) => {
+    const skill = mockState.skills[id];
+    if (!skill) return null;
+    return {
+      id,
+      name: skill.name,
+      tool: "claude-code",
+      scope: "project",
+      preview: "",
+      sizeBytes: Buffer.byteLength(skill.content),
+      absPath: "/mock/path/SKILL.md",
+      content: skill.content,
+    };
+  },
+}));
+
+import { buildChatContext } from "../context-builder";
+
+beforeEach(() => {
+  mockState.activeSkillId = null;
+  mockState.activeSkillIds = [];
+  mockState.skills = {};
+  mockState.runtimeId = "ollama";
+});
+
+describe("active skill Tier 0 injection", () => {
+  it("does NOT inject anything when activeSkillId is null (common case)", async () => {
+    const ctx = await buildChatContext({ conversationId: "conv-1" });
+    expect(ctx.systemPrompt).not.toContain("## Active Skill:");
+  });
+
+  it("injects the skill's SKILL.md content under an Active Skill header when bound", async () => {
+    mockState.activeSkillId = ".claude/skills/capture";
+    mockState.skills[".claude/skills/capture"] = {
+      name: "capture",
+      content: "# capture\n\nCapture web content as markdown.",
+    };
+
+    const ctx = await buildChatContext({ conversationId: "conv-1" });
+    expect(ctx.systemPrompt).toContain("## Active Skill: capture");
+    expect(ctx.systemPrompt).toContain("Capture web content as markdown");
+  });
+
+  it("silently emits no section when the bound skill id is not found (skill deleted)", async () => {
+    mockState.activeSkillId = "dangling-id";
+    const ctx = await buildChatContext({ conversationId: "conv-1" });
+    expect(ctx.systemPrompt).not.toContain("## Active Skill:");
+  });
+
+  it("caps very large SKILL.md content to the token budget", async () => {
+    mockState.activeSkillId = "huge-skill";
+    mockState.skills["huge-skill"] = {
+      name: "capture",
+      content: "A".repeat(100_000), // ~25K tokens at 4 chars/token
+    };
+    const ctx = await buildChatContext({ conversationId: "conv-1" });
+    // Budget is 4_000 tokens = ~16_000 chars; expect truncation marker
+    expect(ctx.systemPrompt).toContain("...(truncated)");
+    // Full 100K chars must NOT be inline
+    expect(ctx.systemPrompt.length).toBeLessThan(50_000);
+  });
+
+  describe("runtime capability flag (stagentInjectsSkills)", () => {
+    it("does NOT inject on claude-code (native skill support — would duplicate)", async () => {
+      mockState.runtimeId = "claude-code";
+      mockState.activeSkillId = ".claude/skills/capture";
+      mockState.skills[".claude/skills/capture"] = {
+        name: "capture",
+        content: "# capture\n\nBody.",
+      };
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).not.toContain("## Active Skill:");
+      expect(ctx.systemPrompt).not.toContain("Body.");
+    });
+
+    it("does inject composed skills on claude-code when activeSkillIds are set", async () => {
+      mockState.runtimeId = "claude-code";
+      mockState.activeSkillId = ".claude/skills/researcher";
+      mockState.activeSkillIds = [".claude/skills/technical-writer"];
+      mockState.skills[".claude/skills/researcher"] = {
+        name: "researcher",
+        content: "Always gather sources first.",
+      };
+      mockState.skills[".claude/skills/technical-writer"] = {
+        name: "technical-writer",
+        content: "Prefer crisp, publishable prose.",
+      };
+
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).toContain("## Active Skill: researcher");
+      expect(ctx.systemPrompt).toContain("## Active Skill: technical-writer");
+    });
+
+    it("does NOT inject on openai-codex-app-server (native skill support — would duplicate)", async () => {
+      mockState.runtimeId = "openai-codex-app-server";
+      mockState.activeSkillId = ".agents/skills/capture";
+      mockState.skills[".agents/skills/capture"] = {
+        name: "capture",
+        content: "# capture\n\nBody.",
+      };
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).not.toContain("## Active Skill:");
+    });
+
+    it("DOES inject on ollama (no native support — Stagent must inject)", async () => {
+      mockState.runtimeId = "ollama";
+      mockState.activeSkillId = ".claude/skills/capture";
+      mockState.skills[".claude/skills/capture"] = {
+        name: "capture",
+        content: "# capture\n\nOllama needs this.",
+      };
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).toContain("## Active Skill: capture");
+      expect(ctx.systemPrompt).toContain("Ollama needs this.");
+    });
+
+    it("falls through and injects when runtimeId is unknown (safer default than dropping)", async () => {
+      mockState.runtimeId = "some-future-runtime-not-in-catalog";
+      mockState.activeSkillId = ".claude/skills/capture";
+      mockState.skills[".claude/skills/capture"] = {
+        name: "capture",
+        content: "# capture\n\nBody.",
+      };
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      // Unknown runtime → catalog throws → catch → fall through to injection.
+      expect(ctx.systemPrompt).toContain("## Active Skill: capture");
+    });
+  });
+
+  describe("composition budget trimming", () => {
+    it("keeps multiple composed skills when the combined payload fits", async () => {
+      mockState.runtimeId = "claude-code";
+      mockState.activeSkillId = ".claude/skills/researcher";
+      mockState.activeSkillIds = [".claude/skills/technical-writer"];
+      mockState.skills[".claude/skills/researcher"] = {
+        name: "researcher",
+        content: "Collect sources.",
+      };
+      mockState.skills[".claude/skills/technical-writer"] = {
+        name: "technical-writer",
+        content: "Write clearly.",
+      };
+
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).toContain("## Active Skill: researcher");
+      expect(ctx.systemPrompt).toContain("## Active Skill: technical-writer");
+      expect(ctx.systemPrompt).not.toContain("## Active Skill Note");
+    });
+
+    it("omits oldest composed skills first when the combined payload exceeds budget", async () => {
+      mockState.runtimeId = "claude-code";
+      mockState.activeSkillId = ".claude/skills/oldest";
+      mockState.activeSkillIds = [
+        ".claude/skills/middle",
+        ".claude/skills/newest",
+      ];
+      mockState.skills[".claude/skills/oldest"] = {
+        name: "oldest",
+        content: "O".repeat(8_000),
+      };
+      mockState.skills[".claude/skills/middle"] = {
+        name: "middle",
+        content: "M".repeat(8_000),
+      };
+      mockState.skills[".claude/skills/newest"] = {
+        name: "newest",
+        content: "N".repeat(2_000),
+      };
+
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).toContain("## Active Skill Note");
+      expect(ctx.systemPrompt).toContain("Omitted 1 older active skill to fit the prompt budget: oldest.");
+      expect(ctx.systemPrompt).not.toContain("## Active Skill: oldest");
+      expect(ctx.systemPrompt).toContain("## Active Skill: middle");
+      expect(ctx.systemPrompt).toContain("## Active Skill: newest");
+    });
+
+    it("truncates the newest remaining skill when even one section exceeds budget", async () => {
+      mockState.runtimeId = "claude-code";
+      mockState.activeSkillId = ".claude/skills/oldest";
+      mockState.activeSkillIds = [".claude/skills/newest"];
+      mockState.skills[".claude/skills/oldest"] = {
+        name: "oldest",
+        content: "O".repeat(8_000),
+      };
+      mockState.skills[".claude/skills/newest"] = {
+        name: "newest",
+        content: "N".repeat(40_000),
+      };
+
+      const ctx = await buildChatContext({ conversationId: "conv-1" });
+      expect(ctx.systemPrompt).toContain("## Active Skill Note");
+      expect(ctx.systemPrompt).toContain("oldest");
+      expect(ctx.systemPrompt).toContain("## Active Skill: newest");
+      expect(ctx.systemPrompt).toContain("...(truncated)");
+      expect(ctx.systemPrompt).not.toContain("## Active Skill: oldest");
+    });
+  });
+});

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

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import { cleanFilterInput } from "../clean-filter-input";
+import { parseFilterInput } from "@/lib/filters/parse";
+
+// Smoke through the full chain: parse the raw popover input, then clean
+// the result. Mirrors what `chat-command-popover.tsx` does at the
+// SaveViewFooter call site so the assertions catch any regression in
+// either the parser OR the cleaner.
+function persisted(input: string): string {
+  const parsed = parseFilterInput(input);
+  return cleanFilterInput(parsed.clauses, parsed.rawQuery);
+}
+
+describe("cleanFilterInput", () => {
+  it("strips bare mention-trigger prefix from clauses-only input", () => {
+    expect(persisted("@task: #priority:high")).toBe("#priority:high");
+  });
+
+  it("strips trigger prefix and preserves free text", () => {
+    // Order: clauses first, then rawQuery — matches the cleaner's
+    // documented behavior.
+    expect(persisted("@task: foo #priority:high")).toBe(
+      "#priority:high foo"
+    );
+  });
+
+  it("leaves clean inputs untouched (no trigger residue)", () => {
+    expect(persisted("#status:blocked")).toBe("#status:blocked");
+    expect(persisted("#status:blocked #priority:high")).toBe(
+      "#status:blocked #priority:high"
+    );
+  });
+
+  it("preserves multi-word free text", () => {
+    expect(persisted('@project: my big query #status:active')).toBe(
+      "#status:active my big query"
+    );
+  });
+
+  it("never emits ':' not preceded by '#' (regression assertion)", () => {
+    const tricky = [
+      "@task: #status:blocked",
+      "@project: foo #status:active",
+      "@workflow: #status:running #priority:high",
+      "#status:blocked",
+    ];
+    for (const input of tricky) {
+      const result = persisted(input);
+      // After every ':' there must be a non-':' char, and every ':' must
+      // be immediately preceded by either an alpha char (the key) or
+      // we expect the form #key:value. Simpler: assert no occurrence of
+      // ': ' (trigger residue always has a trailing space) and no
+      // alpha-only-prefix-colon at the start.
+      expect(result).not.toMatch(/^[a-z]+:\s/i);
+    }
+  });
+
+  it("handles empty clauses + empty rawQuery", () => {
+    expect(cleanFilterInput([], "")).toBe("");
+  });
+
+  it("handles clauses + only-trigger rawQuery", () => {
+    // `@task:` with no other input → rawQuery is `@task:` → cleaned to ""
+    expect(cleanFilterInput([{ key: "status", value: "blocked" }], "@task:")).toBe(
+      "#status:blocked"
+    );
+  });
+});

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

@@ -0,0 +1,68 @@
+import { describe, it, expect } from "vitest";
+import {
+  COMMAND_TABS,
+  GROUP_TO_TAB,
+  partitionCatalogByTab,
+  isCommandTabId,
+  type CommandTabId,
+} from "../command-tabs";
+import type { ToolCatalogEntry, ToolGroup } from "../tool-catalog";
+
+const entry = (name: string, group: ToolGroup): ToolCatalogEntry => ({
+  name,
+  description: name,
+  group,
+});
+
+describe("command-tabs", () => {
+  it("exposes four tabs in canonical order", () => {
+    expect(COMMAND_TABS.map((t) => t.id)).toEqual([
+      "actions",
+      "skills",
+      "tools",
+      "entities",
+    ]);
+  });
+
+  it("maps every ToolGroup to exactly one tab", () => {
+    const groups: ToolGroup[] = [
+      "Session", "Tasks", "Projects", "Workflows", "Schedules", "Documents", "Tables",
+      "Notifications", "Profiles", "Skills", "Usage", "Settings", "Chat",
+      "Browser", "Utility",
+    ];
+    for (const g of groups) {
+      expect(GROUP_TO_TAB[g]).toBeDefined();
+    }
+  });
+
+  it("routes Session group to the Actions tab", () => {
+    expect(GROUP_TO_TAB.Session).toBe("actions");
+  });
+
+  it("routes Skills group to the Skills tab", () => {
+    expect(GROUP_TO_TAB.Skills).toBe("skills");
+  });
+
+  it("routes Browser + Utility to the Tools tab", () => {
+    expect(GROUP_TO_TAB.Browser).toBe("tools");
+    expect(GROUP_TO_TAB.Utility).toBe("tools");
+  });
+
+  it("partitions catalog entries by tab", () => {
+    const catalog: ToolCatalogEntry[] = [
+      entry("list_tasks", "Tasks"),
+      entry("researcher", "Skills"),
+      entry("take_screenshot", "Browser"),
+    ];
+    const part = partitionCatalogByTab(catalog);
+    expect(part.actions.map((e) => e.name)).toEqual(["list_tasks"]);
+    expect(part.skills.map((e) => e.name)).toEqual(["researcher"]);
+    expect(part.tools.map((e) => e.name)).toEqual(["take_screenshot"]);
+    expect(part.entities).toEqual([]);
+  });
+
+  it("isCommandTabId rejects unknown values", () => {
+    expect(isCommandTabId("actions")).toBe(true);
+    expect(isCommandTabId("random")).toBe(false);
+  });
+});