@desplega.ai/agent-swarm 1.93.0 → 1.95.0

package/src/tests/metrics-http.test.ts

@@ -76,7 +76,60 @@ describe("Metrics HTTP API", () => {
     const body = (await res.json()) as { metrics: Metric[]; total: number };
     expect(body.total).toBeGreaterThanOrEqual(1);
     const starter = body.metrics.find((metric) => metric.slug === "swarm-operations-overview");
-    expect(starter?.definition.widgets.map((widget) => widget.viz.type)).toContain("multi-line");
+    expect(starter?.definition.layout?.columns).toBe(3);
+    expect(starter?.definition.widgets.map((widget) => widget.id)).toEqual([
+      "tasks-created-per-day",
+      "usage-by-user",
+      "usage-by-model",
+      "avg-cost-per-task-by-model",
+      "avg-task-time-by-model",
+      "cost-per-minute-by-model",
+      "cost-per-minute-by-agent",
+      "agent-performance",
+      "task-outcomes-by-day",
+      "recent-task-outcomes",
+    ]);
+    expect(
+      starter?.definition.variables?.find((variable) => variable.key === "userFilter"),
+    ).toMatchObject({
+      type: "select",
+      defaultValue: "all",
+      optionsQuery: { valueKey: "id", labelKey: "label" },
+    });
+    expect(
+      starter?.definition.variables?.find((variable) => variable.key === "agentFilter"),
+    ).toMatchObject({
+      type: "select",
+      defaultValue: "all",
+      optionsQuery: { valueKey: "id", labelKey: "label" },
+    });
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${starter!.id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse & {
+      metric: Metric;
+      variables: Record<string, string>;
+    };
+    expect(runBody.variables.userFilter).toBe("all");
+    expect(runBody.variables.agentFilter).toBe("all");
+    expect(
+      runBody.metric.definition.variables?.find((variable) => variable.key === "userFilter")
+        ?.options?.[0],
+    ).toEqual({
+      label: "All requesters",
+      value: "all",
+    });
+    expect(
+      runBody.metric.definition.variables?.find((variable) => variable.key === "agentFilter")
+        ?.options?.[0],
+    ).toEqual({
+      label: "All agents",
+      value: "all",
+    });
   });
 
   test("create, run, update snapshots prior definition", async () => {
@@ -221,8 +274,79 @@ describe("Metrics HTTP API", () => {
     expect(runBody.widgets[0]?.result.rows[0]).toHaveProperty("count");
   });
 
+  test("run resolves dynamic select variable options from read-only SQL", async () => {
+    const created = await fetch(`${BASE}/api/metrics/definitions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug: "dynamic-variable-options",
+        title: "Dynamic Variable Options",
+        definition: {
+          version: 1,
+          variables: [
+            {
+              key: "agent",
+              label: "Agent",
+              type: "select",
+              optionsQuery: {
+                sql: "SELECT 'agent-a' AS id, 'Agent A' AS name UNION ALL SELECT 'agent-b' AS id, 'Agent B' AS name",
+                valueKey: "id",
+                labelKey: "name",
+              },
+            },
+          ],
+          widgets: [
+            {
+              id: "selected-agent",
+              title: "Selected agent",
+              query: {
+                sql: "SELECT ? AS agent",
+                params: ["{{agent}}"],
+                maxRows: 10,
+              },
+              viz: { type: "table", columns: [{ key: "agent", label: "Agent" }] },
+            },
+          ],
+        },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const { id } = (await created.json()) as { id: string; version: number };
+
+    const run = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: { agent: "agent-b" } }),
+    });
+    expect(run.status).toBe(200);
+    const runBody = (await run.json()) as MetricRunResponse & {
+      metric: Metric;
+      variables: Record<string, string>;
+    };
+    expect(runBody.variables.agent).toBe("agent-b");
+    expect(runBody.metric.definition.variables?.[0]?.options).toEqual([
+      { label: "Agent A", value: "agent-a" },
+      { label: "Agent B", value: "agent-b" },
+    ]);
+    expect(runBody.widgets[0]?.result.rows[0]).toEqual({ agent: "agent-b" });
+
+    const defaultedRun = await fetch(`${BASE}/api/metrics/definitions/${id}/run`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ variables: {} }),
+    });
+    expect(defaultedRun.status).toBe(200);
+    const defaultedBody = (await defaultedRun.json()) as { variables: Record<string, string> };
+    expect(defaultedBody.variables.agent).toBe("agent-a");
+  });
+
   test("saved metric SQL rejects writes and multiple statements", async () => {
-    for (const sql of ["DELETE FROM agent_tasks", "SELECT 1; SELECT 2"]) {
+    for (const [sql, target] of [
+      ["DELETE FROM agent_tasks", "widget"],
+      ["SELECT 1; SELECT 2", "widget"],
+      ["DELETE FROM agents", "variable"],
+      ["SELECT 1; SELECT 2", "variable"],
+    ] as const) {
       const res = await fetch(`${BASE}/api/metrics/definitions`, {
         method: "POST",
         headers,
@@ -230,11 +354,21 @@ describe("Metrics HTTP API", () => {
           title: "Bad Metric",
           definition: {
             version: 1,
+            variables:
+              target === "variable"
+                ? [
+                    {
+                      key: "agent",
+                      type: "select",
+                      optionsQuery: { sql, valueKey: "id" },
+                    },
+                  ]
+                : undefined,
             widgets: [
               {
                 id: "bad",
                 title: "Bad",
-                query: { sql },
+                query: { sql: target === "widget" ? sql : "SELECT 1 AS x" },
                 viz: { type: "stat", value: "x" },
               },
             ],

package/src/tests/migration-046-budgets.test.ts

@@ -1,6 +1,7 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, getDb, initDb } from "../be/db";
+import { seedPricingFromModelsDev } from "../be/seed-pricing";
 import { CODEX_MODEL_PRICING } from "../providers/codex-models";
 
 const TEST_DB_PATH = "./test-migration-046.sqlite";
@@ -173,6 +174,38 @@ describe("migration 046 — budgets and pricing", () => {
     }
   });
 
+  test("models.dev seed includes Claude Mythos 5 pricing rows", () => {
+    const db = getDb();
+    const result = seedPricingFromModelsDev({ quiet: true });
+    expect(result.modelsdevFound).toBe(true);
+
+    const expectedPrices = {
+      input: 10,
+      cached_input: 1,
+      cache_write: 12.5,
+      output: 50,
+    } as const;
+    const seededKeys = [
+      ["claude", "claude-mythos-5"],
+      ["claude-managed", "claude-mythos-5"],
+      ["claude", "mythos"],
+      ["claude-managed", "mythos"],
+      ["pi", "mythos"],
+    ] as const;
+
+    for (const [provider, model] of seededKeys) {
+      for (const [tokenClass, price] of Object.entries(expectedPrices)) {
+        const row = db
+          .prepare<PricingRow, [string, string, string]>(
+            `SELECT * FROM pricing
+             WHERE provider = ? AND model = ? AND token_class = ? AND effective_from = 0`,
+          )
+          .get(provider, model, tokenClass);
+        expect(row?.price_per_million_usd).toBe(price);
+      }
+    }
+  });
+
   test("idx_pricing_lookup index exists", () => {
     const db = getDb();
     const idx = db

package/src/tests/migration-runner-regressions.test.ts

@@ -2,9 +2,11 @@ import { Database } from "bun:sqlite";
 import { afterEach, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, initDb } from "../be/db";
+import { runMigrations } from "../be/migrations/runner";
 
 const INCOMPLETE_DB_PATH = "./test-migration-incomplete.sqlite";
 const FRESH_DB_PATH = "./test-migration-fresh.sqlite";
+const REPAIR_DB_PATH = "./test-migration-repair.sqlite";
 
 async function removeDbFiles(dbPath: string): Promise<void> {
   for (const suffix of ["", "-wal", "-shm"]) {
@@ -22,6 +24,7 @@ afterEach(async () => {
   closeDb();
   await removeDbFiles(INCOMPLETE_DB_PATH);
   await removeDbFiles(FRESH_DB_PATH);
+  await removeDbFiles(REPAIR_DB_PATH);
 });
 
 describe("migration regressions", () => {
@@ -98,4 +101,70 @@ describe("migration regressions", () => {
     expect(requestedByFk?.table).toBe("users");
     expect(requestedByFk?.to).toBe("id");
   });
+
+  test("repairs seed-as-090 history so 090_model_tiers is never skipped", () => {
+    // 2026-06-10 incident: PR #722 shipped the metrics seed as migration 090
+    // and production applied it; PR #719 then renumbered the seed to 091 and
+    // took 090 for model tiers. The runner keys applied migrations on version,
+    // so those databases skipped 090_model_tiers and crashed on the missing
+    // modelTier column. repairRenumberedModelTiers() in the runner must detect
+    // that history and fix it on boot.
+    const SEED_NAME = "090_seed_swarm_operations_metrics";
+    const SEED_CHECKSUM = "8ca4a05263b42d115b419f468bf5113caa5b7ee4363177568897513549224b01";
+
+    // Raw Database + runMigrations directly: initDb()'s test-template fast
+    // path skips the runner entirely, and the repair lives in the runner.
+    const database = new Database(REPAIR_DB_PATH, { create: true });
+    runMigrations(database);
+
+    // Reconstruct the divergent history: modelTier columns absent, version 90
+    // recorded as the seed migration.
+    database.run("ALTER TABLE agent_tasks DROP COLUMN modelTier");
+    database.run("ALTER TABLE scheduled_tasks DROP COLUMN modelTier");
+    database.run("UPDATE _migrations SET name = ?, checksum = ? WHERE version = 90", [
+      SEED_NAME,
+      SEED_CHECKSUM,
+    ]);
+
+    // Next boot repairs the history.
+    runMigrations(database);
+
+    for (const table of ["agent_tasks", "scheduled_tasks"]) {
+      const columns = database
+        .prepare<{ name: string }, []>(`PRAGMA table_info(${table})`)
+        .all()
+        .map((column) => column.name);
+      expect(columns).toContain("modelTier");
+    }
+
+    const row = database
+      .prepare<{ name: string; checksum: string }, []>(
+        "SELECT name, checksum FROM _migrations WHERE version = 90",
+      )
+      .get();
+    expect(row?.name).toBe("090_model_tiers");
+    expect(row?.checksum).not.toBe(SEED_CHECKSUM);
+
+    // The original failure mode: inserting a task with a modelTier value.
+    const now = new Date().toISOString();
+    expect(() => {
+      database.run(
+        `INSERT INTO agent_tasks (id, task, status, source, modelTier, createdAt, lastUpdatedAt)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [crypto.randomUUID(), "boot triage", "pending", "system", "regular", now, now],
+      );
+    }).not.toThrow();
+
+    // Healthy histories are untouched: booting again is a no-op.
+    runMigrations(database);
+    const rowAfter = database
+      .prepare<{ name: string; checksum: string }, []>(
+        "SELECT name, checksum FROM _migrations WHERE version = 90",
+      )
+      .get();
+    expect(rowAfter?.name).toBe("090_model_tiers");
+    expect(rowAfter?.checksum).toBe(row?.checksum);
+
+    database.close();
+  });
 });

package/src/tests/model-control.test.ts

@@ -12,7 +12,17 @@ import {
   updateScheduledTask,
   upsertSwarmConfig,
 } from "../be/db";
+import {
+  parseModelTier,
+  resolveModelTier,
+  resolveTaskModelSelection,
+  splitLegacyModelAlias,
+} from "../model-tiers";
 import { runScheduleNow } from "../scheduler";
+import { createScheduleInputSchema } from "../tools/schedules/create-schedule";
+import { updateScheduleInputSchema } from "../tools/schedules/update-schedule";
+import { sendTaskInputSchema } from "../tools/send-task";
+import { taskActionInputSchema } from "../tools/task-action";
 
 const TEST_DB_PATH = "./test-model-control.sqlite";
 
@@ -84,6 +94,24 @@ describe("Model Control - Task Creation", () => {
     expect(task.model).toBe("sonnet");
     expect(task.status).toBe("offered");
   });
+
+  test("should store modelTier when creating a task with portable tier", () => {
+    const task = createTaskExtended("Test task with tier", { modelTier: "smart" });
+    expect(task.model).toBeUndefined();
+    expect(task.modelTier).toBe("smart");
+
+    const retrieved = getTaskById(task.id);
+    expect(retrieved?.modelTier).toBe("smart");
+  });
+
+  test("should preserve freeform concrete model strings", () => {
+    const task = createTaskExtended("Test task with freeform model", {
+      model: "openrouter/anthropic/claude-sonnet-4.6",
+    });
+
+    expect(task.model).toBe("openrouter/anthropic/claude-sonnet-4.6");
+    expect(task.modelTier).toBeUndefined();
+  });
 });
 
 describe("Model Control - Schedule Creation", () => {
@@ -102,7 +130,7 @@ describe("Model Control - Schedule Creation", () => {
   });
 
   test("should store all valid model values on schedules", () => {
-    for (const model of ["haiku", "sonnet", "opus", "fable"] as const) {
+    for (const model of ["haiku", "sonnet", "opus", "fable", "gpt-5.5"] as const) {
       const schedule = createScheduledTask({
         name: `model-schedule-all-${model}-${Date.now()}`,
         intervalMs: 60000,
@@ -123,6 +151,21 @@ describe("Model Control - Schedule Creation", () => {
 
     expect(schedule.model).toBeUndefined();
   });
+
+  test("should store modelTier on scheduled task creation", () => {
+    const schedule = createScheduledTask({
+      name: "model-schedule-tier",
+      intervalMs: 60000,
+      taskTemplate: "Scheduled with portable tier",
+      modelTier: "regular",
+    });
+
+    expect(schedule.model).toBeUndefined();
+    expect(schedule.modelTier).toBe("regular");
+
+    const retrieved = getScheduledTaskById(schedule.id);
+    expect(retrieved?.modelTier).toBe("regular");
+  });
 });
 
 describe("Model Control - Schedule Update", () => {
@@ -169,6 +212,23 @@ describe("Model Control - Schedule Update", () => {
     expect(updated?.model).toBe("haiku");
     expect(updated?.priority).toBe(90);
   });
+
+  test("should update and clear modelTier on existing schedule", () => {
+    const schedule = createScheduledTask({
+      name: "model-tier-update-test",
+      intervalMs: 60000,
+      taskTemplate: "Update model tier test",
+      modelTier: "regular",
+    });
+
+    expect(schedule.modelTier).toBe("regular");
+
+    const updated = updateScheduledTask(schedule.id, { modelTier: "ultra" });
+    expect(updated?.modelTier).toBe("ultra");
+
+    const cleared = updateScheduledTask(schedule.id, { modelTier: null });
+    expect(cleared?.modelTier).toBeUndefined();
+  });
 });
 
 describe("Model Control - Schedule to Task Propagation", () => {
@@ -213,6 +273,28 @@ describe("Model Control - Schedule to Task Propagation", () => {
     const task = getTaskById(row!.id);
     expect(task?.model).toBeUndefined();
   });
+
+  test("should propagate modelTier from schedule to task on manual run", async () => {
+    const schedule = createScheduledTask({
+      name: "model-tier-propagate-manual",
+      intervalMs: 60000,
+      taskTemplate: "Propagated model tier task (manual)",
+      modelTier: "smart",
+      enabled: true,
+    });
+
+    await runScheduleNow(schedule.id);
+
+    const { getDb } = await import("../be/db");
+    const row = getDb()
+      .query("SELECT id FROM agent_tasks WHERE task = ? ORDER BY createdAt DESC LIMIT 1")
+      .get("Propagated model tier task (manual)") as { id: string } | null;
+
+    expect(row).not.toBeNull();
+    const task = getTaskById(row!.id);
+    expect(task?.model).toBeUndefined();
+    expect(task?.modelTier).toBe("smart");
+  });
 });
 
 describe("Model Control - Config MODEL_OVERRIDE Resolution", () => {
@@ -268,71 +350,105 @@ describe("Model Control - Config MODEL_OVERRIDE Resolution", () => {
 });
 
 describe("Model Control - Priority Resolution Logic", () => {
-  // The runner resolves model as: task.model || freshEnv.MODEL_OVERRIDE || "opus"
-  // We test the same logic pattern here to ensure correctness
-
-  function resolveModel(taskModel?: string, configOverride?: string): string {
-    return taskModel || configOverride || "opus";
-  }
-
   test("task.model takes highest priority", () => {
-    expect(resolveModel("haiku", "sonnet")).toBe("haiku");
+    expect(
+      resolveTaskModelSelection({
+        model: "gpt-5.5",
+        modelTier: "smol",
+        harnessProvider: "codex",
+      }).model,
+    ).toBe("gpt-5.5");
   });
 
-  test("config MODEL_OVERRIDE is used when task has no model", () => {
-    expect(resolveModel(undefined, "sonnet")).toBe("sonnet");
+  test("task.modelTier resolves using the claiming worker harness", () => {
+    expect(resolveModelTier({ tier: "smol", harnessProvider: "claude" })).toBe("haiku");
+    expect(resolveModelTier({ tier: "smol", harnessProvider: "codex" })).toBe("gpt-5.4-mini");
+    expect(resolveModelTier({ tier: "smart", harnessProvider: "opencode" })).toBe(
+      "openrouter/deepseek/deepseek-v4-pro",
+    );
+    expect(resolveModelTier({ tier: "ultra", harnessProvider: "pi" })).toBe(
+      "openrouter/anthropic/claude-opus-4.8",
+    );
   });
 
-  test("defaults to 'opus' when no task model and no config override", () => {
-    expect(resolveModel(undefined, undefined)).toBe("opus");
+  test("task.modelTier supports env map and direct tier overrides", () => {
+    expect(
+      resolveModelTier({
+        tier: "regular",
+        harnessProvider: "codex",
+        env: { MODEL_TIER_MAP: JSON.stringify({ regular: "gpt-5.3-codex" }) },
+      }),
+    ).toBe("gpt-5.3-codex");
+    expect(
+      resolveModelTier({
+        tier: "regular",
+        harnessProvider: "codex",
+        env: {
+          MODEL_TIER_MAP: JSON.stringify({ regular: "gpt-5.3-codex" }),
+          MODEL_TIER_REGULAR: "gpt-5.5",
+        },
+      }),
+    ).toBe("gpt-5.5");
   });
 
-  test("empty string task model falls through to config", () => {
-    expect(resolveModel("", "sonnet")).toBe("sonnet");
+  test("legacy model aliases parse as tiers", () => {
+    expect(parseModelTier("haiku")).toBe("smol");
+    expect(parseModelTier("sonnet")).toBe("regular");
+    expect(parseModelTier("opus")).toBe("smart");
+    expect(parseModelTier("fable")).toBe("ultra");
+    expect(splitLegacyModelAlias({ model: "opus" })).toEqual({ modelTier: "smart" });
   });
 
-  test("empty string config override falls through to default", () => {
-    expect(resolveModel(undefined, "")).toBe("opus");
+  test("freeform concrete model strings stay concrete", () => {
+    expect(splitLegacyModelAlias({ model: "gpt-5.5" })).toEqual({
+      model: "gpt-5.5",
+      modelTier: undefined,
+    });
   });
 
-  test("all three levels specified — task wins", () => {
-    expect(resolveModel("haiku", "sonnet")).toBe("haiku");
-    // "opus" is the hardcoded default, tested implicitly
+  test("missing task model selection falls through to adapter/config", () => {
+    expect(
+      resolveTaskModelSelection({ model: "", modelTier: undefined, harnessProvider: "codex" }),
+    ).toEqual({ source: "none" });
   });
 });
 
 describe("Model Control - Zod Validation Schema", () => {
-  // The MCP tools use z.enum(["haiku", "sonnet", "opus"]) for validation.
-  // We test the schema directly to ensure only valid values are accepted.
-
-  test("should accept valid model values", async () => {
-    const { z } = await import("zod");
-    const modelSchema = z.enum(["haiku", "sonnet", "opus"]).optional();
-
-    expect(modelSchema.parse("haiku")).toBe("haiku");
-    expect(modelSchema.parse("sonnet")).toBe("sonnet");
-    expect(modelSchema.parse("opus")).toBe("opus");
-    expect(modelSchema.parse(undefined)).toBeUndefined();
+  test("task tools accept freeform concrete models and model tiers", () => {
+    expect(
+      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", model: "gpt-5.5" })
+        .model,
+    ).toBe("gpt-5.5");
+    expect(
+      taskActionInputSchema.parse({ action: "create", task: "x", modelTier: "ultra" }).modelTier,
+    ).toBe("ultra");
   });
 
-  test("should reject invalid model values", async () => {
-    const { z } = await import("zod");
-    const modelSchema = z.enum(["haiku", "sonnet", "opus"]).optional();
-
-    expect(() => modelSchema.parse("gpt-4")).toThrow();
-    expect(() => modelSchema.parse("claude")).toThrow();
-    expect(() => modelSchema.parse("turbo")).toThrow();
-    expect(() => modelSchema.parse("")).toThrow();
-    expect(() => modelSchema.parse(123)).toThrow();
-    expect(() => modelSchema.parse(null)).toThrow();
+  test("task tools reject empty model strings and invalid tiers", () => {
+    expect(() =>
+      sendTaskInputSchema.parse({ agentId: crypto.randomUUID(), task: "x", model: "" }),
+    ).toThrow();
+    expect(() =>
+      taskActionInputSchema.parse({ action: "create", task: "x", modelTier: "massive" }),
+    ).toThrow();
   });
 
   test("nullable model schema (update-schedule) should accept null", async () => {
-    const { z } = await import("zod");
-    const modelSchema = z.enum(["haiku", "sonnet", "opus"]).nullable().optional();
+    expect(updateScheduleInputSchema.shape.model.parse(null)).toBeNull();
+    expect(updateScheduleInputSchema.shape.model.parse("gpt-5.5")).toBe("gpt-5.5");
+    expect(updateScheduleInputSchema.shape.modelTier.parse(null)).toBeNull();
+    expect(updateScheduleInputSchema.shape.modelTier.parse("smol")).toBe("smol");
+  });
 
-    expect(modelSchema.parse(null)).toBeNull();
-    expect(modelSchema.parse("haiku")).toBe("haiku");
-    expect(modelSchema.parse(undefined)).toBeUndefined();
+  test("create schedule schema accepts freeform model and modelTier", () => {
+    const parsed = createScheduleInputSchema.parse({
+      name: "schema-model-tier",
+      taskTemplate: "x",
+      intervalMs: 60000,
+      model: "openrouter/openai/gpt-5.5",
+      modelTier: "smart",
+    });
+    expect(parsed.model).toBe("openrouter/openai/gpt-5.5");
+    expect(parsed.modelTier).toBe("smart");
   });
 });

package/src/tests/opencode-adapter.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-import { writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import type { Event as OpencodeEvent } from "@opencode-ai/sdk";
 import type { ProviderEvent, ProviderResult, ProviderSessionConfig } from "../providers/types";
@@ -156,6 +156,15 @@ describe("OpencodeSession — SSE→ProviderEvent mapping", () => {
     ];
     const { emitted, result, serverCloseCalls } = await driveSession(events);
 
+    const sessionInit = emitted.find((e) => e.type === "session_init");
+    expect(sessionInit).toBeDefined();
+    if (sessionInit?.type === "session_init") {
+      expect(sessionInit.provider).toBe("opencode");
+      expect(sessionInit.harnessVariant).toBe("stock");
+      expect(typeof sessionInit.harnessVariantMeta?.version).toBe("string");
+      expect((sessionInit.harnessVariantMeta?.version as string).length).toBeGreaterThan(0);
+    }
+
     const resultEvent = emitted.find((e) => e.type === "result");
     expect(resultEvent).toBeDefined();
     if (resultEvent?.type === "result") {
@@ -605,16 +614,22 @@ describe("OpencodeSession — context_usage emission (phase 9 fix)", () => {
 // ── DES-300: per-task isolation ────────────────────────────────────────────────
 
 describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
+  let prevOpencodeSkillsDir: string | undefined;
+
   beforeEach(() => {
+    prevOpencodeSkillsDir = process.env.OPENCODE_SKILLS_DIR;
     lastPromptArgs = undefined;
     lastCreateOpencodeConfig = undefined;
     mock.restore();
   });
 
   afterEach(() => {
+    if (prevOpencodeSkillsDir === undefined) delete process.env.OPENCODE_SKILLS_DIR;
+    else process.env.OPENCODE_SKILLS_DIR = prevOpencodeSkillsDir;
     // Clean up any written files from tests
     Bun.$`rm -rf /tmp/opencode-task-1.json /tmp/opencode-data-task-1`.quiet().nothrow();
     Bun.$`rm -rf /tmp/test/.opencode`.quiet().nothrow();
+    rmSync("/tmp/opencode-skills-test", { recursive: true, force: true });
   });
 
   test("session.prompt receives agent=swarm-<taskId>", async () => {
@@ -629,6 +644,28 @@ describe("OpencodeAdapter — per-task isolation (DES-300)", () => {
     expect(args.body?.agent).toBe("swarm-task-1");
   });
 
+  test("inlines a leading slash skill before sending prompt", async () => {
+    const skillDir = "/tmp/opencode-skills-test/work-on-task";
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(join(skillDir, "SKILL.md"), "Use the task worker procedure.");
+    process.env.OPENCODE_SKILLS_DIR = "/tmp/opencode-skills-test";
+
+    const events: OpencodeEvent[] = [
+      { type: "session.idle", properties: { sessionID: "sess-abc-123" } },
+    ];
+    const cfg = testConfig({
+      taskId: "task-1",
+      prompt: "/work-on-task task-123\n\nTask body.",
+    });
+    await driveSession(events, cfg);
+
+    const args = lastPromptArgs as { body?: { parts?: Array<{ type: string; text: string }> } };
+    const text = args.body?.parts?.[0]?.text ?? "";
+    expect(text).toStartWith("Use the task worker procedure.");
+    expect(text).toContain("User request: task-123\n\nTask body.");
+    expect(text).not.toContain("/work-on-task task-123");
+  });
+
   test("createOpencode receives config with model, mcp.swarm, and permission", async () => {
     const events: OpencodeEvent[] = [
       { type: "session.idle", properties: { sessionID: "sess-abc-123" } },