@stigmer/cli 3.2.3 → 3.4.0

package/src/commands/mcp-server.ts

@@ -35,6 +35,7 @@ Environment variables:
   STIGMER_SERVER_ADDRESS         gRPC address (default: CLI config, else localhost:7234)
   STIGMER_API_KEY                API key (auto-resolved from CLI config for cloud)
   STIGMER_MCP_TRANSPORT          stdio | http | both (default: stdio)
+  STIGMER_MCP_ROSTER             full | records (default: full; records = the five record tools only)
   STIGMER_MCP_HTTP_PORT          HTTP listen port (default: 8080)
   STIGMER_MCP_LOG_FORMAT         text | json (default: text)
   STIGMER_MCP_LOG_LEVEL          debug | info | warn | error (default: info)

package/src/registry/metadata.ts

@@ -35,6 +35,7 @@ export const KIND_META: ReadonlyMap<ApiResourceKind, KindMeta> = new Map([
   [ApiResourceKind.agent_share, { name: "AgentShare", displayName: "Agent Share", idPrefix: "ash" }],
   [ApiResourceKind.agent_channel, { name: "AgentChannel", displayName: "Agent Channel", idPrefix: "ach" }],
   [ApiResourceKind.channel_app, { name: "ChannelApp", displayName: "Channel App", idPrefix: "chapp" }],
+  [ApiResourceKind.datastore, { name: "Datastore", displayName: "Datastore", idPrefix: "dst" }],
   [ApiResourceKind.agent_instance, { name: "AgentInstance", displayName: "Agent Instance", idPrefix: "ain" }],
   [ApiResourceKind.workflow_instance, { name: "WorkflowInstance", displayName: "Workflow Instance", idPrefix: "win" }],
   [ApiResourceKind.session, { name: "Session", displayName: "Session", idPrefix: "ses" }],
@@ -60,6 +61,7 @@ export const CLI_RELEVANT_KINDS: readonly ApiResourceKind[] = [
   ApiResourceKind.agent_share,
   ApiResourceKind.agent_channel,
   ApiResourceKind.channel_app,
+  ApiResourceKind.datastore,
   ApiResourceKind.agent_instance,
   ApiResourceKind.workflow_instance,
   ApiResourceKind.session,

package/src/registry/verb-support.ts

@@ -48,6 +48,10 @@ export const VERB_SUPPORT: ReadonlyMap<ApiResourceKind, ReadonlySet<Verb>> = new
   // Secret fields round-trip as ***REDACTED***; applying a fetched manifest
   // preserves the stored secrets (the OAuthApp marker convention).
   [ApiResourceKind.channel_app, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
+  // Record reads/writes are agent tools and record RPCs, not CLI verbs; the
+  // generic verbs cover the declarative path (apply a manifest, inspect,
+  // tear down — delete is guarded server-side for non-empty datastores).
+  [ApiResourceKind.datastore, new Set<Verb>([Verb.Apply, Verb.Validate, Verb.Get, Verb.List, Verb.Delete])],
   [ApiResourceKind.agent_instance, new Set<Verb>([Verb.Apply, Verb.Get, Verb.List, Verb.Delete])],
   // No list: proto exposes getByWorkflow (requires workflow_id), not a generic list.
   [ApiResourceKind.workflow_instance, new Set<Verb>([Verb.Apply, Verb.Get, Verb.Delete])],

package/src/resources/apply/apply.integration.test.ts

@@ -17,6 +17,8 @@ import { type ConnectRouter, createClient } from "@connectrpc/connect";
 import { connectNodeAdapter } from "@connectrpc/connect-node";
 import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import { AgentCommandController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/command_pb";
+import type { Datastore } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
+import { DatastoreCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/command_pb";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { McpServerCommandController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/command_pb";
 import { createNodeTransport, normalizeEndpoint } from "@stigmer/sdk/node";
@@ -30,10 +32,12 @@ const openSessions = new Set<ServerHttp2Session>();
 
 let appliedAgents: Agent[] = [];
 let appliedMcps: McpServer[] = [];
+let appliedDatastores: Datastore[] = [];
 
 beforeEach(() => {
   appliedAgents = [];
   appliedMcps = [];
+  appliedDatastores = [];
 });
 
 function writeYaml(dir: string, name: string, body: string): string {
@@ -56,6 +60,12 @@ beforeAll(async () => {
         return req;
       },
     });
+    router.service(DatastoreCommandController, {
+      apply: (req) => {
+        appliedDatastores.push(req);
+        return req;
+      },
+    });
   };
 
   backend = createHttp2Server(connectNodeAdapter({ routes }));
@@ -146,6 +156,65 @@ describe("file-mode apply — fidelity (raw controller preserves full proto)", (
   });
 });
 
+const DATASTORE_YAML = [
+  "apiVersion: agentic.stigmer.ai/v1",
+  "kind: Datastore",
+  "metadata:",
+  "  name: clinic-records",
+  "  slug: clinic-records",
+  "spec:",
+  "  timezone: Asia/Kolkata",
+  "  authorization:",
+  "    roles:",
+  "      - name: patient",
+  "    default_role: patient",
+  "  collections:",
+  "    - name: bookings",
+  "      fields:",
+  "        - name: slot_start",
+  "          type: timestamp",
+  "          required: true",
+  "      uniques:",
+  "        - name: one_per_slot",
+  "          fields: [slot_start]",
+  '          message: "that slot is already booked"',
+  "",
+].join("\n");
+
+describe("file-mode apply — datastore", () => {
+  it("applies a Datastore through the raw controller with the spec intact", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "apply-it-"));
+    try {
+      writeYaml(dir, "datastore.yaml", DATASTORE_YAML);
+      const items = resolveApplyItems(dir);
+      expect(items).toHaveLength(1);
+
+      const outcome = await applyItem(controllerFn, items[0], "acme", false);
+      expect(outcome.result.message).toBe("Datastore created successfully");
+
+      expect(appliedDatastores).toHaveLength(1);
+      const spec = appliedDatastores[0].spec;
+      expect(spec?.timezone).toBe("Asia/Kolkata");
+      expect(spec?.authorization?.defaultRole).toBe("patient");
+      expect(spec?.collections[0]?.uniques[0]?.message).toBe("that slot is already booked");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("sorts a Datastore before the Agent that references it", () => {
+    const dir = mkdtempSync(join(tmpdir(), "apply-it-"));
+    try {
+      writeYaml(dir, "agent.yaml", AGENT_WITH_ID);
+      writeYaml(dir, "datastore.yaml", DATASTORE_YAML);
+      const items = resolveApplyItems(dir);
+      expect(items.map((i) => i.handler.displayName)).toEqual(["Datastore", "Agent"]);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("file-mode apply — orchestration", () => {
   it("sorts items into dependency order (mcp_server before agent)", () => {
     const dir = mkdtempSync(join(tmpdir(), "apply-it-"));

package/src/resources/apply/apply.ts

@@ -44,16 +44,19 @@ export interface ApplyOutcome {
 const APPLY_ORDER: ReadonlyMap<ApiResourceKind, number> = new Map([
   [ApiResourceKind.organization, 0],
   [ApiResourceKind.mcp_server, 1],
-  [ApiResourceKind.agent, 2],
-  [ApiResourceKind.workflow, 3],
-  [ApiResourceKind.environment, 4],
-  [ApiResourceKind.identity_provider, 5],
-  [ApiResourceKind.oauth_app, 6],
-  [ApiResourceKind.agent_instance, 7],
-  [ApiResourceKind.workflow_instance, 8],
-  [ApiResourceKind.session, 9],
-  // After agent (2) and environment (4): a share references both.
-  [ApiResourceKind.agent_share, 10],
+  // Before agent: an Agent references a Datastore via datastore_usages
+  // (the McpServer-before-Agent pattern; mirrors the SDK manifest registry).
+  [ApiResourceKind.datastore, 2],
+  [ApiResourceKind.agent, 3],
+  [ApiResourceKind.workflow, 4],
+  [ApiResourceKind.environment, 5],
+  [ApiResourceKind.identity_provider, 6],
+  [ApiResourceKind.oauth_app, 7],
+  [ApiResourceKind.agent_instance, 8],
+  [ApiResourceKind.workflow_instance, 9],
+  [ApiResourceKind.session, 10],
+  // After agent and environment: a share references both.
+  [ApiResourceKind.agent_share, 11],
 ]);
 
 /** Expand a path into ordered, kind-resolved apply items (strict YAML parse). */

package/src/resources/apply/handlers.ts

@@ -23,6 +23,8 @@ import { type AgentInstance, AgentInstanceSchema } from "@stigmer/protos/ai/stig
 import { AgentInstanceCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/command_pb";
 import { type AgentShare, AgentShareSchema } from "@stigmer/protos/ai/stigmer/agentic/agentshare/v1/api_pb";
 import { AgentShareCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentshare/v1/command_pb";
+import { type Datastore, DatastoreSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
+import { DatastoreCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/command_pb";
 import { type Environment, EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
 import { EnvironmentCommandController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/command_pb";
 import { type McpServer, McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
@@ -74,6 +76,15 @@ export const APPLY_HANDLERS: ReadonlyMap<ApiResourceKind, ApplyHandler> = new Ma
       apply: (c, m) => c(McpServerCommandController).apply(m as McpServer),
     },
   ],
+  [
+    ApiResourceKind.datastore,
+    {
+      kind: ApiResourceKind.datastore,
+      displayName: "Datastore",
+      schema: DatastoreSchema,
+      apply: (c, m) => c(DatastoreCommandController).apply(m as Datastore),
+    },
+  ],
   [
     ApiResourceKind.agent,
     {

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

@@ -25,6 +25,7 @@ const SEARCH_KINDS = new Set<ApiResourceKind>([
   ApiResourceKind.mcp_server,
   ApiResourceKind.project,
   ApiResourceKind.skill,
+  ApiResourceKind.datastore,
 ]);
 
 export async function listResources(

package/src/resources/mutate-verbs.integration.test.ts

@@ -16,9 +16,21 @@ import { AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentex
 import { AgentExecutionCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/command_pb";
 import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { AgentExecutionQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/query_pb";
+import { AgentChannelSchema } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/api_pb";
+import { AgentChannelCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/command_pb";
+import { AgentChannelQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentchannel/v1/query_pb";
 import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/api_pb";
 import { AgentInstanceCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/command_pb";
 import { AgentInstanceQueryController } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/query_pb";
+import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/api_pb";
+import { ChannelAppCommandController } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/command_pb";
+import { ChannelAppQueryController } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/query_pb";
+import { DatastoreSchema } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/api_pb";
+import { DatastoreCommandController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/command_pb";
+import { DatastoreQueryController } from "@stigmer/protos/ai/stigmer/agentic/datastore/v1/query_pb";
+import { EnvironmentSchema } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/api_pb";
+import { EnvironmentCommandController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/command_pb";
+import { EnvironmentQueryController } from "@stigmer/protos/ai/stigmer/agentic/environment/v1/query_pb";
 import { McpServerSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
 import { McpServerCommandController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/command_pb";
 import { McpServerQueryController } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/query_pb";
@@ -51,6 +63,28 @@ const knownWorkflow = create(WorkflowSchema, {
   metadata: { name: "Deploy", slug: "deploy", org: "acme", id: "wfl_1" },
 });
 
+// The mock treats this datastore as NON-EMPTY: delete refuses without the
+// force acknowledgment, mirroring the server's GuardNonEmptyStep contract.
+const knownDatastore = create(DatastoreSchema, {
+  metadata: { name: "clinic-records", slug: "clinic-records", org: "acme", id: "dst_1" },
+});
+
+// Byte-shaped like the Go server's GuardNonEmptyStep refusal (delete_guards.go).
+const nonEmptyGuardMessage =
+  'datastore "clinic-records" holds 12 records across 3 collections; deleting destroys them — pass force to acknowledge';
+
+const knownEnvironment = create(EnvironmentSchema, {
+  metadata: { name: "clinic-patient-db", slug: "clinic-patient-db", org: "acme", id: "env_1" },
+});
+
+const knownChannel = create(AgentChannelSchema, {
+  metadata: { name: "clinic-patient-whatsapp", slug: "clinic-patient-whatsapp", org: "acme", id: "ach_1" },
+});
+
+const knownChannelApp = create(ChannelAppSchema, {
+  metadata: { name: "clinic-meta-app", slug: "clinic-meta-app", org: "acme", id: "chapp_1" },
+});
+
 // Pending execution (cancellable) vs. an already-terminal one.
 const pendingExecution = create(AgentExecutionSchema, {
   metadata: { id: "aex_run" },
@@ -72,10 +106,20 @@ const openSessions = new Set<ServerHttp2Session>();
 // Spies for the command-side calls, reset per test.
 let cancelCalls: string[] = [];
 let tagCalls: { workflowId: string; versionHash: string; tag: string }[] = [];
+// Force-carrying deletes record what actually rode the RPC.
+let datastoreDeletes: { resourceId: string; force: boolean }[] = [];
+let environmentDeletes: { resourceId: string; force: boolean }[] = [];
+let channelAppDeletes: { resourceId: string; force: boolean }[] = [];
+// agent_channel's delete is a typed ID — no force field exists on the wire.
+let channelDeleteIds: string[] = [];
 
 beforeEach(() => {
   cancelCalls = [];
   tagCalls = [];
+  datastoreDeletes = [];
+  environmentDeletes = [];
+  channelAppDeletes = [];
+  channelDeleteIds = [];
 });
 
 beforeAll(async () => {
@@ -118,6 +162,60 @@ beforeAll(async () => {
       },
     });
 
+    router.service(DatastoreQueryController, {
+      getByReference: (req) => {
+        if (req.slug !== "clinic-records") throw new ConnectError("datastore not found", Code.NotFound);
+        return knownDatastore;
+      },
+    });
+    router.service(DatastoreCommandController, {
+      delete: (req) => {
+        datastoreDeletes.push({ resourceId: req.resourceId, force: req.force });
+        // Mirrors GuardNonEmptyStep: a non-empty datastore refuses without force.
+        if (!req.force) throw new ConnectError(nonEmptyGuardMessage, Code.FailedPrecondition);
+        return knownDatastore;
+      },
+    });
+
+    router.service(EnvironmentQueryController, {
+      getByReference: (req) => {
+        if (req.slug !== "clinic-patient-db") throw new ConnectError("environment not found", Code.NotFound);
+        return knownEnvironment;
+      },
+    });
+    router.service(EnvironmentCommandController, {
+      delete: (req) => {
+        environmentDeletes.push({ resourceId: req.resourceId, force: req.force });
+        return knownEnvironment;
+      },
+    });
+
+    router.service(AgentChannelQueryController, {
+      getByReference: (req) => {
+        if (req.slug !== "clinic-patient-whatsapp") throw new ConnectError("agent channel not found", Code.NotFound);
+        return knownChannel;
+      },
+    });
+    router.service(AgentChannelCommandController, {
+      delete: (req) => {
+        channelDeleteIds.push(req.value);
+        return knownChannel;
+      },
+    });
+
+    router.service(ChannelAppQueryController, {
+      getByReference: (req) => {
+        if (req.slug !== "clinic-meta-app") throw new ConnectError("channel app not found", Code.NotFound);
+        return knownChannelApp;
+      },
+    });
+    router.service(ChannelAppCommandController, {
+      delete: (req) => {
+        channelAppDeletes.push({ resourceId: req.resourceId, force: req.force });
+        return knownChannelApp;
+      },
+    });
+
     router.service(WorkflowQueryController, {
       getByReference: (req) => {
         if (req.slug !== "deploy") throw new ConnectError("workflow not found", Code.NotFound);
@@ -208,9 +306,17 @@ describe("delete (standard kinds)", () => {
     expect(classify(err)?.exitCode).toBe(ExitCode.NotFound);
   });
 
-  it("rejects an unknown type with a usage error", async () => {
+  it("rejects an unknown type and lists exactly the wired types", async () => {
     const err = await planDelete(client, "bogus", "x", "acme").catch((e) => e);
     expect(classify(err)?.exitCode).toBe(ExitCode.Usage);
+    // The list is derived from DELETE_HANDLERS (+ the two special cases), so
+    // it must name the wired kinds and never the declared-but-unwired ones.
+    const message = String(err.message);
+    for (const wired of ["datastore", "environment", "agentchannel", "channelapp", "execution", "organization"]) {
+      expect(message).toContain(wired);
+    }
+    expect(message).not.toContain("session");
+    expect(message).not.toContain("oauthapp");
   });
 
   it("rejects a kind that has no delete handler with a usage error", async () => {
@@ -219,6 +325,77 @@ describe("delete (standard kinds)", () => {
   });
 });
 
+describe("delete (force acknowledgment)", () => {
+  it("threads --force to the datastore delete RPC as the destroy-records ack", async () => {
+    const plan = await planDelete(client, "datastore", "clinic-records", "acme", true);
+    const result = await plan.perform();
+
+    expect(result.status).toBe("success");
+    expect(result.message).toBe("Datastore deleted successfully");
+    expect(datastoreDeletes).toEqual([{ resourceId: "dst_1", force: true }]);
+  });
+
+  it("surfaces the non-empty guard refusal verbatim when force is absent", async () => {
+    const plan = await planDelete(client, "datastore", "clinic-records", "acme");
+    const err = await plan.perform().catch((e) => e);
+
+    // A confirmed-but-unforced delete must NOT bypass the server guard: the
+    // RPC carries force=false and the refusal reaches the user verbatim.
+    expect(datastoreDeletes).toEqual([{ resourceId: "dst_1", force: false }]);
+    const classified = classify(err);
+    expect(classified?.exitCode).toBe(ExitCode.Usage);
+    expect(classified?.message).toBe(`Precondition failed: ${nonEmptyGuardMessage}`);
+  });
+
+  it("warns up front that datastore records are destroyed and force-guarded", async () => {
+    const plan = await planDelete(client, "datastore", "clinic-records", "acme");
+    expect(plan.warning.hints).toContain("All records held by this datastore will be destroyed.");
+    expect(plan.warning.hints).toContain(
+      "A datastore holding records is refused unless --force acknowledges destroying them.",
+    );
+  });
+});
+
+describe("delete (cutover kinds: environment, agent channel, channel app)", () => {
+  it("deletes an environment via the DeleteResourceInput shape", async () => {
+    const plan = await planDelete(client, "environment", "clinic-patient-db", "acme");
+    const result = await plan.perform();
+
+    expect(result.status).toBe("success");
+    expect(result.message).toBe("Environment deleted successfully");
+    expect(environmentDeletes).toEqual([{ resourceId: "env_1", force: false }]);
+  });
+
+  it("threads --force through the environment delete (generic ack carrier)", async () => {
+    const plan = await planDelete(client, "environment", "clinic-patient-db", "acme", true);
+    await plan.perform();
+    expect(environmentDeletes).toEqual([{ resourceId: "env_1", force: true }]);
+  });
+
+  it("deletes an agent channel via its typed-ID contract, ignoring force gracefully", async () => {
+    const plan = await planDelete(client, "agent-channel", "clinic-patient-whatsapp", "acme", true);
+
+    // The teardown-vs-pause distinction rides the warning (server doc contract).
+    expect(plan.warning.hints).toContain(
+      "Delete is the connection's full teardown; to pause instead, apply with spec.enabled: false.",
+    );
+
+    const result = await plan.perform();
+    expect(result.status).toBe("success");
+    expect(result.message).toBe("Agent Channel deleted successfully");
+    expect(channelDeleteIds).toEqual(["ach_1"]);
+  });
+
+  it("deletes a channel app via the DeleteResourceInput shape", async () => {
+    const plan = await planDelete(client, "channel-app", "clinic-meta-app", "acme");
+    const result = await plan.perform();
+
+    expect(result.status).toBe("success");
+    expect(result.message).toBe("Channel App deleted successfully");
+    expect(channelAppDeletes).toEqual([{ resourceId: "chapp_1", force: false }]);
+  });
+});
+
 describe("delete execution (cancel special case)", () => {
   it("cancels a non-terminal execution", async () => {
     const plan = await planDelete(client, "execution", "aex_run", "");