sim 2.1.5 → 2.1.6-dev.86.1

package/dist/index.js

@@ -2314,6 +2314,30 @@ function credentialsPath() {
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 
+// src/embed-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function setSoftExitCode(code) {
+  const ctx = embedStore.getStore();
+  if (ctx)
+    ctx.softExitCode = code;
+  else
+    process.exitCode = code;
+}
+var embedStore = new AsyncLocalStorage;
+function embeddedProfile() {
+  const ctx = embedStore.getStore();
+  if (!ctx)
+    return null;
+  return {
+    name: "embedded",
+    endpoint: ctx.identity.endpoint,
+    apiKey: ctx.identity.apiKey,
+    workspaceId: ctx.identity.workspaceId ?? null,
+    output: "json",
+    sources: { endpoint: "flag", apiKey: "flag", workspaceId: "flag", output: "flag" }
+  };
+}
+
 // src/config/ini.ts
 class ProfileConfigError extends Error {
   constructor(message) {
@@ -2629,6 +2653,9 @@ function refuseBlankOverrides(overrides) {
   }
 }
 function resolveProfile(overrides = {}) {
+  const embedded = embeddedProfile();
+  if (embedded)
+    return embedded;
   refuseBlankOverrides(overrides);
   const named = overrides.profile || process.env.SIM_PROFILE;
   const name = named || DEFAULT_PROFILE;
@@ -2681,14 +2708,22 @@ function resolveProfile(overrides = {}) {
 // src/version.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 function readPackageVersion() {
-  const metadata = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
-  if (typeof metadata !== "object" || metadata === null || !("version" in metadata) || typeof metadata.version !== "string") {
-    throw new Error("CLI package metadata is missing a valid version");
-  }
-  return metadata.version;
+  try {
+    const metadata = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
+    if (typeof metadata === "object" && metadata !== null && "version" in metadata && typeof metadata.version === "string") {
+      return metadata.version;
+    }
+  } catch {}
+  return "0.0.0-embedded";
+}
+var cachedVersion = null;
+function cliVersion() {
+  cachedVersion ??= readPackageVersion();
+  return cachedVersion;
+}
+function userAgent() {
+  return `sim-cli/${cliVersion()} node/${process.versions.node} (${process.platform}; ${process.arch})`;
 }
-var CLI_VERSION = readPackageVersion();
-var USER_AGENT = `sim-cli/${CLI_VERSION} node/${process.versions.node} (${process.platform}; ${process.arch})`;
 
 // src/http/environment.ts
 var reported = new Set;
@@ -2971,7 +3006,7 @@ class SimClient {
         headers: {
           ...apiKey ? { "x-api-key": apiKey } : {},
           accept: "application/json",
-          "user-agent": USER_AGENT,
+          "user-agent": userAgent(),
           ...hasBody ? { "content-type": "application/json" } : {},
           ...options.headers
         },
@@ -6470,7 +6505,7 @@ async function pollForKey(endpoint, auth, signal) {
         headers: {
           "content-type": "application/json",
           accept: "application/json",
-          "user-agent": USER_AGENT
+          "user-agent": userAgent()
         },
         body: JSON.stringify({ request: auth.request, verifier: auth.pollSecret }),
         signal,
@@ -6631,8 +6666,8 @@ var V2_OPERATIONS = {
       },
       outputColumns: {
         kind: "array",
-        required: true,
-        describe: "Columns created for producer outputs."
+        default: [],
+        describe: "Columns to create for producer outputs. An entry naming a column the table already has attaches that column to the group instead of creating it (its `type` must match), and an output whose column already exists may omit its entry entirely — so `[]` attaches existing columns only."
       },
       autoRun: {
         kind: "boolean",
@@ -6936,7 +6971,7 @@ var V2_OPERATIONS = {
       rowId: { kind: "string", describe: "Row whose runs should be canceled for row scope." },
       filter: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       excludeRowIds: { kind: "array", describe: "Rows excluded from an all-scope cancellation." }
     }
@@ -6967,6 +7002,11 @@ var V2_OPERATIONS = {
       conversationId: {
         kind: "string",
         describe: "Conversation to continue; a new one starts when omitted."
+      },
+      effort: {
+        kind: "enum",
+        values: ["low", "medium", "high", "xhigh", "max"],
+        describe: "Model effort for this turn; defaults to the deployment default (high)."
       }
     }
   },
@@ -7495,7 +7535,7 @@ var V2_OPERATIONS = {
       description: { kind: "string", describe: "Optional credential description." },
       id: {
         kind: "string",
-        describe: "Required only when provider discovery requests a client-generated ID."
+        describe: "Optional client-generated credential ID. The server mints one when it is omitted, so no provider requires it. A `slack-custom-bot` credential may supply one so its Slack Request URL, which embeds the ID, can be configured before the credential exists; every other provider ignores it."
       },
       credentials: {
         kind: "string",
@@ -7571,7 +7611,7 @@ var V2_OPERATIONS = {
       rowIds: { kind: "array", describe: "Explicit row subset to run." },
       filter: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       excludeRowIds: { kind: "array", describe: "Rows excluded from a select-all run scope." },
       limit: { kind: "object", describe: "Optional cap on eligible rows to run." }
@@ -8093,7 +8133,7 @@ var V2_OPERATIONS = {
       workspaceId: { kind: "string", required: true, describe: "Unique workspace identifier." },
       filter: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       limit: { kind: "integer", describe: "Maximum matching rows to delete." },
       rowIds: { kind: "array", describe: "Explicit row identifiers to delete." }
@@ -8263,37 +8303,6 @@ var V2_OPERATIONS = {
       }
     }
   },
-  executeTool: {
-    method: "POST",
-    path: "/api/v2/tools/[toolId]/execute",
-    pathParams: ["toolId"],
-    pathParamDocs: {
-      toolId: "Tool identifier. An unversioned name resolves to the newest version, and the response echoes the resolved id."
-    },
-    responseMode: "json",
-    summary: "Run Tool",
-    personalKeyOnly: true,
-    body: {
-      workspaceId: {
-        kind: "string",
-        required: true,
-        describe: "Workspace whose integration allowlist, credentials, and environment variables govern this call."
-      },
-      input: {
-        kind: "object",
-        default: {},
-        describe: "Arguments for the tool, keyed by the parameter ids the tool catalog publishes for it. A parameter whose visibility is `user-only` also accepts an environment-variable reference written as the whole value, `{{VAR_NAME}}`, resolved server-side against the workspace environment; any other value is sent verbatim."
-      },
-      credentialId: {
-        kind: "string",
-        describe: "Credential to authenticate with. Required when the tool declares an OAuth requirement; the workspace credentials list names the candidates."
-      },
-      timeoutSeconds: {
-        kind: "integer",
-        describe: "How long to wait for the tool before abandoning the call."
-      }
-    }
-  },
   executeWorkflow: {
     method: "POST",
     path: "/api/v2/workflows/[workflowId]/execute",
@@ -8326,7 +8335,7 @@ var V2_OPERATIONS = {
       },
       selectedOutputs: {
         kind: "array",
-        describe: "Block output references to include in a streamed response. Use `<blockName>.<outputPath>` for the executed workflow or `<childWorkflowId>.<blockName>.<outputPath>` for a child workflow; block names are normalized workflow reference names. Selecting a child workflow applies to every invocation of it. Requires `stream: true` — it shapes the streamed envelope only, so it is rejected on a sync request and when `async` is true. To narrow a finished run, pass `selectedOutputs` to the run resource instead."
+        describe: "Block output references to include in the response. Use `<blockName>.<outputPath>` for the executed workflow or `<childWorkflowId>.<blockName>.<outputPath>` for a child workflow; block names are normalized workflow reference names, and selecting a child workflow applies to every invocation of it. On a sync request the named outputs come back in `blockOutputs`, keyed by these selector strings exactly as sent; on a stream they shape the streamed envelope. A selector whose block name or id matches no block in the workflow is rejected with `400` naming the available blocks, before the run starts. A selector whose block did not run or whose path is absent is omitted. Rejected when `async` is true — a queued run has produced nothing to select; narrow the finished run via the run resource instead."
       },
       includeThinking: {
         kind: "boolean",
@@ -8364,7 +8373,13 @@ var V2_OPERATIONS = {
     pathParams: ["workflowId"],
     pathParamDocs: { workflowId: "Unique workflow identifier." },
     responseMode: "json",
-    summary: "Export Workflow"
+    summary: "Export Workflow",
+    query: {
+      includeWorkspaceBindings: {
+        kind: "boolean",
+        describe: "Whether to keep workspace-scoped bindings — table, knowledge base, document, folder, channel, and other resource selectors — in the exported state. Defaults to false, the sharing-safe export in which those ids are cleared because they resolve nowhere else. Send true for a same-workspace round trip so the re-imported workflow can run without re-selecting them. Credentials, passwords, and table sub-block values are cleared either way."
+      }
+    }
   },
   getAuditLog: {
     method: "GET",
@@ -8585,6 +8600,10 @@ var V2_OPERATIONS = {
         values: ["info", "error"],
         describe: "Severity level to include."
       },
+      includeHandledErrors: {
+        kind: "boolean",
+        describe: "Whether runs with a handled block error are counted as `handledErrorRuns`, and whether `level=error` also selects them. Off by default: counting them scans each run’s stored trace."
+      },
       startDate: {
         kind: "string",
         describe: "Only include runs started at or after this UTC ISO 8601 timestamp, e.g. `2026-08-06T00:00:00Z`. A date without a time, or a timestamp carrying a UTC offset instead of `Z`, is rejected, as is year `0000`, which names no storable instant."
@@ -8596,7 +8615,26 @@ var V2_OPERATIONS = {
       segmentCount: {
         kind: "integer",
         default: 72,
-        describe: "Number of equal time buckets to divide the window into, from 1 to 500. Exactly this many buckets are always returned. Buckets are never narrower than one minute, so on a short window the series extends past the end of the window rather than being compressed, and the trailing buckets are empty."
+        describe: "Number of equal time buckets to divide the window into, from 1 to 500. It is the ceiling on how many buckets a series carries: with `includeEmpty=true` exactly this many are returned, otherwise only the buckets holding at least one run. Buckets are never narrower than one minute, so on a short window the series extends past the end of the window rather than being compressed, and the trailing buckets are empty."
+      },
+      includeEmpty: {
+        kind: "enum",
+        values: [
+          "true",
+          "1",
+          "yes",
+          "on",
+          "y",
+          "enabled",
+          "false",
+          "0",
+          "no",
+          "off",
+          "n",
+          "disabled"
+        ],
+        default: false,
+        describe: "Whether buckets with no runs are included in every series. Off by default, so each series carries only the buckets that hold at least one run; set it to publish exactly `segmentCount` buckets per series, empty ones included. The listed spellings are the whole accepted vocabulary and are case-sensitive; any other value is rejected."
       }
     }
   },
@@ -8654,7 +8692,7 @@ var V2_OPERATIONS = {
       groupId: "Workflow or enrichment group to run."
     },
     responseMode: "json",
-    summary: "Get Enrichment Run Detail",
+    summary: "Get Row Group Run",
     query: {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
     }
@@ -8978,8 +9016,7 @@ var V2_OPERATIONS = {
           "knowledge-base",
           "voice-input",
           "enrichment",
-          "voice-output",
-          "api-tool"
+          "voice-output"
         ],
         describe: "Restrict results to one usage source."
       },
@@ -9043,6 +9080,10 @@ var V2_OPERATIONS = {
         values: ["builtin", "custom"],
         describe: "Restrict to shipped blocks or to this workspace’s deployed custom blocks."
       },
+      includeSunset: {
+        kind: "boolean",
+        describe: "Include `legacy` and `deprecated` blocks. Off by default: a sunset block keeps executing where it is already placed, but it is not offered for new authoring. Each returned entry carries `sunset.replacedBy`, the block to build with instead."
+      },
       sortBy: {
         kind: "enum",
         values: ["id", "name", "category"],
@@ -9118,6 +9159,21 @@ var V2_OPERATIONS = {
       search: {
         kind: "string",
         describe: "Case-insensitive substring match against the connector name."
+      },
+      detail: {
+        kind: "enum",
+        values: ["summary", "full"],
+        default: "summary",
+        describe: "Projection of each item. `summary` (the default) carries the identifier, name, description, and auth mode; `full` adds the version, the complete auth settings, the `sourceConfig` field schema, incremental-sync support, and tag definitions."
+      },
+      limit: {
+        kind: "integer",
+        default: 25,
+        describe: "Maximum connector types to return per page. Must be a whole number from 1 to 100. Defaults to 25."
+      },
+      cursor: {
+        kind: "string",
+        describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
       }
     }
   },
@@ -9697,6 +9753,10 @@ var V2_OPERATIONS = {
         kind: "string",
         describe: "Opaque cursor from the previous page. Send it back with the same sort and filters; only `limit` may change. Change anything else and pagination must restart without a cursor."
       },
+      includeHandledErrors: {
+        kind: "boolean",
+        describe: "Whether `level=error` also selects runs that finished at `info` after a block error was recovered by an error path. Off by default: such a run succeeded, so it is an error only to a caller auditing error handling. Every row reports `hasHandledErrors` whether or not this is set. Job runs carry no block trace, so the flag never widens that branch."
+      },
       status: {
         kind: "string",
         describe: "Comma-separated execution statuses to include, from `pending` | `running` | `paused` | `redacting` | `completed` | `failed` | `cancelled`. An empty entry is rejected. ANDed with `level`, which reports severity rather than lifecycle."
@@ -9907,7 +9967,7 @@ var V2_OPERATIONS = {
     pathParams: ["tableId"],
     pathParamDocs: { tableId: "Unique table identifier." },
     responseMode: "json",
-    summary: "List Active Run Dispatches",
+    summary: "List Run Dispatches",
     query: {
       workspaceId: { kind: "string", required: true, describe: "Workspace that owns the table." }
     }
@@ -10319,8 +10379,8 @@ var V2_OPERATIONS = {
       },
       limit: {
         kind: "integer",
-        default: 50,
-        describe: "Maximum workspaces to return per page. Must be a whole number from 1 to 100. Defaults to 50."
+        default: 25,
+        describe: "Maximum workspaces to return per page. Must be a whole number from 1 to 100. Defaults to 25."
       },
       cursor: {
         kind: "string",
@@ -10432,7 +10492,9 @@ var V2_OPERATIONS = {
     method: "GET",
     path: "/api/v2/files/[fileId]/text",
     pathParams: ["fileId"],
-    pathParamDocs: { fileId: "File identifier." },
+    pathParamDocs: {
+      fileId: "File identifier, or the file’s VFS path: `files/<folder>/<name>`, or `uploads/<name>` for a Chat upload."
+    },
     responseMode: "json",
     summary: "Read File Text",
     query: {
@@ -10455,7 +10517,7 @@ var V2_OPERATIONS = {
       destinationPath: {
         kind: "string",
         required: true,
-        describe: "New full path for the folder and its descendants."
+        describe: "Where the folder lands, with `mv` semantics. A path naming an existing folder receives the source as a child under its current name; `/` moves it to the workspace root under its current name; any other path becomes the folder’s new full path (a rename, a relocation, or both)."
       }
     }
   },
@@ -10471,7 +10533,7 @@ var V2_OPERATIONS = {
       destinationPath: {
         kind: "string",
         required: true,
-        describe: "New full path for the folder and its descendants."
+        describe: "Where the folder lands, with `mv` semantics. A path naming an existing folder receives the source as a child under its current name; `/` moves it to the workspace root under its current name; any other path becomes the folder’s new full path (a rename, a relocation, or both)."
       }
     }
   },
@@ -10487,7 +10549,7 @@ var V2_OPERATIONS = {
       destinationPath: {
         kind: "string",
         required: true,
-        describe: "New full path for the folder and its descendants."
+        describe: "Where the folder lands, with `mv` semantics. A path naming an existing folder receives the source as a child under its current name; `/` moves it to the workspace root under its current name; any other path becomes the folder’s new full path (a rename, a relocation, or both)."
       }
     }
   },
@@ -10503,7 +10565,7 @@ var V2_OPERATIONS = {
       destinationPath: {
         kind: "string",
         required: true,
-        describe: "New full path for the folder and its descendants."
+        describe: "Where the folder lands, with `mv` semantics. A path naming an existing folder receives the source as a child under its current name; `/` moves it to the workspace root under its current name; any other path becomes the folder’s new full path (a rename, a relocation, or both)."
       }
     }
   },
@@ -10833,7 +10895,7 @@ var V2_OPERATIONS = {
       q: { kind: "string", required: true, describe: "Case-insensitive cell substring to find." },
       predicate: {
         kind: "unknown",
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       sort: { kind: "array", describe: "Ordered table-row sort specification." }
     }
@@ -11275,7 +11337,7 @@ var V2_OPERATIONS = {
       filter: {
         kind: "unknown",
         required: true,
-        describe: 'Recursive predicate tree. Each group node is exactly one non-empty `all` or `any` array whose members are further groups or `{ field, op, value }` conditions; the root must be a group, not a bare condition. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
+        describe: 'A single `{ field, op, value }` condition or a recursive `all`/`any` group; either form is normalized to a grouped predicate after validation. At most 100 members per group, 10 levels of nesting, and 500 nodes in total. The negating operators include nulls: `ne`, `nin`, `ncontains`, `nlike`, and `nilike` match rows whose column is null or absent, so "not X" is not the complement of "X" over a nullable column. That holds for every column type, multi-select included. To exclude nulls, `all`-combine the negation with `isNotEmpty` (multi-select) or `isNotNull`. Comparison: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`. Membership: `in`, `nin` (array operand). Emptiness: `isEmpty`, `isNotEmpty`, `isNull`, `isNotNull` (no operand). Substring, always case-insensitive, operand matched literally: `contains`, `ncontains`, `startsWith`, `endsWith`. Pattern: `like`/`nlike` (case-sensitive), `ilike`/`nilike` (case-insensitive). **`*` is the only wildcard** and stands for any run of characters; `%`, `_`, and backslash match themselves. Use `like: "Hi*"`, not `like: "Hi%"`. A `select` column compares by option id and restricts its operators: single-select accepts `eq`, `ne`, `in`, `nin`; multi-select accepts `contains`, `ncontains`. Option names are accepted as operands and resolved to ids.'
       },
       data: {
         kind: "object",
@@ -11859,7 +11921,7 @@ function whoamiCommand() {
     });
     const exitCode = WHOAMI_EXIT_CODES[verification.status];
     if (exitCode !== 0)
-      process.exitCode = exitCode;
+      setSoftExitCode(exitCode);
   });
 }
 var PROFILE_COLUMNS = [
@@ -12228,7 +12290,7 @@ var CLI_CONTRACT = {
   },
   deleteTableView: { confirm: "This deletes the saved view and its filters." },
   deleteWorkflowGroup: {
-    confirm: "This deletes the group, every column it fed, and the values in them.",
+    confirm: "This deletes the group AND its output columns with all of their row data; the workflow it pointed at is untouched.",
     fields: [
       { header: "id" },
       { header: "deleted", format: "bool" },
@@ -12348,7 +12410,7 @@ var CLI_CONTRACT = {
   },
   applyWorkflowOperations: {
     command: "workflows operations apply",
-    confirm: "This edits the draft graph, and a delete operation removes blocks and their edges.",
+    confirm: "This edits the draft graph: the batch adds, edits, or deletes blocks and their edges as written.",
     flags: {
       operations: { json: true, describe: WORKFLOW_OPERATIONS_HELP },
       setBlockEnabled: { json: true, describe: WORKFLOW_SET_BLOCK_ENABLED_HELP }
@@ -13057,24 +13119,6 @@ var CLI_CONTRACT = {
     describe: "Print a workflow as a portable JSON document",
     document: true
   },
-  executeTool: {
-    command: "tools execute",
-    describe: "Run one built-in tool and print what it produced",
-    flags: {
-      input: {
-        json: true,
-        describe: "Tool arguments as JSON, keyed by the parameter ids `sim tools get <toolId>` lists"
-      },
-      credentialId: { describe: "Credential to authenticate with, required for OAuth tools" },
-      timeoutSeconds: { name: "timeout", describe: "Seconds to wait before abandoning the call" }
-    },
-    fields: [
-      { path: "toolId", header: "Tool" },
-      { path: "status", header: "Status" },
-      { path: "output", header: "Output" },
-      { path: "error.message", header: "Error" }
-    ]
-  },
   executeWorkflow: {
     command: "workflows run",
     describe: "Run a deployed workflow or execute saved state manually",
@@ -13088,7 +13132,7 @@ var CLI_CONTRACT = {
       selectedOutputs: {
         name: "select-output",
         list: true,
-        describe: "Return streamed outputs as blockName.path or childWorkflowId.blockName.path; selecting a child workflow applies to every invocation, requires --follow"
+        describe: "Return blockName.path values (e.g. agent_1.content), or childWorkflowId.blockName.path for a child workflow (applies to every invocation) — in blockOutputs on a sync run, or from the streamed result with --follow; missing paths are omitted. Not available with --async"
       },
       stream: { omit: true },
       includeThinking: { omit: true },
@@ -13112,7 +13156,7 @@ var CLI_CONTRACT = {
       selectedOutputs: {
         name: "select-output",
         list: true,
-        describe: "Include blockId or blockId.path values in JSON or YAML output; block names are not resolved on a finished run"
+        describe: "Include blockName.path or blockId.path values (e.g. agent_1.content) in JSON or YAML output; names resolve against the workflow’s current blocks, and missing paths are omitted"
       }
     },
     fields: [
@@ -13306,6 +13350,13 @@ function readArgumentSource(raw, flagName) {
     return { text: raw.slice(1), from: "" };
   if (!raw.startsWith("@"))
     return { text: raw, from: "" };
+  const embedded = embedStore.getStore();
+  if (embedded) {
+    const preloaded = embedded.fileArguments?.[raw.slice(1)];
+    if (preloaded !== undefined)
+      return { text: preloaded, from: " (read from your machine)" };
+    throw new SimApiError(`--${flagName}: no file "${raw.slice(1)}" on this machine — write it first (run_code), or pass the value inline`, 0);
+  }
   const path = raw.slice(1);
   if (path === "-") {
     if (process.stdin.isTTY) {
@@ -13961,7 +14012,7 @@ function renderResult(operation, format, raw, spec, options = {}, envelope) {
     printDocument(format, raw);
     return;
   }
-  const data = unwrapResource(raw);
+  const data = format === "json" || format === "yaml" ? raw : unwrapResource(raw);
   if (spec.itemsPath) {
     const items = at(data, spec.itemsPath);
     if (!Array.isArray(items)) {
@@ -13989,25 +14040,20 @@ function renderResult(operation, format, raw, spec, options = {}, envelope) {
 }
 
 // src/runtime/execute.ts
-var RUN_OUTCOME_OPERATIONS = {
-  executeWorkflow: {
-    failed: "The workflow run failed.",
-    cancelled: "The workflow run was cancelled."
-  },
-  executeTool: {
-    failed: "The tool call failed."
-  }
+var RUN_OUTCOME_OPERATIONS = new Set(["executeWorkflow"]);
+var FAILED_RUN_STATUS_MESSAGES = {
+  failed: "The workflow run failed.",
+  cancelled: "The workflow run was cancelled."
 };
 function runFailureMessage(operation, payload) {
-  const failureMessages = RUN_OUTCOME_OPERATIONS[operation];
-  if (!failureMessages)
+  if (!RUN_OUTCOME_OPERATIONS.has(operation))
     return null;
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
     return null;
   const { status, error } = payload;
   if (typeof status !== "string")
     return null;
-  const fallback = failureMessages[status];
+  const fallback = FAILED_RUN_STATUS_MESSAGES[status];
   if (!fallback)
     return null;
   const reported2 = error?.message;
@@ -14080,6 +14126,22 @@ function countOf(value) {
 function lengthOf(value) {
   return Array.isArray(value) ? value.length : 0;
 }
+var RESULT_NOTES = {
+  replaceWorkflowChatDeployment: (payload, body) => {
+    const authType = payload.authType ?? body?.authType ?? "public";
+    return authType === "public" ? "note: auth type is public — anyone with the link can chat; pass --auth-type password|email to restrict it." : null;
+  }
+};
+function writeResultNote(operation, payload, body) {
+  const note = RESULT_NOTES[operation];
+  if (!note)
+    return;
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const message = note(record, body);
+  if (message)
+    process.stderr.write(source_default.dim(`${message}
+`));
+}
 function bulkFailureMessage(operation, payload, body) {
   const check = BULK_OUTCOME_CHECKS[operation];
   if (!check)
@@ -14205,6 +14267,7 @@ async function executeOperation(operation, commandSpec, operationSpec, invocatio
   });
   const payload = result?.data ?? result;
   renderResult(operation, profile.output, payload, commandSpec, { expandedTrace: requestFlags.trace === true }, result);
+  writeResultNote(operation, payload, request.body);
   const failure = runFailureMessage(operation, payload) ?? bulkFailureMessage(operation, payload, request.body);
   if (failure)
     throw new SimApiError(failure, 0);
@@ -14975,6 +15038,18 @@ async function saveStagedFile(body, target, force) {
   }
 }
 async function saveToFile(body, target, force) {
+  const embedded = embedStore.getStore();
+  if (embedded) {
+    if (!embedded.writeFile) {
+      throw new SimApiError(`--output-file cannot save ${target} here: this surface has no machine to write to. Read the file instead, or pipe a text command with | to-sandbox <name>.`, 0);
+    }
+    const bytes2 = new Uint8Array(await new Response(body).arrayBuffer());
+    const written = await embedded.writeFile(target, bytes2);
+    if (!written) {
+      throw new SimApiError(`Could not write ${target} on your machine — the workbench is not running yet; run any run_code call first, then retry.`, 0);
+    }
+    return;
+  }
   return saveStagedFile(body, target, force);
 }
 async function streamToStdout(body, output = process.stdout) {
@@ -15046,6 +15121,16 @@ function attachFileGet(files) {
 import { constants } from "node:fs";
 import { access, stat } from "node:fs/promises";
 import { basename } from "node:path";
+function embeddedFileKey(path) {
+  return path.startsWith("@") ? path.slice(1) : path;
+}
+function embeddedFileContent(embedded, path) {
+  const key = embeddedFileKey(path);
+  const content = embedded.fileArguments?.[key];
+  if (content !== undefined)
+    return content;
+  throw new SimApiError(`Files on your machine are passed as @path: use @${key}. (If it does not exist yet, write it with run_code or | to-sandbox first.)`, 0);
+}
 var CONTENT_TYPES = {
   css: "text/css",
   csv: "text/csv",
@@ -15079,6 +15164,14 @@ function contentTypeFor(name) {
   return CONTENT_TYPES[extension] ?? "application/octet-stream";
 }
 async function localFile(path, override) {
+  const embedded = embedStore.getStore();
+  if (embedded) {
+    const content = embeddedFileContent(embedded, path);
+    const size2 = Buffer.byteLength(content);
+    if (size2 === 0)
+      throw new SimApiError(`${path} is empty`, 0);
+    return { name: override ?? basename(embeddedFileKey(path)), size: size2 };
+  }
   let size;
   try {
     const stats = await stat(path);
@@ -15141,7 +15234,8 @@ async function uploadParts(client, workspaceId, session, transfer, blob) {
 }
 async function finishUploadSession(client, workspaceId, session, path) {
   try {
-    const blob = await openAsBlob(path);
+    const embedded = embedStore.getStore();
+    const blob = embedded ? new Blob([embeddedFileContent(embedded, path)]) : await openAsBlob(path);
     if (session.transfer.method === "put") {
       await uploadPut(session.transfer, blob);
     } else {
@@ -15247,9 +15341,11 @@ function attachKnowledgeDocumentUpload(documents) {
     printProtocolResult(profile.output, {
       id: completed.document.id,
       knowledgeBaseId: completed.document.knowledgeBaseId,
-      name: completed.document.filename,
-      size: completed.document.fileSize,
-      status: completed.document.processingStatus
+      filename: completed.document.filename,
+      fileSize: completed.document.fileSize,
+      mimeType: completed.document.mimeType,
+      processingStatus: completed.document.processingStatus,
+      chunkCount: completed.document.chunkCount
     });
   });
 }
@@ -15766,14 +15862,11 @@ var AGENT_STREAM_PROTOCOL_HEADER = "x-sim-stream-protocol";
 var AGENT_STREAM_PROTOCOL_V1 = "agent-events-v1";
 var DONE_SENTINEL = "[DONE]";
 function resolveWorkflowRunSelection(flags) {
-  const manual = flags.manual === true;
   const trigger = typeof flags.trigger === "string" ? flags.trigger : undefined;
   const useMockPayload = flags.mockPayload === true;
+  const manual = flags.manual === true || trigger !== undefined || useMockPayload;
   const fromBlock = typeof flags.fromBlock === "string" ? flags.fromBlock : undefined;
   const sourceRun = typeof flags.sourceRun === "string" ? flags.sourceRun : undefined;
-  if ((trigger || useMockPayload) && !manual) {
-    throw new SimApiError("--trigger and --mock-payload require --manual", 0);
-  }
   if (fromBlock && (trigger || useMockPayload)) {
     throw new SimApiError("--from-block cannot be combined with --trigger or --mock-payload", 0);
   }
@@ -15980,8 +16073,8 @@ function followOrDelegate(previous) {
       command.setOptionValue("run", selection);
     const flags = command.optsWithGlobals();
     if (flags.follow !== true) {
-      if (Array.isArray(flags.selectOutput) && flags.selectOutput.length > 0) {
-        throw new SimApiError(flags.async === true ? "--select-output shapes a streamed result, and --async returns as soon as the run is queued, so there is no stream to shape. Drop one of them, or read the finished run with: sim workflows runs get <runId> --workflow <workflowId> --select-output <blockId>[.path] — that resource matches block ids, not the block names --select-output takes here." : "--select-output shapes a streamed result; add --follow. To narrow a run that has already finished: sim workflows runs get <runId> --workflow <workflowId> --select-output <blockId>[.path] — that resource matches block ids, not the block names --select-output takes here.", 0);
+      if (Array.isArray(flags.selectOutput) && flags.selectOutput.length > 0 && flags.async === true) {
+        throw new SimApiError("--select-output names outputs of a completed run, and --async returns as soon as the run is queued. Drop one of them, or read the finished run with: sim workflows runs get <runId> --workflow <workflowId> --select-output <blockId>[.path] — that resource matches block ids, not the block names --select-output takes here.", 0);
       }
       if (flags.includeThinking === true || flags.includeToolCalls === true) {
         throw new SimApiError("--include-thinking and --include-tool-calls describe a stream; add --follow", 0);
@@ -16003,7 +16096,119 @@ function attachWorkflowRunFollow(workflows) {
   }
   const held = run._actionHandler;
   const previous = typeof held === "function" ? held : null;
-  run.option("--manual", "Run the current saved workflow state instead of the active deployment").option("--trigger <blockId>", "Enter a manual run through this runnable trigger (requires --manual)").option("--mock-payload", "Use the selected trigger's server-derived mock payload (requires --manual)").option("--from-block <blockId>", "Run manually from this saved workflow block").option("--source-run <runId>", "Prior run whose persisted state supplies upstream outputs (requires --from-block)").option("--follow", "Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns").option("--include-thinking", "Show model reasoning while following (requires --follow)").option("--include-tool-calls", "Show tool calls while following (requires --follow)").action(followOrDelegate(previous));
+  run.option("--manual", "Run the current saved workflow state instead of the active deployment").option("--trigger <blockId>", "Enter the run through this runnable trigger; runs the current saved workflow state (implies --manual)").option("--mock-payload", "Use the selected trigger's server-derived mock payload; runs the current saved workflow state (implies --manual)").option("--from-block <blockId>", "Run manually from this saved workflow block").option("--source-run <runId>", "Prior run whose persisted state supplies upstream outputs (requires --from-block)").option("--follow", "Stream the run as it happens; progress on stderr, result on stdout. The stream reports only success and output, so the result omits the run id and timings a non-streaming run returns").option("--include-thinking", "Show model reasoning while following (requires --follow)").option("--include-tool-calls", "Show tool calls while following (requires --follow)").action(followOrDelegate(previous));
+}
+
+// src/commands/protocol/workflow-run-get.ts
+var BLOCK_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SELECT_OUTPUT_FLAG = "select-output";
+function normalizeBlockName(name) {
+  return name.toLowerCase().replace(/\s+/g, "").replace(/\./g, "");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function loadWorkflowBlocks(client, workflowId) {
+  const operation = V2_OPERATIONS.getWorkflowState;
+  const raw = await client.request(resolvePath(operation.path, { workflowId }), {
+    method: operation.method
+  });
+  const state = isRecord2(raw) && isRecord2(raw.data) ? raw.data : raw;
+  const blocks = isRecord2(state) && isRecord2(state.blocks) ? Object.entries(state.blocks) : [];
+  return blocks.map(([key, block]) => ({
+    id: isRecord2(block) && typeof block.id === "string" ? block.id : key,
+    name: isRecord2(block) && typeof block.name === "string" ? block.name : ""
+  }));
+}
+function splitSelector(selector) {
+  const dot = selector.indexOf(".");
+  return dot === -1 ? { head: selector, path: "" } : { head: selector.slice(0, dot), path: selector.slice(dot) };
+}
+function isIdHeaded(selector) {
+  return BLOCK_ID.test(splitSelector(selector).head);
+}
+function resolveSelection(typed, blocks, workflowId) {
+  const resolved = [];
+  const typedBy = new Map;
+  const unresolved = [];
+  for (const selector of typed) {
+    const { head, path } = splitSelector(selector);
+    let blockId = head;
+    if (!BLOCK_ID.test(head)) {
+      const wanted = normalizeBlockName(head);
+      const matches = blocks.filter((block) => block.id === head || normalizeBlockName(block.name) === wanted);
+      if (matches.length === 0) {
+        unresolved.push(selector);
+        continue;
+      }
+      if (matches.length > 1) {
+        throw new SimApiError(`--${SELECT_OUTPUT_FLAG} ${selector} names ${matches.length} blocks (${matches.map((block) => block.id).join(", ")}); pass the block id instead`, 0);
+      }
+      blockId = matches[0].id;
+    }
+    const rewritten = `${blockId}${path}`;
+    resolved.push(rewritten);
+    if (!typedBy.has(rewritten))
+      typedBy.set(rewritten, selector);
+  }
+  if (unresolved.length > 0) {
+    const names = blocks.map((block) => block.name).filter((name) => name !== "");
+    throw new SimApiError(`--${SELECT_OUTPUT_FLAG} did not resolve to any block on this run: ${unresolved.join(", ")}. Pass a block id or its name — "blockId", "blockId.path", "blockName" or "blockName.path"; names match ignoring case, spaces and dots. Blocks on workflow ${workflowId}: ${names.length > 0 ? names.join(", ") : "none"}.`, 0);
+  }
+  return { resolved, typedBy };
+}
+function keyByTyped(payload, typedBy) {
+  if (!isRecord2(payload) || !isRecord2(payload.blockOutputs))
+    return payload;
+  const blockOutputs = {};
+  for (const [key, value] of Object.entries(payload.blockOutputs)) {
+    blockOutputs[typedBy.get(key) ?? key] = value;
+  }
+  return { ...payload, blockOutputs };
+}
+async function readRunByName(runId, typed, command) {
+  const flags = command.optsWithGlobals();
+  const { client, profile } = clientFrom(command);
+  const operation = V2_OPERATIONS.getWorkflowRun;
+  const spec = CLI_CONTRACT.getWorkflowRun ?? {};
+  buildRequest("getWorkflowRun", [runId], flags, profile.workspaceId);
+  const workflowId = String(flags.workflow);
+  const selection = resolveSelection(typed, await loadWorkflowBlocks(client, workflowId), workflowId);
+  const request = buildRequest("getWorkflowRun", [runId], { ...flags, selectOutput: selection.resolved }, profile.workspaceId);
+  let result;
+  try {
+    result = await client.request(request.path, {
+      method: operation.method,
+      headers: request.headers,
+      query: request.query,
+      body: request.body
+    });
+  } catch (error) {
+    throw retypeApiError(error, "getWorkflowRun", spec, operation);
+  }
+  renderResult("getWorkflowRun", profile.output, keyByTyped(result?.data ?? result, selection.typedBy), spec, {}, result);
+}
+function attachWorkflowRunGet(runs) {
+  const get = runs.commands.find((command) => command.name() === "get");
+  const held = get?._actionHandler;
+  if (!get || typeof held !== "function") {
+    throw new Error("workflows runs get must be registered before block names can be attached to it");
+  }
+  const previous = held;
+  get.action(async (runId, _options, command) => {
+    const raw = command.optsWithGlobals().selectOutput;
+    if (raw === undefined) {
+      await previous(command.processedArgs);
+      return;
+    }
+    const typed = readListValues(raw, SELECT_OUTPUT_FLAG);
+    command.setOptionValue("selectOutput", typed);
+    if (typed.every(isIdHeaded)) {
+      await previous(command.processedArgs);
+      return;
+    }
+    await readRunByName(runId, typed, command);
+  });
 }
 
 // src/commands/protocol/workflow-run-wait.ts
@@ -16020,18 +16225,21 @@ var MAX_POLL_DELAY_MS = 15000;
 var POLL_BACKOFF_FACTOR = 2;
 var DEFAULT_WAIT_TIMEOUT_SECONDS = 3600;
 var WAIT_TIMEOUT_FLAG = "--wait-timeout <seconds>";
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString(value) {
   return typeof value === "string" && value !== "" ? value : null;
 }
+function runData(raw) {
+  return isRecord3(raw) && isRecord3(raw.data) ? raw.data : raw;
+}
 function readRun(raw) {
-  const run = isRecord2(raw) && isRecord2(raw.data) ? raw.data : raw;
-  if (!isRecord2(run) || typeof run.status !== "string") {
+  const run = isRecord3(raw) && isRecord3(raw.data) ? raw.data : raw;
+  if (!isRecord3(run) || typeof run.status !== "string") {
     throw new SimApiError("Run status response carried no status.", 0);
   }
-  const paused = isRecord2(run.paused) ? run.paused : null;
+  const paused = isRecord3(run.paused) ? run.paused : null;
   return {
     status: run.status,
     pauseKind: paused ? optionalString(paused.pauseKind) : null,
@@ -16100,19 +16308,19 @@ function attachWorkflowRunWait(runs) {
         const outcome = classify(snapshot);
         if (outcome) {
           progress.finish();
-          renderResult("getWorkflowRun", profile.output, raw, runSpec());
+          renderResult("getWorkflowRun", profile.output, runData(raw), runSpec());
           const message = explain(outcome, runId, options.workflow, snapshot);
           if (message)
             console.error(source_default.red(message));
-          process.exitCode = WAIT_EXIT_CODES[outcome];
+          setSoftExitCode(WAIT_EXIT_CODES[outcome]);
           return;
         }
         const remainingMs = deadline - Date.now();
         if (remainingMs <= 0) {
           progress.finish();
-          renderResult("getWorkflowRun", profile.output, raw, runSpec());
+          renderResult("getWorkflowRun", profile.output, runData(raw), runSpec());
           console.error(source_default.red(`Timed out after ${timeoutSeconds}s waiting for run ${runId} (status: ${snapshot.status}${snapshot.resumeAt ? `, resuming at ${snapshot.resumeAt}` : ""}). Raise ${WAIT_TIMEOUT_FLAG}, or set it to 0 to wait indefinitely.`));
-          process.exitCode = WAIT_EXIT_CODES.timeout;
+          setSoftExitCode(WAIT_EXIT_CODES.timeout);
           return;
         }
         progress.advance(snapshot.status, Date.now() - startedAt);
@@ -16168,7 +16376,9 @@ function attachProtocolCommands(program2) {
     createFolder: "createWorkflowFolder"
   });
   attachWorkflowRunFollow(workflows);
-  attachWorkflowRunWait(group(workflows, "runs"));
+  const runs = group(workflows, "runs");
+  attachWorkflowRunGet(runs);
+  attachWorkflowRunWait(runs);
   attachLogsFollow(group(program2, "logs"));
   attachChat(program2);
 }
@@ -16396,7 +16606,7 @@ function addVersionOption(program2) {
     }
     program2.error("error: --version reports the Sim CLI version and takes no value. A command that acts on a deployment version reads it from --to-version.");
   });
-  program2.version(CLI_VERSION, "-V, --version [none]", "output the version number (takes no value)");
+  program2.version(cliVersion(), "-V, --version [none]", "output the version number (takes no value)");
 }
 function buildProgram(options = {}) {
   const program2 = new Command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim",
-  "version": "2.1.5",
+  "version": "2.1.6-dev.86.1",
   "description": "Sim CLI - talk to the Sim API from your terminal",
   "type": "module",
   "bin": {
@@ -57,5 +57,11 @@
     "@types/node": "24.2.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.0"
+  },
+  "exports": {
+    "./embed": {
+      "types": "./src/embed.ts",
+      "default": "./src/embed.ts"
+    }
   }
 }