@stigmer/cli 3.4.0 → 3.4.1

package/src/local/daemon/launch.ts

@@ -99,9 +99,8 @@ export async function up(options: UpOptions = {}, home: string = homedir()): Pro
 }
 
 /**
- * Bootstrap the system seedpack into the freshly-started local backend (the TS
- * equivalent of the Go daemon's EnsureSeedpackBootstrapped). Idempotent via a
- * content-hash marker, so repeated `up`s are cheap. Best-effort: the stack is
+ * Bootstrap the system seedpack into the freshly-started local backend.
+ * Idempotent via a content-hash marker, so repeated `up`s are cheap. Best-effort: the stack is
  * already serving by this point, so a seedpack failure is surfaced as a warning
  * with a retry hint rather than tearing the stack down.
  */
@@ -228,23 +227,16 @@ async function stopManagedTemporal(home: string): Promise<void> {
 // the config file, so the launcher must write it into the daemon contract explicitly
 // — unlike a shell-exported key, it cannot flow by env inheritance. resolveApiKey's
 // precedence (env var > config file) makes both cases one code path; when the env
-// var is set this re-writes the same value. Only the effective provider's key is
-// passed: the config file stores a single key, keyed to the chosen provider.
-function resolveLlmKeyInputs(config: Config): Pick<DaemonEnvInputs, "anthropicApiKey" | "openaiApiKey"> {
+// var is set this re-writes the same value. Anthropic is the only provider the
+// local stack executes on, so it is the only key with a persisted delivery path.
+function resolveLlmKeyInputs(config: Config): Pick<DaemonEnvInputs, "anthropicApiKey"> {
+  if (resolveProvider(config) !== "anthropic") return {};
   const key = resolveApiKey(config);
-  if (key === "") return {};
-  switch (resolveProvider(config)) {
-    case "anthropic":
-      return { anthropicApiKey: key };
-    case "openai":
-      return { openaiApiKey: key };
-    default:
-      return {};
-  }
+  return key === "" ? {} : { anthropicApiKey: key };
 }
 
-// Default to managed Temporal unless the opaque local config explicitly opts out
-// (Go parity: managed is the default). Wave 4's `setup` models this section.
+// Default to managed Temporal unless the opaque local config explicitly opts
+// out — zero-config `stigmer up` must work on a fresh machine.
 function isTemporalManaged(config: Config): boolean {
   const local = config.backend.local as { temporal?: { managed?: boolean } } | undefined;
   return local?.temporal?.managed !== false;

package/src/local/llm-config.test.ts

@@ -7,7 +7,6 @@ import {
   resolveModel,
   resolveProvider,
   setLlm,
-  withProviderDefaults,
 } from "./llm-config.js";
 
 function config(local?: unknown): Config {
@@ -15,60 +14,50 @@ function config(local?: unknown): Config {
 }
 
 describe("detectProviderFromEnv", () => {
-  it("prefers Anthropic, then OpenAI, else empty", () => {
-    expect(detectProviderFromEnv({ ANTHROPIC_API_KEY: "a", OPENAI_API_KEY: "b" })).toBe("anthropic");
-    expect(detectProviderFromEnv({ OPENAI_API_KEY: "b" })).toBe("openai");
+  it("detects Anthropic only — the sole provider local execution supports", () => {
+    expect(detectProviderFromEnv({ ANTHROPIC_API_KEY: "a" })).toBe("anthropic");
+    // Other provider keys in the shell must not flip the local story.
+    expect(detectProviderFromEnv({ OPENAI_API_KEY: "b" })).toBe("");
     expect(detectProviderFromEnv({})).toBe("");
   });
 });
 
 describe("resolveProvider", () => {
   it("honors env override > config > autodetect", () => {
-    const cfg = config({ llm: { provider: "ollama" } });
-    expect(resolveProvider(cfg, { STIGMER_LLM_PROVIDER: "openai" })).toBe("openai");
-    expect(resolveProvider(cfg, {})).toBe("ollama");
+    const cfg = config({ llm: { provider: "anthropic" } });
+    expect(resolveProvider(cfg, { STIGMER_LLM_PROVIDER: "other" })).toBe("other");
+    expect(resolveProvider(cfg, {})).toBe("anthropic");
     expect(resolveProvider(config(), { ANTHROPIC_API_KEY: "x" })).toBe("anthropic");
     expect(resolveProvider(config(), {})).toBe("");
   });
 });
 
 describe("resolveModel", () => {
-  it("falls back to the provider default", () => {
-    expect(resolveModel(config({ llm: { provider: "anthropic" } }), {})).toBe("claude-sonnet-4.5");
-    expect(resolveModel(config({ llm: { provider: "openai" } }), {})).toBe("gpt-4");
-    expect(resolveModel(config({ llm: { provider: "ollama" } }), {})).toBe("qwen2.5-coder:7b");
+  it("returns the explicit override, else empty — the registry owns the default", () => {
+    // No hardcoded model version anywhere in the CLI: unset means "platform
+    // default", resolved by the runner from the model registry.
+    expect(resolveModel(config({ llm: { provider: "anthropic" } }), {})).toBe("");
+    expect(resolveModel(config(), {})).toBe("");
     expect(resolveModel(config({ llm: { provider: "anthropic", model: "claude-x" } }), {})).toBe("claude-x");
     expect(resolveModel(config({ llm: { provider: "anthropic" } }), { STIGMER_LLM_MODEL: "envm" })).toBe("envm");
   });
 });
 
 describe("resolveApiKey", () => {
-  it("uses the provider-specific env var, then config", () => {
+  it("uses ANTHROPIC_API_KEY, then config", () => {
     const cfg = config({ llm: { provider: "anthropic", api_key: "cfgkey" } });
     expect(resolveApiKey(cfg, { ANTHROPIC_API_KEY: "envkey" })).toBe("envkey");
     expect(resolveApiKey(cfg, {})).toBe("cfgkey");
   });
-});
 
-describe("withProviderDefaults", () => {
-  it("fills model and base URL per provider, keeping api_key only when set", () => {
-    expect(withProviderDefaults({ provider: "anthropic" })).toEqual({ provider: "anthropic", model: "claude-sonnet-4.5" });
-    expect(withProviderDefaults({ provider: "ollama" })).toEqual({
-      provider: "ollama",
-      model: "qwen2.5-coder:7b",
-      base_url: "http://localhost:11434",
-    });
-    expect(withProviderDefaults({ provider: "openai", api_key: "k" })).toEqual({
-      provider: "openai",
-      model: "gpt-4",
-      api_key: "k",
-    });
+  it("returns empty for non-anthropic providers (e.g. hand-edited config)", () => {
+    expect(resolveApiKey(config({ llm: { provider: "other", api_key: "k" } }), {})).toBe("");
   });
 });
 
 describe("setLlm", () => {
   it("preserves sibling local keys and can clear the section", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "openai" } });
+    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic" } });
     const updated = setLlm(cfg, { provider: "anthropic", model: "m" });
     expect(readLlm(updated)).toEqual({ provider: "anthropic", model: "m" });
     expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });

package/src/local/llm-config.ts

@@ -2,12 +2,23 @@
 // the LLM settings `setup` writes and `status` reads.
 //
 // The config module (config/config.ts) carries `backend.local` through verbatim
-// so the TS CLI never drops fields it does not model. This module adds a *typed
-// lens* for the one sub-tree T05 owns — `local.llm` — and ports the Go CLI's
-// `ResolveLLM*` precedence (env override > config file > provider default) so the
-// two CLIs agree on which provider/model is effectively in force. Writes merge
-// into a shallow copy of `local`, preserving every sibling key (temporal,
-// execution, …).
+// so the CLI never drops fields it does not model. This module adds a *typed
+// lens* for the one sub-tree setup owns — `local.llm` — and resolves the
+// effective provider/model with env-override precedence (env > config file >
+// API-key autodetect). Writes merge into a shallow copy of `local`, preserving
+// every sibling key (temporal, execution, …).
+//
+// Local agent execution is Anthropic-only: the native runner constructs
+// Anthropic clients, and the platform model registry's native-harness entries
+// are all Anthropic models. Two invariants follow:
+//
+//   1. The model registry — not this config — owns the default execution model.
+//      The runner resolves it from the registry at execution time, so this
+//      module never hardcodes a model version (hardcoded versions here drifted
+//      from the registry repeatedly). An unset model means "platform default".
+//   2. `provider` exists to route the right API key to the runner, not to
+//      select an execution backend; "anthropic" is the only provider the local
+//      stack can serve.
 
 import type { Config } from "../config/config.js";
 
@@ -16,7 +27,6 @@ export interface LlmSettings {
   provider?: string;
   model?: string;
   api_key?: string;
-  base_url?: string;
 }
 
 interface LocalSection {
@@ -24,18 +34,6 @@ interface LocalSection {
   [key: string]: unknown;
 }
 
-/** Default model per provider, matching the Go setup wizard's choices. */
-const DEFAULT_MODEL: Record<string, string> = {
-  ollama: "qwen2.5-coder:7b",
-  anthropic: "claude-sonnet-4.5",
-  openai: "gpt-4",
-};
-
-/** Default base URL per provider (only Ollama needs one). */
-const DEFAULT_BASE_URL: Record<string, string> = {
-  ollama: "http://localhost:11434",
-};
-
 function localSection(config: Config): LocalSection {
   const local = config.backend.local;
   return local !== null && typeof local === "object" ? (local as LocalSection) : {};
@@ -47,12 +45,11 @@ export function readLlm(config: Config): LlmSettings | undefined {
 }
 
 /**
- * Detect a provider from API keys present in the environment (Anthropic first,
- * then OpenAI), matching the Go CLI's `DetectProviderFromAPIKeys`.
+ * Detect a provider from API keys present in the environment. Anthropic is the
+ * only provider local execution supports, so only ANTHROPIC_API_KEY counts.
  */
 export function detectProviderFromEnv(env: NodeJS.ProcessEnv = process.env): string {
   if (env.ANTHROPIC_API_KEY) return "anthropic";
-  if (env.OPENAI_API_KEY) return "openai";
   return "";
 }
 
@@ -64,33 +61,22 @@ export function resolveProvider(config: Config, env: NodeJS.ProcessEnv = process
   return detectProviderFromEnv(env);
 }
 
-/** Effective model: env override > config > provider default. */
+/**
+ * Effective model override: env override > config. Empty string means "no
+ * override" — the runner picks the default from the platform model registry.
+ */
 export function resolveModel(config: Config, env: NodeJS.ProcessEnv = process.env): string {
   if (env.STIGMER_LLM_MODEL) return env.STIGMER_LLM_MODEL;
-  const llm = readLlm(config);
-  if (llm?.model) return llm.model;
-  return DEFAULT_MODEL[resolveProvider(config, env)] ?? "";
+  return readLlm(config)?.model ?? "";
 }
 
-/** Effective API key: provider-specific env var > config. */
+/** Effective API key: ANTHROPIC_API_KEY env var > config. */
 export function resolveApiKey(config: Config, env: NodeJS.ProcessEnv = process.env): string {
-  const provider = resolveProvider(config, env);
-  const envKey = provider === "anthropic" ? env.ANTHROPIC_API_KEY : provider === "openai" ? env.OPENAI_API_KEY : "";
-  if (envKey) return envKey;
+  if (resolveProvider(config, env) !== "anthropic") return "";
+  if (env.ANTHROPIC_API_KEY) return env.ANTHROPIC_API_KEY;
   return readLlm(config)?.api_key ?? "";
 }
 
-/** Fill in provider-appropriate defaults for a partial selection. */
-export function withProviderDefaults(settings: LlmSettings): LlmSettings {
-  const provider = settings.provider ?? "";
-  const out: LlmSettings = { provider };
-  out.model = settings.model ?? DEFAULT_MODEL[provider];
-  if (settings.api_key) out.api_key = settings.api_key;
-  const baseUrl = settings.base_url ?? DEFAULT_BASE_URL[provider];
-  if (baseUrl) out.base_url = baseUrl;
-  return out;
-}
-
 /**
  * Return a copy of `config` with the LLM section replaced, preserving every
  * other key under `backend.local`. Passing `undefined` clears the LLM section

package/src/local/setup/wizard.test.ts

@@ -1,25 +1,33 @@
 import { describe, expect, it } from "vitest";
 import type { Config } from "../../config/config.js";
 import { readLlm } from "../llm-config.js";
-import { applyChoice, buildLlmForChoice } from "./wizard.js";
+import { PROVIDER_CHOICES, applyChoice, buildLlmForChoice } from "./wizard.js";
 
 function config(local?: unknown): Config {
   return { backend: { type: "local", local } };
 }
 
+// Regression pin: every provider offered by `stigmer setup` promises an
+// execution path the native runner must actually serve. The runner constructs
+// Anthropic clients only and the registry's native-harness entries are all
+// Anthropic — so this list is anthropic + skip, full stop. If this test fails
+// because a provider was added, the native runner and model registry must gain
+// real support for it first (see sdk/react DISABLED_PROVIDERS for the same
+// decision on the UI side).
+describe("PROVIDER_CHOICES", () => {
+  it("offers exactly anthropic and skip", () => {
+    expect([...PROVIDER_CHOICES]).toEqual(["anthropic", "skip"]);
+  });
+});
+
 describe("buildLlmForChoice", () => {
-  it("applies provider defaults and overrides", () => {
-    expect(buildLlmForChoice("anthropic")).toEqual({ provider: "anthropic", model: "claude-sonnet-4.5" });
+  it("persists no model unless explicitly overridden — the registry owns the default", () => {
+    expect(buildLlmForChoice("anthropic")).toEqual({ provider: "anthropic" });
     expect(buildLlmForChoice("anthropic", { apiKey: "k", model: "m" })).toEqual({
       provider: "anthropic",
       model: "m",
       api_key: "k",
     });
-    expect(buildLlmForChoice("ollama", { baseUrl: "http://host:1" })).toEqual({
-      provider: "ollama",
-      model: "qwen2.5-coder:7b",
-      base_url: "http://host:1",
-    });
   });
 
   it("returns undefined for skip (clears config)", () => {
@@ -29,14 +37,14 @@ describe("buildLlmForChoice", () => {
 
 describe("applyChoice", () => {
   it("writes the selection while preserving siblings", () => {
-    const cfg = config({ temporal: { managed: true }, llm: { provider: "openai" } });
+    const cfg = config({ temporal: { managed: true }, llm: { provider: "anthropic", model: "stale" } });
     const updated = applyChoice(cfg, "anthropic", { apiKey: "k" });
-    expect(readLlm(updated)).toEqual({ provider: "anthropic", model: "claude-sonnet-4.5", api_key: "k" });
+    expect(readLlm(updated)).toEqual({ provider: "anthropic", api_key: "k" });
     expect((updated.backend.local as { temporal: unknown }).temporal).toEqual({ managed: true });
   });
 
   it("skip clears the llm section", () => {
-    const updated = applyChoice(config({ llm: { provider: "openai" } }), "skip");
+    const updated = applyChoice(config({ llm: { provider: "anthropic" } }), "skip");
     expect(readLlm(updated)).toBeUndefined();
   });
 });

package/src/local/setup/wizard.ts

@@ -1,35 +1,47 @@
 // LLM provider selection for `stigmer setup`.
 //
 // The decision logic is a pure function (`buildLlmForChoice`) shared by the
-// non-interactive flag path and the interactive menu, so both produce identical
-// config and the rules are unit-testable in isolation. The interactive menu
-// (`runInteractiveWizard`) is a thin shell around it, mirroring the Go wizard's
-// provider list and API-key handling (env var first, then a hidden prompt).
+// non-interactive flag path and the interactive prompt, so both produce
+// identical config and the rules are unit-testable in isolation.
+//
+// Local agent execution is Anthropic-only (the native runner only constructs
+// Anthropic clients and the registry's native entries are Anthropic models),
+// so the interactive flow is a single API-key prompt rather than a provider
+// menu. The model is deliberately NOT asked for: the platform model registry
+// owns the execution default, and an explicit override is a power-user flag
+// (`stigmer setup --model …`), not a setup question.
 
 import type { Config } from "../../config/config.js";
-import { type LlmSettings, setLlm, withProviderDefaults } from "../llm-config.js";
-import { promptLine, promptSecret } from "./prompt.js";
+import { type LlmSettings, setLlm } from "../llm-config.js";
+import { promptSecret } from "./prompt.js";
 
-export type ProviderChoice = "anthropic" | "openai" | "ollama" | "skip";
+/**
+ * The providers `stigmer setup` accepts. This is the single source of truth
+ * for the CLI's local-provider surface — `setup --provider` validates against
+ * it and a regression test pins it, because every entry here promises an
+ * execution path the native runner must actually serve.
+ */
+export const PROVIDER_CHOICES = ["anthropic", "skip"] as const;
+
+export type ProviderChoice = (typeof PROVIDER_CHOICES)[number];
 
 export interface SelectionInputs {
   apiKey?: string;
   model?: string;
-  baseUrl?: string;
 }
 
 /**
  * Resolve a provider choice (plus optional overrides) to the LLM settings to
- * persist. "skip" yields `undefined`, which clears the section.
+ * persist. "skip" yields `undefined`, which clears the section. An omitted
+ * model is stored as absent — meaning "platform default", resolved from the
+ * model registry at execution time.
  */
 export function buildLlmForChoice(choice: ProviderChoice, inputs: SelectionInputs = {}): LlmSettings | undefined {
   if (choice === "skip") return undefined;
-  return withProviderDefaults({
-    provider: choice,
-    model: inputs.model,
-    api_key: inputs.apiKey,
-    base_url: inputs.baseUrl,
-  });
+  const settings: LlmSettings = { provider: choice };
+  if (inputs.model) settings.model = inputs.model;
+  if (inputs.apiKey) settings.api_key = inputs.apiKey;
+  return settings;
 }
 
 /** Apply a provider choice to a config, returning the updated copy. */
@@ -38,41 +50,24 @@ export function applyChoice(config: Config, choice: ProviderChoice, inputs: Sele
 }
 
 /**
- * Run the interactive provider menu against the current terminal. Returns the
- * updated config, or `null` if the user aborts. For cloud providers, an API key
- * already in the environment is used without prompting (matching the Go wizard).
+ * Run the interactive setup against the current terminal: one Anthropic
+ * API-key prompt. A key already in the environment is used without prompting
+ * (and never persisted — env precedence makes a copy redundant); an empty
+ * entry is an explicit skip.
  */
-export async function runInteractiveWizard(config: Config, env: NodeJS.ProcessEnv = process.env): Promise<Config | null> {
-  process.stderr.write("\nChoose your LLM provider (required for agent execution):\n\n");
-  process.stderr.write("  [1] Anthropic  — Cloud API, best quality (requires API key)\n");
-  process.stderr.write("  [2] OpenAI     — Cloud API (requires API key)\n");
-  process.stderr.write("  [3] Ollama     — Free, local, offline (lower quality output)\n");
-  process.stderr.write("  [4] Skip       — Configure later (agents won't execute)\n\n");
+export async function runInteractiveWizard(config: Config, env: NodeJS.ProcessEnv = process.env): Promise<Config> {
+  process.stderr.write("\nStigmer runs local agents on Anthropic Claude models.\n");
+  process.stderr.write("The model is chosen automatically from the platform model registry.\n\n");
 
-  for (;;) {
-    const choice = (await promptLine("Select [1-4]: ")).trim();
-    switch (choice) {
-      case "1":
-        return applyChoice(config, "anthropic", { apiKey: await resolveCloudKey("anthropic", env) });
-      case "2":
-        return applyChoice(config, "openai", { apiKey: await resolveCloudKey("openai", env) });
-      case "3":
-        return applyChoice(config, "ollama");
-      case "4":
-        return applyChoice(config, "skip");
-      default:
-        process.stderr.write("Invalid choice. Please enter 1, 2, 3, or 4.\n");
-    }
+  if (env.ANTHROPIC_API_KEY) {
+    process.stderr.write("Using ANTHROPIC_API_KEY from environment\n");
+    return applyChoice(config, "anthropic");
   }
-}
 
-async function resolveCloudKey(provider: "anthropic" | "openai", env: NodeJS.ProcessEnv): Promise<string | undefined> {
-  const envVar = provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
-  const existing = env[envVar];
-  if (existing) {
-    process.stderr.write(`Using ${envVar} from environment\n`);
-    return undefined; // env var takes precedence; do not persist a copy
+  const key = (await promptSecret("Enter your Anthropic API key (press Enter to skip)")).trim();
+  if (key === "") {
+    process.stderr.write("Skipped. Agents won't execute until a provider is configured (stigmer setup).\n");
+    return applyChoice(config, "skip");
   }
-  const key = (await promptSecret(`Enter your ${provider === "anthropic" ? "Anthropic" : "OpenAI"} API key`)).trim();
-  return key === "" ? undefined : key;
+  return applyChoice(config, "anthropic", { apiKey: key });
 }

package/src/local/status.test.ts

@@ -55,10 +55,30 @@ describe("buildStatusResult", () => {
     expect(field(result, "Runner", "Status")).toBe("Running ✓ (polling)");
     expect(field(result, "Runner", "Restarts")).toBe("1");
     expect(field(result, "LLM Configuration", "Provider")).toBe("Anthropic (Cloud)");
+    // No model configured: the platform model registry owns the execution
+    // default, and status says so instead of asserting a version.
+    expect(field(result, "LLM Configuration", "Model")).toBe("Auto (platform default)");
     expect(field(result, "LLM Configuration", "API Key")).toBe("Configured ✓");
     expect(field(result, "Web UI", "Temporal")).toBe("http://localhost:8233");
   });
 
+  it("shows an explicit model override verbatim", async () => {
+    writeHealth({ daemon_pid: process.pid, started_at: new Date().toISOString(), components: {} });
+    writeFileSync(configPath(home), "backend:\n  type: local\n  local:\n    llm:\n      provider: anthropic\n      model: claude-x\n      api_key: sk-x\n");
+
+    const result = await buildStatusResult(home, open);
+    expect(field(result, "LLM Configuration", "Model")).toBe("claude-x");
+  });
+
+  it("reports a non-anthropic provider as unknown — local execution is Anthropic-only", async () => {
+    writeHealth({ daemon_pid: process.pid, started_at: new Date().toISOString(), components: {} });
+    writeFileSync(configPath(home), "backend:\n  type: local\n  local:\n    llm:\n      provider: ollama\n");
+
+    const result = await buildStatusResult(home, open);
+    expect(field(result, "LLM Configuration", "Provider")).toBe("Unknown (ollama)");
+    expect(field(result, "LLM Configuration", "Status")).toBe("Agents will not execute");
+  });
+
   it("shows runner as starting before the readiness marker", async () => {
     writeHealth({
       daemon_pid: process.pid,

package/src/local/status.ts

@@ -89,7 +89,7 @@ function addComponentSection(result: CommandResult, name: string, label: string,
 
   let status = `${displayState(state)} ${symbolFor(state)}`;
   // The runner reports observed readiness (it polls its Temporal queue) on top
-  // of mere liveness — the truthful-visibility improvement over the Go CLI.
+  // of mere liveness — a live process that hasn't connected yet is "starting".
   if (name === "runner" && state === "running") {
     status += component.ready === true ? " (polling)" : " (starting)";
   }
@@ -120,21 +120,23 @@ function addLlmSection(result: CommandResult, home: string): void {
     return;
   }
 
-  const model = resolveModel(config);
-  switch (provider) {
-    case "ollama":
-      section.field("Provider", "Local (Ollama)");
-      section.field("Model", model);
-      break;
-    case "anthropic":
-    case "openai":
-      section.field("Provider", provider === "anthropic" ? "Anthropic (Cloud)" : "OpenAI (Cloud)");
-      section.field("Model", model);
-      section.field("API Key", resolveApiKey(config) !== "" ? "Configured ✓" : "Not configured ✗");
-      break;
-    default:
-      section.field("Provider", `Unknown (${provider})`);
+  // Anthropic is the only provider local execution supports. Anything else in
+  // the config (hand-edited, or left over from an older CLI) is reported as
+  // unknown rather than pretended to work.
+  if (provider !== "anthropic") {
+    section.field("Provider", `Unknown (${provider})`);
+    section.field("Status", "Agents will not execute");
+    result.hint("Reconfigure the provider: stigmer setup");
+    return;
   }
+
+  // An unset model is not a gap: the platform model registry picks the
+  // execution default, so the CLI reports that truthfully instead of asserting
+  // a version it does not control.
+  const model = resolveModel(config);
+  section.field("Provider", "Anthropic (Cloud)");
+  section.field("Model", model !== "" ? model : "Auto (platform default)");
+  section.field("API Key", resolveApiKey(config) !== "" ? "Configured ✓" : "Not configured ✗");
 }
 
 function addWebUiSection(result: CommandResult, health: HealthState): void {

package/src/resources/list.ts

@@ -1,13 +1,17 @@
 // `list` dispatch: render a collection of resources for a kind.
 //
 // Most registry kinds are search-indexed and list through the unified
-// SearchService (matching the Go CLI's search-backed list). Organizations,
-// API keys, and agent instances are not search-indexed and use their
-// dedicated find/list RPCs.
+// SearchService. Kinds that are deliberately not search-indexed
+// (organizations, API keys, agent instances, agent channels, channel apps)
+// use their dedicated find/list RPCs with bespoke table shapes.
 
 import { create } from "@bufbuild/protobuf";
+import { AgentChannelSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
+import { ListAgentChannelsRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/io_pb";
 import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
 import { ListAgentInstancesRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/io_pb";
+import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
+import { ListChannelAppsByOrgInputSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/io_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { PageInfoSchema } from "@stigmer/protos/ai/stigmer/commons/rpc/pagination_pb";
 import { ApiKeySchema } from "@stigmer/protos/ai/stigmer/iam/apikey/v1/api_pb";
@@ -18,7 +22,12 @@ import { UsageError } from "../errors/index.js";
 import type { OutputFormat } from "../output/index.js";
 import { bool, type JsonObject, obj, renderCollection, str, type TableShape } from "./render.js";
 
-// Kinds the SearchService indexes; mirrors the Go CLI's search-backed list set.
+// Kinds that list through the SearchService (list mode: empty query, org
+// scope). Must stay in step with the server's SearchableKinds allowlist
+// (backend/services/stigmer-server/pkg/query/search/valueobject/
+// search_criteria.go): a kind present here but absent there silently lists
+// as empty. agent_channel and channel_app are deliberately NOT here — they
+// are not_search_indexed by design and take dedicated-RPC branches below.
 const SEARCH_KINDS = new Set<ApiResourceKind>([
   ApiResourceKind.agent,
   ApiResourceKind.workflow,
@@ -26,6 +35,7 @@ const SEARCH_KINDS = new Set<ApiResourceKind>([
   ApiResourceKind.project,
   ApiResourceKind.skill,
   ApiResourceKind.datastore,
+  ApiResourceKind.environment,
 ]);
 
 export async function listResources(
@@ -49,6 +59,19 @@ export async function listResources(
     );
     return renderCollection(AgentInstanceSchema, result.items, format, INSTANCE_TABLE);
   }
+  if (kind === ApiResourceKind.agent_channel) {
+    const result = await client.agentChannel.list(
+      create(ListAgentChannelsRequestSchema, { org, pageInfo: create(PageInfoSchema, { num: 1, size: limit }) }),
+    );
+    return renderCollection(AgentChannelSchema, result.items, format, AGENT_CHANNEL_TABLE);
+  }
+  if (kind === ApiResourceKind.channel_app) {
+    // listByOrg has no pagination on its contract (the per-org set is small
+    // by design); the limit is applied client-side so --limit stays honest.
+    // `channelapp` (not `channelApp`) is a recorded SDK codegen naming quirk.
+    const result = await client.channelapp.listByOrg(create(ListChannelAppsByOrgInputSchema, { org }));
+    return renderCollection(ChannelAppSchema, result.entries.slice(0, limit), format, CHANNEL_APP_TABLE);
+  }
   if (!SEARCH_KINDS.has(kind)) {
     throw new UsageError("list is not implemented for this resource type");
   }
@@ -83,6 +106,55 @@ const INSTANCE_TABLE: TableShape = {
   },
 };
 
+// A channel serves traffic only when installed AND enabled (the install
+// lifecycle and the owner's serving switch are deliberately distinct), so
+// the table surfaces both signals side by side.
+const AGENT_CHANNEL_TABLE: TableShape = {
+  resourceName: "agent channels",
+  headers: ["ID", "SLUG", "AGENT", "PROVIDER", "STATE", "ENABLED"],
+  row: (json) => {
+    const metadata = obj(json, "metadata");
+    const spec = obj(json, "spec");
+    const agentRef = obj(spec, "agent_ref");
+    return [
+      str(metadata, "id"),
+      str(metadata, "slug"),
+      `${str(agentRef, "org")}/${str(agentRef, "slug")}`,
+      providerOf(spec),
+      // Zero-valued enums are omitted from protojson; a channel is
+      // initialized to pending_install on create, so "-" is the rare
+      // unspecified case, matching the date() empty convention.
+      str(obj(json, "status"), "install_state") || "-",
+      bool(spec, "enabled") ? "true" : "false",
+    ];
+  },
+};
+
+// Secret fields never reach this table: list responses are redacted
+// server-side in both editions (the RedactChannelApp pipeline).
+const CHANNEL_APP_TABLE: TableShape = {
+  resourceName: "channel apps",
+  headers: ["ID", "SLUG", "PROVIDER", "CREATED"],
+  row: (json) => {
+    const metadata = obj(json, "metadata");
+    return [
+      str(metadata, "id"),
+      str(metadata, "slug"),
+      providerOf(obj(json, "spec")),
+      date(str(obj(obj(obj(json, "status"), "audit"), "spec_audit"), "created_at")),
+    ];
+  },
+};
+
+// The provider_config oneof serializes as exactly one provider-named key in
+// protojson (AgentChannelSpec and ChannelAppSpec share the same oneof
+// shape). Extend this list when a new provider arm lands in the protos.
+const PROVIDER_KEYS = ["slack", "whatsapp"] as const;
+
+function providerOf(spec: JsonObject): string {
+  return PROVIDER_KEYS.find((key) => key in spec) ?? "-";
+}
+
 const ORG_TABLE: TableShape = {
   resourceName: "organizations",
   headers: ["NAME", "SLUG", "ID"],