@desplega.ai/agent-swarm 1.75.0 → 1.76.0

package/src/tests/stop-hook-task-resolution.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Stop-hook task-context resolution.
+ *
+ * Regression for the silent-drop bug PR #444's gate trace surfaced: every Stop
+ * hook logged `hasTaskId: false` because TASK_FILE on disk had been cleaned up
+ * mid-session, so `Bun.file(taskFile).text()` threw and the catch swallowed it.
+ * Fix: prefer the AGENT_SWARM_TASK_ID env var (set by `claude-adapter.ts`) and
+ * only fall back to the file. See `resolveStopHookTaskContext` in hook.ts.
+ */
+import { describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { resolveStopHookTaskContext } from "../hooks/hook";
+
+describe("resolveStopHookTaskContext", () => {
+  test("prefers AGENT_SWARM_TASK_ID env var when TASK_FILE is missing on disk", async () => {
+    const missingPath = `/tmp/stop-hook-missing-${Date.now()}.json`;
+    // Sanity: file must not exist.
+    try {
+      await unlink(missingPath);
+    } catch {}
+
+    const { taskContext, taskId } = await resolveStopHookTaskContext({
+      AGENT_SWARM_TASK_ID: "task-from-env-123",
+      TASK_FILE: missingPath,
+    });
+
+    expect(taskId).toBe("task-from-env-123");
+    // taskContext stays empty because the file (which carries the human task
+    // text) wasn't readable. That's fine — the LLM rater only needs taskId.
+    expect(taskContext).toBe("");
+  });
+
+  test("env var alone (no TASK_FILE) still populates taskId", async () => {
+    const { taskContext, taskId } = await resolveStopHookTaskContext({
+      AGENT_SWARM_TASK_ID: "task-env-only",
+    });
+    expect(taskId).toBe("task-env-only");
+    expect(taskContext).toBe("");
+  });
+
+  test("falls back to TASK_FILE.id when env var unset", async () => {
+    const path = `/tmp/stop-hook-file-${Date.now()}.json`;
+    await Bun.write(path, JSON.stringify({ id: "task-from-file-456", task: "do the thing" }));
+    try {
+      const { taskContext, taskId } = await resolveStopHookTaskContext({
+        TASK_FILE: path,
+      });
+      expect(taskId).toBe("task-from-file-456");
+      expect(taskContext).toBe("Task: do the thing");
+    } finally {
+      await unlink(path).catch(() => {});
+    }
+  });
+
+  test("env var wins over TASK_FILE.id but file still seeds taskContext", async () => {
+    const path = `/tmp/stop-hook-both-${Date.now()}.json`;
+    await Bun.write(path, JSON.stringify({ id: "task-from-file", task: "human task text" }));
+    try {
+      const { taskContext, taskId } = await resolveStopHookTaskContext({
+        AGENT_SWARM_TASK_ID: "task-from-env",
+        TASK_FILE: path,
+      });
+      expect(taskId).toBe("task-from-env");
+      expect(taskContext).toBe("Task: human task text");
+    } finally {
+      await unlink(path).catch(() => {});
+    }
+  });
+
+  test("missing file with no env var → both undefined/empty (no throw)", async () => {
+    const { taskContext, taskId } = await resolveStopHookTaskContext({
+      TASK_FILE: `/tmp/stop-hook-nope-${Date.now()}.json`,
+    });
+    expect(taskId).toBeUndefined();
+    expect(taskContext).toBe("");
+  });
+
+  test("no env at all → both undefined/empty", async () => {
+    const { taskContext, taskId } = await resolveStopHookTaskContext({});
+    expect(taskId).toBeUndefined();
+    expect(taskContext).toBe("");
+  });
+
+  test("malformed TASK_FILE JSON does not throw, env var still wins", async () => {
+    const path = `/tmp/stop-hook-bad-${Date.now()}.json`;
+    await Bun.write(path, "not json {");
+    try {
+      const { taskContext, taskId } = await resolveStopHookTaskContext({
+        AGENT_SWARM_TASK_ID: "task-env-survives",
+        TASK_FILE: path,
+      });
+      expect(taskId).toBe("task-env-survives");
+      expect(taskContext).toBe("");
+    } finally {
+      await unlink(path).catch(() => {});
+    }
+  });
+});

package/src/tests/template-recommendations.test.ts

@@ -0,0 +1,148 @@
+/**
+ * Phase 3 — unit tests for `ui/src/lib/template-recommendations.ts`.
+ *
+ * Lives in `src/tests/` (not under `ui/`) because `ui/` has no test runner
+ * configured. The recommendation lib is pure logic with only a `StatusResponse`
+ * type import, so the cross-tree relative import works without aliases.
+ */
+
+import { describe, expect, test } from "bun:test";
+import type { StatusResponse } from "../../ui/src/api/types.ts";
+import {
+  type DetectedIntegration,
+  detectedFromStatus,
+  recommendTemplates,
+  topRecommendation,
+} from "../../ui/src/lib/template-recommendations.ts";
+
+function makeStatus(overrides: {
+  slack?: "unverified" | "configured" | "verified";
+  github?: "unverified" | "configured" | "verified";
+  linear?: "unverified" | "configured" | "verified";
+  jira?: "unverified" | "configured" | "verified";
+}): StatusResponse {
+  return {
+    identity: {
+      name: "Swarm",
+      logo_url: null,
+      brand_color: null,
+      is_cloud: false,
+      marketing_url: null,
+      hide_cloud_promo: false,
+    },
+    setup: [
+      { id: "harness", label: "Harness", state: "unverified" },
+      { id: "slack", label: "Slack", state: overrides.slack ?? "unverified" },
+      { id: "github", label: "GitHub", state: overrides.github ?? "unverified" },
+      { id: "linear", label: "Linear", state: overrides.linear ?? "unverified" },
+      { id: "jira", label: "Jira", state: overrides.jira ?? "unverified" },
+      { id: "workers", label: "Workers", state: "unverified" },
+      { id: "first_task", label: "First task", state: "unverified" },
+    ],
+    activity: { agents_online: 0, leads_online: 0, recent_tasks_count: 0 },
+    agent_fs: { configured: false, base_url: null },
+    health: "broken",
+  };
+}
+
+describe("recommendTemplates — priority rules", () => {
+  test("slack + github → pr-triage", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["slack", "github"]));
+    expect(recs[0]?.templateId).toBe("pr-triage");
+  });
+
+  test("linear + github → issue-to-pr", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["linear", "github"]));
+    expect(recs[0]?.templateId).toBe("issue-to-pr");
+  });
+
+  test("jira → bug-intake", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["jira"]));
+    expect(recs[0]?.templateId).toBe("bug-intake");
+  });
+
+  test("empty set → hello-world fallback", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>());
+    expect(recs).toHaveLength(1);
+    expect(recs[0]?.templateId).toBe("hello-world");
+    expect(recs[0]?.reason).toMatch(/hello world/i);
+  });
+
+  test("slack alone falls through to hello-world (no PR-triage promo without GitHub)", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["slack"]));
+    expect(recs[0]?.templateId).toBe("hello-world");
+  });
+
+  test("github alone falls through to hello-world", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["github"]));
+    expect(recs[0]?.templateId).toBe("hello-world");
+  });
+
+  test("linear alone falls through to hello-world", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["linear"]));
+    expect(recs[0]?.templateId).toBe("hello-world");
+  });
+
+  test("priority — slack+github+linear matches pr-triage first, also matches issue-to-pr", () => {
+    const recs = recommendTemplates(new Set<DetectedIntegration>(["slack", "github", "linear"]));
+    // pr-triage comes first because slack+github rule is listed before linear+github.
+    expect(recs[0]?.templateId).toBe("pr-triage");
+    expect(recs.map((r) => r.templateId)).toContain("issue-to-pr");
+  });
+
+  test("all four detected — all three rule-based recs returned, no fallback", () => {
+    const recs = recommendTemplates(
+      new Set<DetectedIntegration>(["slack", "github", "linear", "jira"]),
+    );
+    const ids = recs.map((r) => r.templateId);
+    expect(ids).toEqual(["pr-triage", "issue-to-pr", "bug-intake"]);
+    expect(ids).not.toContain("hello-world");
+  });
+});
+
+describe("detectedFromStatus", () => {
+  test("verified milestones count as detected", () => {
+    const status = makeStatus({ slack: "verified", github: "verified" });
+    const detected = detectedFromStatus(status);
+    expect(detected.has("slack")).toBe(true);
+    expect(detected.has("github")).toBe(true);
+  });
+
+  test("configured milestones count as detected (live-call not required)", () => {
+    const status = makeStatus({ slack: "configured", jira: "configured" });
+    const detected = detectedFromStatus(status);
+    expect(detected.has("slack")).toBe(true);
+    expect(detected.has("jira")).toBe(true);
+  });
+
+  test("unverified milestones do NOT count as detected", () => {
+    const status = makeStatus({ slack: "unverified", github: "unverified" });
+    const detected = detectedFromStatus(status);
+    expect(detected.size).toBe(0);
+  });
+
+  test("non-integration milestones (harness, workers, first_task) are excluded", () => {
+    const status = makeStatus({});
+    // All four integration milestones are unverified by default; harness etc.
+    // are also unverified — none should leak into the detected set.
+    const detected = detectedFromStatus(status);
+    expect(detected.size).toBe(0);
+  });
+});
+
+describe("topRecommendation — end-to-end from a /status payload", () => {
+  test("slack+github verified → pr-triage", () => {
+    const status = makeStatus({ slack: "verified", github: "verified" });
+    expect(topRecommendation(status).templateId).toBe("pr-triage");
+  });
+
+  test("linear configured + github verified → issue-to-pr", () => {
+    const status = makeStatus({ linear: "configured", github: "verified" });
+    expect(topRecommendation(status).templateId).toBe("issue-to-pr");
+  });
+
+  test("nothing connected → hello-world", () => {
+    const status = makeStatus({});
+    expect(topRecommendation(status).templateId).toBe("hello-world");
+  });
+});

package/src/tests/use-dismissible-card.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Phase 4 — pure-logic tests for `ui/src/hooks/use-dismissible-card.ts`.
+ *
+ * Lives in `src/tests/` (not under `ui/`) because:
+ *   - `ui/` has no test runner configured (no vitest/jest).
+ *   - The repo-root `bun test` already wires preload + DB fixtures.
+ *   - We test the pure `deriveStorageKey()` helper plus localStorage-shape
+ *     semantics by stubbing `globalThis.localStorage` — no React renderer.
+ *
+ * Hook semantics covered:
+ *   - Namespace key derivation (format + uniqueness across apiUrls).
+ *   - Dismiss / restore round-trip via the underlying localStorage shape.
+ *   - Namespace isolation between two distinct apiUrls.
+ *   - Graceful failure when `localStorage` throws.
+ *
+ * Cross-tab `storage` event handling lives in the React layer and is
+ * covered by the qa-use sessions in Success Criteria; pure-logic tests
+ * cannot exercise the `addEventListener("storage", …)` wiring meaningfully.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+// Import the pure helper directly — the parent `use-dismissible-card.ts`
+// pulls in React + the `@/lib/config` alias chain via `useConfig`, which
+// the bun-test runner can't resolve outside Vite.
+import { deriveStorageKey } from "../../ui/src/hooks/use-dismissible-card-key.ts";
+
+// Minimal in-memory localStorage shim for the round-trip / failure tests.
+class MemoryStorage {
+  private store = new Map<string, string>();
+  private throwOnSet = false;
+
+  setThrowOnSet(value: boolean) {
+    this.throwOnSet = value;
+  }
+  getItem(key: string): string | null {
+    return this.store.has(key) ? (this.store.get(key) as string) : null;
+  }
+  setItem(key: string, value: string): void {
+    if (this.throwOnSet) throw new Error("QuotaExceededError (simulated)");
+    this.store.set(key, value);
+  }
+  removeItem(key: string): void {
+    this.store.delete(key);
+  }
+  clear(): void {
+    this.store.clear();
+  }
+}
+
+afterEach(() => {
+  // Clean up the global between tests so leakage can't mask bugs.
+  // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+  delete (globalThis as any).localStorage;
+});
+
+describe("deriveStorageKey", () => {
+  test("namespaces by apiUrl + cardKey under swarm:v1 prefix", () => {
+    expect(deriveStorageKey("http://localhost:3013", "home-welcome")).toBe(
+      "swarm:v1:http://localhost:3013:home-welcome",
+    );
+  });
+
+  test("two distinct apiUrls produce distinct keys for the same cardKey", () => {
+    const a = deriveStorageKey("http://a.local:3013", "home-welcome");
+    const b = deriveStorageKey("http://b.local:3013", "home-welcome");
+    expect(a).not.toBe(b);
+  });
+
+  test("two distinct cardKeys produce distinct keys for the same apiUrl", () => {
+    const a = deriveStorageKey("http://localhost:3013", "home-welcome");
+    const b = deriveStorageKey("http://localhost:3013", "setup:row:harness");
+    expect(a).not.toBe(b);
+  });
+
+  test("structured cardKey separators (colons) survive the round-trip", () => {
+    expect(deriveStorageKey("http://x", "setup:tour-complete")).toBe(
+      "swarm:v1:http://x:setup:tour-complete",
+    );
+  });
+});
+
+describe("dismiss / restore round-trip via localStorage shape", () => {
+  test("dismiss writes '1' under the namespaced key; restore removes it", () => {
+    const storage = new MemoryStorage();
+    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+    (globalThis as any).localStorage = storage;
+
+    const key = deriveStorageKey("http://localhost:3013", "home-welcome");
+
+    // Initially undismissed.
+    expect(storage.getItem(key)).toBeNull();
+
+    // Simulate dismiss.
+    storage.setItem(key, "1");
+    expect(storage.getItem(key)).toBe("1");
+
+    // Simulate restore.
+    storage.removeItem(key);
+    expect(storage.getItem(key)).toBeNull();
+  });
+
+  test("namespace isolation: dismissing on apiUrl A does not affect apiUrl B", () => {
+    const storage = new MemoryStorage();
+    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+    (globalThis as any).localStorage = storage;
+
+    const keyA = deriveStorageKey("http://a.local:3013", "home-welcome");
+    const keyB = deriveStorageKey("http://b.local:3013", "home-welcome");
+
+    storage.setItem(keyA, "1");
+
+    expect(storage.getItem(keyA)).toBe("1");
+    expect(storage.getItem(keyB)).toBeNull();
+  });
+});
+
+describe("graceful failure when localStorage throws", () => {
+  test("setItem throw is swallowed by the hook's try/catch contract", () => {
+    const storage = new MemoryStorage();
+    storage.setThrowOnSet(true);
+    // biome-ignore lint/suspicious/noExplicitAny: test-only shim
+    (globalThis as any).localStorage = storage;
+
+    const key = deriveStorageKey("http://localhost:3013", "home-welcome");
+
+    // Direct call DOES throw — confirm the test shim is wired up.
+    expect(() => storage.setItem(key, "1")).toThrow();
+
+    // The hook contract is `try { localStorage.setItem(...) } catch {}` —
+    // emulate that wrapper and assert no error escapes to the caller.
+    const swallow = () => {
+      try {
+        storage.setItem(key, "1");
+      } catch {
+        // intentionally swallow
+      }
+    };
+    expect(swallow).not.toThrow();
+  });
+});

package/src/tools/swarm-config/set-config.ts

@@ -1,7 +1,11 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { maskSecrets, upsertSwarmConfig } from "@/be/db";
-import { isReservedConfigKey, reservedKeyError } from "@/be/swarm-config-guard";
+import {
+  isReservedConfigKey,
+  reservedKeyError,
+  validateConfigValue,
+} from "@/be/swarm-config-guard";
 import { createToolRegistrar } from "@/tools/utils";
 import { SwarmConfigSchema, SwarmConfigScopeSchema } from "@/types";
 
@@ -89,6 +93,18 @@ export const registerSetConfigTool = (server: McpServer) => {
           };
         }
 
+        const validationError = validateConfigValue(key, value);
+        if (validationError) {
+          return {
+            content: [{ type: "text", text: validationError }],
+            structuredContent: {
+              yourAgentId: requestInfo.agentId,
+              success: false,
+              message: validationError,
+            },
+          };
+        }
+
         const config = upsertSwarmConfig({
           scope,
           scopeId: scope === "global" ? null : scopeId,

package/src/types.ts

@@ -57,6 +57,7 @@ export const AgentTaskSourceSchema = z.enum([
   "mcp",
   "slack",
   "api",
+  "ui",
   "github",
   "gitlab",
   "agentmail",
@@ -233,6 +234,72 @@ export const UserSchema = z.object({
 
 export type User = z.infer<typeof UserSchema>;
 
+// ============================================================================
+// Inbox Item State (per-user dismiss/snooze/done for action-items inbox)
+// ============================================================================
+//
+// Action-items inbox buckets:
+//   - approval           — pending approval requests
+//   - credential_missing — agents in waiting_for_credentials state
+//   - broken_task        — tasks in failed/cancelled status
+//   - to_read            — sessions/tasks marked unread for the user
+//   - to_start_template  — task-templates the user hasn't dismissed
+//
+// Statuses:
+//   - open      — visible in inbox
+//   - snoozed   — hidden until snoozeUntil; reappears as `open`
+//   - dismissed — hidden permanently (until item itself reactivates)
+//   - done      — user marked complete
+export const InboxItemTypeSchema = z.enum([
+  "approval",
+  "credential_missing",
+  "broken_task",
+  "to_read",
+  "to_start_template",
+]);
+export type InboxItemType = z.infer<typeof InboxItemTypeSchema>;
+
+export const InboxItemStatusSchema = z.enum(["open", "snoozed", "dismissed", "done"]);
+export type InboxItemStatus = z.infer<typeof InboxItemStatusSchema>;
+
+export const InboxItemStateSchema = z.object({
+  id: z.string(),
+  userId: z.string(),
+  itemType: InboxItemTypeSchema,
+  itemId: z.string(),
+  status: InboxItemStatusSchema,
+  snoozeUntil: z.string().optional(),
+  dismissedAt: z.string().optional(),
+  doneAt: z.string().optional(),
+  createdAt: z.string(),
+  lastUpdatedAt: z.string(),
+});
+export type InboxItemState = z.infer<typeof InboxItemStateSchema>;
+
+// ============================================================================
+// Task Templates ("To start" bucket — polymorphic starters registry)
+// ============================================================================
+//
+// kind:
+//   - task     — v1 default; payload is `{}` and the task prompt lives in `prompt`
+//   - workflow — v2 hook; payload `{ workflowId: string }`, prompt may be empty
+//   - schedule — v2 hook; payload `{ cron: string, prompt: string }`
+export const TaskTemplateKindSchema = z.enum(["task", "workflow", "schedule"]);
+export type TaskTemplateKind = z.infer<typeof TaskTemplateKindSchema>;
+
+export const TaskTemplateSchema = z.object({
+  id: z.string(),
+  title: z.string().min(1),
+  description: z.string(),
+  prompt: z.string(),
+  kind: TaskTemplateKindSchema.default("task"),
+  payload: z.record(z.string(), z.unknown()).default({}),
+  category: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  createdAt: z.string(),
+});
+export type TaskTemplate = z.infer<typeof TaskTemplateSchema>;
+
 export const AgentStatusSchema = z.enum(["idle", "busy", "offline", "waiting_for_credentials"]);
 
 export const AgentSchema = z.object({
@@ -272,14 +339,64 @@ export const AgentSchema = z.object({
   // Harness provider this agent runs (claude, opencode, codex, ...)
   provider: ProviderNameSchema.optional(),
 
+  // Phase 1.5 (cloud-personalization): harness provider pushed by the worker
+  // on registration. Mirrors `provider` but lives in its own column so the
+  // server can answer "what harnesses are deployed?" without joining
+  // anywhere else, and so an operator can re-assign via
+  // PATCH /api/agents/:id/harness-provider without restarting the worker.
+  // Worker boot path is NOT yet rewritten (DES-359 tracks that) — the
+  // PATCH is a planning/forecast mechanism today; on next worker restart,
+  // the env-driven value wins.
+  harnessProvider: ProviderNameSchema.nullable().optional(),
+
   // Env-var names the worker is blocked on when status is
   // `waiting_for_credentials`. Null otherwise.
   credentialMissing: z.array(z.string()).nullable().optional(),
 
+  // Worker-self-reported credential snapshot for this agent's harness.
+  // Pairs with `harnessProvider`. Null = unreported (worker hasn't booted
+  // yet, or CRED_CHECK_DISABLE=1 was set). Migration 055 adds the column.
+  credStatus: z
+    .lazy(() => AgentCredStatusSchema)
+    .nullable()
+    .optional(),
+
   createdAt: z.iso.datetime().default(() => new Date().toISOString()),
   lastUpdatedAt: z.iso.datetime().default(() => new Date().toISOString()),
 });
 
+// ---------------------------------------------------------------------------
+// Worker-reported credential snapshot
+// ---------------------------------------------------------------------------
+// `provider` is intentionally absent from the JSON — already on the agent row
+// as `harnessProvider`; the status endpoint joins them at read time.
+//
+// `reportKind` records the trigger that produced the report:
+//   - "boot": worker startup, full check (presence + live test).
+//   - "post_task": worker finished a task and `harness_provider` differed
+//     from its cached value, so it re-ran a full check (presence + live test).
+//
+// The cache-hit post-task path does NOT produce a new report; the row's
+// `reportedAt` deliberately stays at the last actual check.
+export const AgentCredStatusLiveTestSchema = z.object({
+  ok: z.boolean(),
+  error: z.string().nullable().default(null),
+  latency_ms: z.number(),
+  testedAt: z.number(), // unix ms
+});
+export type AgentCredStatusLiveTest = z.infer<typeof AgentCredStatusLiveTestSchema>;
+
+export const AgentCredStatusSchema = z.object({
+  ready: z.boolean(),
+  missing: z.array(z.string()).default([]),
+  satisfiedBy: z.enum(["env", "file", "side-effect-pending"]).nullable().default(null),
+  hint: z.string().nullable().default(null),
+  liveTest: AgentCredStatusLiveTestSchema.nullable().default(null),
+  reportedAt: z.number(), // unix ms
+  reportKind: z.enum(["boot", "post_task"]).default("boot"),
+});
+export type AgentCredStatus = z.infer<typeof AgentCredStatusSchema>;
+
 export const AgentWithTasksSchema = AgentSchema.extend({
   tasks: z.array(AgentTaskSchema).default([]),
 });

package/src/utils/harness-provider.ts

@@ -0,0 +1,32 @@
+import { type ProviderName, ProviderNameSchema } from "../types";
+
+const SUPPORTED_PROVIDERS = ProviderNameSchema.options;
+
+/**
+ * Resolve the effective `HARNESS_PROVIDER` for a worker.
+ *
+ * Precedence (highest first):
+ *   1. `resolvedEnv.HARNESS_PROVIDER` — value coming from `swarm_config`
+ *      (overlay produced by `fetchResolvedEnv`, scoped repo > agent > global).
+ *   2. `fallbackEnv.HARNESS_PROVIDER` — raw `process.env`.
+ *   3. `"claude"` — final default.
+ *
+ * Invalid values (anything outside `ProviderNameSchema`) log a warning and
+ * fall back to `"claude"` rather than throwing — boot must not be killed
+ * by a typo'd swarm_config row.
+ */
+export function resolveHarnessProvider(
+  resolvedEnv: Record<string, string | undefined>,
+  fallbackEnv: Record<string, string | undefined> = process.env,
+): ProviderName {
+  const candidate = resolvedEnv.HARNESS_PROVIDER?.trim() || fallbackEnv.HARNESS_PROVIDER?.trim();
+  if (!candidate) return "claude";
+  const parsed = ProviderNameSchema.safeParse(candidate);
+  if (!parsed.success) {
+    console.warn(
+      `[harness-provider] Invalid HARNESS_PROVIDER="${candidate}" (must be one of: ${SUPPORTED_PROVIDERS.join(", ")}); falling back to "claude"`,
+    );
+    return "claude";
+  }
+  return parsed.data;
+}

package/tsconfig.json

@@ -35,9 +35,7 @@
   },
   "exclude": [
     "ui",
-    "new-ui",
     "templates-ui",
-    "landing",
     "node_modules",
     "scripts",
     "src/tests",

package/src/providers/credentials.ts

@@ -1,74 +0,0 @@
-/**
- * Provider-agnostic credential check dispatcher.
- *
- * Used by:
- * - The worker boot loop (`src/commands/credential-wait.ts`) to decide
- *   whether the worker can claim tasks yet.
- * - The dashboard credential-status endpoint, which surfaces the per-provider
- *   `missing[]` list as a "blocked on …" hint.
- *
- * The predicate functions live alongside their adapters so they evolve
- * together; this module is a thin switch with documentation/UI hints
- * exported as a static map for the credential-status API.
- */
-
-import { checkClaudeCredentials } from "./claude-adapter";
-import { checkClaudeManagedCredentials } from "./claude-managed-adapter";
-import { checkCodexCredentials } from "./codex-adapter";
-import { checkDevinCredentials } from "./devin-adapter";
-import { checkOpencodeCredentials } from "./opencode-adapter";
-import { checkPiMonoCredentials } from "./pi-mono-adapter";
-import type { CredCheckOptions, CredStatus } from "./types";
-
-export type SupportedProvider = "claude" | "claude-managed" | "codex" | "devin" | "opencode" | "pi";
-
-/**
- * Static documentation of which env vars each provider considers when running
- * `checkCredentials`. Used by the dashboard to render hints before any worker
- * has reported its dynamic state. The arrays are illustrative — the real
- * authoritative answer always comes from the predicate function (which may
- * fold in `MODEL_OVERRIDE`-conditional logic for pi/opencode and file-based
- * fallbacks for codex/pi/opencode).
- */
-export const REQUIRED_CRED_VARS_BY_PROVIDER: Record<SupportedProvider, readonly string[]> = {
-  claude: ["CLAUDE_CODE_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
-  "claude-managed": [
-    "ANTHROPIC_API_KEY",
-    "MANAGED_AGENT_ID",
-    "MANAGED_ENVIRONMENT_ID",
-    "MCP_BASE_URL",
-  ],
-  codex: ["OPENAI_API_KEY", "CODEX_OAUTH"],
-  devin: ["DEVIN_API_KEY", "DEVIN_ORG_ID"],
-  opencode: ["OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"],
-  pi: ["ANTHROPIC_API_KEY", "OPENROUTER_API_KEY", "OPENAI_API_KEY"],
-};
-
-/**
- * Run the predicate for `provider`. Unknown providers throw — call sites
- * should treat that as a configuration bug, not a user-correctable state.
- */
-export function checkProviderCredentials(
-  provider: string,
-  env: Record<string, string | undefined>,
-  opts?: CredCheckOptions,
-): CredStatus {
-  switch (provider) {
-    case "claude":
-      return checkClaudeCredentials(env);
-    case "claude-managed":
-      return checkClaudeManagedCredentials(env);
-    case "codex":
-      return checkCodexCredentials(env, opts);
-    case "devin":
-      return checkDevinCredentials(env);
-    case "opencode":
-      return checkOpencodeCredentials(env, opts);
-    case "pi":
-      return checkPiMonoCredentials(env, opts);
-    default:
-      throw new Error(
-        `checkProviderCredentials: unknown provider "${provider}". Supported: claude, claude-managed, codex, devin, opencode, pi.`,
-      );
-  }
-}