@stigmer/cli 3.12.3 → 3.12.5

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/list.ts

@@ -1,12 +1,14 @@
 // `list` dispatch: render a collection of resources for a kind.
 //
-// Most registry kinds are search-indexed and list through the unified
-// SearchService. Kinds that are deliberately not search-indexed
-// (organizations, API keys, agent instances, agent channels, channel apps,
-// schedules) use their dedicated find/list RPCs with bespoke table shapes,
-// registered in LIST_HANDLERS — the same map-dispatch shape as the get,
-// delete, and apply registries, so the conformance test in
-// registry/registry.test.ts can hold all four to the verb matrix.
+// Most registry kinds list through the unified SearchService. The rest take
+// dedicated find/list RPCs with bespoke table shapes, registered in
+// LIST_HANDLERS — either because the kind is not search-indexed (API keys,
+// agent channels, channel apps, schedules) or because the dedicated RPC is
+// the better list surface than the kind's search index (organizations are
+// caller-scoped; agent instances and sessions carry columns search results
+// don't have). Same map-dispatch shape as the get, delete, and apply
+// registries, so the conformance test in registry/registry.test.ts can hold
+// all four to the verb matrix.
 //
 // Handlers FETCH, the dispatcher RENDERS: every handler returns entries plus
 // its schema/table pair, and listResources alone applies --limit and renders.
@@ -23,6 +25,8 @@ import { ChannelAppSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/
 import { ListChannelAppsByOrgInputSchema } from "@stigmer/protos/ai/stigmer/agentic/channelapp/v1/io_pb";
 import { ScheduleSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/api_pb";
 import { ListSchedulesRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/schedule/v1/io_pb";
+import { SessionSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
+import { ListSessionsRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/io_pb";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
 import { PageInfoSchema } from "@stigmer/protos/ai/stigmer/commons/rpc/pagination_pb";
 import { ApiKeySchema } from "@stigmer/protos/ai/stigmer/iam/apikey/v1/api_pb";
@@ -37,8 +41,8 @@ import { bool, type JsonObject, obj, renderCollection, str, type TableShape } fr
 // scope). Must stay in step with the server's SearchableKinds allowlist
 // (backend/services/stigmer-server/pkg/query/search/valueobject/
 // search_criteria.go): a kind present here but absent there silently lists
-// as empty. The LIST_HANDLERS kinds are deliberately NOT here — they are
-// not_search_indexed by design and take dedicated-RPC handlers below.
+// as empty. The LIST_HANDLERS kinds are deliberately NOT here — see the
+// header: not search-indexed, or better served by their dedicated RPC.
 export const SEARCH_KINDS: ReadonlySet<ApiResourceKind> = new Set<ApiResourceKind>([
   ApiResourceKind.agent,
   ApiResourceKind.workflow,
@@ -129,6 +133,19 @@ export const LIST_HANDLERS: ReadonlyMap<ApiResourceKind, ListFn> = new Map<ApiRe
       return { schema: ScheduleSchema, entries: result.items, table: SCHEDULE_TABLE };
     },
   ],
+  [
+    ApiResourceKind.session,
+    async (client, _org, limit) => {
+      // Sessions ARE search-indexed, but list deliberately uses the dedicated
+      // RPC: the table's columns (agent instance, subject) don't exist on
+      // SearchResult rows, and the RPC is caller-scoped like organization and
+      // api_key above — the agent_instance precedent, not an oversight.
+      // Promoted from a bespoke pre-gate route in commands/list.ts by
+      // stigmer/stigmer#469 (it had shipped working-but-unadvertised).
+      const result = await client.session.list(create(ListSessionsRequestSchema, { pageSize: limit }));
+      return { schema: SessionSchema, entries: result.entries, table: SESSION_TABLE };
+    },
+  ],
 ]);
 
 export async function listResources(
@@ -177,6 +194,20 @@ export const SEARCH_TABLE: TableShape = {
   ],
 };
 
+// A session's identity for follow-up commands is its ID (`stigmer session
+// resume <id>`), so the ID leads; agent instance and subject are how a human
+// recognizes which conversation it was.
+const SESSION_TABLE: TableShape = {
+  resourceName: "sessions",
+  headers: ["SESSION ID", "AGENT", "SUBJECT", "CREATED"],
+  row: (json) => [
+    str(obj(json, "metadata"), "id"),
+    str(obj(json, "spec"), "agent_instance_id") || "-",
+    truncate(str(obj(json, "spec"), "subject") || "-", 50),
+    date(str(obj(json, "metadata"), "created_at")),
+  ],
+};
+
 const INSTANCE_TABLE: TableShape = {
   resourceName: "agent instances",
   headers: ["ID", "SLUG", "AGENT", "DESCRIPTION"],

package/src/resources/read-completion.integration.test.ts

@@ -25,9 +25,9 @@ import type { AddressInfo } from "node:net";
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 import { classify, ExitCode } from "../errors/index.js";
 import { getExecution, listAgentExecutions, renderExecutionList } from "./execution.js";
+import { listResources } from "./list.js";
 import { renderResource } from "./render.js";
 import { searchResources } from "./search.js";
-import { listSessions, renderSessionList } from "./session.js";
 import { getSessionUsageReport, renderSessionUsage } from "./usage.js";
 
 const knownExec = create(AgentExecutionSchema, {
@@ -141,10 +141,20 @@ describe("execution integration", () => {
   });
 });
 
+// Session list runs through the same registry dispatch as every other kind
+// (LIST_HANDLERS; promoted from a bespoke route by stigmer/stigmer#469).
 describe("session integration", () => {
-  it("lists sessions as a human table", async () => {
-    const result = await listSessions(client, 50);
-    expect(renderSessionList(result, "table")).toContain("ses_1");
+  it("lists sessions through the registry dispatch as a human table", async () => {
+    const rendered = await listResources(client, ApiResourceKind.session, "", 50, "table");
+    expect(rendered).toContain("SESSION ID");
+    expect(rendered).toContain("ses_1");
+    expect(rendered).toContain("Fix the build");
+  });
+
+  it("renders session list json as the entries array every list kind shares", async () => {
+    const rendered = await listResources(client, ApiResourceKind.session, "", 50, "json");
+    const json = JSON.parse(rendered);
+    expect(json).toEqual([toJson(SessionSchema, knownSession, { useProtoFieldName: true })]);
   });
 });
 

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

@@ -70,6 +70,27 @@ const BASE_FLAGS: AgentExecFlags = {
 // 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 +124,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

@@ -65,6 +65,18 @@ export interface PreparedRun {
   readonly serviceTier: ServiceTierFlag;
 }
 
+/** 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;
+}
+
 /**
  * Validate flags and resolve all execution inputs. The `org` is used to inject
  * STIGMER_ORG_ID and the `client` to upload non-workspace attachments.
@@ -74,11 +86,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);
 
+  // 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);
 
   const runtimeEnv = loadAndMergeEnv({
@@ -107,13 +130,30 @@ 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,
   };
 }
 
+/**
+ * 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

package/src/resources/session.ts

@@ -1,17 +1,15 @@
-// `list sessions` support. Sessions, like executions, are runtime resources that
-// bypass the resource registry: there is no `get`/`create`/`delete session` in
-// the unified verbs, only a list. This module owns the alias predicate and the
-// list fetch so the command layer stays declarative.
+// Read helpers for the dedicated `stigmer session` command surface (resume
+// and friends). Session LIST is a first-class registry verb served by
+// LIST_HANDLERS in resources/list.ts — stigmer/stigmer#469 promoted it there
+// from a bespoke pre-gate route in commands/list.ts. get/delete stay
+// deliberately unpromised in the verb matrix (stigmer/stigmer#354);
+// resume-style flows read sessions through these helpers instead.
 
 import { create } from "@bufbuild/protobuf";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import { ListAgentExecutionsBySessionRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/io_pb";
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
-import { ListSessionsRequestSchema, SessionListSchema } from "@stigmer/protos/ai/stigmer/agentic/session/v1/io_pb";
 import type { Stigmer } from "@stigmer/sdk";
-import type { OutputFormat } from "../output/index.js";
-import type { ResourceResult } from "./get-bindings.js";
-import { obj, renderListMessage, str, type TableShape } from "./render.js";
 
 // Mirrors Go's execution.MaxPageSize — fetch the whole session history in one
 // call (sessions don't accumulate enough executions to need pagination here).
@@ -33,34 +31,3 @@ export async function listExecutionsBySession(client: Stigmer, sessionId: string
   return list.entries;
 }
 
-/** True for the `session`/`sessions` type-alias family. */
-export function isSessionAlias(type: string): boolean {
-  const normalized = type.trim().toLowerCase();
-  return normalized === "session" || normalized === "sessions";
-}
-
-/** List sessions for the current context, paginated by `limit`. */
-export async function listSessions(client: Stigmer, limit: number): Promise<ResourceResult> {
-  const message = await client.session.list(create(ListSessionsRequestSchema, { pageSize: limit }));
-  return { schema: SessionListSchema, message };
-}
-
-const SESSION_TABLE: TableShape = {
-  resourceName: "sessions",
-  headers: ["SESSION ID", "AGENT", "SUBJECT", "CREATED"],
-  row: (json) => [
-    str(obj(json, "metadata"), "id"),
-    dash(str(obj(json, "spec"), "agent_instance_id")),
-    dash(str(obj(json, "spec"), "subject")),
-    dash(str(obj(json, "metadata"), "created_at")),
-  ],
-};
-
-/** Render a session list (json/yaml = full envelope; table = grid). */
-export function renderSessionList(result: ResourceResult, format: OutputFormat): string {
-  return renderListMessage(result.schema, result.message, format, SESSION_TABLE);
-}
-
-function dash(value: string): string {
-  return value === "" ? "-" : value;
-}

package/src/resources/skill.test.ts

@@ -4,9 +4,6 @@
 import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { create } from "@bufbuild/protobuf";
-import { Code, ConnectError } from "@connectrpc/connect";
-import { PushSkillRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/io_pb";
 import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
 import type { Stigmer } from "@stigmer/sdk";
 import { unzipSync, zipSync } from "fflate";
@@ -19,7 +16,6 @@ import {
   hasSkillFile,
   parseSkillMetadata,
   parseVisibility,
-  pushRouted,
   pushSkill,
   pushSkillFromArchive,
   readSkillArchive,
@@ -354,76 +350,8 @@ describe("formatBytes / shortHash", () => {
   });
 });
 
-// ─── pushRouted — transfer-lane size routing (#675) ──────────────────────
-
-describe("pushRouted size routing", () => {
-  const INLINE_MAX = 10 * 1024 * 1024 - 64 * 1024;
-
-  function routingFakeClient(overrides: Record<string, any> = {}) {
-    const calls = { push: [] as any[], mint: [] as any[] };
-    const client = {
-      skill: {
-        async push(req: any) {
-          calls.push.push(req);
-          return { metadata: { id: "skill_x" } };
-        },
-        async createArtifactUploadUrl(req: any) {
-          calls.mint.push(req);
-          return { url: "http://localhost:7234/v1/skill-artifacts/uploads/sau_t", artifactUploadRef: "sau_t", ttlSeconds: 900 };
-        },
-        ...overrides,
-      },
-    } as any;
-    return { client, calls };
-  }
-
-  afterEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it("keeps small artifacts inline (no mint, bytes in the request)", async () => {
-    const { client, calls } = routingFakeClient();
-    const req = create(PushSkillRequestSchema, { org: "acme", artifact: new Uint8Array(1024) });
-
-    await pushRouted(client, req);
-
-    expect(calls.mint).toHaveLength(0);
-    expect(calls.push).toHaveLength(1);
-    expect(calls.push[0].artifact.length).toBe(1024);
-  });
-
-  it("stages large artifacts over HTTP and pushes by reference", async () => {
-    const { client, calls } = routingFakeClient();
-    const artifact = new Uint8Array(INLINE_MAX + 1);
-    const req = create(PushSkillRequestSchema, { org: "acme", artifact, tag: "stable", message: "big" });
-
-    let putBytes = 0;
-    vi.stubGlobal("fetch", vi.fn(async (_url: string, init: any) => {
-      putBytes = init.body.length;
-      return { ok: true } as any;
-    }));
-
-    await pushRouted(client, req);
-
-    expect(calls.mint).toHaveLength(1);
-    expect(calls.mint[0].sizeBytes).toBe(BigInt(artifact.length));
-    expect(putBytes).toBe(artifact.length);
-    expect(calls.push).toHaveLength(1);
-    expect(calls.push[0].artifact.length).toBe(0);
-    expect(calls.push[0].artifactUploadRef).toBe("sau_t");
-    // The rewrite must not lose the rest of the request.
-    expect(calls.push[0].tag).toBe("stable");
-    expect(calls.push[0].message).toBe("big");
-  });
-
-  it("fails loud against servers that predate the transfer lane", async () => {
-    const { client } = routingFakeClient({
-      async createArtifactUploadUrl() {
-        throw new ConnectError("unknown method", Code.Unimplemented);
-      },
-    });
-    const req = create(PushSkillRequestSchema, { org: "acme", artifact: new Uint8Array(INLINE_MAX + 1) });
-
-    await expect(pushRouted(client, req)).rejects.toThrow(/Upgrade stigmer-server/);
-  });
-});
+// The transfer-lane size routing moved down into the SDK (stigmer#701):
+// its pins live in sdk/typescript/src/__tests__/skill.test.ts, exercised
+// through the REAL generated client and error wrapping — the fake client
+// this file previously used threw raw ConnectError, which the SDK's
+// wrapError makes unreachable on the real path.