@agentuity/cli 2.0.11 → 2.0.13

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

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { getCommand } from '../../../../command-prefix';
 import * as tui from '../../../../tui';
 import { createCommand } from '../../../../types';
-import { createSandboxClient, getSandboxRegion } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 
 const SNAPSHOT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
 const SNAPSHOT_TAG_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
@@ -88,15 +88,15 @@ export const createSubcommand = createCommand({
 		}
 
 		const profileName = config?.name;
-		const region = await getSandboxRegion(
+		const sandboxInfo = await resolveSandboxTarget(
 			logger,
 			auth,
-			profileName,
+			null,
 			args.sandboxId,
-			orgId,
+			profileName,
 			config
 		);
-		const client = createSandboxClient(logger, auth, region);
+		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 
 		const snapshot = await snapshotCreate(client, {
 			sandboxId: args.sandboxId,
@@ -104,7 +104,7 @@ export const createSubcommand = createCommand({
 			description: opts.description,
 			tag: opts.tag,
 			public: opts.public,
-			orgId,
+			orgId: sandboxInfo.orgId ?? orgId,
 		});
 
 		if (!options.json) {

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

@@ -1,17 +1,69 @@
-import { readFileSync } from 'node:fs';
+import { fstatSync, readFileSync, statSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { FileToWrite, Logger } from '@agentuity/core';
-import { APIClient, getServiceUrls, sandboxGet } from '@agentuity/server';
+import { APIClient, getServiceUrls, sandboxGet, sandboxResolve } from '@agentuity/server';
 import { deleteResourceRegion, getResourceInfo, setResourceInfo } from '../../../cache';
 import { getGlobalCatalystAPIClient } from '../../../config';
 import { ErrorCode } from '../../../errors';
 import * as tui from '../../../tui';
 import type { AuthData, Config } from '../../../types';
 
+/**
+ * Detect if a file descriptor is redirected to /dev/null (or NUL on Windows).
+ * Used to optimize stream creation - when output goes to /dev/null, we can
+ * skip creating the stream entirely on the server.
+ *
+ * @param fd - File descriptor (1 for stdout, 2 for stderr)
+ * @returns true if the fd points to /dev/null
+ */
+export function detectNullStream(fd: number): boolean {
+	try {
+		const fdStat = fstatSync(fd);
+		const nullPath = process.platform === 'win32' ? 'NUL' : '/dev/null';
+		const nullStat = statSync(nullPath);
+		return fdStat.dev === nullStat.dev && fdStat.ino === nullStat.ino;
+	} catch {
+		return false;
+	}
+}
+
 export function createSandboxClient(logger: Logger, auth: AuthData, region: string): APIClient {
 	return new APIClient(getServiceUrls(region).catalyst, logger, auth.apiKey);
 }
 
+export interface ResolvedSandboxTarget {
+	region: string;
+	orgId: string;
+}
+
+/**
+ * Resolve sandbox routing context using cache-first lookup.
+ * Falls back to the CLI resolve endpoint on cache miss or partial cache.
+ */
+export async function resolveSandboxTarget(
+	logger: Logger,
+	auth: AuthData,
+	apiClient: APIClient | null = null,
+	sandboxId: string,
+	profileName = 'production',
+	config?: Config | null
+): Promise<ResolvedSandboxTarget> {
+	const cachedInfo = await getResourceInfo('sandbox', profileName, sandboxId);
+	if (cachedInfo?.region && cachedInfo?.orgId) {
+		logger.trace(
+			`[sandbox] Found cached target for ${sandboxId}: ${cachedInfo.region}/${cachedInfo.orgId}`
+		);
+		return { region: cachedInfo.region, orgId: cachedInfo.orgId };
+	}
+
+	logger.trace(`[sandbox] Cache miss for target ${sandboxId}, resolving via CLI API`);
+	const globalClient =
+		apiClient ?? (await getGlobalCatalystAPIClient(logger, auth, profileName, undefined, config));
+	const sandbox = await sandboxResolve(globalClient, sandboxId);
+	await setResourceInfo('sandbox', profileName, sandboxId, sandbox.region, sandbox.orgId);
+	return { region: sandbox.region, orgId: sandbox.orgId };
+}
+
 /**
  * Look up the region for a sandbox, using cache-first strategy.
  * Falls back to API lookup if not in cache.
@@ -64,6 +116,15 @@ export async function cacheSandboxRegion(
 	await setResourceInfo('sandbox', profileName, sandboxId, region);
 }
 
+export async function cacheSandboxTarget(
+	profileName = 'production',
+	sandboxId: string,
+	region: string,
+	orgId?: string
+): Promise<void> {
+	await setResourceInfo('sandbox', profileName, sandboxId, region, orgId);
+}
+
 /**
  * Clear cached region for a sandbox after delete
  */

package/src/cmd/coder/create.ts

@@ -46,9 +46,9 @@ export const createCoderSubcommand = createSubcommand({
 		},
 		{
 			command: getCommand(
-				'coder create "Review this change" --default-agent code-review --agent-slugs code-review'
+				'coder create "Review this change" --default-agent code-review --enabled-agents code-review'
 			),
-			description: 'Create with published custom agents and a custom default route target',
+			description: 'Create with a selected agent roster and a custom default route target',
 		},
 	],
 	schema: {
@@ -96,10 +96,10 @@ export const createCoderSubcommand = createSubcommand({
 			// Resources
 			workspaceId: z.string().optional().describe('Workspace ID to use'),
 			tags: z.string().optional().describe('Comma-separated tags'),
-			agentSlugs: z
+			enabledAgents: z
 				.string()
 				.optional()
-				.describe('Comma-separated published custom agent slugs to include'),
+				.describe('Comma-separated built-in/custom agents to include'),
 			env: z
 				.string()
 				.optional()
@@ -121,7 +121,7 @@ export const createCoderSubcommand = createSubcommand({
 		// Build the create session request body from flags
 		const body: CoderCreateSessionRequest & {
 			defaultAgent?: string;
-			agentSlugs?: string[];
+			enabledAgents?: string[];
 		} = {
 			task: args.task,
 			...(opts?.label && { label: opts.label }),
@@ -167,10 +167,10 @@ export const createCoderSubcommand = createSubcommand({
 				.split(',')
 				.map((t) => t.trim())
 				.filter(Boolean);
-		if (opts?.agentSlugs)
-			body.agentSlugs = opts.agentSlugs
+		if (opts?.enabledAgents)
+			body.enabledAgents = opts.enabledAgents
 				.split(',')
-				.map((slug) => slug.trim())
+				.map((name) => name.trim())
 				.filter(Boolean);
 		if (opts?.savedSkillIds)
 			body.savedSkillIds = opts.savedSkillIds

package/src/cmd/coder/start.ts

@@ -128,6 +128,8 @@ export const startSubcommand = createSubcommand({
 	},
 	async handler(ctx) {
 		const { opts, options } = ctx;
+		// Keep Pi's interactive install telemetry disabled for Agentuity CLI sessions.
+		process.env.PI_TELEMETRY = '0';
 
 		// Resolve working directory from optional --dir option
 		let cwd = process.cwd();
@@ -388,6 +390,7 @@ export const startSubcommand = createSubcommand({
 			AGENTUITY_CODER_HUB_URL: hubWsUrl,
 		};
 		env.AGENTUITY_CODER_API_KEY = ctx.auth.apiKey;
+		env.AGENTUITY_ORGID = ctx.orgId;
 
 		if (opts?.agent) {
 			env.AGENTUITY_CODER_AGENT = opts.agent;

package/src/cmd/coder/tui-init.ts

@@ -43,7 +43,7 @@ export async function probeHubInitAccess(
 	try {
 		const response = await fetchImpl(`${hubHttpUrl}/api/hub/init`, {
 			headers,
-			signal: AbortSignal.timeout(5_000),
+			signal: AbortSignal.timeout(10_000),
 		});
 
 		let payload: unknown;

package/src/cmd/coder/update.ts

@@ -54,10 +54,10 @@ export const updateSubcommand = createSubcommand({
 			loopAutoContinue: z.boolean().optional().describe('Auto-continue loop'),
 			loopAllowDetached: z.boolean().optional().describe('Allow detached loop execution'),
 			tags: z.string().optional().describe('Comma-separated tags (replaces existing)'),
-			agentSlugs: z
+			enabledAgents: z
 				.string()
 				.optional()
-				.describe('Comma-separated published custom agent slugs (replaces existing)'),
+				.describe('Comma-separated built-in/custom agents (replaces existing)'),
 		}),
 	},
 	async handler(ctx) {
@@ -81,10 +81,10 @@ export const updateSubcommand = createSubcommand({
 				.map((t) => t.trim())
 				.filter(Boolean);
 		}
-		if (opts?.agentSlugs) {
-			body.agentSlugs = opts.agentSlugs
+		if (opts?.enabledAgents) {
+			body.enabledAgents = opts.enabledAgents
 				.split(',')
-				.map((slug) => slug.trim())
+				.map((name) => name.trim())
 				.filter(Boolean);
 		}
 
@@ -105,7 +105,7 @@ export const updateSubcommand = createSubcommand({
 
 		if (Object.keys(body).length === 0) {
 			tui.fatal(
-				'No update fields provided. Use --label, --visibility, --tags, --agent, --default-agent, --agent-slugs, --workflow-mode, or loop options.',
+				'No update fields provided. Use --label, --visibility, --tags, --agent, --default-agent, --enabled-agents, --workflow-mode, or loop options.',
 				ErrorCode.VALIDATION_FAILED
 			);
 		}
@@ -125,7 +125,7 @@ export const updateSubcommand = createSubcommand({
 			if (opts?.tags) fields.push(`Tags: ${(body.tags as string[]).join(', ')}`);
 			if (opts?.agent) fields.push(`Agent: ${opts.agent}`);
 			if (opts?.defaultAgent) fields.push(`Default agent: ${opts.defaultAgent}`);
-			if (opts?.agentSlugs) fields.push(`Custom agents: ${opts.agentSlugs}`);
+			if (opts?.enabledAgents) fields.push(`Enabled agents: ${opts.enabledAgents}`);
 			if (opts?.workflowMode || body.loop) fields.push(`Workflow: ${body.workflowMode}`);
 
 			for (const f of fields) {

package/src/cmd/coder/workspace/common.ts

@@ -0,0 +1,103 @@
+import {
+	type CoderCreateWorkspaceRequest,
+	type CoderUpdateWorkspaceRequest,
+	type CoderWorkspaceDetail,
+} from '@agentuity/core/coder';
+import { StructuredError } from '@agentuity/core';
+import * as tui from '../../../tui';
+
+export const EMPTY_WORKSPACE_ERROR =
+	'A workspace needs at least one repo, dependency, setup script, saved skill, skill bucket, or agent';
+export const SetupScriptValidationError = StructuredError('SetupScriptValidationError')<{
+	message: string;
+	path?: string;
+}>();
+
+export function parseCommaList(value?: string): string[] {
+	return value
+		? value
+				.split(',')
+				.map((item) => item.trim())
+				.filter(Boolean)
+		: [];
+}
+
+export async function readSetupScript(input: {
+	setupScript?: string;
+	setupScriptFile?: string;
+}): Promise<string | undefined> {
+	if (input.setupScript !== undefined && input.setupScriptFile) {
+		throw new SetupScriptValidationError({
+			message: 'Use either --setup-script or --setup-script-file, not both.',
+		});
+	}
+	if (input.setupScript !== undefined) return input.setupScript;
+	if (!input.setupScriptFile) return undefined;
+	try {
+		return await Bun.file(input.setupScriptFile).text();
+	} catch (error) {
+		throw new SetupScriptValidationError({
+			message: `Failed to read setup script file "${input.setupScriptFile}": ${
+				error instanceof Error ? error.message : String(error)
+			}`,
+			path: input.setupScriptFile,
+			cause: error,
+		});
+	}
+}
+
+export function hasWorkspaceSelections(input: CoderCreateWorkspaceRequest): boolean {
+	return (
+		(input.repos?.length ?? 0) > 0 ||
+		(input.dependencies?.length ?? 0) > 0 ||
+		Boolean(input.setupScript?.trim()) ||
+		(input.savedSkillIds?.length ?? 0) > 0 ||
+		(input.skillBucketIds?.length ?? 0) > 0 ||
+		(input.enabledAgents?.length ?? 0) > 0
+	);
+}
+
+export function hasWorkspaceUpdate(input: CoderUpdateWorkspaceRequest): boolean {
+	return Object.keys(input).length > 0;
+}
+
+export function formatWorkspaceValidationMessage(issues: Array<{ message: string }>): string {
+	const messages = [...new Set(issues.map((issue) => issue.message).filter(Boolean))];
+	if (messages.length === 0) {
+		return 'Invalid workspace configuration';
+	}
+	if (messages.includes(EMPTY_WORKSPACE_ERROR)) {
+		return `${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, or --enabled-agents.`;
+	}
+	return messages.join('; ');
+}
+
+export function printWorkspaceSummary(workspace: CoderWorkspaceDetail): void {
+	const enabledAgents = Array.isArray(workspace.enabledAgents)
+		? workspace.enabledAgents.filter((name): name is string => typeof name === 'string')
+		: [];
+	const dependencies = Array.isArray(workspace.dependencies) ? workspace.dependencies : [];
+
+	tui.output(`  Name:        ${tui.bold(workspace.name)}`);
+	if (workspace.description) {
+		tui.output(`  Description: ${workspace.description}`);
+	}
+	tui.output(`  Scope:       ${workspace.scope}`);
+	tui.output(`  Repos:       ${workspace.repoCount}`);
+	tui.output(`  Selections:  ${workspace.selectionCount}`);
+	if (dependencies.length > 0) {
+		tui.output(`  Dependencies:${dependencies.length === 1 ? ` ${dependencies[0]}` : ''}`);
+		for (const dependency of dependencies.length === 1 ? [] : dependencies) {
+			tui.output(`    - ${dependency}`);
+		}
+	}
+	if (workspace.setupScript) {
+		tui.output('  Setup:       configured');
+	}
+	if (workspace.snapshot?.status) {
+		tui.output(`  Snapshot:    ${workspace.snapshot.status}`);
+	}
+	if (enabledAgents.length > 0) {
+		tui.output(`  Agents:      ${enabledAgents.join(', ')}`);
+	}
+}

package/src/cmd/coder/workspace/create.ts

@@ -1,37 +1,51 @@
 import { z } from 'zod';
-import { CoderClient, type CoderCreateWorkspaceRequest } from '@agentuity/core/coder';
-import { ValidationOutputError } from '@agentuity/core';
+import { APIError, ValidationInputError, ValidationOutputError } from '@agentuity/core';
+import {
+	CoderClient,
+	CoderCreateWorkspaceRequestSchema,
+	type CoderCreateWorkspaceRequest,
+} from '@agentuity/core/coder';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { resolveGitHubRepo } from '../resolve-repo';
+import {
+	EMPTY_WORKSPACE_ERROR,
+	formatWorkspaceValidationMessage,
+	hasWorkspaceSelections,
+	parseCommaList,
+	printWorkspaceSummary,
+	readSetupScript,
+} from './common';
 
 export const createWorkspaceSubcommand = createSubcommand({
 	name: 'create',
 	aliases: ['new', 'add'],
-	description: 'Create a new Coder workspace',
+	description: 'Create a new Coder workspace with at least one repo or agent',
 	tags: ['mutating', 'requires-auth'],
 	requires: { auth: true, org: true },
 	examples: [
-		{
-			command: getCommand('coder workspace create "My Workspace"'),
-			description: 'Create a workspace with a name',
-		},
 		{
 			command: getCommand(
-				'coder workspace create "My Workspace" --description "For frontend work" --scope org'
+				'coder workspace create "My Workspace" --repo https://github.com/org/repo --repo-branch main'
 			),
-			description: 'Create an org-scoped workspace with description',
+			description: 'Create a workspace with a repository',
 		},
 		{
 			command: getCommand(
-				'coder workspace create "My Workspace" --repo https://github.com/org/repo --repo-branch main'
+				'coder workspace create "My Workspace" --dependency git --setup-script-file ./setup.sh --scope org'
 			),
-			description: 'Create a workspace with a repository',
+			description: 'Create an org-scoped workspace with dependencies and a setup script',
+		},
+		{
+			command: getCommand('coder workspace create "My Workspace" --enabled-agents code-review'),
+			description: 'Create a workspace with an agent roster',
 		},
 		{
-			command: getCommand('coder workspace create "My Workspace" --json'),
+			command: getCommand(
+				'coder workspace create "My Workspace" --enabled-agents code-review --json'
+			),
 			description: 'Create a workspace and return JSON output',
 		},
 	],
@@ -45,10 +59,22 @@ export const createWorkspaceSubcommand = createSubcommand({
 			scope: z.string().optional().describe('Workspace scope: user or org'),
 			repo: z.string().optional().describe('Repository URL to add'),
 			repoBranch: z.string().optional().describe('Branch for the repository'),
-			agentSlugs: z
+			dependency: z
+				.string()
+				.optional()
+				.describe('Comma-separated APT dependencies to install into workspace snapshots'),
+			setupScript: z
+				.string()
+				.optional()
+				.describe('Inline shell script to run while preparing workspace snapshots'),
+			setupScriptFile: z
 				.string()
 				.optional()
-				.describe('Comma-separated published custom agent slugs to add'),
+				.describe('Path to a shell script to run while preparing workspace snapshots'),
+			enabledAgents: z
+				.string()
+				.optional()
+				.describe('Comma-separated built-in/custom agents to include'),
 		}),
 	},
 	async handler(ctx) {
@@ -59,9 +85,7 @@ export const createWorkspaceSubcommand = createSubcommand({
 			orgId: ctx.orgId,
 		});
 
-		const body: CoderCreateWorkspaceRequest & {
-			agentSlugs?: string[];
-		} = {
+		const body: CoderCreateWorkspaceRequest = {
 			name: args.name,
 			...(opts?.description && { description: opts.description }),
 			...(opts?.scope && { scope: opts.scope as 'user' | 'org' }),
@@ -78,18 +102,44 @@ export const createWorkspaceSubcommand = createSubcommand({
 				return;
 			}
 		}
-		if (opts?.agentSlugs) {
-			body.agentSlugs = opts.agentSlugs
-				.split(',')
-				.map((slug) => slug.trim())
-				.filter(Boolean);
+		if (opts?.dependency) {
+			body.dependencies = parseCommaList(opts.dependency);
+		}
+		try {
+			const setupScript = await readSetupScript({
+				setupScript: opts?.setupScript,
+				setupScriptFile: opts?.setupScriptFile,
+			});
+			if (setupScript !== undefined) body.setupScript = setupScript;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to read setup script: ${msg}`, ErrorCode.VALIDATION_FAILED);
+			return;
+		}
+		if (opts?.enabledAgents) {
+			body.enabledAgents = parseCommaList(opts.enabledAgents);
+		}
+		if (!hasWorkspaceSelections(body)) {
+			tui.fatal(
+				`Failed to create workspace: ${EMPTY_WORKSPACE_ERROR}. Use --repo, --dependency, --setup-script, or --enabled-agents.`,
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		const validationResult = CoderCreateWorkspaceRequestSchema.safeParse(body);
+		if (!validationResult.success) {
+			ctx.logger.trace(
+				'Validation issues: %s',
+				JSON.stringify(validationResult.error.issues, null, 2)
+			);
+			tui.fatal(
+				`Failed to create workspace: ${formatWorkspaceValidationMessage(validationResult.error.issues)}`,
+				ErrorCode.VALIDATION_FAILED
+			);
 		}
 
 		try {
-			const created = await client.createWorkspace(body);
-			const createdAgentSlugs = Array.isArray(created.agentSlugs)
-				? created.agentSlugs.filter((slug): slug is string => typeof slug === 'string')
-				: [];
+			const created = await client.createWorkspace(validationResult.data);
 
 			if (options.json) {
 				return created;
@@ -97,22 +147,19 @@ export const createWorkspaceSubcommand = createSubcommand({
 
 			tui.success(`Workspace ${created.id} created.`);
 			tui.newline();
-			tui.output(`  Name:        ${tui.bold(created.name)}`);
-			if (created.description) {
-				tui.output(`  Description: ${created.description}`);
-			}
-			tui.output(`  Scope:       ${created.scope}`);
-			tui.output(`  Repos:       ${created.repoCount}`);
-			tui.output(`  Selections:  ${created.selectionCount}`);
-			if (createdAgentSlugs.length > 0) {
-				tui.output(`  Agents:      ${createdAgentSlugs.join(', ')}`);
-			}
+			printWorkspaceSummary(created);
 
 			return created;
 		} catch (err) {
-			if (err instanceof ValidationOutputError) {
+			if (err instanceof ValidationInputError || err instanceof ValidationOutputError) {
 				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
 				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+				tui.fatal(
+					`Failed to create workspace: ${formatWorkspaceValidationMessage(err.issues)}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
 				tui.fatal(`Failed to create workspace: ${err.message}`, ErrorCode.VALIDATION_FAILED);
 			}
 			const msg = err instanceof Error ? err.message : String(err);

package/src/cmd/coder/workspace/get.ts

@@ -5,6 +5,7 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
+import { printWorkspaceSummary } from './common';
 
 function formatRelativeTime(isoDate: string): string {
 	const parsed = new Date(isoDate).getTime();
@@ -63,11 +64,7 @@ export const getWorkspaceSubcommand = createSubcommand({
 			tui.header(`Workspace: ${workspace.name}`);
 			tui.newline();
 			tui.output(`  ID:          ${workspace.id}`);
-			tui.output(`  Name:        ${tui.bold(workspace.name)}`);
-			if (workspace.description) {
-				tui.output(`  Description: ${workspace.description}`);
-			}
-			tui.output(`  Scope:       ${workspace.scope}`);
+			printWorkspaceSummary(workspace);
 			tui.output(`  Owner:       ${workspace.ownerUserId}`);
 			tui.output(`  Created:     ${formatRelativeTime(workspace.createdAt)}`);
 			tui.output(`  Updated:     ${formatRelativeTime(workspace.updatedAt)}`);

package/src/cmd/coder/workspace/index.ts

@@ -2,6 +2,9 @@ import { createCommand } from '../../../types';
 import { listSubcommand } from './list';
 import { createWorkspaceSubcommand } from './create';
 import { getWorkspaceSubcommand } from './get';
+import { refreshWorkspaceSnapshotSubcommand } from './refresh';
+import { updateWorkspaceSubcommand } from './update';
+import { validateWorkspaceDependenciesSubcommand } from './validate-dependencies';
 import { deleteWorkspaceSubcommand } from './delete';
 import { getCommand } from '../../../command-prefix';
 
@@ -17,7 +20,9 @@ export const workspaceCommand = createCommand({
 			description: 'List all workspaces',
 		},
 		{
-			command: getCommand('coder workspace create "My Workspace"'),
+			command: getCommand(
+				'coder workspace create "My Workspace" --repo https://github.com/org/repo'
+			),
 			description: 'Create a new workspace',
 		},
 		{
@@ -28,11 +33,18 @@ export const workspaceCommand = createCommand({
 			command: getCommand('coder workspace delete ws_abc123'),
 			description: 'Delete a workspace',
 		},
+		{
+			command: getCommand('coder workspace validate-dependencies git,nodejs'),
+			description: 'Validate workspace dependencies',
+		},
 	],
 	subcommands: [
 		listSubcommand,
 		createWorkspaceSubcommand,
 		getWorkspaceSubcommand,
+		updateWorkspaceSubcommand,
+		refreshWorkspaceSnapshotSubcommand,
+		validateWorkspaceDependenciesSubcommand,
 		deleteWorkspaceSubcommand,
 	],
 });

package/src/cmd/coder/workspace/list.ts

@@ -83,6 +83,8 @@ export const listSubcommand = createSubcommand({
 				Name: w.name,
 				Scope: w.scope,
 				Repos: String(w.repoCount),
+				Deps: String(w.dependencies?.length ?? 0),
+				Snapshot: w.snapshot?.status ?? '',
 				Selections: String(w.selectionCount),
 				Created: formatRelativeTime(w.createdAt),
 			})),
@@ -91,6 +93,8 @@ export const listSubcommand = createSubcommand({
 				{ name: 'Name', alignment: 'left' },
 				{ name: 'Scope', alignment: 'center' },
 				{ name: 'Repos', alignment: 'right' },
+				{ name: 'Deps', alignment: 'right' },
+				{ name: 'Snapshot', alignment: 'left' },
 				{ name: 'Selections', alignment: 'right' },
 				{ name: 'Created', alignment: 'right' },
 			]

package/src/cmd/coder/workspace/refresh.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+import { APIError, ValidationOutputError } from '@agentuity/core';
+import { CoderClient } from '@agentuity/core/coder';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { printWorkspaceSummary } from './common';
+
+export const refreshWorkspaceSnapshotSubcommand = createSubcommand({
+	name: 'refresh',
+	aliases: ['snapshot-refresh', 'rebuild'],
+	description: 'Refresh a Coder workspace snapshot',
+	tags: ['mutating', 'requires-auth'],
+	requires: { auth: true, org: true },
+	examples: [
+		{
+			command: getCommand('coder workspace refresh ws_abc123'),
+			description: 'Queue a workspace snapshot refresh',
+		},
+	],
+	schema: {
+		args: z.object({
+			workspaceId: z.string().describe('Workspace ID to refresh'),
+		}),
+		options: z.object({
+			url: z.string().optional().describe('Coder API URL override'),
+		}),
+	},
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const client = new CoderClient({
+			apiKey: ctx.auth.apiKey,
+			url: opts?.url,
+			orgId: ctx.orgId,
+		});
+
+		try {
+			const workspace = await client.refreshWorkspaceSnapshot(args.workspaceId);
+			if (options.json) {
+				return workspace;
+			}
+
+			tui.success(`Workspace ${workspace.id} snapshot refresh queued.`);
+			tui.newline();
+			printWorkspaceSummary(workspace);
+			return workspace;
+		} catch (err) {
+			if (err instanceof ValidationOutputError) {
+				ctx.logger.trace('Validation response URL: %s', err.url ?? 'unknown');
+				ctx.logger.trace('Validation issues: %s', JSON.stringify(err.issues, null, 2));
+			}
+			if (err instanceof APIError && err.status >= 400 && err.status < 500) {
+				tui.fatal(
+					`Failed to refresh workspace snapshot: ${err.message}`,
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.fatal(`Failed to refresh workspace snapshot: ${msg}`, ErrorCode.NETWORK_ERROR);
+		}
+	},
+});