@stigmer/cli 3.12.4 → 3.12.6

package/src/resources/apply/apply.ts

@@ -8,6 +8,7 @@
 
 import { create, fromJson, type JsonValue, type Message } from "@bufbuild/protobuf";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import type { Workflow } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/api_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
 import { UpdateVisibilityInputSchema } from "@stigmer/protos/ai/stigmer/commons/apiresource/io_pb";
@@ -19,6 +20,7 @@ import { UsageError } from "../../errors/index.js";
 import { CommandResult } from "../../output/index.js";
 import { defaultRegistry, Verb } from "../../registry/index.js";
 import { loadDocuments, resolveYamlFiles } from "../documents.js";
+import { decodeWorkflowTaskConfigs } from "../task-configs.js";
 import { type ApplyHandler, APPLY_HANDLERS, type ControllerFn } from "./handlers.js";
 
 export interface ApplyItem {
@@ -112,7 +114,15 @@ export async function applyItem(
  */
 export function marshalItem(item: ApplyItem): Message {
   try {
-    return fromJson(item.handler.schema, item.document, { ignoreUnknownFields: false });
+    const message = fromJson(item.handler.schema, item.document, { ignoreUnknownFields: false });
+    // Workflow task_config blocks live inside an open Struct the top-level
+    // decode cannot see into; decode them per kind so a dry-run (and the
+    // reconciler's marshal) rejects exactly what a real apply rejects
+    // (stigmer/stigmer#778).
+    if (item.handler.kind === ApiResourceKind.workflow) {
+      decodeWorkflowTaskConfigs(message as Workflow);
+    }
+    return message;
   } catch (err) {
     throw new UsageError(`invalid ${item.handler.displayName} in ${item.filePath}: ${(err as Error).message}`);
   }

package/src/resources/connect/connect.ts

@@ -1,7 +1,9 @@
-// `connect mcp-server` orchestration. Mirrors Go's mcpserver.Connect (connect.go):
-// resolve the server, then either push to the backend (the Connect RPC runs
-// discovery server-side and persists capabilities + tool-approval policies) or,
-// for --dry-run, discover locally and return without persisting.
+// `connect mcp-server` orchestration. Resolve the server, then either run the
+// server-side connect (discovery + tool-approval classification, persisted on
+// the resource) or, for --dry-run, discover locally and return without
+// persisting. The server-side path uses the async lane — startConnect + poll
+// (stigmer/stigmer#425) — with a blocking-RPC fallback for backends that
+// predate it.
 //
 // OAuth: when a server requires OAuth, has no existing grant, and no --env was
 // supplied, the interactive browser flow (oauth.ts) shepherds the user through
@@ -11,10 +13,12 @@
 
 import { create } from "@bufbuild/protobuf";
 import type { McpServer } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/api_pb";
+import type { ConnectInput } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/io_pb";
 import { ConnectInputSchema, GetOAuthGrantStatusInputSchema } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/io_pb";
 import type { DiscoveredCapabilities } from "@stigmer/protos/ai/stigmer/agentic/mcpserver/v1/status_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import type { Stigmer } from "@stigmer/sdk";
+import { connectAndWait, ConnectStillRunningError, CONNECT_SETTLE_BOUND_MS } from "@stigmer/sdk";
 import type { BackendType } from "../../config/config.js";
 import { CliExitError, ExitCode, UsageError } from "../../errors/index.js";
 import { defaultRegistry } from "../../registry/index.js";
@@ -49,6 +53,13 @@ export interface ConnectResult {
   readonly capabilities: DiscoveredCapabilities | undefined;
   /** Set when capabilities were persisted (non-dry-run); undefined for dry-run. */
   readonly updated: McpServer | undefined;
+  /**
+   * Start-time advisory from the backend's connect pre-flight (e.g. "no
+   * runner appears to be polling the task queue"). Only set on the async
+   * lane, and only when the operation ultimately settled anyway — surfaced
+   * so the user learns their runner came up late.
+   */
+  readonly warning?: string;
 }
 
 /** Connect to an MCP server and discover its capabilities (push or dry-run). */
@@ -75,50 +86,65 @@ export async function connectMcpServer(client: Stigmer, opts: ConnectOptions): P
 
   await ensureOAuthSatisfied(client, server, opts);
 
-  const push = client.mcpServer.connect(
-    create(ConnectInputSchema, {
-      mcpServerId: server.metadata?.id ?? "",
-      org: opts.org,
-      runtimeEnv: buildRuntimeEnv(server, opts.envOverrides),
-    }),
-  );
-  const updated = opts.pushTimeoutMs === undefined
-    ? await push
-    : await boundedPush(push, opts.pushTimeoutMs, server);
-  return { server, capabilities: updated.status?.discoveredCapabilities, updated };
+  const input = create(ConnectInputSchema, {
+    mcpServerId: server.metadata?.id ?? "",
+    org: opts.org,
+    runtimeEnv: buildRuntimeEnv(server, opts.envOverrides),
+  });
+  return serverSideConnect(client, server, input, opts);
 }
 
-// Soft timeout on the server-side connect (the client/client.ts idiom): races
-// the RPC against a timer without cancelling it — the backend's connect
-// workflow keeps running and persists its result on its own, so the message
-// says exactly that instead of implying the connect failed.
-async function boundedPush<T>(push: Promise<T>, timeoutMs: number, server: McpServer): Promise<T> {
+// Run the server-side connect through the SDK's shared async-lane protocol
+// (connectAndWait, stigmer/stigmer#425): startConnect + poll, with the
+// blocking-RPC fallback for backends that predate the lane. The CLI's job is
+// only to translate its --timeout semantics and turn a still-running stop
+// into its own actionable guidance.
+async function serverSideConnect(
+  client: Stigmer,
+  server: McpServer,
+  input: ConnectInput,
+  opts: ConnectOptions,
+): Promise<ConnectResult> {
   const slug = server.metadata?.slug ?? server.metadata?.id ?? "the server";
-  let timer: NodeJS.Timeout | undefined;
-  const timeout = new Promise<never>((_, reject) => {
-    timer = setTimeout(
-      () =>
-        reject(
-          new CliExitError(
-            `Stopped waiting for the connect of MCP server '${slug}' after ${timeoutMs / 1000}s (--timeout)`,
-            ExitCode.Connection,
-            [
-              "The server-side connect is still running and will persist its result if it succeeds.",
-              `Check the outcome with: stigmer get mcp-server ${slug}`,
-              "Re-run without --timeout to wait for completion.",
-            ],
-          ),
-        ),
-      timeoutMs,
-    );
-  });
-  // The losing push may settle after the CLI has started exiting; swallow its
-  // late rejection so it cannot surface as an unhandled-rejection crash.
-  void push.catch(() => {});
+  let warning = "";
   try {
-    return await Promise.race([push, timeout]);
-  } finally {
-    if (timer !== undefined) clearTimeout(timer);
+    const updated = await connectAndWait(client.mcpServer, input, {
+      deadlineMs: opts.pushTimeoutMs,
+      onStarted: (started) => {
+        warning = started.status?.connectStatus?.warning ?? "";
+      },
+    });
+    return {
+      server,
+      capabilities: updated.status?.discoveredCapabilities,
+      updated,
+      warning: warning !== "" ? warning : undefined,
+    };
+  } catch (err) {
+    if (!(err instanceof ConnectStillRunningError)) throw err;
+    if (opts.pushTimeoutMs !== undefined) {
+      // The user's explicit --timeout fired: historical soft-bound semantics.
+      throw new CliExitError(
+        `Stopped waiting for the connect of MCP server '${slug}' after ${opts.pushTimeoutMs / 1000}s (--timeout)`,
+        ExitCode.Connection,
+        [
+          "The server-side connect is still running and will persist its result if it succeeds.",
+          `Check the outcome with: stigmer get mcp-server ${slug}`,
+          "Re-run without --timeout to wait for completion.",
+        ],
+      );
+    }
+    // The SDK's settle bound fired: past the backend's own ceiling, only a
+    // connect_status orphaned by a backend restart can still read CONNECTING.
+    throw new CliExitError(
+      `The connect of MCP server '${slug}' did not settle within ${CONNECT_SETTLE_BOUND_MS / 60_000} minutes`,
+      ExitCode.Connection,
+      [
+        "This usually means the backend restarted mid-operation.",
+        `Check the current state with: stigmer get mcp-server ${slug}`,
+        "Re-run the connect to start a fresh operation.",
+      ],
+    );
   }
 }
 

package/src/resources/connect/display.ts

@@ -26,6 +26,9 @@ export function renderConnectResult(result: ConnectResult, sink: ConnectSink, co
   sink(result.updated !== undefined
     ? style.green("✓ Connected — capabilities and tool approvals saved")
     : style.yellow("⚠ Dry run — results not saved to backend"));
+  if (result.warning !== undefined) {
+    sink(style.yellow(`⚠ ${result.warning}`));
+  }
   sink("");
 }
 

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

@@ -47,6 +47,7 @@ function makePrepared(overrides: Partial<PreparedRun> = {}): PreparedRun {
     autoApproveAll: false,
     mode: "",
     serviceTier: "",
+    thinking: "",
     ...overrides,
   };
 }

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

@@ -43,6 +43,7 @@ export async function executeResolvedAgent(input: ResolvedAgentExecInput): Promi
     model: prepared.model,
     mode: prepared.mode,
     serviceTier: prepared.serviceTier,
+    thinking: prepared.thinking,
     autoApproveAll: prepared.autoApproveAll,
   });
 

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

@@ -4,7 +4,7 @@
 // is faked to capture the exact proto sent to the RPC.
 
 import { describe, expect, it } from "vitest";
-import { InteractionMode, ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { InteractionMode, ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { create } from "@bufbuild/protobuf";
 import {
   LocalPathSourceSchema,
@@ -41,6 +41,7 @@ describe("createAgentExecution", () => {
       model: "claude",
       mode: "plan",
       serviceTier: "",
+      thinking: "",
       autoApproveAll: true,
     });
 
@@ -69,6 +70,7 @@ describe("createAgentExecution", () => {
       model: "",
       mode: "",
       serviceTier: "",
+      thinking: "",
       autoApproveAll: false,
     });
     expect(exec.spec?.message).toBe("hi");
@@ -88,6 +90,7 @@ describe("createAgentExecution", () => {
       model: "composer-2.5",
       mode: "",
       serviceTier: "fast",
+      thinking: "",
       autoApproveAll: false,
     });
     expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.FAST);
@@ -108,11 +111,52 @@ describe("createAgentExecution", () => {
       model: "",
       mode: "",
       serviceTier: "standard",
+      thinking: "",
       autoApproveAll: false,
     });
     expect(exec.spec?.executionConfig?.serviceTier).toBe(ServiceTier.STANDARD);
   });
 
+  it("maps --thinking enabled to the enum (#772)", async () => {
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "x",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [],
+      model: "claude-haiku-4-5",
+      mode: "",
+      serviceTier: "",
+      thinking: "enabled",
+      autoApproveAll: false,
+    });
+    expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.ENABLED);
+  });
+
+  it("maps an explicit --thinking disabled to DISABLED, not UNSPECIFIED", async () => {
+    // The tier's #772 twin: unspecified-vs-explicit-disabled is the same
+    // load-bearing ledger distinction.
+    const { fn } = fakeController();
+    const exec = await createAgentExecution(fn, {
+      agentId: "agt_1",
+      orgId: "acme",
+      message: "x",
+      runtimeEnv: {},
+      attachments: [],
+      workspaceFileRefs: [],
+      workspaceEntries: [],
+      model: "",
+      mode: "",
+      serviceTier: "",
+      thinking: "disabled",
+      autoApproveAll: false,
+    });
+    expect(exec.spec?.executionConfig?.thinkingMode).toBe(ThinkingMode.DISABLED);
+  });
+
   it("leaves InteractionMode unspecified for agent mode", async () => {
     const { fn } = fakeController();
     const exec = await createAgentExecution(fn, {
@@ -126,6 +170,7 @@ describe("createAgentExecution", () => {
       model: "m",
       mode: "agent",
       serviceTier: "",
+      thinking: "",
       autoApproveAll: false,
     });
     expect(exec.spec?.sessionId).toBe("ses_1");
@@ -152,6 +197,7 @@ describe("createAgentExecution", () => {
       model: "",
       mode: "",
       serviceTier: "",
+      thinking: "",
       autoApproveAll: false,
     });
 
@@ -175,6 +221,7 @@ describe("createAgentExecution", () => {
       model: "",
       mode: "",
       serviceTier: "",
+      thinking: "",
       autoApproveAll: false,
     });
     expect(exec.spec?.sessionSpec).toBeUndefined();

package/src/resources/run/create.ts

@@ -10,7 +10,7 @@ import type { Client } from "@connectrpc/connect";
 import { create, type DescService } from "@bufbuild/protobuf";
 import { type AgentExecution, AgentExecutionSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { AgentExecutionCommandController } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/command_pb";
-import { InteractionMode, ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { InteractionMode, ServiceTier, ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import type { Attachment } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
 import {
   AgentExecutionSpecSchema,
@@ -29,7 +29,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 } from "./prepare.js";
+import type { RunMode, ServiceTierFlag, ThinkingFlag } from "./prepare.js";
 
 const API_VERSION = "agentic.stigmer.ai/v1";
 
@@ -58,6 +58,7 @@ export interface CreateAgentExecutionInput {
   readonly model: string;
   readonly mode: RunMode;
   readonly serviceTier: ServiceTierFlag;
+  readonly thinking: ThinkingFlag;
   readonly autoApproveAll: boolean;
 }
 
@@ -84,7 +85,7 @@ export async function createAgentExecution(
         input.workspaceEntries.length > 0
           ? create(SessionSpecSchema, { workspaceEntries: [...input.workspaceEntries] })
           : undefined,
-      executionConfig: buildExecutionConfig(input.model, input.mode, input.serviceTier),
+      executionConfig: buildExecutionConfig(input.model, input.mode, input.serviceTier, input.thinking),
     }),
   });
   return controller(AgentExecutionCommandController).create(execution);
@@ -123,19 +124,23 @@ export async function createWorkflowExecution(
 // 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
-// --service-tier value maps to the enum even for "standard": unspecified vs
-// explicit-standard is a load-bearing ledger distinction (#357).
+// --service-tier or --thinking value maps to the enum even for the base
+// choice ("standard"/"disabled"): unspecified vs explicit is a load-bearing
+// ledger distinction (#357/#772).
 function buildExecutionConfig(
   model: string,
   mode: RunMode,
   serviceTier: ServiceTierFlag,
+  thinking: ThinkingFlag,
 ): ExecutionConfig | undefined {
-  if (model === "" && mode === "" && serviceTier === "") return undefined;
+  if (model === "" && mode === "" && serviceTier === "" && thinking === "") return undefined;
   const cfg = create(ExecutionConfigSchema);
   if (model !== "") cfg.modelName = model;
   if (mode === "plan") cfg.interactionMode = InteractionMode.PLAN;
   if (serviceTier === "fast") cfg.serviceTier = ServiceTier.FAST;
   else if (serviceTier === "standard") cfg.serviceTier = ServiceTier.STANDARD;
+  if (thinking === "enabled") cfg.thinkingMode = ThinkingMode.ENABLED;
+  else if (thinking === "disabled") cfg.thinkingMode = ThinkingMode.DISABLED;
   return cfg;
 }
 

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 } from "./prepare.js";
+import { type AgentExecFlags, parseApprovalAction, prepareAgentExec, validateMode, validateServiceTier, validateThinking } from "./prepare.js";
 
 describe("parseApprovalAction", () => {
   it("maps each accepted value (case-insensitive)", () => {
@@ -47,6 +47,18 @@ describe("validateServiceTier", () => {
   });
 });
 
+describe("validateThinking", () => {
+  it("accepts empty, disabled, and enabled", () => {
+    expect(() => validateThinking("")).not.toThrow();
+    expect(() => validateThinking("disabled")).not.toThrow();
+    expect(() => validateThinking("enabled")).not.toThrow();
+  });
+
+  it("rejects anything else before a network round trip", () => {
+    expect(() => validateThinking("harder")).toThrow(/must be "disabled" or "enabled"/);
+  });
+});
+
 const BASE_FLAGS: AgentExecFlags = {
   message: "hi",
   attach: [],
@@ -64,12 +76,34 @@ const BASE_FLAGS: AgentExecFlags = {
   autoApprove: false,
   mode: "",
   serviceTier: "",
+  thinking: "",
 };
 
 // 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 {
+  return {
+    agentExecution: {},
+    identityAccount: {
+      whoAmI: () =>
+        Promise.resolve({ spec: { preferences: { defaultNativeModel } } }),
+    },
+  } as unknown as Stigmer;
+}
+
+/** Stub whose whoAmI rejects (auth failure, backend without the RPC, ...). */
+function clientWithFailingWhoAmI(): Stigmer {
+  return {
+    agentExecution: {},
+    identityAccount: {
+      whoAmI: () => Promise.reject(new Error("unimplemented")),
+    },
+  } as unknown as Stigmer;
+}
+
 describe("prepareAgentExec env injection", () => {
   it("injects STIGMER_ORG_ID when absent", async () => {
     const prepared = await prepareAgentExec(BASE_FLAGS, STUB_CLIENT, "acme");
@@ -103,3 +137,62 @@ describe("prepareAgentExec env injection", () => {
     expect(prepared.mode).toBe("plan");
   });
 });
+
+describe("prepareAgentExec account-preference model fill (oss#293 Phase 1.5)", () => {
+  it("fills an omitted --model from the account preference on cloud", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreference("claude-sonnet-4.6"),
+      "acme",
+      undefined,
+      { cloudBackend: true },
+    );
+    expect(prepared.model).toBe("claude-sonnet-4.6");
+  });
+
+  it("an explicit --model always outranks the preference", async () => {
+    const prepared = await prepareAgentExec(
+      { ...BASE_FLAGS, model: "gpt-5.3" },
+      clientWithPreference("claude-sonnet-4.6"),
+      "acme",
+      undefined,
+      { cloudBackend: true },
+    );
+    expect(prepared.model).toBe("gpt-5.3");
+  });
+
+  it("never consults identity on a local backend", async () => {
+    // The failing stub doubles as a call detector: local mode must not even
+    // attempt whoAmI, so a rejecting client cannot affect the result.
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithFailingWhoAmI(),
+      "acme",
+      undefined,
+      { cloudBackend: false },
+    );
+    expect(prepared.model).toBe("");
+  });
+
+  it("falls through silently when whoAmI fails — a missing preference never fails a run", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithFailingWhoAmI(),
+      "acme",
+      undefined,
+      { cloudBackend: true },
+    );
+    expect(prepared.model).toBe("");
+  });
+
+  it("stays empty when the account declares no native default", async () => {
+    const prepared = await prepareAgentExec(
+      BASE_FLAGS,
+      clientWithPreference(""),
+      "acme",
+      undefined,
+      { cloudBackend: true },
+    );
+    expect(prepared.model).toBe("");
+  });
+});

package/src/resources/run/prepare.ts

@@ -26,6 +26,12 @@ export type RunMode = "" | "agent" | "plan";
  */
 export type ServiceTierFlag = "" | "standard" | "fast";
 
+/**
+ * The `--thinking` flag's value space (#772), the tier's twin: empty means
+ * unset — distinct from an explicit "disabled" for the same ledger reason.
+ */
+export type ThinkingFlag = "" | "disabled" | "enabled";
+
 /** Raw agent-execution flags shared by `run` and `draft` (Go's agentExecFlags). */
 export interface AgentExecFlags {
   readonly message: string;
@@ -44,6 +50,7 @@ export interface AgentExecFlags {
   readonly autoApprove: boolean;
   readonly mode: RunMode;
   readonly serviceTier: ServiceTierFlag;
+  readonly thinking: ThinkingFlag;
 }
 
 /**
@@ -63,6 +70,19 @@ export interface PreparedRun {
   readonly autoApproveAll: boolean;
   readonly mode: RunMode;
   readonly serviceTier: ServiceTierFlag;
+  readonly thinking: ThinkingFlag;
+}
+
+/** Optional behavior switches for {@link prepareAgentExec}. */
+export interface PrepareAgentExecOptions {
+  /**
+   * When `true` (the caller's backend is Stigmer Cloud) and `--model` is
+   * omitted, the model is filled from the caller's account preference
+   * (`IdentityAccountPreferences.default_native_model`) via `whoAmI()`.
+   * Local mode has no IdentityAccount, so callers pass `false` there and
+   * the omitted model keeps resolving to the platform default.
+   */
+  readonly cloudBackend?: boolean;
 }
 
 /**
@@ -74,10 +94,22 @@ export async function prepareAgentExec(
   client: Stigmer,
   org: string,
   progress?: ProgressSink,
+  options?: PrepareAgentExecOptions,
 ): Promise<PreparedRun> {
   const defaultAction = parseApprovalAction(flags.approveDefault);
   validateMode(flags.mode);
   validateServiceTier(flags.serviceTier);
+  validateThinking(flags.thinking);
+
+  // Layered model seed (oss#293 Phase 1.5): an explicit --model always wins;
+  // an omitted one fills from the account preference on cloud. `run` and
+  // `draft` always create a NEW session (threading lives in `resume`, which
+  // does not pass through here), so the fill never injects a native model
+  // into an existing cursor-harness session.
+  const model =
+    flags.model === "" && options?.cloudBackend === true
+      ? await resolveModelFromAccountPreference(client)
+      : flags.model;
 
   const workspaceEntries = parseWorkspaceEntries(flags.workspace, flags.branch, flags.commit);
 
@@ -107,13 +139,31 @@ export async function prepareAgentExec(
     message: flags.message,
     detach: flags.detach,
     verbose: flags.verbose,
-    model: flags.model,
+    model,
     autoApproveAll: flags.autoApprove,
     mode: flags.mode,
     serviceTier: flags.serviceTier,
+    thinking: flags.thinking,
   };
 }
 
+/**
+ * Best-effort read of the caller's default model for native-harness runs
+ * (CLI sessions are native — there is no --harness flag yet, so the cursor
+ * default is deliberately not consulted). Any failure — network, auth, a
+ * backend without IdentityAccount — resolves to "" and the run proceeds
+ * exactly as an unfilled --model does today: a missing preference must
+ * never fail a run.
+ */
+async function resolveModelFromAccountPreference(client: Stigmer): Promise<string> {
+  try {
+    const account = await client.identityAccount.whoAmI();
+    return account.spec?.preferences?.defaultNativeModel ?? "";
+  } catch {
+    return "";
+  }
+}
+
 /**
  * Parse the `--approve-default` flag to an ApprovalAction. Empty means "no
  * default" (UNSPECIFIED). Mirrors Go's approval.ParseAction, including the
@@ -162,3 +212,18 @@ export function validateServiceTier(tier: string): asserts tier is ServiceTierFl
     );
   }
 }
+
+/**
+ * Validate the `--thinking` flag, the tier check's twin (#772). Empty means
+ * "platform default" (which resolves to disabled — never the provider
+ * account default). The server refuses enabled on models without the
+ * registry thinking capability; this check only catches spelling errors
+ * before a network round trip.
+ */
+export function validateThinking(mode: string): asserts mode is ThinkingFlag {
+  if (mode !== "" && mode !== "disabled" && mode !== "enabled") {
+    throw new UsageError(
+      `invalid --thinking value "${mode}": must be "disabled" or "enabled"`,
+    );
+  }
+}