@stigmer/server 3.20.0 → 3.22.0

package/src/authorization/__tests__/skip-lane-inventory.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Pins the coverage inventory's own rule for `is_skip_authorization` lanes
+ * (docs/authorization-coverage.md, "How to read the tables"): a skip lane
+ * reaches no Authorizer in either edition, so what guards it is whatever
+ * its Handler cell names — and a cell that names nothing is a lane open to
+ * every authenticated caller that nobody has said so about. Two things are
+ * held here, so the doc cannot drift from the server it describes:
+ *
+ *   1. The set of skip-annotated methods the open-source server SERVES
+ *      (the empty composition's routes replayed into a recorder, a method
+ *      counted only when its service's implementation map carries it — a
+ *      partially implemented service lists more on its descriptor than it
+ *      serves) equals the set of skip rows in the doc, service by method.
+ *      A new skip lane without a row, or a row for a lane that is no
+ *      longer a skip, fails here.
+ *   2. Every skip row's Handler cell carries one of the three markers the
+ *      doc defines — `guard: <Name>`, `driver: <Seam>`,
+ *      `by design: <reason>` — and every `guard:` names a pipeline step or
+ *      a handler's guard function that exists by that name in `src/`
+ *      outside the tests, so a renamed or removed guard cannot leave the
+ *      doc pointing at nothing.
+ *
+ * The rule lives in the doc; this test only enforces it. The doc is the
+ * one inventory (the package guide mandates updating it with every
+ * annotation change), and a second list here would be the drift this
+ * test exists to prevent.
+ */
+import {
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { getOption } from "@bufbuild/protobuf";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { is_skip_authorization } from "@stigmer/protos/ai/stigmer/commons/rpc/method_options_pb";
+
+import { loadConfig } from "../../boot/config.js";
+import { composeServer } from "../../boot/compose.js";
+import type { ComposedServer } from "../../boot/compose.js";
+import {
+  baseConfig,
+  servedMethods,
+  silentLogger,
+} from "../../extensions/__tests__/composed-support.js";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(HERE, "../../..");
+const COVERAGE_DOC = path.join(PACKAGE_ROOT, "docs/authorization-coverage.md");
+const SRC = path.join(PACKAGE_ROOT, "src");
+
+/** A skip row: `| Service.method | is_skip_authorization | <handler cell> |`. */
+const SKIP_ROW =
+  /^\| ([A-Za-z]+)\.([A-Za-z]+) \| is_skip_authorization \| (.*) \|$/;
+
+const MARKERS = ["guard:", "driver:", "by design:"] as const;
+
+interface SkipRow {
+  readonly method: string;
+  readonly handler: string;
+}
+
+function skipRowsOf(doc: string): SkipRow[] {
+  const rows: SkipRow[] = [];
+  for (const line of doc.split("\n")) {
+    const m = SKIP_ROW.exec(line);
+    if (m !== null) {
+      rows.push({ method: `${m[1]}.${m[2]}`, handler: m[3] ?? "" });
+    }
+  }
+  return rows;
+}
+
+/** Every `guard: <Name>` a handler cell names. */
+function guardsOf(handler: string): string[] {
+  return [...handler.matchAll(/guard: ([A-Za-z]+)/g)].map((m) => m[1] ?? "");
+}
+
+/** Every non-test `.ts` source under `src/`, read once. */
+function sourceText(): string {
+  const parts: string[] = [];
+  const walk = (dir: string): void => {
+    for (const entry of readdirSync(dir)) {
+      const full = path.join(dir, entry);
+      if (statSync(full).isDirectory()) {
+        if (entry !== "__tests__") {
+          walk(full);
+        }
+      } else if (full.endsWith(".ts") && !full.endsWith(".test.ts")) {
+        parts.push(readFileSync(full, "utf8"));
+      }
+    }
+  };
+  walk(SRC);
+  return parts.join("\n");
+}
+
+describe("the skip-lane inventory (docs/authorization-coverage.md) is true to the served server", () => {
+  let dir: string;
+  let server: ComposedServer;
+
+  beforeAll(async () => {
+    dir = mkdtempSync(path.join(tmpdir(), "skip-lane-inventory-test-"));
+    server = await composeServer({
+      config: loadConfig(baseConfig(dir)),
+      logger: silentLogger,
+      portOverride: 0,
+      host: "127.0.0.1",
+    });
+  });
+
+  afterAll(async () => {
+    await server.shutdown();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("the doc's skip rows are exactly the skip-annotated methods the server serves", () => {
+    const served = new Set<string>();
+    for (const method of servedMethods(server.routes)) {
+      if (getOption(method, is_skip_authorization)) {
+        const serviceName = method.parent.typeName.split(".").at(-1) ?? "";
+        served.add(`${serviceName}.${method.name}`);
+      }
+    }
+    const documented = new Set(
+      skipRowsOf(readFileSync(COVERAGE_DOC, "utf8")).map((r) => r.method),
+    );
+    expect([...served].sort()).toEqual([...documented].sort());
+  });
+
+  it("every skip row names its guard, its driver or says the lane is open by design", () => {
+    const bare = skipRowsOf(readFileSync(COVERAGE_DOC, "utf8"))
+      .filter((r) => !MARKERS.some((marker) => r.handler.includes(marker)))
+      .map((r) => r.method);
+    expect(bare).toEqual([]);
+  });
+
+  it("every guard a skip row names is a step or a guard function that exists by that name in src/", () => {
+    const source = sourceText();
+    const dangling: string[] = [];
+    for (const row of skipRowsOf(readFileSync(COVERAGE_DOC, "utf8"))) {
+      for (const guard of guardsOf(row.handler)) {
+        // A step is registered by its quoted name; a guard function by its
+        // declaration.
+        const isStep = source.includes(`"${guard}"`);
+        const isFunction = new RegExp(`function ${guard}\\(`).test(source);
+        if (!isStep && !isFunction) {
+          dangling.push(`${row.method} names guard ${guard}`);
+        }
+      }
+    }
+    expect(dangling).toEqual([]);
+  });
+});

package/src/authorization/__tests__/wire-permissions.test.ts

@@ -117,12 +117,11 @@ describe("every static (kind, permission) the served RPCs ask about is a declare
     expect(undeclared).toEqual([]);
   });
 
-  it("asks about every served kind the model declares except the two no RPC targets statically", () => {
+  it("asks about every served kind the model declares except the one no RPC targets statically", () => {
     // iam_policy's RPCs target the policy's RESOURCE (`resource_kind_path`
-    // or the load-then-authorize `get`); execution_context's RPCs are
-    // `is_skip_authorization` lanes (or unannotated) whose handlers gate on
-    // the runner's execution-scoped token. Every other declared kind is
-    // asked about by at least one static annotation.
+    // or the load-then-authorize `get`). Every other declared kind is asked
+    // about by at least one static annotation — execution_context through
+    // its `get` and `delete`; its runner-token lane stays a skip.
     const asked = new Set(wireQuestions().map((q) => kindEnumName(q.kind)));
     expect([...asked].sort()).toEqual(
       [
@@ -135,6 +134,7 @@ describe("every static (kind, permission) the served RPCs ask about is a declare
         "artifact",
         "channel_app",
         "environment",
+        "execution_context",
         "identity_account",
         "mcp_server",
         "memory",

package/src/authorization/evaluator.ts

@@ -67,8 +67,15 @@ import {
  */
 export const MAX_RESOLUTION_DEPTH = 25;
 
+/**
+ * The faults an evaluation can raise. Two are consumer bugs by the seam
+ * contracts (a kind the model does not declare; the `internal` class
+ * offered to the list scope's restrict verb, which the shared helper
+ * answers before any driver); the rest are the model's own.
+ */
 export type EvaluationFault =
   | "undeclared-target-kind"
+  | "internal-caller-offered"
   | "resolution-depth-exceeded"
   | "resolution-cycle"
   | "unknown-condition";

package/src/authorization/list-read-scope.ts

@@ -38,17 +38,25 @@
  *     lane can show it either.
  *
  * The `internal` class — the server acting as itself over the in-process
- * transport — keeps every offered id and enumerates every id of the kind:
- * the in-process authorization skip (pipeline/interceptors/auth.ts, ruling
- * Q4) applied to a list answer, as the built-in directory applies it to a
- * directory answer. No in-process edge reaches a list lane today; the arm
- * is pinned so a future one meets the same rule every other lane keeps.
+ * transport — is answered by the seam, not here: `restrictListByReadScope`
+ * returns the org-narrowed rows for the class before any driver is asked
+ * (extensions/list-read-scope.ts, the header's contract line), the
+ * Authorize step's trust-domain rule applied to a list answer. So this
+ * driver's `restrictListEntries` REFUSES the class (`internal-caller-offered`):
+ * being offered it means a caller reached the driver around the one
+ * consumption idiom, and evaluating the server as a person would return
+ * a quiet short list — the failure shape stigmer#1207 fixed. The
+ * enumeration verb has no helper in front of it and keeps its own arm:
+ * every id of the kind, as the built-in directory answers the class with
+ * every organization. No in-process edge reaches an enumeration lane
+ * today; the arm is pinned so a future one meets the rule.
  *
  * Faults THROW and are never an empty answer (the seam: an empty set means
  * "authorized to see nothing"; an outage is the pipeline's sanitized
- * INTERNAL). A kind the model does not declare is a consumer bug by the
- * seam's contract and faults through the evaluator, loud; the model
- * declares exactly the open-source tier, so no served lane can reach it.
+ * INTERNAL). A kind the model does not declare, like the internal class
+ * above, is a consumer bug by the seam's contract and faults through the
+ * evaluator, loud; the model declares exactly the open-source tier, so no
+ * served lane can reach it.
  *
  * Logging. One debug line per call — kind, offered, kept, elapsed — what
  * an operator needs to answer "why is Alice's list short" beside the
@@ -188,6 +196,12 @@ export function newBuiltInListReadScope(
       entries: ReadonlyArray<ListEntryMeta>,
     ): Promise<ReadonlySet<string>> {
       requireDeclared(kind);
+      if (caller.callerClass === "internal") {
+        throw new AuthorizationEvaluationError(
+          "internal-caller-offered",
+          `the internal caller class was offered to the list scope for kind '${kindEnumName(kind)}' — the shared helper answers that class before any driver; a list lane reached the driver around it`,
+        );
+      }
       // One candidate per unique id: a lane offers each row once, and a
       // duplicate would only spend a walk to learn the same answer.
       const unique = new Map<string, RowFacts>();
@@ -196,9 +210,6 @@ export function newBuiltInListReadScope(
           unique.set(entry.id, rowFactsOfEntry(kind, entry));
         }
       }
-      if (caller.callerClass === "internal") {
-        return new Set(unique.keys());
-      }
       return visibleAmong(caller, kind, [...unique.values()]);
     },
 

package/src/authorization/model/__tests__/registry.test.ts

@@ -104,6 +104,7 @@ const WIRE_PERMISSIONS_BY_TYPE: Readonly<
     "can_create_environment",
     "can_create_skill",
     "can_create_plugin",
+    "can_create_mcp_server",
     "can_create_idp",
     "can_create_identity_account",
     "can_create_oauth_app",
@@ -111,6 +112,7 @@ const WIRE_PERMISSIONS_BY_TYPE: Readonly<
     "can_create_channel_app",
     "can_create_execution_in",
     "can_create_agent_share",
+    "can_create_agent_instance",
     "can_grant_access",
     "can_view_access",
     "can_view_billing",

package/src/authorization/model/organization.ts

@@ -39,6 +39,7 @@ export const organizationDeclaration = declareKind({
     ["can_create_environment", computed("member")],
     ["can_create_skill", computed("admin")],
     ["can_create_plugin", computed("admin")],
+    ["can_create_mcp_server", computed("admin")],
     ["can_create_idp", computed("admin")],
     ["can_create_identity_account", computed("admin")],
     ["can_create_oauth_app", computed("admin")],
@@ -46,6 +47,7 @@ export const organizationDeclaration = declareKind({
     ["can_create_channel_app", computed("admin")],
     ["can_create_execution_in", union(computed("member"), computed("guest"))],
     ["can_create_agent_share", computed("admin")],
+    ["can_create_agent_instance", computed("member")],
     ["can_grant_access", computed("admin")],
     ["can_view_access", computed("viewer")],
     ["can_view_billing", computed("viewer")],

package/src/boot/compose.ts

@@ -1269,7 +1269,6 @@ export async function composeServer(
       logger,
       authorizer,
       temporalConfig,
-      agentInstanceCreator: () => requireInProcess().agentInstanceCreator,
       gateSteps: extensions.gateSteps,
       sandboxLane,
       authorizationLifecycle,

package/src/boot/inprocess.ts

@@ -60,7 +60,6 @@ import type {
 } from "../domain/agentexecution/create-execution-context-step.js";
 import type { ConnectExecutionContextClient } from "../domain/mcpserver/connect.js";
 import type { ManagedEnvironmentClient } from "../domain/mcpserver/oauth/managed-env.js";
-import type { AgentInstanceCreator } from "../domain/session/steps.js";
 import type { WorkflowInstanceCreator } from "../domain/workflow/steps.js";
 import type { ExecutionWorkflowInstanceCreator } from "../domain/workflowexecution/create-steps.js";
 import type {
@@ -89,7 +88,6 @@ import type { CallOptions } from "@connectrpc/connect";
 /** The narrow in-process surfaces the domains consume (DD-002). */
 export interface InProcessClients {
   readonly agentInstanceApplier: AgentInstanceApplier;
-  readonly agentInstanceCreator: AgentInstanceCreator;
   readonly parentAgentLoader: ParentAgentLoader;
   readonly workflowInstanceCreator: WorkflowInstanceCreator;
   readonly parentWorkflowLoader: ParentWorkflowLoader;
@@ -254,13 +252,6 @@ export function createInProcessClients(
       applyAsCaller: (instance, caller) =>
         agentInstanceCommand.apply(instance, asCaller(caller)),
     },
-    // CREATE (not apply) so a duplicate default-instance slug surfaces
-    // as AlreadyExists instead of silently updating — as the original
-    // caller (ruling R5).
-    agentInstanceCreator: {
-      createAsCaller: (instance, caller) =>
-        agentInstanceCommand.create(instance, asCaller(caller)),
-    },
     parentAgentLoader: {
       get: (agentId) =>
         agentQuery.get(create(AgentIdSchema, { value: agentId })),

package/src/domain/agent/__tests__/agent.test.ts

@@ -6,11 +6,6 @@
  * the router transport, traversing the whole chain).
  *
  * The load-bearing pins:
- *   - default-agent resolution (stigmer/stigmer#356): NotFound copy when
- *     nothing is labeled; FailedPrecondition copy when labeled agents
- *     exist but none is public; incumbent-wins (LOWEST metadata.id) among
- *     public labeled candidates — an older non-public labeled agent never
- *     wins;
  *   - MCP env-merge semantics: agent-declared entries win, among servers
  *     first-encountered wins, only declaration fields are copied;
  *   - enabled-tools validation (#402): byte-pinned INVALID_ARGUMENT copy
@@ -46,10 +41,6 @@ import { composeServer } from "../../../boot/compose.js";
 import type { ComposedServer } from "../../../boot/compose.js";
 import { createLogger } from "../../../boot/logger.js";
 import { ResourceNotFoundError } from "../../../store/interface.js";
-import {
-  DEFAULT_AGENT_LABEL,
-  DEFAULT_AGENT_LABEL_VALUE,
-} from "../defaultagent.js";
 
 const silentLogger = createLogger({
   level: "error",
@@ -197,65 +188,6 @@ async function grpcError(run: () => Promise<unknown>): Promise<ConnectError> {
   }
 }
 
-// The getDefault tests are order-dependent within this describe: the
-// platform default is a GLOBAL singleton, so the empty state must be
-// asserted before any labeled agent exists.
-describe("agent getDefault (platform default resolution, #356)", () => {
-  it("answers NotFound with the configured-hint copy when nothing carries the label", async () => {
-    // org is required for authorization scoping only; resolution is global.
-    const error = await grpcError(() => query.getDefault({ org: ORG }));
-    expect(error.code).toBe(Code.NotFound);
-    expect(error.rawMessage).toBe(
-      "No default agent available. Ensure an agent with label " +
-        "stigmer.ai/default-agent=true and visibility_public exists: " +
-        "no agent labeled stigmer.ai/default-agent=true",
-    );
-  });
-
-  it("answers FailedPrecondition when labeled agents exist but none is public", async () => {
-    await command.create(
-      agentInput({
-        name: "Labeled But Org Visible",
-        labels: { [DEFAULT_AGENT_LABEL]: DEFAULT_AGENT_LABEL_VALUE },
-      }),
-    );
-
-    const error = await grpcError(() => query.getDefault({ org: ORG }));
-    expect(error.code).toBe(Code.FailedPrecondition);
-    expect(error.rawMessage).toBe(
-      "Default agent exists but is not visibility_public: agents labeled " +
-        "stigmer.ai/default-agent=true exist but none is visibility_public",
-    );
-  });
-
-  it("serves the incumbent — the LOWEST metadata.id among PUBLIC labeled candidates", async () => {
-    const first = await command.create(
-      agentInput({
-        name: "Public Default One",
-        visibility: ApiResourceVisibility.visibility_public,
-        labels: { [DEFAULT_AGENT_LABEL]: DEFAULT_AGENT_LABEL_VALUE },
-      }),
-    );
-    const second = await command.create(
-      agentInput({
-        name: "Public Default Two",
-        visibility: ApiResourceVisibility.visibility_public,
-        labels: { [DEFAULT_AGENT_LABEL]: DEFAULT_AGENT_LABEL_VALUE },
-      }),
-    );
-
-    const firstId = first.metadata!.id;
-    const secondId = second.metadata!.id;
-    const incumbentId = firstId < secondId ? firstId : secondId;
-
-    // The older NON-public labeled agent (previous test) has a lower id
-    // than both public candidates; incumbent-wins must skip it.
-    // A DIFFERENT org resolves the same singleton — resolution is global.
-    const resolved = await query.getDefault({ org: "globex" });
-    expect(resolved.metadata?.id).toBe(incumbentId);
-  });
-});
-
 describe("agent MCP env merge (merge_mcp_env_specs)", () => {
   it("merges declarations: agent-declared wins, first-encountered server wins, declaration fields copied", async () => {
     await seedMcpServer({

package/src/domain/agent/controller.ts

@@ -4,8 +4,8 @@
  * default instance through the in-process agentinstance client (the
  * agent↔agentinstance mutual edge, wired as a lazy provider in the
  * composition root — sub-project DD-002); delete cascades ALL instances
- * (oss#611) and same-org shares before the agent row; GetDefault serves
- * the platform default-agent resolution (defaultagent.ts).
+ * (oss#611) and same-org shares before the agent row. There is no default
+ * agent to serve: a session with no agent runs the built-in assistant.
  *
  * Pipeline per RPC mirrors the Go step chains character-for-character.
  * Proven by agent.conformance.test.ts (CONFORMANCE_TARGET=local) and
@@ -20,10 +20,7 @@ import { AgentCommandController } from "@stigmer/protos/ai/stigmer/agentic/agent
 import { AgentQueryController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/query_pb";
 import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
 import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
-import type {
-  AgentId,
-  GetDefaultAgentRequest,
-} from "@stigmer/protos/ai/stigmer/agentic/agent/v1/io_pb";
+import type { AgentId } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/io_pb";
 import type {
   ApiResourceReference,
   UpdateVisibilityInput,
@@ -40,6 +37,10 @@ import type { PipelineStep } from "../../pipeline/pipeline.js";
 import { callerIdentityOf } from "../../pipeline/interceptors/auth.js";
 import { RequestContext } from "../../pipeline/request-context.js";
 import { newAuthorizeStep } from "../../pipeline/steps/authorize.js";
+import {
+  loadedTargetAsMethod,
+  newAuthorizeResolvedTargetStep,
+} from "../../pipeline/steps/authorize-resolved-target.js";
 import { newGuardReservedLabelsStep } from "../../pipeline/steps/guard-reserved-labels.js";
 import {
   newAuthorizeVisibilityTransitionStep,
@@ -98,7 +99,6 @@ import {
   newCascadeDeleteInstancesStep,
   newCascadeDeleteSharesStep,
   newCreateDefaultInstanceStep,
-  newLoadDefaultAgentStep,
   newMergeMcpServerEnvSpecsStep,
   newUpdateAgentStatusWithDefaultInstanceStep,
   newValidateEnabledToolsStep,
@@ -136,7 +136,6 @@ export function registerAgentServices(
   router.service(AgentQueryController, {
     get: (id, ctx) => get(deps, id, ctx),
     getByReference: (ref, ctx) => getByReference(deps, ref, ctx),
-    getDefault: (req, ctx) => getDefault(deps, req, ctx),
   });
 }
 
@@ -532,36 +531,12 @@ async function getByReference(
     )
     .addStep(newValidateProtoStep())
     .addStep(newLoadByReferenceStep(deps.store, AgentSchema))
-    .build()
-    .execute(reqCtx);
-  return reqCtx.get(TARGET_RESOURCE_KEY) as Agent;
-}
-
-/**
- * GetDefault — the platform default agent (label + visibility_public,
- * incumbent-wins). Used by frontends for the session-first UX where users
- * start a conversation without explicitly selecting an agent.
- */
-async function getDefault(
-  deps: AgentControllerDeps,
-  req: GetDefaultAgentRequest,
-  ctx: HandlerContext,
-): Promise<Agent> {
-  const reqCtx = new RequestContext(
-    AgentQueryController.method.getDefault.input,
-    req,
-    callerIdentityOf(ctx),
-    kindOf(ctx),
-  );
-  await newPipeline<typeof AgentQueryController.method.getDefault.input>(
-    "agent-get-default",
-    deps.logger,
-  )
     .addStep(
-      newAuthorizeStep(AgentQueryController.method.getDefault, deps.authorizer),
+      newAuthorizeResolvedTargetStep(
+        deps.authorizer,
+        loadedTargetAsMethod(AgentQueryController.method.get),
+      ),
     )
-    .addStep(newValidateProtoStep())
-    .addStep(newLoadDefaultAgentStep(deps.store, deps.logger))
     .build()
     .execute(reqCtx);
   return reqCtx.get(TARGET_RESOURCE_KEY) as Agent;

package/src/domain/agent/steps.ts

@@ -6,7 +6,7 @@
  * embody agent-specific contracts: the default-instance choreography, the
  * cascade rules, MCP env merging, and enabled-tools validation.
  */
-import { Code, ConnectError } from "@connectrpc/connect";
+import { ConnectError } from "@connectrpc/connect";
 import { create, fromBinary } from "@bufbuild/protobuf";
 import type { DescMessage } from "@bufbuild/protobuf";
 
@@ -43,15 +43,9 @@ import { notifyDefaultInstanceLinked } from "../../pipeline/steps/authorization-
 import type { PipelineStep } from "../../pipeline/pipeline.js";
 import type { RequestContext } from "../../pipeline/request-context.js";
 import { EXISTING_RESOURCE_KEY } from "../../pipeline/steps/load-existing.js";
-import { TARGET_RESOURCE_KEY } from "../../pipeline/steps/load-target.js";
 import { findResourceBySlug } from "../../pipeline/steps/helpers.js";
 import type { Store } from "../../store/interface.js";
 import { buildDefaultInstanceRequest } from "../agentinstance/defaultinstance.js";
-import {
-  DefaultAgentNotConfiguredError,
-  DefaultAgentNotPublicError,
-  findDefaultAgent,
-} from "./defaultagent.js";
 
 /** Context key carrying the applied default instance's id (Go DefaultInstanceIDKey). */
 const DEFAULT_INSTANCE_ID_KEY = "default_instance_id";
@@ -636,56 +630,3 @@ export function newCascadeDeleteSharesStep<Desc extends DescMessage>(
     },
   };
 }
-
-// ---------------------------------------------------------------------------
-// LoadDefaultAgent — get_default.go's step: resolve via defaultagent and
-// map its sentinels to the wire contract. Go builds the wire message with
-// WrapError ("%s: %v"), so the sentinel's text RIDES the message — both
-// strings are cross-edition conformance surface.
-// ---------------------------------------------------------------------------
-
-export function newLoadDefaultAgentStep<Desc extends DescMessage>(
-  store: Store,
-  logger: Logger,
-): PipelineStep<Desc> {
-  return {
-    name: "LoadDefaultAgent",
-    async execute(ctx: RequestContext<Desc>): Promise<void> {
-      logger.info("Resolving platform default agent");
-
-      let agent: Agent;
-      try {
-        agent = await findDefaultAgent(store, logger);
-      } catch (error) {
-        if (error instanceof DefaultAgentNotConfiguredError) {
-          throw new ConnectError(
-            `No default agent available. Ensure an agent with label stigmer.ai/default-agent=true and visibility_public exists: ${error.message}`,
-            Code.NotFound,
-          );
-        }
-        if (error instanceof DefaultAgentNotPublicError) {
-          throw new ConnectError(
-            `Default agent exists but is not visibility_public: ${error.message}`,
-            Code.FailedPrecondition,
-          );
-        }
-        // Store/decode failure — an internal fault, not "no default agent".
-        // InternalError keeps the cause off the wire (stigmer/stigmer#478).
-        logger.error("Failed to resolve platform default agent", {
-          error: error instanceof Error ? error.message : String(error),
-        });
-        throw internalError(
-          error,
-          "failed to resolve the platform default agent",
-        );
-      }
-
-      logger.info("Resolved platform default agent", {
-        agentId: agent.metadata?.id ?? "",
-        agentName: agent.metadata?.name ?? "",
-      });
-
-      ctx.set(TARGET_RESOURCE_KEY, agent);
-    },
-  };
-}

package/src/domain/agentchannel/__tests__/create-authorization.test.ts

@@ -0,0 +1,58 @@
+/**
+ * Pins the create lane's authorization question (steps.ts,
+ * resolveChannelCreateTargets): can_edit on the REFERENCED AGENT with the
+ * Java handler's copy, and nothing on the organization (the same-org
+ * invariant already binds the channel to the agent's); a missing
+ * referenced agent throws.
+ */
+import { describe, expect, it } from "vitest";
+import { create } 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 { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
+import { IamPermission } from "@stigmer/protos/ai/stigmer/iam/v1/enum_pb";
+
+import { testCallerIdentity } from "../../../pipeline/__tests__/support.js";
+import { RequestContext } from "../../../pipeline/request-context.js";
+import {
+  CHANNEL_CREATE_DENIED_MESSAGE,
+  REFERENCED_AGENT_KEY,
+  resolveChannelCreateTargets,
+} from "../steps.js";
+
+const agent = create(AgentSchema, {
+  metadata: { id: "agt_01target", name: "helper", org: "acme" },
+});
+
+function ctxFor(stash = true) {
+  const ctx = new RequestContext(
+    AgentChannelSchema,
+    create(AgentChannelSchema, { metadata: { name: "support", org: "acme" } }),
+    testCallerIdentity(),
+    ApiResourceKind.agent_channel,
+  );
+  if (stash) {
+    ctx.set(REFERENCED_AGENT_KEY, agent);
+  }
+  return ctx;
+}
+
+describe("resolveChannelCreateTargets", () => {
+  it("asks can_edit on the referenced agent and nothing else", () => {
+    expect(resolveChannelCreateTargets(ctxFor())).toEqual([
+      {
+        permission: IamPermission.can_edit,
+        resourceKind: ApiResourceKind.agent,
+        resourceId: "agt_01target",
+        deniedMessage: CHANNEL_CREATE_DENIED_MESSAGE,
+      },
+    ]);
+  });
+
+  it("a missing referenced agent is a broken chain invariant and throws", () => {
+    expect(() => resolveChannelCreateTargets(ctxFor(false))).toThrow(
+      "referenced agent not found in context",
+    );
+  });
+});