@stigmer/cli 3.12.8 → 3.12.9

package/src/resources/run/agent-exec.ts

@@ -45,6 +45,7 @@ export async function executeResolvedAgent(input: ResolvedAgentExecInput): Promi
     serviceTier: prepared.serviceTier,
     thinking: prepared.thinking,
     autoApproveAll: prepared.autoApproveAll,
+    harness: prepared.harness,
   });
 
   // The backend owns the canonical session id: it creates the session and
@@ -56,6 +57,7 @@ export async function executeResolvedAgent(input: ResolvedAgentExecInput): Promi
     sessionId,
     model: prepared.model,
     mode: prepared.mode,
+    harness: prepared.harness,
     workspaces: workspaceNames(prepared.workspaceEntries),
   };
 

package/src/resources/run/create.test.ts

@@ -6,6 +6,7 @@
 import { describe, expect, it } from "vitest";
 import { InteractionMode, ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { create } from "@bufbuild/protobuf";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
 import {
   LocalPathSourceSchema,
   WorkspaceEntrySchema,
@@ -43,6 +44,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: true,
+      harness: "",
     });
 
     expect(exec.kind).toBe("AgentExecution");
@@ -72,6 +74,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.message).toBe("hi");
     expect(exec.spec?.executionConfig).toBeUndefined();
@@ -92,6 +95,7 @@ describe("createAgentExecution", () => {
       serviceTier: "fast",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.FAST);
   });
@@ -113,6 +117,7 @@ describe("createAgentExecution", () => {
       serviceTier: "standard",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.STANDARD);
   });
@@ -132,6 +137,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "enabled",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.ENABLED);
   });
@@ -153,6 +159,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "disabled",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.DISABLED);
   });
@@ -172,6 +179,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.sessionId).toBe("ses_1");
     expect(exec.spec?.executionConfig?.interactionMode).toBe(InteractionMode.UNSPECIFIED);
@@ -199,6 +207,7 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
 
     expect(exec.spec?.sessionId).toBe("");
@@ -206,9 +215,16 @@ describe("createAgentExecution", () => {
     // Subject stays empty so the server defaults its sentinel and the async
     // title activity generates a real one.
     expect(exec.spec?.sessionSpec?.subject).toBe("");
+    // No harness opinion: the field stays UNSPECIFIED so the server default
+    // (native) applies — a workspace-only run is byte-identical to before
+    // the --harness flag existed.
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.UNSPECIFIED);
   });
 
-  it("omits session_spec when there are no workspace entries", async () => {
+  it("omits session_spec when there are no workspace entries and no harness (wire-shape regression pin)", async () => {
+    // The pre---harness wire shape for a plain run: NO embedded session_spec
+    // at all. If this pin fails, plain runs have started carrying a spec they
+    // never carried before — a silent contract change, not a feature.
     const { fn } = fakeController();
     const exec = await createAgentExecution(fn, {
       agentId: "agt_1",
@@ -223,9 +239,84 @@ describe("createAgentExecution", () => {
       serviceTier: "",
       thinking: "",
       autoApproveAll: false,
+      harness: "",
     });
     expect(exec.spec?.sessionSpec).toBeUndefined();
   });
+
+  it("stamps cursor harness on a session_spec created just for it (oss#293)", async () => {
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "hi",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "",
+      autoApproveAll: false,
+      harness: "cursor",
+    });
+    // Harness alone justifies the embedded spec: the server clones it onto
+    // the auto-created session (the one-call bootstrap contract).
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
+    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([]);
+  });
+
+  it("stamps an explicit native harness rather than leaving it unspecified", async () => {
+    // "native" may be a deliberate per-run escape from the account's
+    // default_harness preference — it must survive on the wire so it beats
+    // any future change to the server-side default (D3).
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "hi",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "",
+      autoApproveAll: false,
+      harness: "native",
+    });
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.NATIVE);
+  });
+
+  it("carries harness and workspace entries together on one session_spec", async () => {
+    const entry = create(WorkspaceEntrySchema, {
+      name: "repo",
+      source: create(WorkspaceSourceSchema, {
+        source: { case: "localPath", value: create(LocalPathSourceSchema, { path: "/home/user/repo" }) },
+      }),
+    });
+
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "hi",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [entry],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "",
+      autoApproveAll: false,
+      harness: "cursor",
+    });
+    expect(exec.spec?.sessionSpec?.harness).toBe(Harness.CURSOR);
+    expect(exec.spec?.sessionSpec?.workspaceEntries).toEqual([entry]);
+  });
 });
 
 describe("createWorkflowExecution", () => {

package/src/resources/run/create.ts

@@ -18,7 +18,8 @@ import {
   ExecutionConfigSchema,
 } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import type { ExecutionValue } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
-import { SessionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
+import { Harness } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
+import { type SessionSpec, SessionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/spec_pb";
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import {
   type WorkflowExecution,
@@ -29,7 +30,7 @@ import { WorkflowExecutionSpecSchema } from "@stigmer/protos/ai/stigmer/agentic/
 import { ExecutionValueSchema } from "@stigmer/protos/ai/stigmer/agentic/executioncontext/v1/spec_pb";
 import { ApiResourceMetadataSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/metadata_pb";
 import type { RuntimeEnv } from "./env.js";
-import type { RunMode, ServiceTierFlag, ThinkingFlag } from "./prepare.js";
+import type { HarnessFlag, RunMode, ServiceTierFlag, ThinkingFlag } from "./prepare.js";
 
 const API_VERSION = "agentic.stigmer.ai/v1";
 
@@ -60,6 +61,7 @@ export interface CreateAgentExecutionInput {
   readonly serviceTier: ServiceTierFlag;
   readonly thinking: ThinkingFlag;
   readonly autoApproveAll: boolean;
+  readonly harness: HarnessFlag;
 }
 
 /** Create an agent execution. Mirrors Go's createAgentExecution. */
@@ -81,10 +83,7 @@ export async function createAgentExecution(
       agentId: input.agentId ?? "",
       // Subject is left empty: the server defaults its sentinel and the async
       // title activity replaces it, same as any auto-created session.
-      sessionSpec:
-        input.workspaceEntries.length > 0
-          ? create(SessionSpecSchema, { workspaceEntries: [...input.workspaceEntries] })
-          : undefined,
+      sessionSpec: buildSessionSpec(input.workspaceEntries, input.harness),
       executionConfig: buildExecutionConfig(input.model, input.mode, input.serviceTier, input.thinking),
     }),
   });
@@ -121,6 +120,26 @@ export async function createWorkflowExecution(
   return controller(WorkflowExecutionCommandController).create(execution);
 }
 
+// Build the embedded session spec for the one-call bootstrap
+// (stigmer/stigmer#249), or undefined when there is nothing to carry — the
+// pre-existing wire shape for a plain run must stay byte-identical. A resolved
+// harness is stamped explicitly, including "native": the value may be a
+// deliberate per-run escape from the account's default_harness preference, so
+// it must survive any future change to the server-side default. Empty means
+// "no opinion" and stays off the wire (server defaults to native). The server
+// clones this spec onto the auto-created session and then clears it from the
+// persisted execution — the Session resource stays the single source of truth.
+function buildSessionSpec(
+  workspaceEntries: readonly WorkspaceEntry[],
+  harness: HarnessFlag,
+): SessionSpec | undefined {
+  if (workspaceEntries.length === 0 && harness === "") return undefined;
+  const spec = create(SessionSpecSchema, { workspaceEntries: [...workspaceEntries] });
+  if (harness === "cursor") spec.harness = Harness.CURSOR;
+  else if (harness === "native") spec.harness = Harness.NATIVE;
+  return spec;
+}
+
 // Build ExecutionConfig, or undefined when no flag is set so the backend
 // applies its defaults. Mirrors Go's buildExecutionConfig (only "plan" maps to a
 // non-default InteractionMode; "agent"/"" leave it unspecified). An explicit

package/src/resources/run/header.test.ts

@@ -31,6 +31,24 @@ describe("renderSessionHeader", () => {
     expect(agent.text()).not.toContain("Mode:");
   });
 
+  it("surfaces the cursor harness but not native/default (oss#293 D2 visibility)", () => {
+    // A cursor session may have been selected by the account preference, not
+    // a flag — the header is the CLI's only pre-stream channel to say so.
+    const cursor = capture();
+    renderSessionHeader(cursor.out, { agentName: "", sessionId: "s", model: "", mode: "", harness: "cursor", workspaces: [] });
+    expect(cursor.text()).toContain("Harness:");
+    expect(cursor.text()).toContain("Cursor");
+
+    // Native (explicit or defaulted) stays implicit, like agent mode.
+    const native = capture();
+    renderSessionHeader(native.out, { agentName: "", sessionId: "s", model: "", mode: "", harness: "native", workspaces: [] });
+    expect(native.text()).not.toContain("Harness:");
+
+    const unset = capture();
+    renderSessionHeader(unset.out, { agentName: "", sessionId: "s", model: "", mode: "", workspaces: [] });
+    expect(unset.text()).not.toContain("Harness:");
+  });
+
   it("indents extra workspaces under the first", () => {
     const { out, text } = capture();
     renderSessionHeader(out, {

package/src/resources/run/header.ts

@@ -11,7 +11,7 @@
 
 import type { WorkspaceEntry } from "@stigmer/protos/ai/stigmer/agentic/session/v1/workspace_pb";
 import { shouldColorize, styler } from "../../output/style.js";
-import type { RunMode } from "./prepare.js";
+import type { HarnessFlag, RunMode } from "./prepare.js";
 
 export interface SessionHeaderInfo {
   readonly agentName: string;
@@ -20,6 +20,14 @@ export interface SessionHeaderInfo {
   readonly subject?: string;
   readonly model: string;
   readonly mode: RunMode;
+  /**
+   * Resolved harness for the session. Surfaced only when it is "cursor":
+   * a harness switch changes the toolset, conversation-state model, and
+   * billing tier, and it may come from the account preference rather than
+   * a flag — a cursor session must never start silently (the CLI
+   * counterpart of the web composer's harness selector).
+   */
+  readonly harness?: HarnessFlag;
   readonly workspaces: readonly string[];
 }
 
@@ -39,6 +47,8 @@ export function renderSessionHeader(out: { write(chunk: string): unknown; isTTY?
   if (info.sessionId !== "") lines.push(row(s, "Session", info.sessionId));
   if ((info.subject ?? "") !== "") lines.push(row(s, "Subject", info.subject ?? ""));
   if (info.model !== "") lines.push(row(s, "Model", info.model));
+  // Only "cursor" is surfaced; native/"" is the default and stays implicit.
+  if (info.harness === "cursor") lines.push(row(s, "Harness", "Cursor"));
   // Only "plan" is surfaced; "agent"/"" is the default and stays implicit.
   if (info.mode === "plan") lines.push(row(s, "Mode", "Plan (read-only)"));
   if (info.workspaces.length > 0) {

package/src/resources/run/prepare.test.ts

@@ -5,7 +5,7 @@
 import { describe, expect, it } from "vitest";
 import { ApprovalAction } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { Stigmer } from "@stigmer/sdk";
-import { type AgentExecFlags, parseApprovalAction, prepareAgentExec, validateMode, validateServiceTier, validateThinking } from "./prepare.js";
+import { type AgentExecFlags, parseApprovalAction, prepareAgentExec, validateHarness, validateMode, validateServiceTier, validateThinking } from "./prepare.js";
 
 describe("parseApprovalAction", () => {
   it("maps each accepted value (case-insensitive)", () => {
@@ -59,6 +59,24 @@ describe("validateThinking", () => {
   });
 });
 
+describe("validateHarness", () => {
+  it("accepts empty, native, and cursor", () => {
+    expect(() => validateHarness("")).not.toThrow();
+    expect(() => validateHarness("native")).not.toThrow();
+    expect(() => validateHarness("cursor")).not.toThrow();
+  });
+
+  it("rejects anything else before a network round trip", () => {
+    expect(() => validateHarness("turbo")).toThrow(/must be "native" or "cursor"/);
+  });
+
+  it("rejects UI-only harness names that have no proto mapping", () => {
+    // copilot/codex/etc. exist in display metadata but not on the wire —
+    // accepting them here would stamp UNSPECIFIED and silently run native.
+    expect(() => validateHarness("copilot")).toThrow(/must be "native" or "cursor"/);
+  });
+});
+
 const BASE_FLAGS: AgentExecFlags = {
   message: "hi",
   attach: [],
@@ -77,23 +95,35 @@ const BASE_FLAGS: AgentExecFlags = {
   mode: "",
   serviceTier: "",
   thinking: "",
+  harness: "",
 };
 
 // prepareAgentExec only touches client.agentExecution for attachment uploads;
 // with no attachments a bare stub suffices.
 const STUB_CLIENT = { agentExecution: {} } as unknown as Stigmer;
 
-/** Stub whose whoAmI resolves an account carrying the given preference. */
-function clientWithPreference(defaultNativeModel: string): Stigmer {
+/** The shape of IdentityAccountPreferences the stubs below expose. */
+interface StubPreferences {
+  readonly defaultHarness?: string;
+  readonly defaultNativeModel?: string;
+  readonly defaultCursorModel?: string;
+}
+
+/** Stub whose whoAmI resolves an account carrying the given preferences. */
+function clientWithPreferences(preferences: StubPreferences): Stigmer {
   return {
     agentExecution: {},
     identityAccount: {
-      whoAmI: () =>
-        Promise.resolve({ spec: { preferences: { defaultNativeModel } } }),
+      whoAmI: () => Promise.resolve({ spec: { preferences } }),
     },
   } as unknown as Stigmer;
 }
 
+/** Back-compat shorthand for the original native-model-only stub. */
+function clientWithPreference(defaultNativeModel: string): Stigmer {
+  return clientWithPreferences({ defaultNativeModel });
+}
+
 /** Stub whose whoAmI rejects (auth failure, backend without the RPC, ...). */
 function clientWithFailingWhoAmI(): Stigmer {
   return {
@@ -104,6 +134,24 @@ function clientWithFailingWhoAmI(): Stigmer {
   } as unknown as Stigmer;
 }
 
+/** Preference stub that also counts whoAmI invocations (round-trip pin). */
+function countingClient(preferences: StubPreferences): { client: Stigmer; calls: () => number } {
+  let calls = 0;
+  const client = {
+    agentExecution: {},
+    identityAccount: {
+      whoAmI: () => {
+        calls += 1;
+        return Promise.resolve({ spec: { preferences } });
+      },
+    },
+  } as unknown as Stigmer;
+  return { client, calls: () => calls };
+}
+
+/** prepareAgentExec options as `run` passes them: cloud + harness opt-in. */
+const CLOUD_RUN_OPTIONS = { cloudBackend: true, applyAccountHarnessDefault: true } as const;
+
 describe("prepareAgentExec env injection", () => {
   it("injects STIGMER_ORG_ID when absent", async () => {
     const prepared = await prepareAgentExec(BASE_FLAGS, STUB_CLIENT, "acme");
@@ -196,3 +244,197 @@ describe("prepareAgentExec account-preference model fill (oss#293 Phase 1.5)", (
     expect(prepared.model).toBe("");
   });
 });
+
+describe("prepareAgentExec harness resolution (oss#293)", () => {
+  it("fills an omitted --harness from the account preference on cloud when the caller opts in (run)", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreferences({ defaultHarness: "cursor" }),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.harness).toBe("cursor");
+  });
+
+  it("an explicit --harness always outranks the account preference", async () => {
+    // The per-run escape hatch: a cursor-preference user can still force a
+    // native run without touching their settings.
+    const prepared = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "native" },
+      clientWithPreferences({ defaultHarness: "cursor" }),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.harness).toBe("native");
+  });
+
+  it("ignores the preference when the caller has not opted in (draft, D5)", async () => {
+    // draft runs the seedpack's system creator agents — a utility flow that
+    // must not be silently rerouted onto the cursor engine by a preference
+    // meant for the user's own sessions (owner-ratified D5).
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreferences({ defaultHarness: "cursor" }),
+      "acme",
+      undefined,
+      { cloudBackend: true },
+    );
+    expect(prepared.harness).toBe("");
+  });
+
+  it("an explicit --harness still resolves for a non-opted-in caller (draft escape hatch)", async () => {
+    const prepared = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "cursor" },
+      STUB_CLIENT,
+      "acme",
+      undefined,
+      { cloudBackend: false },
+    );
+    expect(prepared.harness).toBe("cursor");
+  });
+
+  it("treats a malformed persisted harness as undeclared", async () => {
+    // A client must not trust stored data it did not write: anything outside
+    // the shipped allowlist resolves as if no preference existed.
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreferences({ defaultHarness: "devin" }),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.harness).toBe("");
+  });
+
+  it("resolves empty when whoAmI fails — a missing preference never fails a run", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithFailingWhoAmI(),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.harness).toBe("");
+    expect(prepared.model).toBe("");
+  });
+
+  it("never consults identity on a local backend, even with the opt-in", async () => {
+    // The failing stub doubles as a call detector, as in the model-fill suite.
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithFailingWhoAmI(),
+      "acme",
+      undefined,
+      { cloudBackend: false, applyAccountHarnessDefault: true },
+    );
+    expect(prepared.harness).toBe("");
+  });
+
+  it("resolves empty when nothing is declared anywhere", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreferences({}),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.harness).toBe("");
+  });
+});
+
+describe("prepareAgentExec harness-aware model fill (oss#293)", () => {
+  const BOTH_MODELS: StubPreferences = {
+    defaultNativeModel: "claude-sonnet-4.6",
+    defaultCursorModel: "composer-2.5",
+  };
+
+  it("fills the cursor model when the explicit harness is cursor", async () => {
+    const prepared = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "cursor" },
+      clientWithPreferences(BOTH_MODELS),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.model).toBe("composer-2.5");
+  });
+
+  it("fills the cursor model when the preference resolves the harness to cursor", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreferences({ ...BOTH_MODELS, defaultHarness: "cursor" }),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.harness).toBe("cursor");
+    expect(prepared.model).toBe("composer-2.5");
+  });
+
+  it("fills the native model when the harness resolves native or empty", async () => {
+    const explicit = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "native" },
+      clientWithPreferences(BOTH_MODELS),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(explicit.model).toBe("claude-sonnet-4.6");
+
+    const unset = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreferences(BOTH_MODELS),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(unset.model).toBe("claude-sonnet-4.6");
+  });
+
+  it("an explicit --model outranks the harness-matched preference", async () => {
+    const prepared = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "cursor", model: "gpt-5.3" },
+      clientWithPreferences(BOTH_MODELS),
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(prepared.model).toBe("gpt-5.3");
+  });
+
+  it("draft with an explicit --harness cursor fills the cursor model despite no harness opt-in (D5)", async () => {
+    // D5 scopes only the silent preference fill; the model fill follows
+    // whatever harness the user explicitly chose.
+    const prepared = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "cursor" },
+      clientWithPreferences(BOTH_MODELS),
+      "acme",
+      undefined,
+      { cloudBackend: true },
+    );
+    expect(prepared.harness).toBe("cursor");
+    expect(prepared.model).toBe("composer-2.5");
+  });
+
+  it("serves both fills from one whoAmI round trip, and none when both flags are explicit", async () => {
+    const single = countingClient({ ...BOTH_MODELS, defaultHarness: "cursor" });
+    const filled = await prepareAgentExec(BASE_FLAGS, single.client, "acme", undefined, CLOUD_RUN_OPTIONS);
+    expect(filled.harness).toBe("cursor");
+    expect(filled.model).toBe("composer-2.5");
+    expect(single.calls(), "harness + model fills share one whoAmI").toBe(1);
+
+    const skipped = countingClient(BOTH_MODELS);
+    const explicit = await prepareAgentExec(
+      { ...BASE_FLAGS, harness: "native", model: "gpt-5.3" },
+      skipped.client,
+      "acme",
+      undefined,
+      CLOUD_RUN_OPTIONS,
+    );
+    expect(explicit.harness).toBe("native");
+    expect(explicit.model).toBe("gpt-5.3");
+    expect(skipped.calls(), "explicit flags leave nothing to fill — no round trip").toBe(0);
+  });
+});