@stigmer/cli 3.3.0 → 3.4.1

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/delete.ts

@@ -45,33 +45,60 @@ interface HasMetadata {
   readonly metadata?: { readonly id?: string; readonly name?: string; readonly slug?: string; readonly org?: string };
 }
 
-type DeleteFn = (client: Stigmer, id: string) => Promise<HasMetadata>;
+// `force` is the RPC-level acknowledgment of destructive side effects (e.g. a
+// datastore's held records) — distinct from, but carried by, the CLI's
+// `-f/--force` flag. Kinds whose delete RPC takes a plain typed ID have no
+// force field and simply ignore the argument.
+type DeleteFn = (client: Stigmer, id: string, force: boolean) => Promise<HasMetadata>;
 
 // Kinds the unified delete handles directly, each bound to its SDK delete call.
 // Kinds that carry a Delete verb but no entry here (identity_provider,
-// oauth_app, environment, workflow_instance, session) fall through to a
+// oauth_app, agent_share, workflow_instance, session) fall through to a
 // "not implemented" usage error, matching Go's default branch.
-// McpServer is the outlier whose delete takes a DeleteResourceInput, not an ID.
+// Kinds whose delete takes a DeleteResourceInput (not an ID) thread the force
+// acknowledgment through; today only the datastore server honors it (the
+// non-empty guard), but force is the contract's generic ack carrier.
 const DELETE_HANDLERS: ReadonlyMap<ApiResourceKind, DeleteFn> = new Map<ApiResourceKind, DeleteFn>([
   [ApiResourceKind.agent, (c, id) => c.agent.delete(id)],
   [ApiResourceKind.agent_instance, (c, id) => c.agentInstance.delete(id)],
   [ApiResourceKind.workflow, (c, id) => c.workflow.delete(id)],
-  [ApiResourceKind.mcp_server, (c, id) => c.mcpServer.delete({ resourceId: id })],
+  [ApiResourceKind.mcp_server, (c, id, force) => c.mcpServer.delete({ resourceId: id, force })],
   [ApiResourceKind.project, (c, id) => c.project.delete(id)],
+  [ApiResourceKind.datastore, (c, id, force) => c.datastore.delete({ resourceId: id, force })],
+  [ApiResourceKind.environment, (c, id, force) => c.environment.delete({ resourceId: id, force })],
+  [ApiResourceKind.agent_channel, (c, id) => c.agentChannel.delete(id)],
+  [ApiResourceKind.channel_app, (c, id, force) => c.channelapp.delete({ resourceId: id, force })],
   [ApiResourceKind.skill, (c, id) => c.skill.delete(id)],
   [ApiResourceKind.api_key, (c, id) => c.apiKey.delete(id)],
 ]);
 
+// The deletable-types list for the unknown-type error, derived from the
+// handler map (plus the two special-cased routes) so it can never drift from
+// what the dispatch below actually supports. Deliberately NOT derived from the
+// registry's verb matrix — that declares Delete for kinds this dispatch does
+// not wire, and listing those would over-promise.
+function availableDeleteTypes(): string {
+  const wired = [...DELETE_HANDLERS.keys()]
+    .map((kind) => defaultRegistry().getByKind(kind)?.singular)
+    .filter((singular): singular is string => singular !== undefined);
+  return [...wired, "execution", "organization"].join(", ");
+}
+
 /**
  * Build the delete plan for a `<type> <reference>` pair. Routes the three
  * special cases first, then the registry-driven standard path. Throws on
  * unknown/unsupported types before any network call.
+ *
+ * `force` is the caller's acknowledgment of destructive side effects; it rides
+ * the delete RPC for kinds whose contract carries a force field (see
+ * DELETE_HANDLERS). The command layer maps `-f/--force` onto it.
  */
 export async function planDelete(
   client: Stigmer,
   typeArg: string,
   reference: string,
   org: string,
+  force = false,
 ): Promise<DeletePlan> {
   if (isExecutionAlias(typeArg)) {
     return planExecutionCancel(client, reference);
@@ -79,9 +106,7 @@ export async function planDelete(
 
   const info = defaultRegistry().getByAlias(typeArg);
   if (info === undefined) {
-    throw new UsageError(
-      `unknown resource type: ${typeArg}\n\nAvailable types: agent, agent-instance, workflow, mcpserver, project, skill, execution, organization`,
-    );
+    throw new UsageError(`unknown resource type: ${typeArg}\n\nAvailable types: ${availableDeleteTypes()}`);
   }
 
   if (info.kind === ApiResourceKind.organization) {
@@ -97,7 +122,7 @@ export async function planDelete(
     throw new UsageError(`delete not implemented for ${info.displayName}`);
   }
 
-  return planStandardDelete(client, info, reference, org, deleteFn);
+  return planStandardDelete(client, info, reference, org, deleteFn, force);
 }
 
 async function planStandardDelete(
@@ -106,6 +131,7 @@ async function planStandardDelete(
   reference: string,
   org: string,
   deleteFn: DeleteFn,
+  force: boolean,
 ): Promise<DeletePlan> {
   // Safe by construction: every DELETE_HANDLERS key also has a get binding.
   const getter = getterFor(info.kind);
@@ -122,7 +148,7 @@ async function planStandardDelete(
   return {
     warning: buildDeleteWarning(info, resource),
     confirmPrompt: "Proceed with deletion? [y/N]",
-    perform: async () => buildDeleteSuccess(info, await deleteFn(client, id)),
+    perform: async () => buildDeleteSuccess(info, await deleteFn(client, id, force)),
   };
 }
 
@@ -200,6 +226,19 @@ function buildDeleteWarning(info: TypeInfo, message: HasMetadata): CommandResult
     warning.hint("This will delete the skill and all its versions.");
   }
 
+  if (info.kind === ApiResourceKind.datastore) {
+    // Mirrors the server's non-empty guard (GuardNonEmptyStep): the delete of
+    // a datastore holding records is refused unless force acknowledges it.
+    warning.hint("All records held by this datastore will be destroyed.");
+    warning.hint("A datastore holding records is refused unless --force acknowledges destroying them.");
+  }
+
+  if (info.kind === ApiResourceKind.agent_channel) {
+    // The server's documented distinction: delete is the connection's full
+    // teardown; disabling is the config-preserving pause.
+    warning.hint("Delete is the connection's full teardown; to pause instead, apply with spec.enabled: false.");
+  }
+
   warning.hint("This action cannot be undone.");
   return warning;
 }

package/src/resources/get-bindings.ts

@@ -5,7 +5,11 @@
 
 import type { DescMessage, Message } from "@bufbuild/protobuf";
 import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { AgentChannelSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
 import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
+import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
+import { DatastoreSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
+import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { SkillSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/api_pb";
 import { WorkflowSchema } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
@@ -29,6 +33,10 @@ const GET_BINDINGS: ReadonlyMap<ApiResourceKind, Getter> = new Map([
   [ApiResourceKind.workflow, refGetter(ApiResourceKind.workflow, WorkflowSchema, (c) => c.workflow)],
   [ApiResourceKind.mcp_server, refGetter(ApiResourceKind.mcp_server, McpServerSchema, (c) => c.mcpServer)],
   [ApiResourceKind.project, refGetter(ApiResourceKind.project, ProjectSchema, (c) => c.project)],
+  [ApiResourceKind.datastore, refGetter(ApiResourceKind.datastore, DatastoreSchema, (c) => c.datastore)],
+  [ApiResourceKind.environment, refGetter(ApiResourceKind.environment, EnvironmentSchema, (c) => c.environment)],
+  [ApiResourceKind.agent_channel, refGetter(ApiResourceKind.agent_channel, AgentChannelSchema, (c) => c.agentChannel)],
+  [ApiResourceKind.channel_app, refGetter(ApiResourceKind.channel_app, ChannelAppSchema, (c) => c.channelapp)],
   [ApiResourceKind.skill, refGetter(ApiResourceKind.skill, SkillSchema, (c) => c.skill)],
   [ApiResourceKind.api_key, idOnlyGetter(ApiKeySchema, (c) => c.apiKey, "API keys")],
 ]);

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"],