@agentuity/cli 1.0.30 → 1.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "1.0.30",
+	"version": "1.0.32",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -41,9 +41,9 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/auth": "1.0.30",
-		"@agentuity/core": "1.0.30",
-		"@agentuity/server": "1.0.30",
+		"@agentuity/auth": "1.0.32",
+		"@agentuity/core": "1.0.32",
+		"@agentuity/server": "1.0.32",
 		"@datasert/cronjs-parser": "^1.4.0",
 		"@vitejs/plugin-react": "^5.1.2",
 		"acorn-loose": "^8.5.2",
@@ -60,10 +60,10 @@
 		"typescript": "^5.9.0",
 		"vite": "^7.2.7",
 		"zod": "^4.3.5",
-		"@agentuity/frontend": "1.0.30"
+		"@agentuity/frontend": "1.0.32"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "1.0.30",
+		"@agentuity/test-utils": "1.0.32",
 		"@types/adm-zip": "^0.5.7",
 		"@types/bun": "latest",
 		"@types/tar-fs": "^2.0.4",

package/src/agent-detection.ts

@@ -294,7 +294,7 @@ function initLinuxFFI(): FFIFunctions {
 			const ppidField = fields[1]; // ppid is 2nd field after state
 			if (!ppidField) return null;
 			const ppid = parseInt(ppidField, 10);
-			return isNaN(ppid) || ppid <= 1 ? null : ppid;
+			return Number.isNaN(ppid) || ppid <= 1 ? null : ppid;
 		} catch {
 			// Ignore errors
 		}

package/src/api.ts

@@ -93,7 +93,7 @@ export function getAppBaseURL(config?: Config | null): string {
 	return baseGetAppBaseURL(config?.name, overrides);
 }
 
-export function getGravityDevModeURL(region: string, config?: Config | null): string {
+export function getGravityDevModeURL(_region: string, config?: Config | null): string {
 	const overrides = config?.overrides as { gravity_url?: string } | undefined;
 	if (overrides?.gravity_url) {
 		return overrides.gravity_url;

package/src/cache/agent-intro.ts

@@ -33,10 +33,9 @@ function getDatabase(): Database {
 export function hasAgentSeenIntro(agentId: string): boolean {
 	try {
 		const row = getDatabase()
-			.query<
-				{ agent_id: string },
-				[string]
-			>('SELECT agent_id FROM agent_intro_seen WHERE agent_id = ?')
+			.query<{ agent_id: string }, [string]>(
+				'SELECT agent_id FROM agent_intro_seen WHERE agent_id = ?'
+			)
 			.get(agentId);
 		return row !== null;
 	} catch {

package/src/cache/resource-region.ts

@@ -92,7 +92,9 @@ export async function getResourceInfo(
 		.query<
 			{ region: string; org_id: string | null; project_id: string | null; last_updated: number },
 			[string, string, string]
-		>('SELECT region, org_id, project_id, last_updated FROM resource_region_cache WHERE resource_type = ? AND profile = ? AND id = ?')
+		>(
+			'SELECT region, org_id, project_id, last_updated FROM resource_region_cache WHERE resource_type = ? AND profile = ? AND id = ?'
+		)
 		.get(type, profile, id);
 
 	if (!row) {

package/src/cache/user-cache.ts

@@ -37,10 +37,9 @@ export function getCachedUserInfo(
 ): { userId: string; firstName: string; lastName: string } | null {
 	try {
 		const row = getDatabase()
-			.query<
-				{ user_id: string; first_name: string; last_name: string },
-				[string]
-			>('SELECT user_id, first_name, last_name FROM user_info_cache WHERE profile = ?')
+			.query<{ user_id: string; first_name: string; last_name: string }, [string]>(
+				'SELECT user_id, first_name, last_name FROM user_info_cache WHERE profile = ?'
+			)
 			.get(profile);
 		if (!row) return null;
 		return {

package/src/cmd/ai/opencode/install.ts

@@ -56,7 +56,7 @@ export const installSubcommand = createSubcommand({
 		const hasExactEntry = openCodeConfig.plugin.includes(pluginEntry);
 
 		// Check if there's an existing entry that needs updating
-		const existingIndex = openCodeConfig.plugin.findIndex((p) => p === '@agentuity/opencode');
+		const existingIndex = openCodeConfig.plugin.indexOf('@agentuity/opencode');
 
 		if (hasExactEntry) {
 			if (!jsonMode) {

package/src/cmd/build/ast.ts

@@ -1269,9 +1269,9 @@ function extractValidatorSchemas(callExpr: ASTCallExpression): {
 				if (unary.argument?.type === 'Identifier') {
 					const identifier = unary.argument as ASTNodeIdentifier;
 					if (identifier.name === 'true') {
-						result.stream = unary.operator === '!' ? false : true;
+						result.stream = unary.operator !== '!';
 					} else if (identifier.name === 'false') {
-						result.stream = unary.operator === '!' ? true : false;
+						result.stream = unary.operator === '!';
 					}
 				}
 			}

package/src/cmd/build/patch/_util.ts

@@ -43,7 +43,7 @@ ${inject}
 
 export function generateGatewayEnvGuard(
 	apikey: string,
-	apikeyval: string,
+	_apikeyval: string,
 	apibase: string,
 	provider: string
 ): string {
@@ -63,7 +63,7 @@ export function generateGatewayEnvGuard(
 
 export function searchBackwards(contents: string, offset: number, val: string): number {
 	for (let i = offset; i >= 0; i--) {
-		if (contents.charAt(i) == val) {
+		if (contents.charAt(i) === val) {
 			return i;
 		}
 	}

package/src/cmd/build/vite/registry-generator.ts

@@ -1067,11 +1067,11 @@ export async function generateRouteRegistry(
 	const generatedContent = `// @generated
 // Auto-generated by Agentuity - DO NOT EDIT
 ${importsStr}${typeImports}${
-		shouldEmitFrontendClient
-			? `
+	shouldEmitFrontendClient
+		? `
 import { createClient } from '@agentuity/frontend';`
-			: ''
-	}
+		: ''
+}
 // ============================================================================
 // Route Schema Type Exports
 // ============================================================================

package/src/cmd/build/vite/workbench-generator.ts

@@ -99,7 +99,7 @@ function generateIndexHtml(): string {
  */
 export async function generateWorkbenchFiles(
 	rootDir: string,
-	projectId: string,
+	_projectId: string,
 	config: WorkbenchConfig,
 	logger: Logger
 ): Promise<void> {

package/src/cmd/cloud/keyvalue/repl.ts

@@ -52,7 +52,8 @@ export const replSubcommand = createCommand({
 					const contentType = isPossiblyJSON(ctx.parsed.args[2]!)
 						? 'application/json'
 						: 'text/plain';
-					const ttl = ctx.parsed.args.length > 3 ? parseInt(ctx.parsed.args[3]!) : undefined;
+					const ttl =
+						ctx.parsed.args.length > 3 ? parseInt(ctx.parsed.args[3]!, 10) : undefined;
 					await storage.set(ctx.parsed.args[0]!, ctx.parsed.args[1]!, ctx.parsed.args[2]!, {
 						contentType,
 						ttl,
@@ -172,7 +173,10 @@ export const replSubcommand = createCommand({
 							const item = results[key];
 							if (!item) continue;
 							const sizeMB = (item.size / (1024 * 1024)).toFixed(2);
-							const date = item.lastUsed != null ? new Date(item.lastUsed).toLocaleString() : 'unknown';
+							const date =
+								item.lastUsed != null
+									? new Date(item.lastUsed).toLocaleString()
+									: 'unknown';
 							ctx.write(
 								`  ${tui.bold(key)}: ${sizeMB} MB, ${item.contentType}, updated ${date}`
 							);

package/src/cmd/cloud/keyvalue/search.ts

@@ -58,7 +58,8 @@ export const searchSubcommand = createCommand({
 					const item = results[key];
 					if (!item) continue;
 					const sizeMB = (item.size / (1024 * 1024)).toFixed(2);
-					const date = item.lastUsed != null ? new Date(item.lastUsed).toLocaleString() : 'unknown';
+					const date =
+						item.lastUsed != null ? new Date(item.lastUsed).toLocaleString() : 'unknown';
 					tui.info(`  ${tui.bold(key)}: ${sizeMB} MB, ${item.contentType}, updated ${date}`);
 				}
 			}

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

@@ -209,7 +209,7 @@ async function uploadToSandbox(
 
 async function uploadSingleFile(
 	client: APIClient,
-	logger: Logger,
+	_logger: Logger,
 	orgId: string,
 	sandboxId: string,
 	resolvedPath: string,
@@ -327,7 +327,7 @@ async function downloadFromSandbox(
 
 async function downloadSingleFile(
 	client: APIClient,
-	logger: Logger,
+	_logger: Logger,
 	orgId: string,
 	sandboxId: string,
 	remotePath: string,

package/src/cmd/cloud/storage/config.ts

@@ -18,20 +18,15 @@ import { getResourceInfo, setResourceInfo } from '../../../cache';
 function displayConfig(config: BucketConfig) {
 	tui.newline();
 	console.log(tui.bold('Bucket:          ') + config.bucket_name);
+	console.log(tui.bold('Storage Tier:    ') + (config.storage_tier ?? tui.muted('default')));
 	console.log(
-		tui.bold('Storage Tier:    ') + (config.storage_tier ?? tui.muted('default'))
-	);
-	console.log(
-		tui.bold('TTL:             ') +
-			(config.ttl != null ? `${config.ttl}s` : tui.muted('default'))
+		tui.bold('TTL:             ') + (config.ttl != null ? `${config.ttl}s` : tui.muted('default'))
 	);
 	console.log(
 		tui.bold('Public:          ') +
 			(config.public != null ? String(config.public) : tui.muted('default'))
 	);
-	console.log(
-		tui.bold('Cache Control:   ') + (config.cache_control ?? tui.muted('default'))
-	);
+	console.log(tui.bold('Cache Control:   ') + (config.cache_control ?? tui.muted('default')));
 
 	if (config.cors) {
 		console.log(tui.bold('CORS:'));

package/src/cmd/cloud/storage/list.ts

@@ -260,15 +260,20 @@ export const listSubcommand = createSubcommand({
 					if (s3.region) console.log(` Region:     ${tui.muted(s3.region)}`);
 					if (s3.endpoint) console.log(` Endpoint:   ${tui.muted(s3.endpoint)}`);
 					if (s3.object_count != null) {
-						const sizeStr = s3.total_size != null ? tui.formatBytes(s3.total_size) : 'unknown';
-						console.log(` Objects:    ${tui.muted(`${s3.object_count.toLocaleString()} (${sizeStr})`)}`);
+						const sizeStr =
+							s3.total_size != null ? tui.formatBytes(s3.total_size) : 'unknown';
+						console.log(
+							` Objects:    ${tui.muted(`${s3.object_count.toLocaleString()} (${sizeStr})`)}`
+						);
 					}
 					if (s3.last_event_at) {
 						const date = new Date(s3.last_event_at);
 						if (Number.isNaN(date.getTime())) {
 							console.log(` Activity:   ${tui.muted('unknown')}`);
 						} else {
-							console.log(` Activity:   ${tui.muted(date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit' }))}`);
+							console.log(
+								` Activity:   ${tui.muted(date.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit' }))}`
+							);
 						}
 					}
 					tui.newline();

package/src/cmd/cloud/task/create.ts

@@ -5,7 +5,7 @@ import * as tui from '../../../tui';
 import { createStorageAdapter, parseMetadataFlag, cacheTaskId } from './util';
 import { getCommand } from '../../../command-prefix';
 import { whoami } from '@agentuity/server';
-import type { TaskPriority, TaskStatus, TaskType } from '@agentuity/core';
+import type { TaskPriority, TaskStatus, TaskType, UserType } from '@agentuity/core';
 import { getCachedUserInfo, setCachedUserInfo } from '../../../cache';
 import { defaultProfileName } from '../../../config';
 
@@ -70,6 +70,10 @@ export const createSubcommand = createCommand({
 				.min(1)
 				.optional()
 				.describe('the display name of the creator (used with --created-id)'),
+			createdType: z
+				.enum(['human', 'agent'])
+				.optional()
+				.describe('the type of the creator - human user or AI agent (default: human)'),
 			projectId: z.string().optional().describe('project ID to associate with the task'),
 			projectName: z
 				.string()
@@ -101,18 +105,23 @@ export const createSubcommand = createCommand({
 
 		// Resolve creator info
 		const createdId = opts.createdId ?? ctx.auth.userId;
-		let creator: { id: string; name: string } | undefined;
-		if (opts.createdId && opts.createdName) {
-			// Explicit creator with name
-			creator = { id: opts.createdId, name: opts.createdName };
-		} else if (!opts.createdId) {
+		const createdType = (opts.createdType as UserType) ?? 'human';
+		let creator: { id: string; name: string; type?: UserType } | undefined;
+		if (opts.createdId) {
+			// Explicit creator — use createdId as name fallback (like project pattern)
+			creator = {
+				id: opts.createdId,
+				name: opts.createdName ?? opts.createdId,
+				type: createdType,
+			};
+		} else {
 			// Using auth userId — check cache first, then fall back to whoami API call
 			const profileName = ctx.config?.name ?? defaultProfileName;
 			const cached = getCachedUserInfo(profileName);
 			if (cached) {
 				const name = [cached.firstName, cached.lastName].filter(Boolean).join(' ');
 				if (name) {
-					creator = { id: createdId, name };
+					creator = { id: createdId, name, type: createdType };
 				}
 			} else {
 				// Fetch from API and cache
@@ -120,7 +129,7 @@ export const createSubcommand = createCommand({
 					const user = await whoami(ctx.apiClient);
 					const name = [user.firstName, user.lastName].filter(Boolean).join(' ');
 					if (name) {
-						creator = { id: createdId, name };
+						creator = { id: createdId, name, type: createdType };
 					}
 					setCachedUserInfo(profileName, createdId, user.firstName, user.lastName);
 				} catch {

package/src/cmd/cloud/task/delete.ts

@@ -0,0 +1,342 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+import { isDryRunMode, outputDryRun } from '../../../explain';
+import type { TaskPriority, TaskStatus, TaskType, BatchDeletedTask } from '@agentuity/core';
+
+const DURATION_UNITS: Record<string, number> = {
+	s: 1000,
+	m: 60 * 1000,
+	h: 60 * 60 * 1000,
+	d: 24 * 60 * 60 * 1000,
+	w: 7 * 24 * 60 * 60 * 1000,
+};
+
+/**
+ * Parse a human-friendly duration string (e.g. "30s", "7d", "24h", "30m", "2w")
+ * into milliseconds. Exported for testing.
+ */
+export function parseDuration(duration: string): number {
+	const match = duration.match(/^(\d+)([smhdw])$/);
+	if (!match) {
+		tui.fatal(
+			`Invalid duration format: "${duration}". Use a number followed by s (seconds), m (minutes), h (hours), d (days), or w (weeks). Examples: 30s, 30m, 24h, 7d, 2w`
+		);
+		// tui.fatal exits, but TypeScript doesn't know that
+		throw new Error('unreachable');
+	}
+	const value = parseInt(match[1]!, 10);
+	const unit = match[2]!;
+	const ms = DURATION_UNITS[unit];
+	if (!ms) {
+		tui.fatal(`Unknown duration unit: "${unit}"`);
+		throw new Error('unreachable');
+	}
+	return value * ms;
+}
+
+function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return `${s.slice(0, max - 1)}…`;
+}
+
+const TaskDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	deleted: z
+		.array(
+			z.object({
+				id: z.string().describe('Deleted task ID'),
+				title: z.string().describe('Deleted task title'),
+			})
+		)
+		.describe('List of deleted tasks'),
+	count: z.number().describe('Number of tasks deleted'),
+	durationMs: z.number().describe('Operation duration in milliseconds'),
+	dryRun: z.boolean().optional().describe('Whether this was a dry run'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm'],
+	description: 'Soft-delete a task by ID or batch-delete tasks by filter',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	requires: { auth: true },
+	examples: [
+		{
+			command: getCommand('cloud task delete task_abc123'),
+			description: 'Delete a single task by ID',
+		},
+		{
+			command: getCommand('cloud task delete --status closed --older-than 7d'),
+			description: 'Delete closed tasks older than 7 days',
+		},
+		{
+			command: getCommand('cloud task delete --status done --limit 10 --dry-run'),
+			description: 'Preview which done tasks would be deleted (dry run)',
+		},
+		{
+			command: getCommand('cloud task delete --status cancelled --confirm'),
+			description: 'Delete all cancelled tasks without confirmation prompt',
+		},
+	],
+	schema: {
+		args: z.object({
+			id: z.string().optional().describe('Task ID to delete (for single delete)'),
+		}),
+		options: z.object({
+			status: z
+				.enum(['open', 'in_progress', 'done', 'closed', 'cancelled'])
+				.optional()
+				.describe('filter batch delete by status'),
+			type: z
+				.enum(['epic', 'feature', 'enhancement', 'bug', 'task'])
+				.optional()
+				.describe('filter batch delete by type'),
+			priority: z
+				.enum(['high', 'medium', 'low', 'none'])
+				.optional()
+				.describe('filter batch delete by priority'),
+			olderThan: z
+				.string()
+				.optional()
+				.describe('filter batch delete by age (e.g. 30s, 7d, 24h, 2w)'),
+			parentId: z.string().optional().describe('filter batch delete by parent task ID'),
+			createdId: z.string().optional().describe('filter batch delete by creator ID'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.max(200)
+				.default(50)
+				.describe('max tasks to delete in batch mode (default: 50, max: 200)'),
+			confirm: z.boolean().optional().default(false).describe('skip confirmation prompt'),
+		}),
+		response: TaskDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		// Determine mode: single delete or batch delete
+		const isSingleDelete = !!args.id;
+		const hasFilters =
+			opts.status ||
+			opts.type ||
+			opts.priority ||
+			opts.olderThan ||
+			opts.parentId ||
+			opts.createdId;
+
+		if (!isSingleDelete && !hasFilters) {
+			tui.fatal(
+				'Provide a task ID for single delete, or use --status, --type, --priority, --older-than, --parent-id, or --created-id for batch delete.'
+			);
+		}
+
+		if (isSingleDelete && hasFilters) {
+			tui.fatal(
+				'Cannot combine task ID with filter options. Use either single delete (by ID) or batch delete (by filters).'
+			);
+		}
+
+		// ── Single delete mode ──────────────────────────────────────────────
+		if (isSingleDelete) {
+			if (isDryRunMode(options)) {
+				outputDryRun(`Would soft-delete task: ${args.id}`, options);
+				return {
+					success: true,
+					deleted: [{ id: args.id!, title: '(dry run)' }],
+					count: 1,
+					durationMs: Date.now() - started,
+					dryRun: true,
+					message: 'Dry run — no tasks were deleted',
+				};
+			}
+
+			if (!opts.confirm) {
+				const confirmed = await tui.confirm(`Delete task "${args.id}"?`, false);
+				if (!confirmed) {
+					if (!options.json) tui.info('Cancelled');
+					return {
+						success: false,
+						deleted: [],
+						count: 0,
+						durationMs: Date.now() - started,
+						message: 'Cancelled',
+					};
+				}
+			}
+
+			const task = await storage.softDelete(args.id!);
+			const durationMs = Date.now() - started;
+
+			if (!options.json) {
+				tui.success(`Deleted task ${tui.bold(task.id)} (${task.title}) in ${durationMs}ms`);
+			}
+
+			return {
+				success: true,
+				deleted: [{ id: task.id, title: task.title }],
+				count: 1,
+				durationMs,
+			};
+		}
+
+		// ── Batch delete mode ───────────────────────────────────────────────
+		// Validate older-than format early (before calling the API)
+		if (opts.olderThan) {
+			parseDuration(opts.olderThan); // will fatal on invalid format
+		}
+
+		const batchParams = {
+			status: opts.status as TaskStatus | undefined,
+			type: opts.type as TaskType | undefined,
+			priority: opts.priority as TaskPriority | undefined,
+			parent_id: opts.parentId,
+			created_id: opts.createdId,
+			older_than: opts.olderThan,
+			limit: opts.limit,
+		};
+
+		// For dry-run and preview, first list what would be matched
+		// (we call batchDelete only when actually executing)
+		if (isDryRunMode(options) || !opts.confirm) {
+			// Use list() to preview matching tasks
+			const preview = await storage.list({
+				status: batchParams.status,
+				type: batchParams.type,
+				priority: batchParams.priority,
+				parent_id: batchParams.parent_id,
+				limit: batchParams.limit,
+				sort: 'created_at',
+				order: 'asc',
+			});
+
+			// Client-side filters for preview (server will apply these on actual delete)
+			let candidates = preview.tasks;
+			if (batchParams.created_id) {
+				candidates = candidates.filter(
+					(t: { created_id: string }) => t.created_id === batchParams.created_id
+				);
+			}
+			if (opts.olderThan) {
+				const durationMs = parseDuration(opts.olderThan);
+				const cutoff = new Date(Date.now() - durationMs);
+				candidates = candidates.filter(
+					(t: { created_at: string }) => new Date(t.created_at) < cutoff
+				);
+			}
+
+			if (candidates.length === 0) {
+				if (!options.json) tui.info('No tasks match the given filters');
+				return {
+					success: true,
+					deleted: [],
+					count: 0,
+					durationMs: Date.now() - started,
+					message: 'No matching tasks found',
+				};
+			}
+
+			// Show preview table
+			if (!options.json) {
+				tui.warning(
+					`Found ${candidates.length} ${tui.plural(candidates.length, 'task', 'tasks')} to delete:`
+				);
+				tui.newline();
+
+				const tableData = candidates.map(
+					(task: {
+						id: string;
+						title: string;
+						status: string;
+						type: string;
+						created_at: string;
+					}) => ({
+						ID: tui.muted(truncate(task.id, 28)),
+						Title: truncate(task.title, 40),
+						Status: task.status,
+						Type: task.type,
+						Created: new Date(task.created_at).toLocaleDateString(),
+					})
+				);
+
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Title', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+					{ name: 'Type', alignment: 'left' },
+					{ name: 'Created', alignment: 'left' },
+				]);
+				tui.newline();
+			}
+
+			// Dry-run: return preview without executing
+			if (isDryRunMode(options)) {
+				outputDryRun(
+					`Would soft-delete ${candidates.length} ${tui.plural(candidates.length, 'task', 'tasks')}`,
+					options
+				);
+				return {
+					success: true,
+					deleted: candidates.map(
+						(t: { id: string; title: string }): BatchDeletedTask => ({
+							id: t.id,
+							title: t.title,
+						})
+					),
+					count: candidates.length,
+					durationMs: Date.now() - started,
+					dryRun: true,
+					message: 'Dry run — no tasks were deleted',
+				};
+			}
+
+			// Confirmation prompt
+			if (!opts.confirm) {
+				const confirmed = await tui.confirm(
+					`Delete ${candidates.length} ${tui.plural(candidates.length, 'task', 'tasks')}?`,
+					false
+				);
+				if (!confirmed) {
+					if (!options.json) tui.info('Cancelled');
+					return {
+						success: false,
+						deleted: [],
+						count: 0,
+						durationMs: Date.now() - started,
+						message: 'Cancelled',
+					};
+				}
+			}
+		}
+
+		// Execute batch delete via server-side API
+		const result = await storage.batchDelete(batchParams);
+		const durationMs = Date.now() - started;
+
+		if (!options.json) {
+			if (result.count > 0) {
+				tui.success(
+					`Deleted ${result.count} ${tui.plural(result.count, 'task', 'tasks')} in ${durationMs}ms`
+				);
+			} else {
+				tui.info('No tasks matched the given filters');
+			}
+		}
+
+		return {
+			success: true,
+			deleted: result.deleted,
+			count: result.count,
+			durationMs,
+		};
+	},
+});
+
+export default deleteSubcommand;