@agentuity/cli 2.0.11 → 2.0.12

package/src/cmd/cloud/sandbox/fs/download.ts

@@ -1,10 +1,14 @@
 import { z } from 'zod';
-import { writeFileSync } from 'node:fs';
+import { createWriteStream } from 'node:fs';
+import { dirname } from 'node:path';
+import { mkdir } from 'node:fs/promises';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxDownloadArchive, sandboxResolve } from '@agentuity/server';
+import { sandboxDownloadArchive } from '@agentuity/server';
 
 export const downloadSubcommand = createCommand({
 	name: 'download',
@@ -48,9 +52,14 @@ export const downloadSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 
@@ -62,25 +71,9 @@ export const downloadSubcommand = createCommand({
 			format,
 			orgId,
 		});
-
-		const chunks: Uint8Array[] = [];
-		const reader = stream.getReader();
-
-		while (true) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			chunks.push(value);
-		}
-
-		const totalBytes = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-		const buffer = new Uint8Array(totalBytes);
-		let offset = 0;
-		for (const chunk of chunks) {
-			buffer.set(chunk, offset);
-			offset += chunk.length;
-		}
-
-		writeFileSync(args.output, buffer);
+		await mkdir(dirname(args.output), { recursive: true });
+		await pipeline(Readable.fromWeb(stream), createWriteStream(args.output));
+		const totalBytes = Bun.file(args.output).size;
 
 		if (!options.json) {
 			tui.success(`Downloaded ${formatSize(totalBytes)} to ${args.output}`);

package/src/cmd/cloud/sandbox/fs/ls.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxListFiles, sandboxResolve } from '@agentuity/server';
+import { sandboxListFiles } from '@agentuity/server';
 
 const FileInfoSchema = z.object({
 	path: z.string(),
@@ -63,9 +63,14 @@ export const lsSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/fs/mkdir.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxMkDir, sandboxResolve } from '@agentuity/server';
+import { sandboxMkDir } from '@agentuity/server';
 
 const MkDirResponseSchema = z.object({
 	success: z.boolean(),
@@ -46,9 +46,14 @@ export const mkdirSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/fs/rm.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxRmFile, sandboxResolve } from '@agentuity/server';
+import { sandboxRmFile } from '@agentuity/server';
 
 const RmFileResponseSchema = z.object({
 	success: z.boolean(),
@@ -35,9 +35,14 @@ export const rmSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/fs/rmdir.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxRmDir, sandboxResolve } from '@agentuity/server';
+import { sandboxRmDir } from '@agentuity/server';
 
 const RmDirResponseSchema = z.object({
 	success: z.boolean(),
@@ -47,9 +47,14 @@ export const rmdirSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/fs/upload.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod';
-import { readFileSync, statSync } from 'node:fs';
+import { createReadStream, statSync } from 'node:fs';
+import { Readable } from 'node:stream';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxUploadArchive, sandboxResolve } from '@agentuity/server';
+import { sandboxUploadArchive } from '@agentuity/server';
 
 export const uploadSubcommand = createCommand({
 	name: 'upload',
@@ -47,9 +48,14 @@ export const uploadSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 
@@ -58,8 +64,8 @@ export const uploadSubcommand = createCommand({
 			logger.fatal(`${args.archive} is not a file`);
 		}
 
-		const content = readFileSync(args.archive);
-		const bytes = content.length;
+		const bytes = stat.size;
+		const content = Readable.toWeb(createReadStream(args.archive)) as ReadableStream<Uint8Array>;
 
 		const format = opts.format ?? detectFormat(args.archive);
 

package/src/cmd/cloud/sandbox/get.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { cacheSandboxRegion, createSandboxClient } from './util';
+import { cacheSandboxTarget, createSandboxClient, resolveSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxGet, sandboxResolve } from '@agentuity/server';
+import { sandboxGet } from '@agentuity/server';
 
 const SandboxResourcesSchema = z.object({
 	memory: z.string().optional().describe('Memory limit (e.g., "512Mi", "1Gi")'),
@@ -62,6 +62,19 @@ export const getSubcommand = createCommand({
 		},
 	],
 	schema: {
+		options: z.object({
+			waitForStatus: z
+				.array(z.string())
+				.optional()
+				.describe('Wait for one of these statuses before returning'),
+			waitMs: z
+				.number()
+				.int()
+				.nonnegative()
+				.max(60000)
+				.optional()
+				.describe('Maximum time in milliseconds to wait for a desired status'),
+		}),
 		args: z.object({
 			sandboxId: z.string().describe('Sandbox ID'),
 		}),
@@ -69,10 +82,16 @@ export const getSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options, auth, logger, config, apiClient } = ctx;
+		const { args, opts, options, auth, logger, config, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			config?.name ?? 'production',
+			config
+		);
 
 		// Create regional client and get full sandbox details
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
@@ -80,11 +99,13 @@ export const getSubcommand = createCommand({
 			sandboxId: args.sandboxId,
 			orgId: sandboxInfo.orgId,
 			includeDeleted: true,
+			waitForStatus: opts.waitForStatus,
+			waitMs: opts.waitMs,
 		});
 
-		// Cache the region for future lookups
+		// Cache routing context for future lookups
 		if (result.region) {
-			await cacheSandboxRegion(config?.name, args.sandboxId, result.region);
+			await cacheSandboxTarget(config?.name, args.sandboxId, result.region, sandboxInfo.orgId);
 		}
 
 		if (!options.json) {

package/src/cmd/cloud/sandbox/job/create.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { jobCreate, sandboxResolve } from '@agentuity/server';
+import { jobCreate } from '@agentuity/server';
 
 export const createSubcommand = createCommand({
 	name: 'create',
@@ -33,8 +33,14 @@ export const createSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, options, auth, logger, apiClient } = ctx;
 
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/job/destroy.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { jobStop, sandboxResolve } from '@agentuity/server';
+import { jobStop } from '@agentuity/server';
 
 export const destroySubcommand = createCommand({
 	name: 'destroy',
@@ -38,8 +38,14 @@ export const destroySubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/job/get.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
-import { jobGet, sandboxResolve } from '@agentuity/server';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
+import { jobGet } from '@agentuity/server';
 
 export const getSubcommand = createCommand({
 	name: 'get',
@@ -22,8 +22,14 @@ export const getSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, options, auth, logger, apiClient } = ctx;
 
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/job/list.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
-import { jobList, sandboxResolve } from '@agentuity/server';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
+import { jobList } from '@agentuity/server';
 
 export const listSubcommand = createCommand({
 	name: 'list',
@@ -28,8 +28,14 @@ export const listSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/job/logs.ts

@@ -1,8 +1,8 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
-import { jobGet, sandboxResolve } from '@agentuity/server';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
+import { jobGet } from '@agentuity/server';
 import { getCommand } from '../../../../command-prefix';
 import { streamUrlToWritable } from '../../../../utils/stream-url';
 
@@ -64,8 +64,14 @@ export const logsSubcommand = createSubcommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 
@@ -121,6 +127,7 @@ export const logsSubcommand = createSubcommand({
 				tail: opts.tail,
 				json: isJson,
 				label: opts.stderr ? 'stderr' : 'stdout',
+				v2: true,
 			});
 
 			return {

package/src/cmd/cloud/sandbox/pause.ts

@@ -1,14 +1,20 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { createSandboxClient, resolveSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxPause, sandboxResolve } from '@agentuity/server';
+import { sandboxPause } from '@agentuity/server';
 
 const SandboxPauseResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
 	sandboxId: z.string().describe('Sandbox ID'),
 	durationMs: z.number().describe('Operation duration in milliseconds'),
+	terminatesAt: z
+		.string()
+		.optional()
+		.describe(
+			'ISO 8601 timestamp when sandbox will auto-terminate if not resumed (omitted if no paused timeout)'
+		),
 });
 
 export const pauseSubcommand = createCommand({
@@ -37,22 +43,42 @@ export const pauseSubcommand = createCommand({
 
 		const started = Date.now();
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 
-		await sandboxPause(client, { sandboxId: args.sandboxId, orgId: sandboxInfo.orgId });
+		const result = await sandboxPause(client, {
+			sandboxId: args.sandboxId,
+			orgId: sandboxInfo.orgId,
+		});
 		const durationMs = Date.now() - started;
 
 		if (!options.json) {
 			tui.success(`paused sandbox ${tui.bold(args.sandboxId)} in ${durationMs}ms`);
+			if (result.terminatesAt) {
+				const terminateDate = new Date(result.terminatesAt);
+				if (!Number.isNaN(terminateDate.getTime())) {
+					tui.info(
+						`this sandbox will auto-terminate at ${tui.bold(terminateDate.toLocaleString())} if not resumed`
+					);
+				} else {
+					tui.info('this sandbox has a paused timeout and will auto-terminate if not resumed');
+				}
+			}
 		}
 
 		return {
 			success: true,
 			sandboxId: args.sandboxId,
 			durationMs,
+			terminatesAt: result.terminatesAt,
 		};
 	},
 });

package/src/cmd/cloud/sandbox/resume.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { createSandboxClient, resolveSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxResume, sandboxResolve } from '@agentuity/server';
+import { sandboxResume } from '@agentuity/server';
 
 const SandboxResumeResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -37,8 +37,14 @@ export const resumeSubcommand = createCommand({
 
 		const started = Date.now();
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 

package/src/cmd/cloud/sandbox/run.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { Writable } from 'node:stream';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, parseFileArgs, cacheSandboxRegion } from './util';
+import { cacheSandboxTarget, createSandboxClient, detectNullStream, parseFileArgs } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxRun } from '@agentuity/server';
 import { validateAptDependencies } from '../../../utils/apt-validator';
@@ -59,6 +59,11 @@ export const runSubcommand = createCommand({
 				.default(false)
 				.optional()
 				.describe('Include timestamps in output (default: true)'),
+			quiet: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Suppress output (do not create stdout/stderr streams)'),
 			snapshot: z.string().optional().describe('Snapshot ID or tag to restore from'),
 			dependency: z
 				.array(z.string())
@@ -149,13 +154,46 @@ export const runSubcommand = createCommand({
 		// Determine if we have stdin data (not a TTY means piped input)
 		const hasStdin = !process.stdin.isTTY;
 
-		// For JSON output, we need to capture output instead of streaming to process
-		const stdout = options.json
-			? createCaptureStream((chunk) => outputChunks.push(chunk))
-			: process.stdout;
-		const stderr = options.json
-			? createCaptureStream((chunk) => outputChunks.push(chunk))
-			: process.stderr;
+		// Detect if stdout/stderr are redirected to /dev/null
+		const stdoutIsNull = detectNullStream(1);
+		const stderrIsNull = detectNullStream(2);
+
+		// Detect stream configuration based on TTY status and flags
+		const streamConfig: {
+			timestamps?: boolean;
+			stdin?: string;
+			stdout?: string;
+			stderr?: string;
+		} = {
+			timestamps: opts.timestamps,
+			// Skip stdin stream when no stdin data available
+			stdin: hasStdin ? undefined : 'ignore',
+		};
+
+		// --quiet: suppress all output streams (no server streams, no local capture)
+		if (opts.quiet) {
+			streamConfig.stdout = 'ignore';
+			streamConfig.stderr = 'ignore';
+		} else if (!options.json) {
+			// Auto-detect /dev/null redirection (only when not in JSON mode)
+			// In JSON mode we need output for the response, so keep streams even if redirected
+			if (stdoutIsNull) {
+				streamConfig.stdout = 'ignore';
+			}
+			if (stderrIsNull) {
+				streamConfig.stderr = 'ignore';
+			}
+		}
+
+		// For JSON output or quiet mode, we need to capture output instead of streaming to process
+		const stdout =
+			options.json || opts.quiet || stdoutIsNull
+				? createCaptureStream((chunk) => outputChunks.push(chunk))
+				: process.stdout;
+		const stderr =
+			options.json || opts.quiet || stderrIsNull
+				? createCaptureStream((chunk) => outputChunks.push(chunk))
+				: process.stderr;
 
 		try {
 			const result = await sandboxRun(client, {
@@ -180,7 +218,7 @@ export const runSubcommand = createCommand({
 					network: opts.network ? { enabled: true } : undefined,
 					timeout: opts.timeout ? { execution: opts.timeout } : undefined,
 					env: Object.keys(envMap).length > 0 ? envMap : undefined,
-					stream: opts.timestamps !== undefined ? { timestamps: opts.timestamps } : undefined,
+					stream: streamConfig,
 					snapshot: opts.snapshot,
 					dependencies: opts.dependency,
 					scopes: opts.scope,
@@ -195,8 +233,8 @@ export const runSubcommand = createCommand({
 				logger,
 			});
 
-			// Cache the region for future lookups (sandbox is destroyed after run but cache helps with lookups during execution)
-			await cacheSandboxRegion(config?.name, result.sandboxId, region);
+			// Cache routing context for follow-up lookup/debug flows during execution.
+			await cacheSandboxTarget(config?.name, result.sandboxId, region, orgId);
 
 			const duration = Date.now() - started;
 			const output = outputChunks.join('');