@trydreamstate/cli 1.2.0 → 1.3.0

package/dist/index.js

@@ -4,6 +4,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CliUsageError = exports.CLI_EXIT = void 0;
 exports.parseCliArgs = parseCliArgs;
 exports.toolTurnToken = toolTurnToken;
+exports.omitsToolTurnForInlineTableRead = omitsToolTurnForInlineTableRead;
+exports.capabilityIdempotencyKey = capabilityIdempotencyKey;
 exports.refusalEnvelope = refusalEnvelope;
 exports.openWebUrl = openWebUrl;
 exports.exitCodeForError = exitCodeForError;
@@ -14,9 +16,12 @@ const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const tableFilePreview_1 = require("./tableFilePreview");
 const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
 const node_util_1 = require("node:util");
 const config_1 = require("./config");
+const pluginInstaller_1 = require("./pluginInstaller");
 const turnCache_1 = require("./turnCache");
+const runWait_1 = require("./runWait");
 const client_1 = require("./client");
 const skillInstaller_1 = require("./skillInstaller");
 exports.CLI_EXIT = { SUCCESS: 0, UNCLASSIFIED: 1, USAGE: 2, AUTH: 3, NOT_FOUND: 4, SERVER: 5, RATE_LIMITED: 6, APPROVAL: 7, TIMEOUT: 8, REFUSED: 9, TRANSPORT: 10 };
@@ -26,13 +31,16 @@ const USAGE = `Dreamstate CLI
 Usage:
   dreamstate --help
   dreamstate --version
-  dreamstate login
-  dreamstate login --token <ds_user_...|ds_live_...>
+  dreamstate login [--no-skills]
+  dreamstate login [--profile <name>] --token <ds_user_...|ds_live_...> [--no-skills]
   dreamstate logout
+  dreamstate install [--agents <claude codex grok>] [--json-output|--json]
+  dreamstate status [--json-output|--json]
+  dreamstate profiles <list|use|current|remove|env> [name] [--json-output|--json]
   dreamstate whoami [--json-output|--json]
   dreamstate workspaces list [--json-output|--json]
   dreamstate workspaces use <id|slug>
-  dreamstate auth login [--api-key-file <path>]
+  dreamstate auth login [--api-key-file <path>] [--no-skills]
   dreamstate auth whoami [--json-output|--json]
   dreamstate packs list [--json-output|--json]
   dreamstate packs get <pack_id> [--json-output|--json]
@@ -45,18 +53,19 @@ Usage:
   dreamstate commands search <term> [--json-output|--json]
   dreamstate tools search --goal <goal> [--terms <csv>] [--limit <n>] [--toolset <pack_id>] [--json-output|--json]
   dreamstate tools get <capability_id> [--json-output|--json]
-  dreamstate tools run <capability_id> [--params <object>|--json <body>] [--turn-token <token>] (--live | --dry-run | --mode <smoke_test|dry_run|live>) [--agent-session-id <uuid>] [--approved] [--approved-effect-unknown] [--max-credits <n>] [--idempotency-key <key>] [--open] [--json-output|--json]
+  dreamstate tools run <capability_id> [--params <object>|--json <body>] [--turn-token <token>] (--live | --dry-run | --mode <smoke_test|dry_run|live>) [--agent-session-id <uuid>] [--approved] [--approved-effect-unknown] [--max-credits <n>] [--idempotency-key <key>] [--wait-timeout <seconds>] [--no-wait] [--open] [--json-output|--json]
   dreamstate sequences <verb> [args] [flags]
   dreamstate workflows <verb> [args] [flags]
   dreamstate tables import --table-id <uuid> --file <path> [--format <csv|json|jsonl|xlsx>] [--preview] [--upsert-key <header>] [--background] [--json-output|--json]
-  dreamstate runs list [--json <query>] [--json-output|--json]
+  dreamstate runs list [--limit <n>] [--cursor <cursor>] [--json <query>] [--json-output|--json]
   dreamstate runs get <run_id> [--json-output|--json]
   dreamstate runs resume <run_id> --state-version <n> [--reason <text>] [--idempotency-key <key>] [--open] [--json-output|--json]
   dreamstate runs events <run_id> [--json-output|--json]
-  dreamstate runs cancel <run_id> --json <body> [--idempotency-key <key>] [--json-output|--json]
+  dreamstate runs cancel <run_id> [--state-version <n>] [--reason <text>] [--json <body>] [--idempotency-key <key>] [--json-output|--json]
 
 All catalog discovery reads live API records. Set DREAMSTATE_API_URL and DREAMSTATE_API_KEY.
-login opens browser approval; login --token stores a ds_user_ session or ds_live_ key (for SSH or remote machines) after verifying it with whoami.
+Run responses wait for terminal run status by default, timeout default is 120 seconds, --no-wait returns immediate response. Timeout prints latest run envelope and exits ${runWait_1.RUN_WAIT_TIMEOUT_EXIT_CODE}.
+login opens browser approval and installs Dreamstate skills for detected agents; --no-skills skips installation. login --token stores a ds_user_ session or ds_live_ key (for SSH or remote machines) after verifying it with whoami.
 Global flag --workspace <id|slug> (any command) or DREAMSTATE_WORKSPACE picks the workspace for one call; workspaces use stores a default. Flag beats env beats stored. A ds_live_ key is bound to one workspace and cannot switch.
 logout deletes the stored credentials file. --agents takes space-separated, comma-separated or repeated values.
 `;
@@ -106,6 +115,22 @@ function nonNegativeInteger(raw, flag) {
         throw new CliUsageError(`${flag} must be a non-negative integer`);
     return value;
 }
+// runs.get returns { data: { run: { state_version } } }. Cancel posts
+// expected_state_version, and a missing read must not invent 0.
+function stateVersionFromRunRead(payload) {
+    const record = payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : null;
+    const data = record && record.data && typeof record.data === 'object' && !Array.isArray(record.data)
+        ? record.data
+        : null;
+    const run = data && data.run && typeof data.run === 'object' && !Array.isArray(data.run)
+        ? data.run
+        : null;
+    const version = run?.state_version;
+    if (typeof version !== 'number' || !Number.isSafeInteger(version) || version < 0) {
+        throw new client_1.CliError('runs cancel could not read state_version from the run. Pass --state-version <n>.', 'invalid_response', 0);
+    }
+    return version;
+}
 function parsePacks(argv) {
     const { values, positionals } = (0, node_util_1.parseArgs)({ args: argv, options: { goal: { type: 'string' }, 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
     if (values.help)
@@ -215,7 +240,7 @@ function parseTools(argv) {
             'idempotency-key': { type: 'string' }, 'json-output': { type: 'boolean' }, open: { type: 'boolean' },
             'dry-run': { type: 'boolean' }, live: { type: 'boolean' }, mode: { type: 'string' },
             'agent-session-id': { type: 'string' }, approved: { type: 'boolean' }, 'approved-effect-unknown': { type: 'boolean' },
-            'max-credits': { type: 'string' }, 'turn-token': { type: 'string' }, help: { type: 'boolean', short: 'h' },
+            'max-credits': { type: 'string' }, 'turn-token': { type: 'string' }, 'wait-timeout': { type: 'string' }, 'no-wait': { type: 'boolean' }, help: { type: 'boolean', short: 'h' },
         }, allowPositionals: true, strict: true });
     if (values.help)
         return { command: 'help' };
@@ -268,20 +293,21 @@ function parseTools(argv) {
         // run without one. What was missing was any way to ASK for live.
         if (body.mode !== undefined)
             requireToolsRunMode(body);
-        return { command: 'tools_run', capabilityId, body, ...(values['turn-token'] ? { turnToken: values['turn-token'] } : {}), ...(values['idempotency-key'] ? { idempotencyKey: values['idempotency-key'] } : {}), ...(values.open ? { open: true } : {}), ...output };
+        const waitTimeout = values['wait-timeout'] === undefined ? 120 : nonNegativeNumber(values['wait-timeout'], '--wait-timeout');
+        return { command: 'tools_run', capabilityId, body, waitTimeout, ...(values['no-wait'] ? { noWait: true } : {}), ...(values['turn-token'] ? { turnToken: values['turn-token'] } : {}), ...(values['idempotency-key'] ? { idempotencyKey: values['idempotency-key'] } : {}), ...(values.open ? { open: true } : {}), ...output };
     }
     throw new CliUsageError('Usage: dreamstate tools <search|get|run>');
 }
 function parseTables(argv) {
     const { values, positionals } = (0, node_util_1.parseArgs)({ args: argv, options: {
             'table-id': { type: 'string' }, file: { type: 'string' }, format: { type: 'string' }, background: { type: 'boolean' },
-            preview: { type: 'boolean' }, 'upsert-key': { type: 'string' },
+            preview: { type: 'boolean' }, 'upsert-key': { type: 'string' }, 'row-kind': { type: 'string' }, 'keep-unmapped-columns': { type: 'string' },
             'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' },
         }, allowPositionals: true, strict: true });
     if (values.help)
         return { command: 'help' };
     if (positionals.length !== 1 || positionals[0] !== 'import' || !values['table-id'] || !values.file) {
-        throw new CliUsageError('Usage: dreamstate tables import --table-id <uuid> --file <path> [--format <csv|json|jsonl|xlsx>] [--preview] [--upsert-key <header>] [--background]');
+        throw new CliUsageError('Usage: dreamstate tables import --table-id <uuid> --file <path> [--format <csv|json|jsonl|xlsx>] [--preview] [--upsert-key <header>] [--row-kind <person|company>] [--keep-unmapped-columns <true|false>] [--background]');
     }
     // --format is an override, not a requirement. Requiring it made the caller restate
     // what the file path already says, and an omitted flag produced a usage error rather
@@ -292,6 +318,14 @@ function parseTables(argv) {
         throw new CliUsageError('--format must be one of csv, json, jsonl, xlsx');
     }
     const upsertKey = values['upsert-key']?.trim();
+    const rowKind = values['row-kind'];
+    if (rowKind !== undefined && rowKind !== 'person' && rowKind !== 'company') {
+        throw new CliUsageError('--row-kind must be person or company');
+    }
+    const keepUnmappedColumns = values['keep-unmapped-columns'];
+    if (keepUnmappedColumns !== undefined && keepUnmappedColumns !== 'true' && keepUnmappedColumns !== 'false') {
+        throw new CliUsageError('--keep-unmapped-columns must be true or false');
+    }
     return {
         command: 'tables_import',
         tableId: values['table-id'],
@@ -299,17 +333,38 @@ function parseTables(argv) {
         ...(format ? { format: format } : {}),
         ...(values.preview ? { preview: true } : {}),
         ...(upsertKey ? { upsertKey } : {}),
+        ...(rowKind ? { rowKind } : {}),
+        ...(keepUnmappedColumns === 'false' ? { keepUnmappedColumns: false } : {}),
         background: Boolean(values.background),
         ...outputOption(values),
     };
 }
+function runsListLimit(raw) {
+    const value = nonNegativeInteger(raw, '--limit');
+    if (value < 1 || value > 500)
+        throw new CliUsageError('--limit must be an integer from 1 to 500');
+    return value;
+}
 function parseRuns(argv) {
-    const { values, positionals } = (0, node_util_1.parseArgs)({ args: argv, options: { json: { type: 'string' }, reason: { type: 'string' }, 'state-version': { type: 'string' }, 'idempotency-key': { type: 'string' }, open: { type: 'boolean' }, 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
+    const { values, positionals } = (0, node_util_1.parseArgs)({ args: argv, options: { json: { type: 'string' }, limit: { type: 'string' }, cursor: { type: 'string' }, reason: { type: 'string' }, 'state-version': { type: 'string' }, 'idempotency-key': { type: 'string' }, open: { type: 'boolean' }, 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
     if (values.help)
         return { command: 'help' };
     const output = outputOption(values);
-    if (positionals.length === 1 && positionals[0] === 'list')
-        return { command: 'runs_list', query: values.json ? parseJsonObject(values.json) : {}, ...output };
+    if (positionals.length === 1 && positionals[0] === 'list') {
+        const query = values.json ? parseJsonObject(values.json) : {};
+        if (values.limit !== undefined)
+            query.limit = runsListLimit(values.limit);
+        if (values.cursor !== undefined) {
+            const cursor = values.cursor.trim();
+            if (!cursor)
+                throw new CliUsageError('--cursor must be a non-empty string');
+            query.cursor = cursor;
+        }
+        return { command: 'runs_list', query, ...output };
+    }
+    if (values.limit !== undefined || values.cursor !== undefined) {
+        throw new CliUsageError('--limit and --cursor are only valid on runs list');
+    }
     const runId = requireOne(positionals, `dreamstate runs ${positionals[0] ?? '<get|events|cancel>'} <run_id>`);
     if (positionals[0] === 'get')
         return { command: 'runs_get', runId, ...output };
@@ -323,9 +378,20 @@ function parseRuns(argv) {
         return { command: 'runs_resume', runId, stateVersion: nonNegativeInteger(values['state-version'], '--state-version'), ...(values.reason ? { reason: values.reason } : {}), ...(values['idempotency-key'] ? { idempotencyKey: values['idempotency-key'] } : {}), ...(values.open ? { open: true } : {}), ...output };
     }
     if (positionals[0] === 'cancel') {
-        if (!values.json)
-            throw new CliUsageError('runs cancel requires --json <body>');
-        return { command: 'runs_cancel', runId, body: parseJsonObject(values.json), ...(values['idempotency-key'] ? { idempotencyKey: values['idempotency-key'] } : {}), ...output };
+        const idempotency = values['idempotency-key'] ? { idempotencyKey: values['idempotency-key'] } : {};
+        if (values.json && (values['state-version'] !== undefined || values.reason)) {
+            throw new CliUsageError('Use either --json <body> or --state-version and --reason with runs cancel, not both.');
+        }
+        if (values.json)
+            return { command: 'runs_cancel', runId, body: parseJsonObject(values.json), ...idempotency, ...output };
+        return {
+            command: 'runs_cancel',
+            runId,
+            ...(values['state-version'] !== undefined ? { stateVersion: nonNegativeInteger(values['state-version'], '--state-version') } : {}),
+            ...(values.reason ? { reason: values.reason } : {}),
+            ...idempotency,
+            ...output,
+        };
     }
     throw new CliUsageError('Usage: dreamstate runs <get|events|cancel> <run_id>');
 }
@@ -342,14 +408,26 @@ function parseCliArgs(argv) {
         return { command: 'version' };
     const [group, ...rest] = argv;
     if (group === 'login') {
-        const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { token: { type: 'string' }, 'api-key-file': { type: 'string' }, 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
+        const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { token: { type: 'string' }, profile: { type: 'string' }, 'api-key-file': { type: 'string' }, 'no-skills': { type: 'boolean' }, 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
         if (values.help)
             return { command: 'help' };
         if (positionals.length)
             throw new CliUsageError('Usage: dreamstate login [--token <ds_user_...|ds_live_...>]');
         if (values.token !== undefined && values['api-key-file'])
             throw new CliUsageError('Use either --token or --api-key-file, not both.');
-        return { command: 'login', ...(values.token !== undefined ? { token: values.token } : {}), ...(values['api-key-file'] ? { apiKeyFile: values['api-key-file'] } : {}), ...outputOption(values) };
+        return { command: 'login', ...(values.token !== undefined ? { token: values.token } : {}), ...(values['api-key-file'] ? { apiKeyFile: values['api-key-file'] } : {}), ...(values.profile ? { profile: (0, config_1.validateProfileName)(values.profile) } : {}), ...(values['no-skills'] ? { noSkills: true } : {}), ...outputOption(values) };
+    }
+    if (group === 'install') {
+        const { values, positionals } = (0, node_util_1.parseArgs)({ args: spaceSeparatedAgents(rest), options: { agents: { type: 'string', multiple: true }, 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
+        if (values.help)
+            return { command: 'help' };
+        if (positionals.length)
+            throw new CliUsageError('Usage: dreamstate install [--agents <claude codex grok>]');
+        const requested = values.agents ? [...new Set(values.agents.flatMap((raw) => csv(raw, '--agents')))] : [...pluginInstaller_1.PLUGIN_AGENTS];
+        const invalid = requested.filter((agent) => !pluginInstaller_1.PLUGIN_AGENTS.includes(agent));
+        if (invalid.length)
+            throw new CliUsageError(`--agents values must be one of: ${pluginInstaller_1.PLUGIN_AGENTS.join(', ')} (got: ${invalid.join(', ')})`);
+        return { command: 'install', agents: requested, ...outputOption(values) };
     }
     if (group === 'logout') {
         const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { 'json-output': { type: 'boolean' }, help: { type: 'boolean', short: 'h' } }, allowPositionals: true, strict: true });
@@ -359,6 +437,27 @@ function parseCliArgs(argv) {
             throw new CliUsageError('Usage: dreamstate logout');
         return { command: 'logout', ...outputOption(values) };
     }
+    if (group === 'status') {
+        const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { 'json-output': { type: 'boolean' } }, allowPositionals: true, strict: true });
+        if (!positionals.length)
+            return { command: 'status', ...outputOption(values) };
+        throw new CliUsageError('Usage: dreamstate status [--json-output]');
+    }
+    if (group === 'profiles') {
+        const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { 'json-output': { type: 'boolean' } }, allowPositionals: true, strict: true });
+        const output = outputOption(values);
+        if (positionals.length === 1 && positionals[0] === 'list')
+            return { command: 'profiles_list', ...output };
+        if (positionals.length === 1 && positionals[0] === 'current')
+            return { command: 'profiles_current', ...output };
+        if (positionals.length === 2 && positionals[0] === 'use')
+            return { command: 'profiles_use', name: (0, config_1.validateProfileName)(positionals[1]), ...output };
+        if (positionals.length === 2 && positionals[0] === 'remove')
+            return { command: 'profiles_remove', name: (0, config_1.validateProfileName)(positionals[1]), ...output };
+        if (positionals.length === 2 && positionals[0] === 'env')
+            return { command: 'profiles_env', name: (0, config_1.validateProfileName)(positionals[1]), ...output };
+        throw new CliUsageError('Usage: dreamstate profiles <list|use <name>|current|remove <name>|env <name>>');
+    }
     if (group === 'whoami') {
         const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { 'json-output': { type: 'boolean' } }, allowPositionals: true, strict: true });
         if (positionals.length === 0)
@@ -376,9 +475,9 @@ function parseCliArgs(argv) {
         throw new CliUsageError('Usage: dreamstate workspaces <list|use <id|slug>>');
     }
     if (group === 'auth') {
-        const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { 'api-key-file': { type: 'string' }, 'json-output': { type: 'boolean' } }, allowPositionals: true, strict: true });
+        const { values, positionals } = (0, node_util_1.parseArgs)({ args: rest, options: { 'api-key-file': { type: 'string' }, 'no-skills': { type: 'boolean' }, 'json-output': { type: 'boolean' } }, allowPositionals: true, strict: true });
         if (positionals.length === 1 && positionals[0] === 'login')
-            return { command: 'login', ...(values['api-key-file'] ? { apiKeyFile: values['api-key-file'] } : {}), ...outputOption(values) };
+            return { command: 'login', ...(values['api-key-file'] ? { apiKeyFile: values['api-key-file'] } : {}), ...(values['no-skills'] ? { noSkills: true } : {}), ...outputOption(values) };
         if (positionals.length === 1 && positionals[0] === 'whoami')
             return { command: 'whoami', ...outputOption(values) };
         throw new CliUsageError('Usage: dreamstate auth <login|whoami>');
@@ -438,6 +537,76 @@ function toolTurnToken(value) {
         return data.tool_turn_token;
     throw new client_1.CliError('tools get did not return a tool_turn_token.', 'invalid_tool_turn_token', 0);
 }
+/**
+ * Free sync reads. The server runs these on the inline read path when
+ * the body has no tool_turn_token and the request has no Idempotency-Key
+ * (isInlineReadEligible). A tools get before the run is a second HTTP the
+ * read does not need. Measured 2026-10-04: tables.workbooks.get full live CLI
+ * 0.726s against whoami 0.455s, about 0.27s of tools get per harness read-back.
+ * knowledge.brain.context.get is the same class (catalog: credit_class free,
+ * async_policy.mode sync, mutates not set). Live 2026-10-05 a standalone
+ * tools get of that id was 0.400s including node startup, next to whoami
+ * 0.422s, so the same-process skip is one HTTP, not a second process.
+ * The set name is historical. Writes are not in this set: they stay fetch-first.
+ */
+const INLINE_READ_CAPABILITIES = new Set([
+    'tables.workbooks.get',
+    'tables.workbooks.overview',
+    'tables.workbooks.list',
+    'tables.columns.list',
+    'tables.columns.stats',
+    'tables.rows.query',
+    'tables.rows.get',
+    'tables.rows.count',
+    'knowledge.brain.context.get',
+    // Both are stored, free, synchronous inbox reads. Keeping either behind a
+    // tools_get turns one list or thread open into two HTTP requests, while the
+    // canonical inline-read gate already validates their read-only contract.
+    'unibox.inbox.unified_list',
+    'unibox.inbox.conversation_get',
+]);
+function omitsToolTurnForInlineTableRead(capabilityId) {
+    return INLINE_READ_CAPABILITIES.has(capabilityId);
+}
+function readIdempotencyContract(fetched) {
+    if (!fetched || typeof fetched !== 'object' || Array.isArray(fetched))
+        return null;
+    const root = fetched;
+    const data = root.data && typeof root.data === 'object' && !Array.isArray(root.data)
+        ? root.data
+        : null;
+    const candidates = [data?.capability, root.capability, data, root];
+    for (const candidate of candidates) {
+        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate))
+            continue;
+        if ('mutates' in candidate || 'idempotency_required' in candidate) {
+            return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Header value, or null when the request must not carry Idempotency-Key.
+ * Any key forces a read onto the durable run path (isInlineReadEligible).
+ * Send one only for an explicit key, or when the tools get contract says
+ * mutates or idempotency_required. Missing flags omit the key: a read whose
+ * contract does not set mutates must not be treated as a write.
+ */
+function capabilityIdempotencyKey(fetched, explicit) {
+    if (typeof explicit === 'string' && explicit.length > 0)
+        return explicit;
+    const contract = readIdempotencyContract(fetched);
+    if (contract?.mutates === true || contract?.idempotency_required === true)
+        return (0, node_crypto_1.randomUUID)();
+    return null;
+}
+function parameterIdempotencyKey(body) {
+    const params = body.params;
+    if (!params || typeof params !== 'object' || Array.isArray(params))
+        return undefined;
+    const key = params.idempotency_key;
+    return typeof key === 'string' && key.length > 0 ? key : undefined;
+}
 function code(error) {
     return error && typeof error === 'object' && typeof error.code === 'string'
         ? error.code
@@ -617,14 +786,97 @@ function whoamiData(value) {
     const data = value && typeof value === 'object' ? value.data : undefined;
     return data && typeof data === 'object' ? data : {};
 }
+function statusData(whoami, health) {
+    const meta = whoami && typeof whoami === 'object' ? whoami.meta : null;
+    const serverVersion = meta && typeof meta === 'object' ? meta.server_version : null;
+    const minimumCliVersion = meta && typeof meta === 'object' ? meta.minimum_cli_version : null;
+    const healthData = health && typeof health === 'object' ? health.data : null;
+    const healthVersion = healthData && typeof healthData === 'object' ? healthData.version : null;
+    const version = typeof serverVersion === 'string' ? serverVersion : typeof healthVersion === 'string' ? healthVersion : null;
+    const minimum = typeof minimumCliVersion === 'string' ? minimumCliVersion : null;
+    const parts = (value) => value.replace(/^v/, '').split('-')[0].split('.').map((part) => Number(part));
+    const [minimumMajor = 0, minimumMinor = 0, minimumPatch = 0] = minimum ? parts(minimum) : [];
+    const [cliMajor = 0, cliMinor = 0, cliPatch = 0] = parts(client_1.CLI_VERSION);
+    const compatible = !minimum || minimumMajor < cliMajor || (minimumMajor === cliMajor && (minimumMinor < cliMinor || (minimumMinor === cliMinor && minimumPatch <= cliPatch)));
+    return {
+        cli_version: client_1.CLI_VERSION,
+        api_version: version,
+        minimum_cli_version: minimum,
+        minimum_cli_version_published: minimum !== null,
+        compatible,
+        upgrade_hint: compatible ? null : 'Run: npm install -g @trydreamstate/cli@latest',
+        health,
+        whoami: whoamiData(whoami),
+    };
+}
 function activeWorkspace(data) {
-    const activeId = data.workspace_id ?? data.active_workspace_id ?? undefined;
+    const activeId = data.workspace_id;
     return activeId ? data.workspaces?.find((workspace) => workspace.id === activeId) : undefined;
 }
 function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-async function loginWithDeviceAuthorization(runtime, stdout, stderr) {
+async function installHostedSkills(client, agents, runtime, options = {}) {
+    const listed = await client.listAllSkills();
+    const entries = listed && typeof listed === 'object' && listed.data?.skills;
+    const ids = Array.isArray(entries) ? entries.map((skill) => skill && typeof skill === 'object' ? skill.id : undefined).filter((id) => typeof id === 'string') : [];
+    if (!ids.length)
+        throw new client_1.CliError('Dreamstate API returned no installable skills.', 'invalid_response', 200);
+    if (ids.some((id) => !/^[a-z0-9][a-z0-9_-]*$/i.test(id)))
+        throw new CliUsageError('Dreamstate API returned an invalid skill id.');
+    const skills = [];
+    for (const id of ids) {
+        const skill = hostedSkill(await client.getSkill(id));
+        if (!/^[a-z0-9][a-z0-9_-]*$/i.test(skill.id))
+            throw new CliUsageError('Dreamstate API returned an invalid skill id.');
+        if (skill.id !== id)
+            throw new client_1.CliError('Dreamstate API returned a mismatched skill id.', 'invalid_response', 200);
+        skills.push(skill);
+    }
+    const packs = await client.listPacks();
+    const whoami = await client.getWhoami();
+    const workspaceId = typeof whoami?.data?.workspace_id === 'string' ? whoami.data.workspace_id : 'unknown';
+    const indexVersion = (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify(skills.map((skill) => [skill.id, skill.description, skill.body, skill.frontmatter ?? {}])))
+        .digest('hex').slice(0, 16);
+    const installed = await (0, skillInstaller_1.installSkills)([...skills, (0, skillInstaller_1.routerSkill)(packs)], {
+        agents,
+        homeDirectory: runtime.homeDirectory,
+        project: Boolean(options.project),
+        copy: Boolean(options.copy) || process.platform === 'win32',
+        workspaceId,
+        indexVersion,
+    });
+    return { files: installed.files, skillIds: [...ids, 'router'] };
+}
+async function installLoginSkills(client, runtime, skip, stderr) {
+    if (skip)
+        return { skipped: 'disabled' };
+    const withPlugin = await (0, pluginInstaller_1.agentsWithDreamstatePlugin)(runtime.homeDirectory);
+    const agents = (await (0, skillInstaller_1.detectInstalledSkillAgents)(runtime.homeDirectory)).filter((agent) => !withPlugin.includes(agent));
+    if (!agents.length && withPlugin.length)
+        return { skipped: 'plugin_installed' };
+    if (!agents.length) {
+        stderr.write('Run dreamstate skills install to install Dreamstate skills.\n');
+        return { skipped: 'no_agents_detected' };
+    }
+    try {
+        const installed = await installHostedSkills(client, agents, runtime);
+        stderr.write(`Installed Dreamstate skills into: ${agents.join(', ')}.\n`);
+        return { installed: agents, files: installed.files.length };
+    }
+    catch {
+        stderr.write('Run dreamstate skills install to install Dreamstate skills.\n');
+        return { skipped: 'installation_failed' };
+    }
+}
+function loginResult(value, skills) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const envelope = value;
+    return { ...envelope, data: { ...(envelope.data && typeof envelope.data === 'object' ? envelope.data : {}), skills } };
+}
+async function loginWithDeviceAuthorization(runtime, stdout, stderr, profile, noSkills = false, jsonOutput = false) {
     const environment = runtime.env ?? process.env;
     const baseUrl = (0, config_1.resolveApiBaseUrl)(environment);
     const state = runtime.deviceState ?? deviceState();
@@ -637,14 +889,19 @@ async function loginWithDeviceAuthorization(runtime, stdout, stderr) {
     for (;;) {
         const claim = await (0, client_1.claimDeviceAuthorization)(baseUrl, authorization.device_code);
         if (claim.status === 'ready') {
-            await (0, config_1.storeApiKey)(claim.token, runtimeCredentialsPath(runtime), claim.workspace.id);
+            if (profile)
+                await (0, config_1.storeCredentialProfile)(profile, claim.token, runtimeCredentialsPath(runtime), claim.workspace.id);
+            else
+                await (0, config_1.storeApiKey)(claim.token, runtimeCredentialsPath(runtime), claim.workspace.id);
             const client = new client_1.DreamstateClient({
                 baseUrl,
                 apiKey: claim.token,
                 requestTimeoutMs: runtime.requestTimeoutMs,
                 onVersionWarning: (message) => (runtime.stderr ?? process.stderr).write(`${message}\n`),
             });
-            print(await client.getWhoami(), stdout, false);
+            const whoami = await client.getWhoami();
+            const skills = await installLoginSkills(client, runtime, noSkills, stderr);
+            print(loginResult(whoami, skills), stdout, jsonOutput);
             return;
         }
         await (runtime.sleep ?? wait)(authorization.interval_seconds * 1_000);
@@ -670,8 +927,9 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
     try {
         const extracted = extractWorkspaceFlag(argv);
         const command = parseCliArgs(extracted.argv);
-        if (command.command === 'help') {
-            print({ ok: true, data: { usage: USAGE }, meta: {} }, stdout, false);
+        if (command.command === 'help' || command.command === 'pack_help') {
+            const packHelp = command.command === 'pack_help' ? command : undefined;
+            print({ ok: true, data: { usage: packHelp?.usage ?? USAGE }, meta: {} }, stdout, Boolean(packHelp?.jsonOutput));
             process.exitCode = exports.CLI_EXIT.SUCCESS;
             return;
         }
@@ -680,6 +938,19 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
             process.exitCode = exports.CLI_EXIT.SUCCESS;
             return;
         }
+        if (command.command === 'install') {
+            const installed = await (0, pluginInstaller_1.installAgentPlugin)({ agents: command.agents, bundleDirectory: (0, node_path_1.join)(__dirname, '..', 'agent-plugin'), homeDirectory: runtime.homeDirectory, run: runtime.runAgentCommand });
+            const done = installed.agents.filter((item) => item.status === 'installed').map((item) => item.agent);
+            const failed = installed.agents.filter((item) => item.status === 'failed');
+            if (failed.length || !done.length) {
+                throw new client_1.CliError(done.length ? 'Dreamstate plugin install failed for some agents.' : 'No supported agent was found. Install Claude Code, Codex or Grok Build, then rerun dreamstate install.', 'plugin_install_failed', 0, { details: installed });
+            }
+            const removedSkills = done.includes('claude') ? await (0, pluginInstaller_1.removeClaudeSkillCopies)(runtime.homeDirectory) : [];
+            stderr.write(`Dreamstate plugin installed for ${done.join(', ')}. Start a new session; the first Dreamstate tool call asks you to sign in.\n`);
+            print({ ok: true, data: { ...installed, removed_skill_copies: removedSkills }, meta: {} }, stdout, Boolean(command.jsonOutput));
+            process.exitCode = exports.CLI_EXIT.SUCCESS;
+            return;
+        }
         if (command.command === 'logout') {
             const path = runtimeCredentialsPath(runtime);
             let removed = true;
@@ -699,6 +970,38 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
             process.exitCode = exports.CLI_EXIT.SUCCESS;
             return;
         }
+        if (command.command === 'profiles_list' || command.command === 'profiles_current' || command.command === 'profiles_use' || command.command === 'profiles_remove' || command.command === 'profiles_env') {
+            const path = runtimeCredentialsPath(runtime);
+            const environment = runtime.env ?? process.env;
+            if (command.command === 'profiles_list') {
+                const current = await (0, config_1.currentCredentialProfile)(path, environment);
+                const profiles = await (0, config_1.listCredentialProfiles)(path);
+                print({ ok: true, data: { current_profile: current, profiles: profiles.map(({ name, workspace }) => ({ name, workspace, active: name === current })) }, meta: {} }, stdout, Boolean(command.jsonOutput));
+            }
+            else if (command.command === 'profiles_current') {
+                print({ ok: true, data: { profile: await (0, config_1.currentCredentialProfile)(path, environment) }, meta: {} }, stdout, Boolean(command.jsonOutput));
+            }
+            else if (command.command === 'profiles_use') {
+                await (0, config_1.useCredentialProfile)(command.name, path);
+                print({ ok: true, data: { profile: command.name }, meta: {} }, stdout, Boolean(command.jsonOutput));
+            }
+            else if (command.command === 'profiles_remove') {
+                const removed = await (0, config_1.removeCredentialProfile)(command.name, path);
+                print({ ok: true, data: { profile: command.name, removed }, meta: {} }, stdout, Boolean(command.jsonOutput));
+            }
+            else {
+                const profiles = await (0, config_1.listCredentialProfiles)(path);
+                if (!profiles.some((profile) => profile.name === command.name))
+                    throw new CliUsageError(`Profile not found: ${command.name}.`);
+                const result = { ok: true, data: { profile: command.name, exports: [`DREAMSTATE_PROFILE=${command.name}`] }, meta: {} };
+                if (command.jsonOutput)
+                    print(result, stdout, true);
+                else
+                    stdout.write(`export DREAMSTATE_PROFILE=${command.name}\n`);
+            }
+            process.exitCode = exports.CLI_EXIT.SUCCESS;
+            return;
+        }
         if (command.command === 'login' && command.token !== undefined) {
             const token = command.token.trim();
             if (!(0, config_1.isDreamstateToken)(token))
@@ -715,8 +1018,23 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
                 onVersionWarning: (message) => stderr.write(`${message}\n`),
             });
             const whoami = await client.getWhoami();
-            await (0, config_1.storeApiKey)(token, runtimeCredentialsPath(runtime));
-            print(whoami, stdout, Boolean(command.jsonOutput));
+            if (command.profile)
+                await (0, config_1.storeCredentialProfile)(command.profile, token, runtimeCredentialsPath(runtime));
+            else
+                await (0, config_1.storeApiKey)(token, runtimeCredentialsPath(runtime));
+            const skills = await installLoginSkills(client, runtime, Boolean(command.noSkills), stderr);
+            print(loginResult(whoami, skills), stdout, Boolean(command.jsonOutput));
+            process.exitCode = exports.CLI_EXIT.SUCCESS;
+            return;
+        }
+        if (command.command === 'status') {
+            const environment = runtime.env ?? process.env;
+            const credentialFilePath = runtimeCredentialsPath(runtime);
+            const apiKey = await (0, config_1.resolveApiKey)(environment, credentialFilePath);
+            const workspace = await (0, config_1.resolveWorkspace)(extracted.workspace, environment, credentialFilePath);
+            const client = new client_1.DreamstateClient({ baseUrl: (0, config_1.resolveApiBaseUrl)(environment), apiKey, ...(workspace ? { workspace } : {}), requestTimeoutMs: runtime.requestTimeoutMs });
+            const [whoami, health] = await Promise.all([client.getStatusWhoami(), client.getHealth()]);
+            print({ ok: true, data: statusData(whoami, health), meta: {} }, stdout, Boolean(command.jsonOutput));
             process.exitCode = exports.CLI_EXIT.SUCCESS;
             return;
         }
@@ -725,14 +1043,16 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
                 const key = await readLoginKey(command, runtime);
                 if (!(0, config_1.isDreamstateToken)(key))
                     throw new CliUsageError('Dreamstate API keys must start with ds_user_ or ds_live_.');
-                const path = await (0, config_1.storeApiKey)(key, runtimeCredentialsPath(runtime));
-                print({ ok: true, data: { credentials_path: path }, meta: {} }, stdout, Boolean(command.jsonOutput));
-                stderr.write('Run dreamstate skills install to install Dreamstate skills.\n');
+                const path = command.profile
+                    ? await (0, config_1.storeCredentialProfile)(command.profile, key, runtimeCredentialsPath(runtime))
+                    : await (0, config_1.storeApiKey)(key, runtimeCredentialsPath(runtime));
+                const client = new client_1.DreamstateClient({ baseUrl: (0, config_1.resolveApiBaseUrl)(runtime.env ?? process.env), apiKey: key, requestTimeoutMs: runtime.requestTimeoutMs, onVersionWarning: (message) => stderr.write(`${message}\n`) });
+                const skills = await installLoginSkills(client, runtime, Boolean(command.noSkills), stderr);
+                print({ ok: true, data: { credentials_path: path, skills }, meta: {} }, stdout, Boolean(command.jsonOutput));
                 process.exitCode = exports.CLI_EXIT.SUCCESS;
                 return;
             }
-            await loginWithDeviceAuthorization(runtime, stdout, stderr);
-            stderr.write('Run dreamstate skills install to install Dreamstate skills.\n');
+            await loginWithDeviceAuthorization(runtime, stdout, stderr, command.profile, Boolean(command.noSkills), Boolean(command.jsonOutput));
             process.exitCode = exports.CLI_EXIT.SUCCESS;
             return;
         }
@@ -824,7 +1144,7 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
                 result = await client.getWhoami();
                 if (!command.jsonOutput) {
                     const data = whoamiData(result);
-                    const activeId = data.workspace_id ?? data.active_workspace_id ?? null;
+                    const activeId = data.workspace_id ?? null;
                     const rows = data.workspaces ?? [];
                     stdout.write(rows.length
                         ? `${rows.map((row) => `${row.id === activeId ? '*' : ' '} ${row.slug ?? '-'}  ${row.name}  ${row.role ?? '-'}  ${row.id}`).join('\n')}\n`
@@ -841,10 +1161,10 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
                 const match = data.workspaces?.find((row) => row.id.toLowerCase() === wanted || row.slug?.toLowerCase() === wanted);
                 if (!match)
                     throw new CliUsageError(`You are not a member of workspace "${command.workspace}". Run dreamstate workspaces list to see the workspaces you can use.`);
-                const stored = await (0, config_1.readStoredCredentials)(credentialFilePath);
+                const stored = await (0, config_1.readStoredCredentials)(await (0, config_1.selectedCredentialsPath)(credentialFilePath, environment));
                 if (!stored)
                     throw new CliUsageError('workspaces use saves the default next to a stored login. Run dreamstate login or dreamstate login --token first.');
-                await (0, config_1.storeApiKey)(stored.token, credentialFilePath, match.id);
+                await (0, config_1.storeApiKey)(stored.token, await (0, config_1.selectedCredentialsPath)(credentialFilePath, environment), match.id);
                 stderr.write(`Default workspace: ${match.name} (${match.slug})\n`);
                 result = { ok: true, data: { workspace: { id: match.id, name: match.name, slug: match.slug }, credentials_path: credentialFilePath }, meta: {} };
                 break;
@@ -868,18 +1188,17 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
                 result = await client.searchSkillDocuments(command.query);
                 break;
             case 'skills_install': {
-                const listed = command.skillId === '*' ? await client.listAllSkills() : null;
-                const entries = listed && typeof listed === 'object' && listed.data?.skills;
-                const ids = command.skillId === '*'
-                    ? Array.isArray(entries) ? entries.map((skill) => skill && typeof skill === 'object' ? skill.id : undefined).filter((id) => typeof id === 'string') : []
-                    : [command.skillId];
-                if (!ids.length)
-                    throw new client_1.CliError('Dreamstate API returned no installable skills.', 'invalid_response', 200);
+                if (command.skillId === '*') {
+                    const installed = await installHostedSkills(client, command.agents, runtime, { project: command.project, copy: command.copy });
+                    result = { ok: true, data: { installed_files: installed.files, skill_ids: installed.skillIds, agents: command.agents, ...(command.project ? { lock_file: 'skills-lock.json' } : {}) }, meta: {} };
+                    break;
+                }
+                const ids = [command.skillId];
                 // A remote id becomes a directory name; refuse traversal before any request or write.
                 if (ids.some((id) => !/^[a-z0-9][a-z0-9_-]*$/i.test(id)))
                     throw new CliUsageError('Dreamstate API returned an invalid skill id.');
-                // One at a time: each read comes from the workspace's private vault,
-                // which admits two reads at once, and fifteen in parallel failed on prod.
+                // Read each skill one at a time because the workspace's private vault
+                // admits two reads at once, and fifteen parallel reads failed in production.
                 const skills = [];
                 for (const id of ids) {
                     const skill = hostedSkill(await client.getSkill(id));
@@ -937,54 +1256,83 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
                 const pending = command.turnToken
                     ? null
                     : await (0, turnCache_1.reusableTurnToken)(turns, baseUrl, turnKey, command.capabilityId, Date.now(), warnTurnCache);
-                const turnToken = command.turnToken ?? pending ?? toolTurnToken(await client.getTool(command.capabilityId));
-                const run = () => client.runCapability(command.capabilityId, { ...command.body, tool_turn_token: turnToken }, command.idempotencyKey);
+                const inlineRead = !command.turnToken && !pending && !command.idempotencyKey && omitsToolTurnForInlineTableRead(command.capabilityId);
+                const fetchedForRun = command.turnToken || pending || inlineRead ? null : await client.getTool(command.capabilityId);
+                let turnToken = command.turnToken ?? pending ?? (inlineRead ? undefined : toolTurnToken(fetchedForRun));
+                const callerParameterKey = parameterIdempotencyKey(command.body);
+                let idempotencyKey = capabilityIdempotencyKey(fetchedForRun, callerParameterKey ?? command.idempotencyKey);
+                let recoveredInlineRead = false;
+                const run = () => client.runCapability(command.capabilityId, {
+                    ...command.body,
+                    ...(turnToken ? { tool_turn_token: turnToken } : {}),
+                }, idempotencyKey);
                 try {
                     try {
                         result = await run();
                     }
                     catch (error) {
-                        // A quote_required refusal binds a fresh quote to this turn, so the
-                        // identical call admits on the next try. Retry once here instead of
-                        // making the caller rerun the same command by hand.
-                        if (command.body.mode !== 'live' || code(error) !== 'quote_required')
+                        // The inline skip is only valid while the server still treats this
+                        // capability as a free sync read. capability_not_fetched means the
+                        // fetch-first fence is on, so retry once on the old get-then-run path.
+                        if (inlineRead && !recoveredInlineRead && code(error) === 'capability_not_fetched') {
+                            recoveredInlineRead = true;
+                            const fetched = await client.getTool(command.capabilityId);
+                            turnToken = toolTurnToken(fetched);
+                            idempotencyKey = capabilityIdempotencyKey(fetched, callerParameterKey ?? command.idempotencyKey);
+                            result = await run();
+                        }
+                        else if (command.body.mode !== 'live' || code(error) !== 'quote_required') {
+                            // A quote_required refusal binds a fresh quote to this turn, so the
+                            // identical call admits on the next try. Retry once here instead of
+                            // making the caller rerun the same command by hand.
                             throw error;
-                        result = await run();
+                        }
+                        else {
+                            result = await run();
+                        }
                     }
                 }
                 catch (error) {
-                    if (!command.turnToken && code(error) === 'quote_required') {
+                    if (!command.turnToken && turnToken && code(error) === 'quote_required') {
                         await (0, turnCache_1.rememberTurnToken)(turns, baseUrl, turnKey, command.capabilityId, turnToken, Date.now(), warnTurnCache);
                     }
                     throw error;
                 }
                 if (!command.turnToken) {
-                    if (command.body.mode === 'dry_run')
+                    if (command.body.mode === 'dry_run' && turnToken)
                         await (0, turnCache_1.rememberTurnToken)(turns, baseUrl, turnKey, command.capabilityId, turnToken, Date.now(), warnTurnCache);
                     else if (pending)
                         await (0, turnCache_1.forgetTurnToken)(turns, baseUrl, turnKey, command.capabilityId, warnTurnCache);
                 }
+                if (!command.noWait && !(0, runWait_1.columnRunReturnsRunId)(command.capabilityId)) {
+                    const waited = await (0, runWait_1.waitForRun)(client, result, command.waitTimeout, runtime.sleep ?? wait);
+                    result = waited.value;
+                    if (waited.timedOut)
+                        process.exitCode = runWait_1.RUN_WAIT_TIMEOUT_EXIT_CODE;
+                }
                 break;
             }
             case 'tables_import': {
                 await (0, promises_1.access)(command.file);
-                const discovered = await client.listTools({
-                    goal: 'prepare a local file import into a table',
-                    query_terms: ['local', 'file', 'import'],
-                });
-                const importCapabilityId = discoveredCapabilityId(discovered);
+                // Search ranking is not an import contract. This exact capability owns the
+                // prepare handoff for caller-local files, while nearby upload capabilities
+                // can also match these words and made a real import fail after local work.
+                const importCapabilityId = 'tables.table_sources.csv_import_prepare';
+                const importContract = await client.getTool(importCapabilityId);
                 result = await client.runCapability(importCapabilityId, {
                     // A mutation run needs the turn token its own get minted; without it
                     // an API-key import was refused after the local file work.
-                    tool_turn_token: toolTurnToken(await client.getTool(importCapabilityId)),
+                    tool_turn_token: toolTurnToken(importContract),
                     mode: 'live',
                     params: {
                         table_id: command.tableId,
                         file_path: command.file,
                         ...(command.format ? { file_kind: command.format } : {}),
                         ...(command.upsertKey ? { upsert_key: command.upsertKey } : {}),
+                        ...(command.rowKind ? { row_kind: command.rowKind } : {}),
+                        ...(command.keepUnmappedColumns === false ? { keep_unmapped_columns: false } : {}),
                     },
-                });
+                }, capabilityIdempotencyKey(importContract));
                 break;
             }
             case 'runs_list':
@@ -1002,15 +1350,20 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
             case 'runs_events':
                 result = await client.getRunEvents(command.runId);
                 break;
-            case 'runs_cancel':
-                result = await client.cancelRun(command.runId, command.body, command.idempotencyKey);
+            case 'runs_cancel': {
+                const body = command.body ?? {
+                    expected_state_version: command.stateVersion ?? stateVersionFromRunRead(await client.getRun(command.runId)),
+                    ...(command.reason ? { reason: command.reason } : {}),
+                };
+                result = await client.cancelRun(command.runId, body, command.idempotencyKey);
                 break;
+            }
             case 'pack': {
                 if (command.pack === 'sequences') {
-                    await require('./commands/sequences').runSequencesCommand(client, command, stdout);
+                    await require('./commands/sequences').runSequencesCommand(client, command, stdout, runtime.sleep ?? wait);
                 }
                 else {
-                    await require('./commands/workflows').runWorkflowsCommand(client, command, stdout);
+                    await require('./commands/workflows').runWorkflowsCommand(client, command, stdout, runtime.sleep ?? wait);
                 }
                 return;
             }
@@ -1022,7 +1375,8 @@ async function runCli(argv = process.argv.slice(2), runtime = {}) {
             printPackRoute(result, stdout);
         else
             print(result, stdout, Boolean(command.jsonOutput));
-        process.exitCode = exports.CLI_EXIT.SUCCESS;
+        if (process.exitCode !== runWait_1.RUN_WAIT_TIMEOUT_EXIT_CODE)
+            process.exitCode = exports.CLI_EXIT.SUCCESS;
     }
     catch (error) {
         const exitCode = exitCodeForError(error);