@stigmer/server 3.20.0 → 3.22.0

package/src/domain/agentexecution/create-steps.ts

@@ -3,6 +3,13 @@
  * compose_declared_preferences_step.go, and
  * compose_recalled_memories_step.go. The chain itself is assembled in
  * controller.ts, mirroring Go buildCreatePipeline order exactly.
+ *
+ * An execution names its target one of three ways (session_id, agent_id,
+ * session_spec.agent_instance_id) or not at all: the all-empty shape is the
+ * built-in assistant (agentexecution/v1/spec.proto), for which
+ * CreateSessionIfNeeded creates a session with no agent and the runner
+ * resolves an agent-less blueprint. Nothing here resolves a stored default
+ * agent into that shape.
  */
 import { create, fromBinary } from "@bufbuild/protobuf";
 
@@ -44,15 +51,10 @@ import {
   notFoundError,
   rethrownStatusError,
 } from "../../pipeline/errors.js";
-import { ConnectError, Code } from "@connectrpc/connect";
+import { ConnectError } from "@connectrpc/connect";
 import type { PipelineStep } from "../../pipeline/pipeline.js";
 import { ResourceNotFoundError } from "../../store/interface.js";
 import type { Store } from "../../store/interface.js";
-import {
-  DefaultAgentNotConfiguredError,
-  DefaultAgentNotPublicError,
-  findDefaultAgent,
-} from "../agent/defaultagent.js";
 import { buildDefaultInstanceRequest } from "../agentinstance/defaultinstance.js";
 
 import type { AgentExecutionStatusObserver } from "../../extensions/status-hooks.js";
@@ -94,120 +96,6 @@ export interface SessionCreator {
 }
 export type SessionCreatorProvider = () => SessionCreator;
 
-// ---------------------------------------------------------------------------
-// ResolveDefaultAgent — create.go resolveDefaultAgentStep.
-// ---------------------------------------------------------------------------
-
-/**
- * Resolves the platform's public default agent when neither session_id
- * nor agent_id (nor a session_spec instance) is provided — the
- * session-first UX, a VALID request shape, not an input error. Resolution
- * (candidate set, visibility preference, deterministic incumbent-wins
- * tie-break) is owned by the defaultagent module, shared with the
- * Agent.GetDefault RPC and session create.
- */
-export function newResolveDefaultAgentStep(
-  store: Store,
-  logger: Logger,
-): PipelineStep<CreateDesc> {
-  return {
-    name: "ResolveDefaultAgent",
-    async execute(ctx) {
-      const spec = ctx.input.spec;
-      if (
-        (spec?.sessionId ?? "") !== "" ||
-        (spec?.agentId ?? "") !== "" ||
-        (spec?.sessionSpec?.agentInstanceId ?? "") !== ""
-      ) {
-        return;
-      }
-
-      logger.info(
-        "Neither session_id nor agent_id provided, resolving platform default agent",
-      );
-
-      let defaultAgent: Agent;
-      try {
-        defaultAgent = await findDefaultAgent(store, logger);
-      } catch (error) {
-        if (error instanceof DefaultAgentNotConfiguredError) {
-          // Caller-actionable message: the create caller can fix this by
-          // supplying a reference — deliberately different from the
-          // Agent.GetDefault RPC's message, whose caller cannot.
-          throw new ConnectError(
-            "No default agent is configured on this platform. Provide session_id or agent_id explicitly, or seed an agent labeled stigmer.ai/default-agent=true with visibility_public",
-            Code.NotFound,
-          );
-        }
-        if (error instanceof DefaultAgentNotPublicError) {
-          throw failedPreconditionError(
-            "Default agent exists but is not visibility_public",
-          );
-        }
-        // Store/decode failure — an internal fault, not "no default
-        // agent". The sanitized wire copy keeps the cause off the wire
-        // (stigmer/stigmer#478).
-        throw internalError(
-          error,
-          "failed to resolve the platform default agent",
-        );
-      }
-
-      const resolvedId = defaultAgent.metadata?.id ?? "";
-      logger.info("Resolved platform default agent", {
-        agentId: resolvedId,
-        agentName: defaultAgent.metadata?.name ?? "",
-      });
-
-      // Set agent_id on newState (not input): later steps and Persist
-      // operate on newState.
-      const newState = ctx.newState;
-      const newSpec = (newState.spec ??= create(AgentExecutionSpecSchema));
-      newSpec.agentId = resolvedId;
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// EnsureSessionOrAgentResolved — the invariant guard.
-// ---------------------------------------------------------------------------
-
-/**
- * Asserts the post-condition that a session, agent, or
- * embedded-session-spec instance reference has been resolved. An
- * invariant guard, NOT input validation: ResolveDefaultAgent runs first
- * and guarantees one of the three or an error, so reaching this step with
- * none set is a server-side programming error — hence Internal, not
- * InvalidArgument. Deliberately diverges from WorkflowExecution's
- * validateWorkflowOrInstanceStep (InvalidArgument), whose check is
- * genuinely reachable (issue #196) — do not "harmonize" the two.
- */
-export function newEnsureSessionOrAgentResolvedStep(
-  logger: Logger,
-): PipelineStep<CreateDesc> {
-  return {
-    name: "EnsureSessionOrAgentResolved",
-    execute(ctx) {
-      const spec = ctx.newState.spec;
-      const hasSessionId = (spec?.sessionId ?? "") !== "";
-      const hasAgentId = (spec?.agentId ?? "") !== "";
-      const hasSpecInstanceId =
-        (spec?.sessionSpec?.agentInstanceId ?? "") !== "";
-      if (!hasSessionId && !hasAgentId && !hasSpecInstanceId) {
-        logger.error(
-          "Invariant violated: no session, agent, or session_spec instance reference resolved after ResolveDefaultAgent",
-        );
-        throw internalError(
-          new Error(
-            "neither session_id, agent_id, nor session_spec.agent_instance_id set after ResolveDefaultAgent",
-          ),
-          "execution target not resolved",
-        );
-      }
-    },
-  };
-}
-
 // ---------------------------------------------------------------------------
 // EnsureEngineAvailable lives in engine.ts (Phase 1); re-exported by the
 // controller for chain assembly.
@@ -233,11 +121,13 @@ export type ExecutionAgentInstanceCreatorProvider =
 
 /**
  * Ensures the referenced agent has a default instance: skips when a
- * session or explicit session_spec instance names the target; loads the
- * agent via the in-process client, creates the default instance when the
- * status lacks one, saves the agent status DIRECTLY to the store
- * (matching Go/Java: repo save, not the Update pipeline), and stores the
- * instance id in the context for the next step.
+ * session or explicit session_spec instance names the target, and when no
+ * agent is named at all (the built-in assistant: there is no agent whose
+ * instance could be created); otherwise loads the agent via the in-process
+ * client, creates the default instance when the status lacks one, saves
+ * the agent status DIRECTLY to the store (matching Go/Java: repo save, not
+ * the Update pipeline), and stores the instance id in the context for the
+ * next step.
  */
 export function newCreateDefaultInstanceIfNeededStep(deps: {
   store: Store;
@@ -261,8 +151,7 @@ export function newCreateDefaultInstanceIfNeededStep(deps: {
         return;
       }
       // An explicit session_spec instance fully specifies the target — no
-      // agent load or default-instance creation needed (a default-agent
-      // lookup would stamp misleading metadata).
+      // agent load or default-instance creation needed.
       const specInstanceId = execution.spec?.sessionSpec?.agentInstanceId ?? "";
       if (specInstanceId !== "") {
         deps.logger.debug(
@@ -271,6 +160,14 @@ export function newCreateDefaultInstanceIfNeededStep(deps: {
         );
         return;
       }
+      // No agent named: the built-in assistant runs in a session with no
+      // instance, so there is nothing to load or create here.
+      if (agentId === "") {
+        deps.logger.debug(
+          "No agent named, the built-in assistant runs; skipping default instance check",
+        );
+        return;
+      }
 
       // 1. Load agent via in-process gRPC (single source of truth). Go
       // returns the client error AS-IS here (create.go: "already a gRPC
@@ -385,7 +282,9 @@ export function newCreateDefaultInstanceIfNeededStep(deps: {
  * bootstrap, stigmer/stigmer#249) is CLONED and forwarded so the session
  * carries workspace_entries, harness, execution_target, MCP servers, and
  * skills from a single create call; defaults fill in the instance (when
- * the spec names none) and the subject sentinel (when empty).
+ * the spec names none and an agent's default instance was resolved; an
+ * empty id here and there is the built-in assistant) and the subject
+ * sentinel (when empty).
  */
 export function buildAutoCreateSessionSpec(
   callerSpec: SessionSpec | undefined,
@@ -407,11 +306,12 @@ export function buildAutoCreateSessionSpec(
 /**
  * Auto-creates the session when session_id is absent: forwards the
  * caller's session_spec, fills the instance from the previous step's
- * context key when needed, owns the session under the CALLER's org (never
- * the agent's — cross-org public agents stay usable), updates the
- * execution with the created id, and CLEARS session_spec (the Session
- * resource is the single source of truth; the persisted execution never
- * carries a second copy that could drift).
+ * context key when an agent was named, leaves it empty for the built-in
+ * assistant, owns the session under the CALLER's org (never the agent's —
+ * cross-org agents stay usable), updates the execution with the created
+ * id, and CLEARS session_spec (the Session resource is the single source
+ * of truth; the persisted execution never carries a second copy that
+ * could drift).
  */
 export function newCreateSessionIfNeededStep(deps: {
   logger: Logger;
@@ -440,12 +340,12 @@ export function newCreateSessionIfNeededStep(deps: {
         hasSessionSpec: callerSpec !== undefined,
       });
 
-      // 1. Resolve the instance when the caller's spec does not name one.
-      // The previous step resolved it and only skips when the spec
-      // carries an explicit instance, so the key is present exactly when
-      // needed.
+      // 1. Resolve the instance when the caller's spec does not name one
+      // and an agent was named: the previous step put the agent's default
+      // instance under the context key exactly then. With no agent the
+      // session is created with no instance — the built-in assistant.
       let defaultInstanceId = "";
-      if ((callerSpec?.agentInstanceId ?? "") === "") {
+      if ((callerSpec?.agentInstanceId ?? "") === "" && agentId !== "") {
         const resolved = ctx.get(DEFAULT_INSTANCE_ID_KEY);
         if (typeof resolved !== "string" || resolved === "") {
           deps.logger.error("DEFAULT_INSTANCE_ID not found in context", {

package/src/domain/agentexecution/run-target.ts

@@ -16,9 +16,13 @@
  *      questions have one answer; asking the blueprint's is what lets the
  *      gate precede the side effect).
  *
- * None of the three set is EnsureSessionOrAgentResolved's invariant arm
- * (ResolveDefaultAgent guarantees one), never a check. Pure over the record
- * being built, where ResolveDefaultAgent writes the resolved agent_id.
+ * None of the three set is the built-in assistant
+ * (agentexecution/v1/spec.proto): a new conversation with no agent, for
+ * which there is no blueprint to spend and so no target to check. The
+ * Authorize step ahead of the gate admitted it with the organization's
+ * can_create_execution_in; CreateSessionIfNeeded then creates the session
+ * with no instance, and every later turn arrives in shape 1. Pure over the
+ * record being built.
  */
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 

package/src/domain/agentinstance/__tests__/create-authorization.composed.test.ts

@@ -0,0 +1,243 @@
+/**
+ * Pins the instance create lane's authorization at the wire, on a real boot
+ * under the require-authentication posture with no unit Authorizer (the
+ * self-host's shape, the built-in Authorizer composed):
+ *
+ *   - a member creates a personal instance of an org-visible agent in their
+ *     organization (can_create_agent_instance is member-level; the parent's
+ *     can_create_instance is its viewer set);
+ *   - a member is refused an instance of a PRIVATE agent with the parent's
+ *     copy — the organization's bar passed, the agent's did not;
+ *   - an outsider naming an organization they hold no row in is refused
+ *     with the organization's copy, before anything about the agent;
+ *   - a member's wire request carrying the reserved default-instance label
+ *     is refused: the label buys nothing from the wire (the reserved-label
+ *     guard refuses it after the caller passes the personal bar);
+ *   - the SAME labelled request the server composes in-process for the
+ *     member (the default-instance self-heal's exact shape: the in-process
+ *     transport, the propagated caller, the parent's organization) is
+ *     admitted with no caller check and attributed to the member — the
+ *     arm that keeps every lane whose run was already admitted (a guest, a
+ *     channel turn, a schedule fire) working when the agent has no default
+ *     instance yet.
+ *
+ * Every negative arm sits beside a positive one so the file cannot pass
+ * vacuously. The resolver's own table is create-authorization.test.ts.
+ */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { Code, ConnectError, createClient } from "@connectrpc/connect";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { AgentCommandController } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/command_pb";
+import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { AgentInstanceCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/v1/command_pb";
+import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
+import { IdentityAccountCommandController } from "@stigmer/protos/ai/stigmer/iam/identityaccount/v1/command_pb";
+import { OrganizationCommandController } from "@stigmer/protos/ai/stigmer/tenancy/organization/v1/command_pb";
+
+import { loadConfig } from "../../../boot/config.js";
+import { composeServer } from "../../../boot/compose.js";
+import type { ComposedServer } from "../../../boot/compose.js";
+import type { ServerExtension } from "../../../extensions/registry.js";
+import {
+  baseConfig,
+  fakeJwt,
+  fakeVerifier,
+  silentLogger,
+  transportFor,
+} from "../../../extensions/__tests__/composed-support.js";
+import {
+  DEFAULT_INSTANCE_LABEL,
+  RESERVED_LABEL_TRUE,
+} from "../../../pipeline/apiresource-labels.js";
+import {
+  IN_PROCESS_CALLER_HEADER,
+  encodeInProcessCaller,
+} from "../../../pipeline/interceptors/auth.js";
+import { buildDefaultInstanceRequest } from "../defaultinstance.js";
+import {
+  INSTANCE_ORGANIZATION_DENIED_MESSAGE,
+  INSTANCE_PARENT_DENIED_MESSAGE,
+} from "../steps.js";
+
+const FOUNDER = "fake|founder";
+const MEMBER = "fake|member";
+const STRANGER = "fake|stranger";
+const ORG = "instance-authz-org";
+
+function organizationInput(slug: string) {
+  return {
+    apiVersion: "tenancy.stigmer.ai/v1",
+    kind: "Organization",
+    metadata: { name: slug, slug, org: "" },
+    spec: { description: slug },
+  };
+}
+
+function agentInput(name: string, visibility: ApiResourceVisibility) {
+  return {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "Agent",
+    metadata: { name, org: ORG, visibility },
+    spec: { instructions: "a conformant instruction body" },
+  };
+}
+
+function instanceInput(
+  name: string,
+  agentId: string,
+  org: string = ORG,
+  labels: Record<string, string> = {},
+) {
+  return {
+    apiVersion: "agentic.stigmer.ai/v1",
+    kind: "AgentInstance",
+    metadata: { name, org, labels },
+    spec: { agentId, description: name },
+  };
+}
+
+async function failureOf(promise: Promise<unknown>): Promise<ConnectError> {
+  try {
+    await promise;
+  } catch (error) {
+    return ConnectError.from(error);
+  }
+  throw new Error("expected the call to fail");
+}
+
+describe("agent instance create under the built-in authorizer", () => {
+  let dir: string;
+  let server: ComposedServer;
+  let port: number;
+  let orgAgent: Agent;
+  let privateAgent: Agent;
+
+  const asFounder = () =>
+    transportFor(port, fakeJwt(FOUNDER, "founder@example.com"));
+  const asMember = () =>
+    transportFor(port, fakeJwt(MEMBER, "member@example.com"));
+  const asStranger = () =>
+    transportFor(port, fakeJwt(STRANGER, "stranger@example.com"));
+
+  beforeAll(async () => {
+    dir = mkdtempSync(path.join(tmpdir(), "instance-create-authz-"));
+    const unit: ServerExtension = {
+      name: "fake-oidc-only",
+      requireAuthentication: true,
+      identityVerifiers: [fakeVerifier],
+    };
+    server = await composeServer({
+      config: loadConfig(baseConfig(dir)),
+      logger: silentLogger,
+      extensions: [unit],
+      portOverride: 0,
+      host: "127.0.0.1",
+    });
+    port = await server.start();
+
+    // The membership rules of a self-host: a person who provisions while
+    // the organization exists joins it as a member; a person provisioned
+    // BEFORE it was founded holds no row on it. So the stranger provisions
+    // first, the founder founds, and the member provisions after.
+    await createClient(
+      IdentityAccountCommandController,
+      asFounder(),
+    ).provisionMyAccount({});
+    await createClient(
+      IdentityAccountCommandController,
+      asStranger(),
+    ).provisionMyAccount({});
+    await createClient(OrganizationCommandController, asFounder()).create(
+      organizationInput(ORG),
+    );
+    await createClient(
+      IdentityAccountCommandController,
+      asMember(),
+    ).provisionMyAccount({});
+
+    const founderAgents = createClient(AgentCommandController, asFounder());
+    orgAgent = await founderAgents.create(
+      agentInput("Org Agent", ApiResourceVisibility.visibility_org),
+    );
+    privateAgent = await founderAgents.create(
+      agentInput("Private Agent", ApiResourceVisibility.visibility_private),
+    );
+  });
+
+  afterAll(async () => {
+    await server.shutdown();
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("a member creates a personal instance of an org-visible agent in their organization", async () => {
+    const created = await createClient(
+      AgentInstanceCommandController,
+      asMember(),
+    ).create(instanceInput("member-personal", orgAgent.metadata!.id));
+    expect(created.metadata?.org).toBe(ORG);
+    expect(created.status?.audit?.specAudit?.createdBy?.id).toBe(MEMBER);
+  });
+
+  it("a member is refused an instance of a PRIVATE agent with the parent's copy", async () => {
+    const error = await failureOf(
+      createClient(AgentInstanceCommandController, asMember()).create(
+        instanceInput("member-on-private", privateAgent.metadata!.id),
+      ),
+    );
+    expect(error.code).toBe(Code.PermissionDenied);
+    expect(error.rawMessage).toBe(INSTANCE_PARENT_DENIED_MESSAGE);
+  });
+
+  it("an outsider naming the organization is refused with the organization's copy, before the agent is named", async () => {
+    const error = await failureOf(
+      createClient(AgentInstanceCommandController, asStranger()).create(
+        instanceInput("stranger-instance", orgAgent.metadata!.id),
+      ),
+    );
+    expect(error.code).toBe(Code.PermissionDenied);
+    expect(error.rawMessage).toBe(INSTANCE_ORGANIZATION_DENIED_MESSAGE);
+  });
+
+  it("the reserved default-instance label buys nothing from the wire", async () => {
+    const error = await failureOf(
+      createClient(AgentInstanceCommandController, asMember()).create(
+        instanceInput("wire-default", orgAgent.metadata!.id, ORG, {
+          [DEFAULT_INSTANCE_LABEL]: RESERVED_LABEL_TRUE,
+        }),
+      ),
+    );
+    // The personal bar admits a member on an org-visible agent; the label
+    // guard then refuses the reserved label a wire caller may not write.
+    expect(error.code).toBe(Code.InvalidArgument);
+    expect(error.rawMessage).toContain(DEFAULT_INSTANCE_LABEL);
+  });
+
+  it("the same labelled request composed in-process for the member is admitted and attributed to them (the self-heal's shape)", async () => {
+    const member = await fakeVerifier.verify(
+      fakeJwt(MEMBER, "member@example.com"),
+    );
+    if (member === null) {
+      throw new Error("the fake verifier must admit the member");
+    }
+    // The agent's own default instance already exists (agent create made
+    // it); the self-heal's request is the same shape under a slug the store
+    // does not hold yet, which is what a legacy agent without one presents.
+    const request = buildDefaultInstanceRequest(orgAgent.metadata!);
+    request.metadata!.name = "org-agent-default-healed";
+    const created = await createClient(
+      AgentInstanceCommandController,
+      server.inProcessTransport,
+    ).create(request, {
+      headers: { [IN_PROCESS_CALLER_HEADER]: encodeInProcessCaller(member) },
+    });
+    expect(created.metadata?.labels?.[DEFAULT_INSTANCE_LABEL]).toBe(
+      RESERVED_LABEL_TRUE,
+    );
+    expect(created.metadata?.org).toBe(ORG);
+    expect(created.status?.audit?.specAudit?.createdBy?.id).toBe(MEMBER);
+  });
+});

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

@@ -0,0 +1,144 @@
+/**
+ * Pins the create lane's authorization questions (steps.ts,
+ * resolveInstanceCreateTargets): a personal instance asks the
+ * organization's bar (can_create_agent_instance on metadata.org) and then
+ * the parent's (can_create_instance on the agent), each with its own copy;
+ * a default instance the server composed in-process for the parent's
+ * organization asks nothing; a labelled request that arrived on the wire,
+ * or that names another organization, takes the personal bar in full; a
+ * missing parent is a thrown chain invariant, never an open lane.
+ */
+import { describe, expect, it } from "vitest";
+import { create } from "@bufbuild/protobuf";
+
+import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { AgentInstanceSchema } from "@stigmer/protos/ai/stigmer/agentic/agentinstance/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 type { CallerIdentity } from "../../../extensions/identity.js";
+import {
+  DEFAULT_INSTANCE_LABEL,
+  RESERVED_LABEL_TRUE,
+} from "../../../pipeline/apiresource-labels.js";
+import { testCallerIdentity } from "../../../pipeline/__tests__/support.js";
+import { RequestContext } from "../../../pipeline/request-context.js";
+import {
+  INSTANCE_ORGANIZATION_DENIED_MESSAGE,
+  INSTANCE_PARENT_DENIED_MESSAGE,
+  PARENT_AGENT_KEY,
+  resolveInstanceCreateTargets,
+} from "../steps.js";
+
+const parent = create(AgentSchema, {
+  metadata: { id: "agt_01parent", name: "helper", org: "acme" },
+});
+
+function ctxFor(
+  org: string,
+  caller: CallerIdentity,
+  labels: Record<string, string> = {},
+  stashParent = true,
+) {
+  const ctx = new RequestContext(
+    AgentInstanceSchema,
+    create(AgentInstanceSchema, {
+      metadata: { name: "mine", org, labels },
+      spec: { agentId: parent.metadata!.id },
+    }),
+    caller,
+    ApiResourceKind.agent_instance,
+  );
+  if (stashParent) {
+    ctx.set(PARENT_AGENT_KEY, parent);
+  }
+  return ctx;
+}
+
+const DEFAULT_LABELS = { [DEFAULT_INSTANCE_LABEL]: RESERVED_LABEL_TRUE };
+
+describe("resolveInstanceCreateTargets", () => {
+  it("a personal instance asks the organization's bar first, then the parent's, each with its own copy", () => {
+    expect(
+      resolveInstanceCreateTargets(ctxFor("acme", testCallerIdentity())),
+    ).toEqual([
+      {
+        permission: IamPermission.can_create_agent_instance,
+        resourceKind: ApiResourceKind.organization,
+        resourceId: "acme",
+        deniedMessage: INSTANCE_ORGANIZATION_DENIED_MESSAGE,
+      },
+      {
+        permission: IamPermission.can_create_instance,
+        resourceKind: ApiResourceKind.agent,
+        resourceId: "agt_01parent",
+        deniedMessage: INSTANCE_PARENT_DENIED_MESSAGE,
+      },
+    ]);
+  });
+
+  it("a cross-org personal instance asks about ITS organization, not the parent's (the marketplace case)", () => {
+    const [orgBar] = resolveInstanceCreateTargets(
+      ctxFor("consumer-org", testCallerIdentity()),
+    );
+    expect(orgBar?.resourceId).toBe("consumer-org");
+  });
+
+  it("a default instance the server composed in-process for the parent's organization asks nothing", () => {
+    expect(
+      resolveInstanceCreateTargets(
+        ctxFor(
+          "acme",
+          testCallerIdentity({ callerClass: "user", origin: "in-process" }),
+          DEFAULT_LABELS,
+        ),
+      ),
+    ).toEqual([]);
+    expect(
+      resolveInstanceCreateTargets(
+        ctxFor(
+          "acme",
+          testCallerIdentity({ callerClass: "channel", origin: "in-process" }),
+          DEFAULT_LABELS,
+        ),
+      ),
+    ).toEqual([]);
+  });
+
+  it("the label alone buys nothing: a labelled request from the wire takes the personal bar in full, the machine class included", () => {
+    expect(
+      resolveInstanceCreateTargets(
+        ctxFor("acme", testCallerIdentity(), DEFAULT_LABELS),
+      ),
+    ).toHaveLength(2);
+    expect(
+      resolveInstanceCreateTargets(
+        ctxFor(
+          "acme",
+          testCallerIdentity({ callerClass: "machine" }),
+          DEFAULT_LABELS,
+        ),
+      ),
+    ).toHaveLength(2);
+  });
+
+  it("a labelled in-process request for another organization is not a default instance to this step", () => {
+    expect(
+      resolveInstanceCreateTargets(
+        ctxFor(
+          "other-org",
+          testCallerIdentity({ callerClass: "user", origin: "in-process" }),
+          DEFAULT_LABELS,
+        ),
+      ),
+    ).toHaveLength(2);
+  });
+
+  it("a missing parent is a broken chain invariant and throws", () => {
+    expect(() =>
+      resolveInstanceCreateTargets(
+        ctxFor("acme", testCallerIdentity(), {}, false),
+      ),
+    ).toThrow("parent agent not found in context");
+  });
+});