@assethub/cli 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,32 +1,34 @@
 #!/usr/bin/env node
-import { execFile } from 'node:child_process';
-import { chmod, mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises';
+import { setTimeout as delay } from 'node:timers/promises';
+import { ingestProjectSources } from './projectSources.js';
+import { writeCanvasComparison } from './canvasComparison.js';
+import { importCanvasAssetWithState } from './canvasAssetImport.js';
+import { execFile, spawn } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { realpathSync } from 'node:fs';
+import { chmod, mkdir, readFile, rename, unlink, writeFile, } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
-import { basename, dirname, extname, join } from 'node:path';
+import { basename, dirname, extname, join, resolve } from 'node:path';
 import { argv, env, exit, stdin, stderr, stdout } from 'node:process';
+import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
 import { AssetHubApiError, createAssetHubClient, } from '@assethub/api-client';
+import { resolveCanvasSelection, saveCanvasSelection } from './canvas.js';
+import { activeExecution, CliExecutionError, executeRecorded, hasRecordedOperation, openExecutionSession, resumeRecorded, waitForExecution, } from './execution.js';
+import { buildRunUploadPlan, formatBytes } from './runsUpload/buildRunUpload.js';
+import { readGraphFolder } from './runsUpload/graphFolder.js';
+import { uploadRun } from './runsUpload/uploadRun.js';
 const defaultBaseUrl = 'https://app.assethub.io';
-const defaultImageModelId = 'imageGen.nanoBanana.pro.openrouter';
+// Mirrors PUBLIC_IMAGE_GENERATE_DEFAULT_MODEL_ID in apps/frontend
+// (src/feature/imageGen/util/publicImageGenDefaultModel.ts). This package does
+// not depend on the app, so the value is duplicated: keep the two in step so
+// `assethub image generate` without --model matches the API's own default.
+const defaultImageModelId = 'imageGen.nanoBanana2.openrouter';
 const defaultMeshModelId = 'meshGen.hunyuan31';
 const defaultProfileName = 'default';
 const defaultPartExtractorName = 'V1.5';
+const artifactGraphPartExtractorApiValue = 'ah_agent_graph_v3_6_1';
 const partExtractorOptions = [
-    {
-        publicName: 'Part Extractor V3',
-        apiValue: 'ah_part_extractor_v3',
-        aliases: ['part extractor v3', 'v3'],
-    },
-    {
-        publicName: 'V1',
-        apiValue: 'ah_part_extractor_v5',
-        aliases: ['v1', '1'],
-    },
-    {
-        publicName: 'V1.5 alpha',
-        apiValue: 'ah_part_extractor_v55',
-        aliases: ['v1.5 alpha', 'v1.5-alpha', '1.5 alpha', '1.5-alpha'],
-    },
     {
         publicName: 'V1.5',
         apiValue: 'ah_part_extractor_v65',
@@ -42,6 +44,11 @@ const partExtractorOptions = [
         apiValue: 'ah_part_extractor_v21_alpha',
         aliases: ['v2.1 alpha', 'v2.1-alpha', '2.1 alpha'],
     },
+    {
+        publicName: 'V3.6.1',
+        apiValue: artifactGraphPartExtractorApiValue,
+        aliases: ['v3.6.1', '3.6.1', 'v3.6.1 primary images first'],
+    },
 ];
 const partExtractorPublicNames = partExtractorOptions
     .map(option => option.publicName)
@@ -49,37 +56,78 @@ const partExtractorPublicNames = partExtractorOptions
 const normalizePartExtractorName = (value) => value.trim().toLowerCase().replace(/\s+/g, ' ');
 const partExtractorByInput = new Map(partExtractorOptions.flatMap(option => [
     [normalizePartExtractorName(option.publicName), option],
-    ...option.aliases.map(alias => [
-        normalizePartExtractorName(alias),
-        option,
-    ]),
+    ...option.aliases.map(alias => [normalizePartExtractorName(alias), option]),
 ]));
 const partExtractorPublicNameByApiValue = new Map(partExtractorOptions.map(option => [option.apiValue, option.publicName]));
 const isInternalPartExtractorId = (value) => value.trim().includes('_');
 const execFileAsync = promisify(execFile);
-const usage = `AssetHub CLI
+export const usage = `AssetHub CLI
+
+Internal preview: canvas/context/layout and moodboards require workspace feature access.
 
 Usage:
   assethub auth login --api-key <key> [--base-url <url>] [--profile <name>]
   assethub auth login --api-key-stdin [--base-url <url>] [--profile <name>]
   assethub auth status [--profile <name>]
   assethub auth logout [--profile <name>]
+  assethub workspace prepare|sync|analyze|verify --internal --manifest <json> --state <json>
+  assethub workspace self-check --internal
+  assethub workspace context put --internal --org <uuid> --actor <uuid> --canvas <id> --file <json> [--if-version <n>] [--order <uuid>]
+  assethub workspace context get --internal --org <uuid> --actor <uuid> --canvas <id> [--out <json>] [--order <uuid>]
+  assethub project ingest <source-dir> --out-dir <directory> [--exclude-dir <relative-path>...]
+  assethub language text|vision --input-json @<json> --operation-id <uuid> [--out <json>]
+  assethub canvas import --canvas <id> --file <image> [--name <name>]
+  assethub canvas context get --canvas <id> [--out <json>]
+  assethub canvas context put --canvas <id> --file <json> [--if-version <n>]
+  assethub canvas layout --canvas <id> --input-json @<json>
+  assethub canvas compare --canvas <id> --source-id <asset-id> --asset-id <asset-id> --out <html>
+  assethub moodboard create --input-json @<json> [--operation-id <uuid>]
+  assethub moodboard list|get|update|archive [<board-id>] [--input-json @<json>]
+  assethub moodboard analyze <board-id> [--revision <uuid>] [--wait]
+  assethub image generate --canvas <id> --context <id> [--context-version <n>] [--context-source <key>] [--moodboard-revision <uuid>] --prompt <text> --wait
   assethub models list [--domain <domain>] [--ids-only] [--limit <n>]
   assethub models get <model-id>
   assethub files import <url> --media-type image|mesh
   assethub files upload <file> --media-type image|mesh
   assethub source create (--file <path> | --source-url <url> | --source-id <id> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri> | --clipboard) --media-type image|mesh [--file-name <name>] [--content-type <type>]
-  assethub image generate --prompt <text> [--file <path> | --source-url <url> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri> | --clipboard] [--file-name <name>] [--content-type <type>] [--model-id <id>] [--batch-size <n>] [--wait] [--download --out-dir <dir>] [--api-version v1|v2]
+  assethub capabilities
+  assethub canvas create [--name <name>] [--operation-id <uuid>]
+  assethub canvas list [--cursor <cursor>] [--limit <n>]
+  assethub canvas get|use|open [<id>]
+  assethub runs list [--canvas <id>] [--cursor <cursor>] [--limit <n>]
+  assethub runs get|watch <run-id> [--timeout-ms <n>]
+  assethub runs resume <operation-id> [--wait]
+  assethub graph show|export [--canvas <id>] [--artifact <node-id>] [--out <path>] [--allow-truncated]
+  assethub graph lineage --artifact <node-id> [--canvas <id>] [--direction ancestors|descendants|both] [--depth <n>]
+  assethub evaluate list
+  assethub evaluations submit --artifact <asset-id> --report <json|file|@file|@-> [--agent <name>] [--canvas <id>] [--reference <asset-id>...] [--run <run-id>] [--operation-id <uuid>] [--require-pass]
+  assethub evaluations list [--canvas <id>] [--artifact <asset-id>]
+  assethub evaluations get <evaluation-id>
+  assethub image generate --input-json <json|@file|@-> [--canvas <id>] [--operation-id <uuid>] [--agent <name>] [--derived-from-run <run-id>] [--from-node <graphId/nodeId> --graph-revision <rev>] [--wait]
+  assethub mesh generate --input-json <json|@file|@-> [--canvas <id>] [--operation-id <uuid>] [--agent <name>] [--derived-from-run <run-id>] [--from-node <graphId/nodeId> --graph-revision <rev>] [--wait]
+  assethub image generate --prompt <text> [--file <path> | --source-url <url> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri> | --clipboard] [--file-name <name>] [--content-type <type>] [--model-id <id>] [--batch-size <n>] [--wait] [--download --out-dir <dir>] [--canvas <id>] [--operation-id <uuid>] [--api-version v2]
   assethub image generate --prompt <text> --source-resource-id <id> --api-version v2 [--model-id <id>] [--batch-size <n>] [--wait]
   assethub mesh generate (--file <path> | --source-url <url> | --source-resource-id <id> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri>) [--file-name <name>] [--content-type <type>] [--model-id <id>] [--name <name>] [--wait] [--download --out-dir <dir>]
   assethub mesh retopo (--source-resource-id <id> | --source-url <url> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri>) --model-id <id> [--file-name <name>] [--content-type <type>] [--wait] [--download --out-dir <dir>]
+  assethub rig check (--file <path> | --source-url <url> | --source-resource-id <id> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri>) [--name <name>] [--wait] [--download --out-dir <dir>]
+  assethub rig create (--file <path> | --source-url <url> | --source-resource-id <id> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri>) [--model v1.0-20240301|v2.5-20260210] [--rig-type biped|quadruped|hexapod|octopod|avian|serpentine|aquatic] [--spec tripo|mixamo] [--out-format glb|fbx] [--name <name>] [--wait] [--download --out-dir <dir>]
+  assethub animate presets [--model v1.0-20240301|v2.5-20260210] [--rig-type <type>]
+  assethub animate retarget --resource-id <id> --animation <preset-id> [--animation <preset-id>... up to 5 total] [--out-format glb|fbx] [--bake-animation true|false] [--export-with-geometry true|false] [--animate-in-place true|false] [--name <name>] [--wait] [--download --out-dir <dir>]
   assethub jobs get <job-id> [--download --out-dir <dir>]
   assethub jobs watch <job-id> [--interval-ms <ms>] [--timeout-ms <ms>] [--download --out-dir <dir>]
   assethub production analyze (--file <path> | --source-url <url> | --source-id <id> | --image-url <url> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri> | --clipboard) [--file-name <name>] [--content-type <type>] [--part-extractor <name>] [--name <name>] [--wait] [--download --out-dir <dir>]
+  assethub production agents
+  assethub production automation --input-json <json|@file|@-> [--canvas <id>] [--operation-id <uuid>] [--wait]
   assethub production status <order-id> [--wait] [--download --out-dir <dir>]
   assethub production execute --order-id <id> --mission-id <id> --task-id <id> [--task-id <id>...] [--part-extractor <name>] [--part-extraction-mode fast|high_quality] [--wait] [--download --out-dir <dir>]
+  assethub production run --order-id <id> --mission-id <id> [--run-mode full_auto|approval] [--task-id <id>...] [--part-extractor <name>] [--part-extraction-mode fast|high_quality] [--allowed-model-id <id>...] [--max-iterations <n>] [--max-cost-credits <n>] [--wait] [--download --out-dir <dir>]
+  assethub production watch <order-id> [--interval-ms <ms>] [--timeout-ms <ms>] [--download --out-dir <dir>]
+  assethub production intervene <order-id> (--exclude <target-id> | --include <target-id> | --add-part <name> | --rename <target-id>=<name> | --reject <target-id>[=<reason>] | --regenerate <target-id>=<mode> | --set-param <key>=<value> | --ops-json <json|@file|@->)... [--idempotency-key <key>]
+  assethub production interventions <order-id>
+  assethub runs upload <path> [--graph-id <id>] [--stream-id <id>] [--rev <n>] [--description <text>] [--tag <tag>...] [--skip-register] [--dry-run]
   assethub parts split (--file <path> | --source-url <url> | --source-id <id> | --image-url <url> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri> | --clipboard | --order-id <id>) [--file-name <name>] [--content-type <type>] [--part-extractor <name>] [--wait] [--task-id <id>...] [--mission-id <id>] [--all-ready] [--download --out-dir <dir>]
   assethub parts compare (--file <path> | --source-url <url> | --source-id <id> | --image-url <url> | --file-ref-json <json> | --stdin | --stdin-base64 | --stdin-data-uri | --stdin-json | --source-json <json|@file|@-> | --data-uri <uri> | --clipboard) [--file-name <name>] [--content-type <type>] [--preprocess-prompt <text>] [--preprocess-model-id <id>] [--fail-on-preprocess-error] [--part-extractor <name>] [--wait] [--task-id <id>...] [--mission-id <id>] [--all-ready] [--download --out-dir <dir>]
+  assethub autopilot [<image>] --demo [--yolo] [--json] [--max-regen <n>] [--stall-rounds <n>] [--tie-epsilon <x>] [--multiview 2-view|4-view|6-view] [--ab-mode serial|cross] [--credit-budget <n>]
 
 Global options:
   --api-key <key>       Overrides saved auth and ASSETHUB_API_KEY.
@@ -101,7 +149,16 @@ Examples:
   cat ./input.png | assethub parts split --stdin --file-name input.png --part-extractor "V1.5" --wait
   assethub image generate --prompt "stylized prop concept" --wait
   assethub mesh generate --file ./input.png --wait
+  assethub animate presets --rig-type biped
+  assethub rig create --source-resource-id mesh_x --rig-type biped --wait
+  assethub animate retarget --resource-id rig_x --animation preset:idle --wait
   assethub production analyze --file ./input.png --part-extractor "V1.5" --wait
+  assethub production run --order-id ord_x --mission-id ms_x --run-mode full_auto --max-cost-credits 200 --wait
+  assethub production watch ord_x
+  assethub production intervene ord_x --exclude 7 --rename 3="left wing" --idempotency-key review-2026-07-29
+  assethub production interventions ord_x
+  assethub runs upload ./out/pluffy-run-2026-07-30 --dry-run
+  assethub runs upload ./out/pluffy-run-2026-07-30 --tag pluffy --description "V3 humanoid, 18 parts"
   assethub parts split --file ./input.png --part-extractor "V1.5" --wait --all-ready
   assethub parts compare --file ./input.png --preprocess-prompt "clean white background, centered product photo" --part-extractor "V1.5" --wait --all-ready
 `;
@@ -127,7 +184,7 @@ const parseArgs = (args) => {
         const value = inlineValue != null
             ? inlineValue
             : next != null && !next.startsWith('--')
-                ? (index += 1, next)
+                ? ((index += 1), next)
                 : true;
         const previous = flags[key];
         if (previous == null) {
@@ -211,11 +268,15 @@ const sanitizeProductionOutput = (value) => {
     if (value == null || typeof value !== 'object') {
         return value;
     }
-    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key]) => key !== 'publicAccessToken')
+        .map(([key, entry]) => [
         key,
-        key === 'agentVersion' && typeof entry === 'string'
-            ? publicPartExtractorName(entry)
-            : sanitizeProductionOutput(entry),
+        key === 'execution'
+            ? entry
+            : key === 'agentVersion' && typeof entry === 'string'
+                ? publicPartExtractorName(entry)
+                : sanitizeProductionOutput(entry),
     ]));
 };
 const parsePositiveIntegerFlag = (flags, name, fallback) => {
@@ -242,6 +303,24 @@ const parseBooleanFlag = (flags, name) => {
     }
     throw new Error(`--${name} must be true or false`);
 };
+/**
+ * An optional flag whose value must come from a fixed set.
+ *
+ * The server stays the authority on what it accepts; this only turns a typo
+ * into an immediate local error that names the valid values, instead of a
+ * round trip that comes back as an opaque 400. Same contract as
+ * `parseBooleanFlag`: absent means `undefined`, present-but-wrong throws.
+ */
+const parseEnumFlag = (flags, name, allowed) => {
+    const raw = getFlag(flags, name);
+    if (raw == null) {
+        return undefined;
+    }
+    if (allowed.includes(raw)) {
+        return raw;
+    }
+    throw new Error(`--${name} must be one of: ${allowed.join(', ')}`);
+};
 const parseMediaType = (value) => {
     if (value === 'image' || value === 'mesh') {
         return value;
@@ -335,15 +414,18 @@ const resolveAuth = async (flags) => {
         return {
             apiKey: storedProfile.apiKey,
             baseUrl: baseUrlFromFlags ?? env.ASSETHUB_API_BASE_URL ?? storedProfile.baseUrl,
-            profile: config.profiles?.[profile] != null ? profile : (fallbackProfileName ?? profile),
+            profile: config.profiles?.[profile] != null
+                ? profile
+                : (fallbackProfileName ?? profile),
             source: 'profile',
         };
     }
     throw new Error('Missing API key. Run "assethub auth login --api-key-stdin", set ASSETHUB_API_KEY, or pass --api-key.');
 };
-const createContext = async (flags) => {
+const createContext = async (flags, args) => {
     const auth = await resolveAuth(flags);
     return {
+        args,
         auth,
         flags,
         client: createAssetHubClient({
@@ -362,8 +444,7 @@ const isBlobLocation = (value) => {
         typeof value.path === 'string') {
         return true;
     }
-    if (value.type === 'signedSupabase' &&
-        typeof value.signedUrl === 'string') {
+    if (value.type === 'signedSupabase' && typeof value.signedUrl === 'string') {
         return true;
     }
     if (value.type === 'asset' && typeof value.assetId === 'string') {
@@ -406,7 +487,10 @@ const blobFromBase64 = (value, contentType, flagName) => {
     if (trimmed.startsWith('data:')) {
         return blobFromDataUri(trimmed, flagName);
     }
-    const normalized = trimmed.replace(/\s+/g, '').replace(/-/g, '+').replace(/_/g, '/');
+    const normalized = trimmed
+        .replace(/\s+/g, '')
+        .replace(/-/g, '+')
+        .replace(/_/g, '/');
     if (normalized === '') {
         throw new Error(`${flagName} input is empty.`);
     }
@@ -437,6 +521,61 @@ const extensionFromMimeType = (mimeType, mediaType) => {
         return 'gltf';
     return mediaType === 'image' ? 'png' : 'glb';
 };
+const contentTypeFromExtension = (extension) => {
+    switch (extension.toLowerCase()) {
+        case 'png':
+            return 'image/png';
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'webp':
+            return 'image/webp';
+        case 'gif':
+            return 'image/gif';
+        case 'bmp':
+            return 'image/bmp';
+        case 'tif':
+        case 'tiff':
+            return 'image/tiff';
+        case 'glb':
+            return 'model/gltf-binary';
+        case 'gltf':
+            return 'model/gltf+json';
+        case 'obj':
+            return 'model/obj';
+        case 'fbx':
+            return 'application/fbx';
+        case 'stl':
+            return 'model/stl';
+        case 'ply':
+            return 'text/plain';
+        case 'usdz':
+            return 'model/vnd.usdz+zip';
+        case 'usd':
+        case 'usdc':
+            return 'model/vnd.usd';
+        default:
+            return undefined;
+    }
+};
+const isNonspecificContentType = (contentType) => {
+    const clean = contentType?.split(';')[0]?.trim().toLowerCase() ?? '';
+    return (clean === '' ||
+        clean === 'application/octet-stream' ||
+        clean === 'binary/octet-stream');
+};
+const inferContentTypeFromFileName = (fileName) => {
+    const extension = extname(fileName).replace(/^\./, '');
+    if (extension === '')
+        return undefined;
+    return contentTypeFromExtension(extension);
+};
+const resolveUploadContentType = (fileName, explicitContentType) => {
+    if (!isNonspecificContentType(explicitContentType)) {
+        return explicitContentType;
+    }
+    return inferContentTypeFromFileName(fileName);
+};
 const ensureFileNameExtension = (fileName, mediaType, mimeType) => {
     if (extname(fileName) !== '') {
         return fileName;
@@ -445,7 +584,9 @@ const ensureFileNameExtension = (fileName, mediaType, mimeType) => {
 };
 const missingSourceMessage = 'Missing source. Pass --file, --source-url, --source-resource-id, --source-id, --file-ref-json, --stdin, --stdin-base64, --stdin-data-uri, --stdin-json, --source-json, --data-uri, or --clipboard.';
 const exactlyOneSourceMessage = 'Pass exactly one source input: --file, --source-url/--image-url, --source-id/--source-resource-id, --file-ref-json, --stdin, --stdin-base64, --stdin-data-uri, --stdin-json, --source-json, --data-uri, or --clipboard.';
-const getSourceUrlFlag = (flags) => getFlag(flags, 'source-url') ?? getFlag(flags, 'image-url') ?? getFlag(flags, 'url');
+const getSourceUrlFlag = (flags) => getFlag(flags, 'source-url') ??
+    getFlag(flags, 'image-url') ??
+    getFlag(flags, 'url');
 const assertFlagHasValue = (value, flagDescription) => {
     if (value === 'true' || value.trim() === '') {
         throw new Error(`Missing required flag value: ${flagDescription}`);
@@ -570,7 +711,15 @@ const sourceDescriptorFromJson = (value, options) => {
     if (resourceId != null) {
         return { kind: 'source', source: { resourceId } };
     }
-    const fileRefValue = value.fileRef ?? value.file_ref ?? value.imageBlobLocation ?? value.image_blob_location ?? value.blobLocation ?? value.blob_location;
+    const uploadId = getFirstString(value, ['uploadId', 'upload_id']);
+    if (uploadId != null)
+        return { kind: 'source', source: { uploadId } };
+    const fileRefValue = value.fileRef ??
+        value.file_ref ??
+        value.imageBlobLocation ??
+        value.image_blob_location ??
+        value.blobLocation ??
+        value.blob_location;
     if (isBlobLocation(fileRefValue)) {
         return { kind: 'source', source: { fileRef: fileRefValue } };
     }
@@ -597,7 +746,13 @@ const sourceDescriptorFromJson = (value, options) => {
             flagName: '--source-json',
         });
     }
-    const url = getFirstString(value, ['sourceUrl', 'source_url', 'url', 'publicUrl', 'public_url']);
+    const url = getFirstString(value, [
+        'sourceUrl',
+        'source_url',
+        'url',
+        'publicUrl',
+        'public_url',
+    ]);
     if (url != null) {
         const source = sourceFromString(url);
         if (source != null) {
@@ -695,24 +850,31 @@ const readClipboardImage = async () => {
         await unlink(filePath).catch(() => undefined);
     }
 };
-const uploadSourceDescriptor = async ({ descriptor, client, mediaType, }) => {
+const uploadSourceDescriptor = async ({ descriptor, client, mediaType, preferUploadId, }) => {
     if (descriptor.kind === 'source') {
         return descriptor.source;
     }
+    const fileName = descriptor.kind === 'file' ? basename(descriptor.path) : descriptor.fileName;
+    const fileNameWithExtension = ensureFileNameExtension(fileName, mediaType, descriptor.contentType);
+    const contentType = resolveUploadContentType(fileNameWithExtension, descriptor.contentType);
     const file = descriptor.kind === 'file'
-        ? await readBlob(descriptor.path, descriptor.contentType)
-        : descriptor.blob;
-    const fileName = descriptor.kind === 'file'
-        ? basename(descriptor.path)
-        : descriptor.fileName;
+        ? await readBlob(descriptor.path, contentType)
+        : isNonspecificContentType(descriptor.blob.type) && contentType != null
+            ? new Blob([descriptor.blob], { type: contentType })
+            : descriptor.blob;
     const upload = await client.v2.uploadFile({
         file,
-        fileName: ensureFileNameExtension(fileName, mediaType, descriptor.contentType),
+        fileName: fileNameWithExtension,
         mediaType,
     });
+    if (preferUploadId) {
+        if (!upload.uploadId)
+            throw new Error('Server did not return a durable upload ID');
+        return { uploadId: upload.uploadId };
+    }
     return { fileRef: upload.fileRef };
 };
-const resolveSource = async ({ flags, client, fileMediaType, }) => {
+const resolveSource = async ({ flags, client, fileMediaType, preferUploadId, }) => {
     const providedCount = sourceInputCount(flags);
     if (providedCount === 0) {
         return undefined;
@@ -741,9 +903,13 @@ const resolveSource = async ({ flags, client, fileMediaType, }) => {
     const filePath = getFlag(flags, 'file');
     if (filePath != null) {
         return await uploadSourceDescriptor({
-            descriptor: { kind: 'file', path: assertFlagHasValue(filePath, '--file <path>') },
+            descriptor: {
+                kind: 'file',
+                path: assertFlagHasValue(filePath, '--file <path>'),
+            },
             client,
             mediaType: fileMediaType,
+            preferUploadId,
         });
     }
     const dataUri = getFlag(flags, 'data-uri');
@@ -752,35 +918,49 @@ const resolveSource = async ({ flags, client, fileMediaType, }) => {
             descriptor: descriptorFromDataUri(assertFlagHasValue(dataUri, '--data-uri <uri>'), fileMediaType, getFlag(flags, 'file-name') ?? 'data-uri', '--data-uri'),
             client,
             mediaType: fileMediaType,
+            preferUploadId,
         });
     }
     if (getFlag(flags, 'source-json') != null) {
         const parsed = parseJsonValue(await readSourceJsonFlag(flags), '--source-json');
         const descriptor = sourceDescriptorFromJson(parsed, {
             mediaType: fileMediaType,
-            fallbackFileName: getFlag(flags, 'file-name') ?? defaultFileNameForMediaType(fileMediaType),
+            fallbackFileName: getFlag(flags, 'file-name') ??
+                defaultFileNameForMediaType(fileMediaType),
         });
         if (descriptor == null) {
             throw new Error('--source-json did not contain a usable source. Expected url, image_url.url, resourceId, fileRef, data URI, base64 data, or path.');
         }
-        return await uploadSourceDescriptor({ descriptor, client, mediaType: fileMediaType });
+        return await uploadSourceDescriptor({
+            descriptor,
+            client,
+            mediaType: fileMediaType,
+            preferUploadId,
+        });
     }
     if (hasFlag(flags, 'stdin-json')) {
         const parsed = parseJsonValue(await readStdin(), '--stdin-json');
         const descriptor = sourceDescriptorFromJson(parsed, {
             mediaType: fileMediaType,
-            fallbackFileName: getFlag(flags, 'file-name') ?? defaultFileNameForMediaType(fileMediaType),
+            fallbackFileName: getFlag(flags, 'file-name') ??
+                defaultFileNameForMediaType(fileMediaType),
         });
         if (descriptor == null) {
             throw new Error('--stdin-json did not contain a usable source. Expected url, image_url.url, resourceId, fileRef, data URI, base64 data, or path.');
         }
-        return await uploadSourceDescriptor({ descriptor, client, mediaType: fileMediaType });
+        return await uploadSourceDescriptor({
+            descriptor,
+            client,
+            mediaType: fileMediaType,
+            preferUploadId,
+        });
     }
     if (hasFlag(flags, 'stdin-data-uri')) {
         return await uploadSourceDescriptor({
             descriptor: descriptorFromDataUri(await readStdin(), fileMediaType, getFlag(flags, 'file-name') ?? 'stdin-data-uri', '--stdin-data-uri'),
             client,
             mediaType: fileMediaType,
+            preferUploadId,
         });
     }
     if (hasFlag(flags, 'stdin-base64')) {
@@ -788,12 +968,14 @@ const resolveSource = async ({ flags, client, fileMediaType, }) => {
             descriptor: descriptorFromBase64({
                 value: await readStdin(),
                 contentType: getContentTypeFlag(flags),
-                fileName: getFlag(flags, 'file-name') ?? defaultFileNameForMediaType(fileMediaType),
+                fileName: getFlag(flags, 'file-name') ??
+                    defaultFileNameForMediaType(fileMediaType),
                 mediaType: fileMediaType,
                 flagName: '--stdin-base64',
             }),
             client,
             mediaType: fileMediaType,
+            preferUploadId,
         });
     }
     if (hasFlag(flags, 'clipboard')) {
@@ -809,6 +991,7 @@ const resolveSource = async ({ flags, client, fileMediaType, }) => {
             },
             client,
             mediaType: fileMediaType,
+            preferUploadId,
         });
     }
     if (hasFlag(flags, 'stdin')) {
@@ -816,11 +999,13 @@ const resolveSource = async ({ flags, client, fileMediaType, }) => {
             descriptor: {
                 kind: 'blob',
                 blob: await readStdinBlob(getContentTypeFlag(flags)),
-                fileName: ensureFileNameExtension(getFlag(flags, 'file-name') ?? defaultFileNameForMediaType(fileMediaType), fileMediaType, getContentTypeFlag(flags)),
+                fileName: ensureFileNameExtension(getFlag(flags, 'file-name') ??
+                    defaultFileNameForMediaType(fileMediaType), fileMediaType, getContentTypeFlag(flags)),
                 contentType: getContentTypeFlag(flags),
             },
             client,
             mediaType: fileMediaType,
+            preferUploadId,
         });
     }
     return undefined;
@@ -832,69 +1017,126 @@ const requireSource = async (options) => {
     }
     return source;
 };
-const sourceToV1ImageInput = (source) => {
-    if (source == null) {
-        return {};
-    }
-    if ('url' in source) {
-        return { imageUrl: source.url };
-    }
-    if ('fileRef' in source) {
-        return { imageBlobLocation: source.fileRef };
-    }
-    throw new Error('v1 image generation does not accept source-resource-id. Use --source-url, --file, or --api-version v2.');
-};
 const resolveProductionAnalyzeSource = async (ctx) => {
-    const source = await requireSource({
+    const source = await recordedSource(ctx, await requireSource({
         flags: ctx.flags,
         client: ctx.client,
         fileMediaType: 'image',
-    });
-    if (source.resourceId != null) {
-        return { imageAssetId: source.resourceId };
-    }
-    if (source.url != null) {
-        return { imageUrl: source.url };
-    }
-    if (source.fileRef == null) {
-        throw new Error(missingSourceMessage);
-    }
-    return { imageBlobLocation: source.fileRef };
+        preferUploadId: true,
+    }));
+    return productionAnalyzeSourceFromSource(source);
 };
 const productionAnalyzeSourceFromSource = (source) => {
-    if (source.resourceId != null) {
+    if (source.uploadId)
+        return { uploadId: source.uploadId };
+    if (source.resourceId)
         return { imageAssetId: source.resourceId };
-    }
-    if (source.url != null) {
+    if (source.url)
         return { imageUrl: source.url };
-    }
-    return { imageBlobLocation: source.fileRef };
+    if (source.fileRef)
+        return { imageBlobLocation: source.fileRef };
+    throw new Error(missingSourceMessage);
 };
 const sourceFromProductionAnalyzeSource = (source) => {
+    if (source.uploadId)
+        return { uploadId: source.uploadId };
     if (source.imageAssetId != null) {
         return { resourceId: source.imageAssetId };
     }
     if (source.imageUrl != null) {
         return { url: source.imageUrl };
     }
-    return { fileRef: source.imageBlobLocation };
+    if (source.imageBlobLocation)
+        return { fileRef: source.imageBlobLocation };
+    throw new Error(missingSourceMessage);
 };
-const productionAnalyzeTerminalStatuses = new Set(['ready', 'failed']);
+const productionAnalyzeTerminalStatuses = new Set([
+    'ready',
+    'completed',
+    'failed',
+]);
 const productionExecuteTerminalStatuses = new Set(['completed', 'failed']);
-const pollProductionStatus = async ({ ctx, orderId, terminalStatuses, }) => {
+const parseRunModeFlag = (flags) => {
+    const raw = getFlag(flags, 'run-mode') ?? 'full_auto';
+    if (raw === 'approval' || raw === 'full_auto') {
+        return raw;
+    }
+    throw new Error('--run-mode must be "approval" or "full_auto"');
+};
+/**
+ * Derive a human-facing run phase from a production status payload. Beyond the
+ * raw order status, this surfaces `waiting_approval` — the state an approval
+ * run parks in once parts are generated but not yet reviewed.
+ */
+const deriveRunPhase = (status) => {
+    const order = status != null && typeof status === 'object' && 'order' in status
+        ? status.order
+        : undefined;
+    const orderStatus = order != null && typeof order.status === 'string' ? order.status : 'unknown';
+    if (orderStatus !== 'in_progress') {
+        return orderStatus;
+    }
+    const summary = status != null && typeof status === 'object' && 'summary' in status
+        ? status.summary
+        : undefined;
+    const pending = summary != null && typeof summary.pendingTasks === 'number'
+        ? summary.pendingTasks
+        : undefined;
+    const completed = summary != null && typeof summary.completedTasks === 'number'
+        ? summary.completedTasks
+        : undefined;
+    if (pending === 0 && completed != null && completed > 0) {
+        return 'waiting_approval';
+    }
+    return 'in_progress';
+};
+const productionWatchTerminalPhases = new Set([
+    'completed',
+    'failed',
+    'waiting_approval',
+]);
+const watchProductionRun = async ({ ctx, orderId, }) => {
     const intervalMs = parsePositiveIntegerFlag(ctx.flags, 'interval-ms', 5000);
-    const timeoutMs = parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 900000);
+    const timeoutMs = parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 1800000);
     const startedAt = Date.now();
+    let lastPhase;
     while (Date.now() - startedAt <= timeoutMs) {
         const status = await ctx.client.v1.getProductionStatus(orderId);
-        const orderStatus = status.order.status;
-        stderr.write(`[poll] order=${orderId} status=${orderStatus}\n`);
-        if (terminalStatuses.has(orderStatus)) {
+        const phase = deriveRunPhase(status);
+        if (phase !== lastPhase) {
+            stderr.write(`[watch] order=${orderId} phase=${phase}\n`);
+            lastPhase = phase;
+        }
+        if (productionWatchTerminalPhases.has(phase)) {
             return status;
         }
         await new Promise(resolve => setTimeout(resolve, intervalMs));
     }
-    throw new Error(`Polling timeout: order=${orderId} did not reach terminal state within ${timeoutMs}ms`);
+    throw new Error(`Watch timeout: order=${orderId} did not reach a terminal phase within ${timeoutMs}ms`);
+};
+const pollProductionStatus = async ({ ctx, orderId, terminalStatuses, }) => {
+    const intervalMs = parsePositiveIntegerFlag(ctx.flags, 'interval-ms', 5000);
+    const timeoutMs = parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 900000);
+    const deadline = Date.now() + timeoutMs;
+    const timeout = () => new CliExecutionError(`Wait timed out for order ${orderId}; server execution continues.`, 3, activeExecution.operationId, activeExecution.execution, activeExecution.runId);
+    while (Date.now() < deadline) {
+        const signal = AbortSignal.timeout(Math.max(1, deadline - Date.now()));
+        let status;
+        try {
+            status = await ctx.client.v1.getProductionStatus(orderId, { signal });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw timeout();
+            throw error;
+        }
+        const orderStatus = status.order.status;
+        stderr.write(`[poll] order=${orderId} status=${orderStatus}\n`);
+        if (terminalStatuses.has(orderStatus))
+            return status;
+        await new Promise(resolve => setTimeout(resolve, Math.min(intervalMs, Math.max(0, deadline - Date.now()))));
+    }
+    throw timeout();
 };
 const pollIfRequested = async ({ ctx, jobId, apiVersion = 'v2', }) => {
     if (!hasFlag(ctx.flags, 'wait')) {
@@ -923,11 +1165,18 @@ const commandSource = async (subcommand, ctx) => {
         throw new Error('Unknown source command. Use "source create".');
     }
     const mediaType = parseMediaType(requireFlag(ctx.flags, 'media-type'));
-    const source = await requireSource({
+    const source = await resolveSource({
         flags: ctx.flags,
         client: ctx.client,
         fileMediaType: mediaType,
+        preferUploadId: true,
     });
+    if (!source)
+        throw new Error(missingSourceMessage);
+    if (source.uploadId != null) {
+        print({ source, uploadId: source.uploadId, mediaType });
+        return;
+    }
     if (source.url != null) {
         print({ source, url: source.url, mediaType });
         return;
@@ -1045,82 +1294,349 @@ const commandFiles = async (subcommand, positionals, ctx) => {
     }
     throw new Error('Unknown files command. Use "files import" or "files upload".');
 };
+const stateOptions = (ctx) => ({
+    client: ctx.client,
+    cwd: process.cwd(),
+    stateDir: env.ASSETHUB_CLI_STATE_DIR ??
+        join(dirname(getConfigPath(ctx.flags)), 'state'),
+});
+const selectedCanvasId = (flags) => getFlag(flags, 'canvas') == null
+    ? undefined
+    : parsePositiveIntegerFlag(flags, 'canvas', 1);
+const executionOptions = (flags) => ({
+    operationId: getFlag(flags, 'operation-id'),
+    parentRunId: getFlag(flags, 'derived-from-run') ?? getFlag(flags, 'parent-run'),
+    agent: getFlag(flags, 'agent')
+        ? {
+            name: getFlag(flags, 'agent'),
+            sessionId: getFlag(flags, 'agent-session'),
+        }
+        : undefined,
+});
+const watchOptions = (flags) => ({
+    intervalMs: parsePositiveIntegerFlag(flags, 'interval-ms', 5000),
+    timeoutMs: parsePositiveIntegerFlag(flags, 'timeout-ms', 900000),
+    onProgress: (run) => stderr.write(`[run] ${run.runId} ${run.status}\n`),
+});
+const readJsonArgument = async (value, flag) => {
+    const text = value === '@-'
+        ? await readStdin()
+        : value.startsWith('@')
+            ? await readFile(resolve(value.slice(1)), 'utf8')
+            : value;
+    const parsed = parseJsonValue(text, flag);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new Error(`${flag} must contain a JSON object`);
+    return parsed;
+};
+const recordedSource = async (ctx, source) => {
+    if (!source)
+        return undefined;
+    if (source.url) {
+        const imported = await ctx.client.v2.importFile({
+            url: source.url,
+            mediaType: 'image',
+        });
+        if (!imported.uploadId)
+            throw new Error('Server did not return a durable upload ID');
+        return { uploadId: imported.uploadId };
+    }
+    if (source.fileRef)
+        throw new Error('Canvas history requires --file, --source-id, --source-url or an uploadId; raw fileRef is unsupported');
+    return source;
+};
+const graphSourceInput = async (ctx, canvasId) => {
+    const fromNode = getFlag(ctx.flags, 'from-node');
+    if (!fromNode) {
+        if (getFlag(ctx.flags, 'graph-revision'))
+            throw new Error('--graph-revision requires --from-node');
+        return undefined;
+    }
+    if (sourceInputCount(ctx.flags) || getFlag(ctx.flags, 'input-json'))
+        throw new Error('--from-node cannot be combined with another source or --input-json');
+    const separator = fromNode.indexOf('/');
+    if (separator < 1)
+        throw new Error('--from-node must be <graphId>/<nodeId>');
+    const graphId = fromNode.slice(0, separator), nodeId = fromNode.slice(separator + 1);
+    const revision = requireFlag(ctx.flags, 'graph-revision');
+    const graph = await ctx.client.v2.getCanvasGraph(canvasId);
+    if (graph.graphId !== graphId || graph.revision !== revision)
+        throw new Error('Graph revision changed or belongs to another canvas; read graph show again');
+    const node = graph.nodes.find(item => item.id === nodeId);
+    const assetId = node?.metadata.assetId;
+    if (typeof assetId !== 'string')
+        throw new Error('Graph node has no source asset in this graph projection');
+    return {
+        source: { resourceId: assetId },
+        graphSource: { graphId, nodeId, revision },
+    };
+};
+const executionExitCode = (execution) => ['failed', 'partial', 'cancelled'].includes(execution.status)
+    ? 1
+    : execution.status === 'needs_review' ||
+        execution.history.status !== 'recorded'
+        ? 3
+        : 0;
+const printRecorded = async (ctx, queued) => {
+    const execution = hasFlag(ctx.flags, 'wait')
+        ? await waitForExecution(ctx.client, queued.execution.runId, watchOptions(ctx.flags))
+        : queued.execution;
+    const job = hasFlag(ctx.flags, 'wait') && execution.jobIds[0]
+        ? await ctx.client.v2.getJob(execution.jobIds[0])
+        : undefined;
+    const downloads = await maybeDownloadUrls(ctx.flags, execution.outputs);
+    print({
+        queued: execution.operation.startsWith('production.')
+            ? sanitizeProductionOutput(queued)
+            : queued,
+        job,
+        execution,
+        apiVersion: execution.operation.startsWith('production.') ? 'v1' : 'v2',
+        ...(downloads ? { downloads } : {}),
+    });
+    process.exitCode = executionExitCode(execution);
+};
 const commandImage = async (subcommand, ctx) => {
-    if (subcommand !== 'generate') {
+    if (subcommand !== 'generate')
         throw new Error('Unknown image command. Use "image generate".');
-    }
-    const source = await resolveSource({
-        flags: ctx.flags,
-        client: ctx.client,
-        fileMediaType: 'image',
+    if (getFlag(ctx.flags, 'api-version') &&
+        getFlag(ctx.flags, 'api-version') !== 'v2')
+        throw new Error('Canvas generation requires --api-version v2');
+    const inputJson = getFlag(ctx.flags, 'input-json');
+    const input = inputJson
+        ? await readJsonArgument(inputJson, '--input-json')
+        : {
+            prompt: requireFlag(ctx.flags, 'prompt'),
+            modelId: getFlag(ctx.flags, 'model-id') ?? defaultImageModelId,
+            batchSize: parsePositiveIntegerFlag(ctx.flags, 'batch-size', 1),
+            negativePrompt: getFlag(ctx.flags, 'negative-prompt'),
+            seed: getFlag(ctx.flags, 'seed') == null
+                ? undefined
+                : parsePositiveIntegerFlag(ctx.flags, 'seed', 1),
+            steps: getFlag(ctx.flags, 'steps') == null
+                ? undefined
+                : parsePositiveIntegerFlag(ctx.flags, 'steps', 1),
+            cfgScale: getFlag(ctx.flags, 'cfg-scale') == null
+                ? undefined
+                : Number(getFlag(ctx.flags, 'cfg-scale')),
+        };
+    if (typeof input.prompt !== 'string' || !input.prompt.trim())
+        throw new Error('Image prompt is required');
+    const contextCanvas = getFlag(ctx.flags, 'context') == null
+        ? undefined
+        : parsePositiveIntegerFlag(ctx.flags, 'context', 1);
+    const explicitCanvas = selectedCanvasId(ctx.flags);
+    if (contextCanvas != null &&
+        explicitCanvas != null &&
+        contextCanvas !== explicitCanvas)
+        throw new Error('--context must match --canvas');
+    const session = await openExecutionSession({
+        ...stateOptions(ctx),
+        canvasId: explicitCanvas ?? contextCanvas,
+        operation: 'image.generate',
     });
-    const apiVersion = getFlag(ctx.flags, 'api-version') ?? 'v1';
-    if (apiVersion !== 'v1' && apiVersion !== 'v2') {
-        throw new Error('--api-version must be "v1" or "v2"');
-    }
-    const commonInput = {
-        prompt: requireFlag(ctx.flags, 'prompt'),
-        modelId: getFlag(ctx.flags, 'model-id') ?? defaultImageModelId,
-        batchSize: parsePositiveIntegerFlag(ctx.flags, 'batch-size', 1),
-        negativePrompt: getFlag(ctx.flags, 'negative-prompt'),
-        seed: getFlag(ctx.flags, 'seed') == null
-            ? undefined
-            : parsePositiveIntegerFlag(ctx.flags, 'seed', 1),
-        steps: getFlag(ctx.flags, 'steps') == null
-            ? undefined
-            : parsePositiveIntegerFlag(ctx.flags, 'steps', 1),
-        cfgScale: getFlag(ctx.flags, 'cfg-scale') == null
-            ? undefined
-            : Number(getFlag(ctx.flags, 'cfg-scale')),
-    };
-    const queued = apiVersion === 'v1'
-        ? await ctx.client.v1.generateImage({
-            ...commonInput,
-            ...sourceToV1ImageInput(source),
-        })
-        : await ctx.client.v2.generateImage({
-            ...commonInput,
-            source,
-        });
-    const job = await pollIfRequested({ ctx, jobId: queued.jobId, apiVersion });
-    print(await withOptionalDownloads(ctx.flags, { queued, job, apiVersion }));
+    if (contextCanvas != null) {
+        const saved = await ctx.client.v2.getCanvasContext(contextCanvas);
+        input.projectContext = {
+            canvasId: contextCanvas,
+            version: getFlag(ctx.flags, 'context-version') == null
+                ? saved.projectContext.version
+                : parsePositiveIntegerFlag(ctx.flags, 'context-version', 1),
+            ...(getFlagValues(ctx.flags, 'context-source').length
+                ? { sourceKeys: getFlagValues(ctx.flags, 'context-source') }
+                : {}),
+        };
+    }
+    const moodboardRevisionId = getFlag(ctx.flags, 'moodboard-revision');
+    if (moodboardRevisionId)
+        input.moodboardRevisionId = moodboardRevisionId;
+    const graphInput = await graphSourceInput(ctx, session.canvas.id);
+    const source = graphInput?.source ??
+        (await recordedSource(ctx, inputJson
+            ? input.source
+            : await resolveSource({
+                flags: ctx.flags,
+                client: ctx.client,
+                fileMediaType: 'image',
+                preferUploadId: true,
+            })));
+    if (source)
+        input.source = source;
+    if (Array.isArray(input.sources))
+        input.sources = await Promise.all(input.sources.map(source => recordedSource(ctx, source)));
+    await printRecorded(ctx, await executeRecorded(session, 'image.generate', input, { ...executionOptions(ctx.flags), graphSource: graphInput?.graphSource }));
 };
 const commandMesh = async (subcommand, ctx) => {
     if (subcommand === 'generate') {
-        const queued = await ctx.client.v2.generateMesh({
+        const inputJson = getFlag(ctx.flags, 'input-json');
+        const input = inputJson
+            ? await readJsonArgument(inputJson, '--input-json')
+            : {
+                modelId: getFlag(ctx.flags, 'model-id') ?? defaultMeshModelId,
+                name: getFlag(ctx.flags, 'name'),
+                faceLimit: getFlag(ctx.flags, 'face-limit') == null
+                    ? undefined
+                    : parsePositiveIntegerFlag(ctx.flags, 'face-limit', 1),
+                isLowPoly: parseBooleanFlag(ctx.flags, 'low-poly'),
+            };
+        const session = await openExecutionSession({
+            ...stateOptions(ctx),
+            canvasId: selectedCanvasId(ctx.flags),
+            operation: 'mesh.generate',
+        });
+        const graphInput = await graphSourceInput(ctx, session.canvas.id);
+        const source = graphInput?.source ??
+            (await recordedSource(ctx, inputJson
+                ? input.source
+                : await resolveSource({
+                    flags: ctx.flags,
+                    client: ctx.client,
+                    fileMediaType: 'image',
+                    preferUploadId: true,
+                })));
+        if (source)
+            input.source = source;
+        if (Array.isArray(input.sources))
+            input.sources = await Promise.all(input.sources.map(source => recordedSource(ctx, source)));
+        if (!input.source && !input.sources)
+            throw new Error(missingSourceMessage);
+        await printRecorded(ctx, await executeRecorded(session, 'mesh.generate', input, { ...executionOptions(ctx.flags), graphSource: graphInput?.graphSource }));
+        return;
+    }
+    if (subcommand === 'retopo') {
+        const queued = await ctx.client.v2.retopo({
             source: await requireSource({
                 flags: ctx.flags,
                 client: ctx.client,
-                fileMediaType: 'image',
+                fileMediaType: 'mesh',
             }),
-            modelId: getFlag(ctx.flags, 'model-id') ?? defaultMeshModelId,
+            modelId: requireFlag(ctx.flags, 'model-id'),
             name: getFlag(ctx.flags, 'name'),
-            faceLimit: getFlag(ctx.flags, 'face-limit') == null
-                ? undefined
-                : parsePositiveIntegerFlag(ctx.flags, 'face-limit', 1),
-            isLowPoly: parseBooleanFlag(ctx.flags, 'low-poly'),
+            faceLevel: getFlag(ctx.flags, 'face-level'),
+            polygonType: getFlag(ctx.flags, 'polygon-type'),
         });
         const job = await pollIfRequested({ ctx, jobId: queued.jobId });
         print(await withOptionalDownloads(ctx.flags, { queued, job }));
         return;
     }
-    if (subcommand === 'retopo') {
-        const queued = await ctx.client.v2.retopo({
+    throw new Error('Unknown mesh command. Use "mesh generate" or "mesh retopo".');
+};
+/**
+ * Accepted values for the rig/animate enum flags, kept next to the commands
+ * that read them. `satisfies` ties each list to the client's own type, so a
+ * new rig type or output format added there fails to compile here rather than
+ * silently going unvalidated.
+ */
+const RIG_MODEL_VERSIONS = [
+    'v1.0-20240301',
+    'v2.5-20260210',
+];
+const RIG_TYPES = [
+    'biped',
+    'quadruped',
+    'hexapod',
+    'octopod',
+    'avian',
+    'serpentine',
+    'aquatic',
+];
+const RIG_SPECS = ['tripo', 'mixamo'];
+const RIG_OUT_FORMATS = ['glb', 'fbx'];
+/**
+ * `/animations/retarget` caps `animations` at five server-side. Rejecting the
+ * sixth here means the user sees the limit before a request is built, rather
+ * than a 400 after typing them all out.
+ */
+const MAX_RETARGET_ANIMATIONS = 5;
+/**
+ * The `animate retarget` request, built from flags alone.
+ *
+ * Split out of the command — like `parseRunsUploadArgs` — so the parts worth
+ * testing (the required/at-most-five guards and the single-vs-plural field
+ * choice) need no client or network.
+ */
+export const buildAnimationRetargetRequest = (flags) => {
+    const resourceId = requireFlag(flags, 'resource-id');
+    const animations = getFlagValues(flags, 'animation');
+    const [firstAnimation] = animations;
+    if (firstAnimation == null) {
+        throw new Error('Missing required flag: --animation');
+    }
+    if (animations.length > MAX_RETARGET_ANIMATIONS) {
+        throw new Error(`--animation accepts at most ${MAX_RETARGET_ANIMATIONS} values, got ${animations.length}`);
+    }
+    const base = {
+        resourceId,
+        outFormat: parseEnumFlag(flags, 'out-format', RIG_OUT_FORMATS),
+        bakeAnimation: parseBooleanFlag(flags, 'bake-animation'),
+        exportWithGeometry: parseBooleanFlag(flags, 'export-with-geometry'),
+        animateInPlace: parseBooleanFlag(flags, 'animate-in-place'),
+        name: getFlag(flags, 'name'),
+    };
+    // Built per branch rather than spread-then-cast: `animation` and
+    // `animations` are mutually exclusive in the request type, and a cast over
+    // the whole object would stop checking the other six fields too.
+    return animations.length === 1
+        ? { ...base, animation: firstAnimation }
+        : { ...base, animations };
+};
+/**
+ * Everything `rig create` sends apart from the source, which needs a client to
+ * resolve. Separated for the same reason as `buildAnimationRetargetRequest`:
+ * the flag validation is the part worth testing.
+ */
+export const buildRigCreateOptions = (flags) => ({
+    model: parseEnumFlag(flags, 'model', RIG_MODEL_VERSIONS),
+    rigType: parseEnumFlag(flags, 'rig-type', RIG_TYPES),
+    spec: parseEnumFlag(flags, 'spec', RIG_SPECS),
+    outFormat: parseEnumFlag(flags, 'out-format', RIG_OUT_FORMATS),
+    name: getFlag(flags, 'name'),
+});
+const commandRig = async (subcommand, ctx) => {
+    if (subcommand === 'check') {
+        const queued = await ctx.client.v2.checkRig({
             source: await requireSource({
                 flags: ctx.flags,
                 client: ctx.client,
                 fileMediaType: 'mesh',
             }),
-            modelId: requireFlag(ctx.flags, 'model-id'),
             name: getFlag(ctx.flags, 'name'),
-            faceLevel: getFlag(ctx.flags, 'face-level'),
-            polygonType: getFlag(ctx.flags, 'polygon-type'),
         });
         const job = await pollIfRequested({ ctx, jobId: queued.jobId });
         print(await withOptionalDownloads(ctx.flags, { queued, job }));
         return;
     }
-    throw new Error('Unknown mesh command. Use "mesh generate" or "mesh retopo".');
+    if (subcommand === 'create') {
+        const queued = await ctx.client.v2.rigMesh({
+            source: await requireSource({
+                flags: ctx.flags,
+                client: ctx.client,
+                fileMediaType: 'mesh',
+            }),
+            ...buildRigCreateOptions(ctx.flags),
+        });
+        const job = await pollIfRequested({ ctx, jobId: queued.jobId });
+        print(await withOptionalDownloads(ctx.flags, { queued, job }));
+        return;
+    }
+    throw new Error('Unknown rig command. Use "rig check" or "rig create".');
+};
+const commandAnimate = async (subcommand, ctx) => {
+    if (subcommand === 'presets') {
+        const result = await ctx.client.v2.listAnimationPresets({
+            model: parseEnumFlag(ctx.flags, 'model', RIG_MODEL_VERSIONS),
+            rigType: parseEnumFlag(ctx.flags, 'rig-type', RIG_TYPES),
+        });
+        print(result);
+        return;
+    }
+    if (subcommand === 'retarget') {
+        const queued = await ctx.client.v2.retargetAnimation(buildAnimationRetargetRequest(ctx.flags));
+        const job = await pollIfRequested({ ctx, jobId: queued.jobId });
+        print(await withOptionalDownloads(ctx.flags, { queued, job }));
+        return;
+    }
+    throw new Error('Unknown animate command. Use "animate presets" or "animate retarget".');
 };
 const commandJobs = async (subcommand, positionals, ctx) => {
     const jobId = requirePositional(positionals, 2, 'job-id');
@@ -1311,14 +1827,17 @@ const firstBlobLocation = (value) => {
         return undefined;
     }
     const record = value;
-    if (record.type === 'supabase' && typeof record.bucket === 'string' && typeof record.path === 'string') {
+    if (record.type === 'supabase' &&
+        typeof record.bucket === 'string' &&
+        typeof record.path === 'string') {
         return {
             type: 'supabase',
             bucket: record.bucket,
             path: record.path,
         };
     }
-    if (record.type === 'signedSupabase' && typeof record.signedUrl === 'string') {
+    if (record.type === 'signedSupabase' &&
+        typeof record.signedUrl === 'string') {
         return {
             type: 'signedSupabase',
             signedUrl: record.signedUrl,
@@ -1342,7 +1861,13 @@ const imageSourceFromCompletedJob = (job) => {
     if (job.resourceId != null && job.resourceId.trim() !== '') {
         return { imageAssetId: job.resourceId };
     }
-    const resourceId = firstStringValueForKeys(job, new Set(['resourceId', 'resource_id', 'assetId', 'asset_id', 'imageAssetId']));
+    const resourceId = firstStringValueForKeys(job, new Set([
+        'resourceId',
+        'resource_id',
+        'assetId',
+        'asset_id',
+        'imageAssetId',
+    ]));
     if (resourceId != null) {
         return { imageAssetId: resourceId };
     }
@@ -1357,6 +1882,14 @@ const imageSourceFromCompletedJob = (job) => {
     throw new Error('Preprocessing completed, but the image job did not include an image source for part splitting.');
 };
 const errorToOutput = (error) => {
+    if (error instanceof CliExecutionError)
+        return {
+            message: error.message,
+            exitCode: error.exitCode,
+            operationId: error.operationId,
+            runId: error.runId,
+            execution: error.execution,
+        };
     if (error instanceof AssetHubApiError) {
         return {
             name: error.name,
@@ -1381,7 +1914,9 @@ const readyTaskIdsFromStatus = (status) => {
         return [];
     }
     return missions.flatMap(mission => {
-        if (mission == null || typeof mission !== 'object' || !('tasks' in mission)) {
+        if (mission == null ||
+            typeof mission !== 'object' ||
+            !('tasks' in mission)) {
             return [];
         }
         const tasks = mission.tasks;
@@ -1415,21 +1950,203 @@ const singleMissionIdFromStatus = (status) => {
     }
     return missionId;
 };
+/**
+ * Flag forms for the intervention ops, one per contract op.
+ *
+ * `params.set` has no `--params-set`: parameters arrive as repeated
+ * `--set-param key=value` and merge into a single op (see below).
+ */
+const interventionOpFlags = [
+    'add-part',
+    'exclude',
+    'include',
+    'regenerate',
+    'reject',
+    'rename',
+    'set-param',
+];
+const isInterventionOpFlag = (name) => interventionOpFlags.includes(name);
+/** Splits on the FIRST `=` so a value may itself contain one. */
+const splitOnFirstEquals = (value) => {
+    const index = value.indexOf('=');
+    return index === -1
+        ? [value, undefined]
+        : [value.slice(0, index), value.slice(index + 1)];
+};
+const requireOpValue = (flag, value, shape) => {
+    if (value == null || value.trim().length === 0) {
+        throw new Error(`--${flag} requires a value: --${flag} ${shape}`);
+    }
+    return value;
+};
+/**
+ * Builds an intervention batch from the raw argument slice.
+ *
+ * Raw argv rather than the parsed `Flags` record on purpose: that record is
+ * keyed by flag name, so it can report every `--exclude` but not whether one of
+ * them preceded an `--add-part`. The batch's order becomes the log's `seq`
+ * order, which is the order the operator made the decisions in, so it has to
+ * survive parsing.
+ *
+ * Repeated `--set-param` flags merge into ONE `params.set` op, emitted at the
+ * position of the first of them. Two parameters set in the same invocation are
+ * one decision; writing them as two log rows would make the log claim the
+ * operator changed their mind halfway through.
+ *
+ * Values are not validated against the contract's key set. The CLI carries no
+ * zod and must not carry a second copy of the contract either -- an unknown
+ * param key is the server's 400 to give, from the one place the contract is
+ * enforced. Only the shape this function itself has to parse is checked here.
+ */
+export const interventionOpsFromArgs = (args) => {
+    const ops = [];
+    let paramsOp = null;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('--'))
+            continue;
+        const [rawName, inlineValue] = splitOnFirstEquals(arg.slice(2));
+        const flag = rawName.trim();
+        if (!isInterventionOpFlag(flag))
+            continue;
+        const next = args[index + 1];
+        const value = inlineValue != null
+            ? inlineValue
+            : next != null && !next.startsWith('--')
+                ? ((index += 1), next)
+                : undefined;
+        if (flag === 'add-part') {
+            ops.push({ op: 'part.add', name: requireOpValue(flag, value, '<name>') });
+            continue;
+        }
+        if (flag === 'exclude' || flag === 'include') {
+            ops.push({
+                op: flag === 'exclude' ? 'part.exclude' : 'part.include',
+                targetId: requireOpValue(flag, value, '<target-id>'),
+            });
+            continue;
+        }
+        if (flag === 'rename') {
+            const [targetId, name] = splitOnFirstEquals(requireOpValue(flag, value, '<target-id>=<name>'));
+            if (targetId.trim().length === 0 ||
+                name == null ||
+                name.trim().length === 0) {
+                throw new Error('--rename requires --rename <target-id>=<name>');
+            }
+            ops.push({ op: 'part.rename', targetId, name });
+            continue;
+        }
+        if (flag === 'regenerate') {
+            const [targetId, mode] = splitOnFirstEquals(requireOpValue(flag, value, '<target-id>=<mode>'));
+            if (targetId.trim().length === 0 ||
+                mode == null ||
+                mode.trim().length === 0) {
+                throw new Error('--regenerate requires --regenerate <target-id>=<mode>');
+            }
+            ops.push({ op: 'part.regenerate', targetId, mode });
+            continue;
+        }
+        if (flag === 'reject') {
+            const [targetId, reason] = splitOnFirstEquals(requireOpValue(flag, value, '<target-id>[=<reason>]'));
+            if (targetId.trim().length === 0) {
+                throw new Error('--reject requires --reject <target-id>[=<reason>]');
+            }
+            // `--reject 7=` is a typo, not "no reason": the contract rejects a blank
+            // one, so it is refused here rather than round-tripped for a 400.
+            if (reason != null && reason.trim().length === 0) {
+                throw new Error('--reject reason must not be blank');
+            }
+            ops.push(reason == null
+                ? { op: 'part.reject', targetId }
+                : { op: 'part.reject', targetId, reason });
+            continue;
+        }
+        const [key, paramValue] = splitOnFirstEquals(requireOpValue(flag, value, '<key>=<value>'));
+        if (key.trim().length === 0 ||
+            paramValue == null ||
+            paramValue.trim().length === 0) {
+            throw new Error('--set-param requires --set-param <key>=<value>');
+        }
+        if (paramsOp == null) {
+            paramsOp = { op: 'params.set', patch: {} };
+            // Cast because the patch is intentionally open here: the contract's key
+            // set is enforced server-side, in one place, not duplicated in the CLI.
+            ops.push(paramsOp);
+        }
+        paramsOp.patch[key] = paramValue;
+    }
+    return ops;
+};
+const readOpsJsonFlag = async (flags) => {
+    const value = getFlag(flags, 'ops-json');
+    if (value == null || value === 'true' || value.trim() === '') {
+        throw new Error('Missing required flag value: --ops-json <json|@file|@->');
+    }
+    const raw = value === '@-' || value === '-'
+        ? await readStdin()
+        : value.startsWith('@')
+            ? await readFile(value.slice(1), 'utf8')
+            : value;
+    const parsed = parseJsonValue(raw, '--ops-json');
+    if (!Array.isArray(parsed)) {
+        throw new Error('--ops-json must be a JSON array of intervention ops');
+    }
+    return parsed;
+};
+const productionSession = (ctx, operation) => openExecutionSession({
+    ...stateOptions(ctx),
+    canvasId: selectedCanvasId(ctx.flags),
+    operation,
+});
+const childOperationId = (parent, step) => {
+    const hash = createHash('sha256')
+        .update(JSON.stringify([parent, step]))
+        .digest('hex');
+    return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-4${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+};
 const commandProduction = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'agents') {
+        print(sanitizeProductionOutput(await ctx.client.v1.getProductionAgents()));
+        return;
+    }
     if (subcommand === 'analyze') {
-        const analyzed = await ctx.client.v1.analyzeProduction({
+        const session = await productionSession(ctx, 'production.analyze');
+        const analyzed = await executeRecorded(session, 'production.analyze', {
             ...(await resolveProductionAnalyzeSource(ctx)),
             agentVersion: resolvePartExtractorForAnalyze(ctx.flags),
             name: getFlag(ctx.flags, 'name'),
-        });
-        const status = hasFlag(ctx.flags, 'wait')
-            ? await pollProductionStatus({
-                ctx,
-                orderId: analyzed.orderId,
-                terminalStatuses: productionAnalyzeTerminalStatuses,
-            })
-            : undefined;
-        print(await withOptionalDownloads(ctx.flags, sanitizeProductionOutput({ analyzed, status })));
+        }, executionOptions(ctx.flags));
+        await printRecorded(ctx, analyzed);
+        return;
+    }
+    if (subcommand === 'automation') {
+        const session = await productionSession(ctx, 'production.automation');
+        const input = getFlag(ctx.flags, 'input-json');
+        const body = input
+            ? await readJsonArgument(input, '--input-json')
+            : {
+                images: [await resolveProductionAnalyzeSource(ctx)],
+                agentVersion: resolvePartExtractorForAnalyze(ctx.flags),
+                name: getFlag(ctx.flags, 'name'),
+            };
+        if (!Array.isArray(body.images) || !body.images.length)
+            throw new Error('production automation requires non-empty images[]');
+        const images = await Promise.all(body.images.map(async (image) => {
+            if (!image || typeof image !== 'object')
+                throw new Error('Invalid automation image source');
+            return productionAnalyzeSourceFromSource((await recordedSource(ctx, sourceFromProductionAnalyzeSource(image))));
+        }));
+        const queued = await executeRecorded(session, 'production.automation', {
+            ...body,
+            images,
+            agentVersion: body.agentVersion ?? resolvePartExtractorForAnalyze(ctx.flags),
+            ...(getFlag(ctx.flags, 'max-cost-credits')
+                ? {
+                    maxCostCredits: parsePositiveIntegerFlag(ctx.flags, 'max-cost-credits', 1),
+                }
+                : {}),
+        }, executionOptions(ctx.flags));
+        await printRecorded(ctx, queued);
         return;
     }
     if (subcommand === 'status') {
@@ -1464,41 +2181,182 @@ const commandProduction = async (subcommand, positionals, ctx) => {
         const agentVersion = partExtractorFlag == null
             ? await resolvePartExtractorFromMission(ctx, orderId, missionId)
             : resolvePartExtractorApiValue(partExtractorFlag);
-        const executed = await ctx.client.v1.executeProduction({
+        const session = await productionSession(ctx, 'production.execute');
+        const executed = await executeRecorded(session, 'production.execute', {
             orderId,
             missionId,
             confirmedTaskIds,
             agentVersion,
             partExtractionMode,
+        }, executionOptions(ctx.flags));
+        await printRecorded(ctx, executed);
+        return;
+    }
+    if (subcommand === 'run') {
+        const orderId = requireFlag(ctx.flags, 'order-id');
+        const missionId = requireFlag(ctx.flags, 'mission-id');
+        const runMode = parseRunModeFlag(ctx.flags);
+        const partExtractionMode = getFlag(ctx.flags, 'part-extraction-mode');
+        if (partExtractionMode != null &&
+            partExtractionMode !== 'fast' &&
+            partExtractionMode !== 'high_quality') {
+            throw new Error('--part-extraction-mode must be "fast" or "high_quality"');
+        }
+        const partExtractorFlag = getPartExtractorFlag(ctx.flags);
+        const agentVersion = partExtractorFlag == null
+            ? await resolvePartExtractorFromMission(ctx, orderId, missionId)
+            : resolvePartExtractorApiValue(partExtractorFlag);
+        const confirmedTaskIds = getFlagValues(ctx.flags, 'task-id');
+        const allowedModelIds = getFlagValues(ctx.flags, 'allowed-model-id');
+        const maxIterations = getFlag(ctx.flags, 'max-iterations') == null
+            ? undefined
+            : parsePositiveIntegerFlag(ctx.flags, 'max-iterations', 1);
+        const maxCostCredits = getFlag(ctx.flags, 'max-cost-credits') == null
+            ? undefined
+            : parsePositiveIntegerFlag(ctx.flags, 'max-cost-credits', 1);
+        const started = await ctx.client.v1.runProduction({
+            orderId,
+            missionId,
+            agentVersion,
+            runMode,
+            ...(confirmedTaskIds.length > 0 ? { confirmedTaskIds } : {}),
+            ...(allowedModelIds.length > 0 ? { allowedModelIds } : {}),
+            ...(partExtractionMode != null
+                ? { partExtractionMode: partExtractionMode }
+                : {}),
+            ...(maxIterations != null ? { maxIterations } : {}),
+            ...(maxCostCredits != null ? { maxCostCredits } : {}),
         });
         const status = hasFlag(ctx.flags, 'wait')
-            ? await pollProductionStatus({
-                ctx,
-                orderId,
-                terminalStatuses: productionExecuteTerminalStatuses,
-            })
+            ? await watchProductionRun({ ctx, orderId })
             : undefined;
-        print(await withOptionalDownloads(ctx.flags, sanitizeProductionOutput({ executed, status })));
+        print(await withOptionalDownloads(ctx.flags, sanitizeProductionOutput({ started, status })));
+        return;
+    }
+    if (subcommand === 'interventions') {
+        const orderId = requirePositional(positionals, 2, 'order-id');
+        print(await ctx.client.v2.listInterventions(orderId));
         return;
     }
-    throw new Error('Unknown production command. Use "production analyze", "production status", or "production execute".');
+    if (subcommand === 'intervene') {
+        const orderId = requirePositional(positionals, 2, 'order-id');
+        const usesOpsJson = hasFlag(ctx.flags, 'ops-json');
+        const flagOps = interventionOpsFromArgs(ctx.args);
+        // Refused rather than concatenated: with both present the batch's order
+        // would depend on which source the CLI happened to read first, and that
+        // order becomes the log's seq order.
+        if (usesOpsJson && flagOps.length > 0) {
+            throw new Error('Use either --ops-json or the individual op flags, not both.');
+        }
+        const interventions = usesOpsJson
+            ? await readOpsJsonFlag(ctx.flags)
+            : flagOps;
+        if (interventions.length === 0) {
+            throw new Error('No interventions given. Use --exclude/--include/--add-part/--rename/--reject/--regenerate/--set-param, or --ops-json.');
+        }
+        const idempotencyKey = getFlag(ctx.flags, 'idempotency-key');
+        const appended = await ctx.client.v2.appendInterventions(orderId, interventions, 
+        // Omitted rather than passed as undefined so the request carries no header
+        // at all; the server then reports `idempotent: false` back.
+        idempotencyKey == null ? {} : { idempotencyKey });
+        print({ appended, interventions });
+        return;
+    }
+    if (subcommand === 'watch') {
+        const orderId = requirePositional(positionals, 2, 'order-id');
+        const status = await watchProductionRun({ ctx, orderId });
+        print(await withOptionalDownloads(ctx.flags, sanitizeProductionOutput({ status })));
+        return;
+    }
+    throw new Error('Unknown production command. Use "production agents", "production analyze", "production automation", "production run", "production watch", "production status", "production execute", "production intervene", or "production interventions".');
+};
+// Multi-phase commands may contain several receipts; only their durable outputs
+// are downloadable, never canvas links, source URLs or evaluation evidence URLs.
+const recordedOutputs = (value) => {
+    if (!value || typeof value !== 'object')
+        return [];
+    if (Array.isArray(value))
+        return value.flatMap(recordedOutputs);
+    return Object.entries(value).flatMap(([key, item]) => {
+        if (key === 'execution' &&
+            item &&
+            typeof item === 'object' &&
+            'outputs' in item &&
+            Array.isArray(item.outputs))
+            return item.outputs;
+        return recordedOutputs(item);
+    });
 };
+const isArtifactGraphPartSplit = (value, execution) => (value != null &&
+    typeof value === 'object' &&
+    'engine' in value &&
+    value.engine === 'artifact-graph') ||
+    execution.resolvedInput?.agentVersion === artifactGraphPartExtractorApiValue;
 const commandParts = async (subcommand, ctx) => {
-    const runPartSplit = async (source) => {
+    const runPartSplit = async (source, operationId = getFlag(ctx.flags, 'operation-id') ?? randomUUID()) => {
         let orderId = source == null ? getFlag(ctx.flags, 'order-id') : undefined;
         if (orderId != null) {
             orderId = assertFlagHasValue(orderId, '--order-id <id>');
         }
+        const partExtractorFlag = getPartExtractorFlag(ctx.flags);
+        const requestedAgentVersion = orderId == null || partExtractorFlag != null
+            ? resolvePartExtractorApiValue(partExtractorFlag ?? defaultPartExtractorName)
+            : undefined;
+        if (requestedAgentVersion === artifactGraphPartExtractorApiValue) {
+            for (const flag of ['task-id', 'mission-id', 'part-extraction-mode']) {
+                if (hasFlag(ctx.flags, flag))
+                    throw new Error(`--${flag} is not supported with V3.6.1`);
+            }
+            if (orderId != null)
+                throw new Error('--order-id is not supported with V3.6.1; use runs resume <operation-id> to resume a graph split');
+        }
+        const session = await productionSession(ctx, orderId == null ? 'production.analyze' : 'production.execute');
+        let execution;
         let analyzed;
         let status;
         if (orderId == null) {
-            const result = await ctx.client.v1.analyzeProduction({
+            const result = await executeRecorded(session, 'production.analyze', {
                 ...(source ?? (await resolveProductionAnalyzeSource(ctx))),
                 agentVersion: resolvePartExtractorForAnalyze(ctx.flags),
                 name: getFlag(ctx.flags, 'name'),
-            });
+            }, { ...executionOptions(ctx.flags), operationId });
             analyzed = result;
-            orderId = result.orderId;
+            execution = result.execution;
+            if (isArtifactGraphPartSplit(result, execution)) {
+                stderr.write(`[run] ${execution.runId} graph=${execution.orderIds[0] ?? execution.runId}\n`);
+                if (hasFlag(ctx.flags, 'wait') || hasFlag(ctx.flags, 'all-ready'))
+                    execution = await waitForExecution(ctx.client, execution.runId, watchOptions(ctx.flags));
+                process.exitCode = executionExitCode(execution);
+                return sanitizeProductionOutput({ execution, analyzed });
+            }
+            orderId = execution.orderIds[0];
+            if (!orderId)
+                throw new CliExecutionError('Analysis receipt omitted its order', 3, operationId, execution);
+            stderr.write(`[run] ${execution.runId} order=${orderId}\n`);
+            const executeOperationId = childOperationId(operationId, 'execute');
+            if ((hasFlag(ctx.flags, 'all-ready') ||
+                getFlagValues(ctx.flags, 'task-id').length > 0) &&
+                (await hasRecordedOperation(session.stateDir, executeOperationId))) {
+                const resumed = await resumeRecorded({
+                    ...stateOptions(ctx),
+                    operationId: executeOperationId,
+                    expectedCanvasId: session.canvas.id,
+                    expectedBody: {
+                        partExtractionMode: getFlag(ctx.flags, 'part-extraction-mode'),
+                        ...(getFlagValues(ctx.flags, 'task-id').length
+                            ? { confirmedTaskIds: getFlagValues(ctx.flags, 'task-id') }
+                            : {}),
+                        ...(getFlag(ctx.flags, 'mission-id')
+                            ? { missionId: getFlag(ctx.flags, 'mission-id') }
+                            : {}),
+                    },
+                });
+                const execution = hasFlag(ctx.flags, 'wait') || hasFlag(ctx.flags, 'all-ready')
+                    ? await waitForExecution(ctx.client, resumed.execution.runId, watchOptions(ctx.flags))
+                    : resumed.execution;
+                process.exitCode = executionExitCode(execution);
+                return { execution, executed: sanitizeProductionOutput(resumed) };
+            }
             if (hasFlag(ctx.flags, 'wait') || hasFlag(ctx.flags, 'all-ready')) {
                 status = await pollProductionStatus({
                     ctx,
@@ -1541,13 +2399,21 @@ const commandParts = async (subcommand, ctx) => {
                 partExtractionMode !== 'high_quality') {
                 throw new Error('--part-extraction-mode must be "fast" or "high_quality"');
             }
-            executed = await ctx.client.v1.executeProduction({
+            const result = await executeRecorded(session, 'production.execute', {
                 orderId,
                 missionId,
                 confirmedTaskIds: taskIds,
                 agentVersion,
                 partExtractionMode,
+            }, {
+                ...executionOptions(ctx.flags),
+                operationId: execution
+                    ? childOperationId(operationId, 'execute')
+                    : operationId,
+                parentRunId: execution?.runId ?? executionOptions(ctx.flags).parentRunId,
             });
+            executed = result;
+            execution = result.execution;
             if (hasFlag(ctx.flags, 'wait')) {
                 executionStatus = await pollProductionStatus({
                     ctx,
@@ -1556,7 +2422,14 @@ const commandParts = async (subcommand, ctx) => {
                 });
             }
         }
+        if (execution &&
+            (hasFlag(ctx.flags, 'wait') || hasFlag(ctx.flags, 'all-ready'))) {
+            execution = await waitForExecution(ctx.client, execution.runId, watchOptions(ctx.flags));
+        }
+        if (execution)
+            process.exitCode = executionExitCode(execution);
         return sanitizeProductionOutput({
+            execution,
             analyzed,
             status,
             executed,
@@ -1564,10 +2437,13 @@ const commandParts = async (subcommand, ctx) => {
         });
     };
     if (subcommand === 'split') {
-        if (getFlag(ctx.flags, 'order-id') != null && sourceInputCount(ctx.flags) > 0) {
+        if (getFlag(ctx.flags, 'order-id') != null &&
+            sourceInputCount(ctx.flags) > 0) {
             throw new Error('Pass either --order-id or one image source, not both.');
         }
-        print(await withOptionalDownloads(ctx.flags, await runPartSplit()));
+        const result = await runPartSplit();
+        const downloads = await maybeDownloadUrls(ctx.flags, recordedOutputs(result));
+        print({ ...result, ...(downloads ? { downloads } : {}) });
         return;
     }
     if (subcommand === 'compare') {
@@ -1578,7 +2454,8 @@ const commandParts = async (subcommand, ctx) => {
         if (preprocessPrompt === 'true') {
             throw new Error('Missing required flag value: --preprocess-prompt <text>');
         }
-        if (preprocessPrompt != null && getFlagValues(ctx.flags, 'task-id').length > 0) {
+        if (preprocessPrompt != null &&
+            getFlagValues(ctx.flags, 'task-id').length > 0) {
             throw new Error('parts compare preprocessing creates a second order. Use --all-ready instead of --task-id.');
         }
         if (preprocessPrompt != null && getFlag(ctx.flags, 'mission-id') != null) {
@@ -1588,17 +2465,22 @@ const commandParts = async (subcommand, ctx) => {
         if (preprocessModelId === 'true') {
             throw new Error('Missing required flag value: --preprocess-model-id <id>');
         }
+        const compareSession = await productionSession(ctx, 'production.analyze');
+        const compareOperationId = getFlag(ctx.flags, 'operation-id') ?? randomUUID();
         const inputSource = productionAnalyzeSourceFromSource(await requireSource({
             flags: ctx.flags,
             client: ctx.client,
             fileMediaType: 'image',
+            preferUploadId: true,
         }));
-        const direct = await runPartSplit(inputSource);
+        const durableInput = productionAnalyzeSourceFromSource((await recordedSource(ctx, sourceFromProductionAnalyzeSource(inputSource))));
+        const direct = await runPartSplit(durableInput, compareOperationId);
         let preprocessed = null;
         if (preprocessPrompt != null && preprocessPrompt !== 'true') {
+            const preprocessOperationId = childOperationId(compareOperationId, 'preprocess');
             try {
-                const queued = await ctx.client.v2.generateImage({
-                    source: sourceFromProductionAnalyzeSource(inputSource),
+                const queued = await executeRecorded(compareSession, 'image.generate', {
+                    source: sourceFromProductionAnalyzeSource(durableInput),
                     prompt: preprocessPrompt,
                     modelId: preprocessModelId ?? defaultImageModelId,
                     batchSize: 1,
@@ -1606,8 +2488,15 @@ const commandParts = async (subcommand, ctx) => {
                     seed: getFlag(ctx.flags, 'preprocess-seed') == null
                         ? undefined
                         : parsePositiveIntegerFlag(ctx.flags, 'preprocess-seed', 1),
+                }, {
+                    ...executionOptions(ctx.flags),
+                    operationId: preprocessOperationId,
                 });
-                const job = await ctx.client.v2.pollJob(queued.jobId, {
+                const completed = await waitForExecution(ctx.client, queued.execution.runId, watchOptions(ctx.flags));
+                const jobId = completed.jobIds[0];
+                if (!jobId)
+                    throw new CliExecutionError('Preprocessing omitted its job', 3, undefined, completed);
+                const job = await ctx.client.v2.pollJob(jobId, {
                     intervalMs: parsePositiveIntegerFlag(ctx.flags, 'interval-ms', 5000),
                     timeoutMs: parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 900000),
                     onPoll: current => {
@@ -1625,27 +2514,445 @@ const commandParts = async (subcommand, ctx) => {
                         job,
                         source: generatedSource,
                     },
-                    split: await runPartSplit(generatedSource),
+                    split: await runPartSplit(generatedSource, childOperationId(compareOperationId, 'preprocessed-split')),
                 };
             }
             catch (error) {
+                const failure = error instanceof CliExecutionError ||
+                    activeExecution.operationId !== preprocessOperationId
+                    ? error
+                    : new CliExecutionError(error instanceof Error ? error.message : String(error), 1, preprocessOperationId, activeExecution.execution, activeExecution.runId);
                 if (hasFlag(ctx.flags, 'fail-on-preprocess-error')) {
-                    throw error;
+                    throw failure;
                 }
+                process.exitCode =
+                    failure instanceof CliExecutionError ? failure.exitCode : 1;
                 preprocessed = {
                     ok: false,
-                    error: errorToOutput(error),
+                    error: errorToOutput(failure),
                 };
             }
         }
-        print(await withOptionalDownloads(ctx.flags, {
-            direct,
-            preprocessed,
-        }));
+        const result = { direct, preprocessed };
+        const downloads = await maybeDownloadUrls(ctx.flags, recordedOutputs(result));
+        print({ ...result, ...(downloads ? { downloads } : {}) });
         return;
     }
     throw new Error('Unknown parts command. Use "parts split" or "parts compare".');
 };
+const pageOptions = (flags) => ({
+    cursor: getFlag(flags, 'cursor'),
+    limit: getFlag(flags, 'limit') == null
+        ? undefined
+        : parsePositiveIntegerFlag(flags, 'limit', 50),
+});
+const canvasForRead = (ctx) => openExecutionSession({
+    ...stateOptions(ctx),
+    canvasId: selectedCanvasId(ctx.flags),
+    create: false,
+});
+const commandCanvas = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'context' ||
+        subcommand === 'import' ||
+        subcommand === 'compare' ||
+        subcommand === 'layout') {
+        const { canvas } = await canvasForRead(ctx);
+        if (subcommand === 'context') {
+            const action = positionals[2];
+            if (action !== 'get' && action !== 'put')
+                throw new Error('Use canvas context get|put');
+            const result = action === 'get'
+                ? await ctx.client.v2.getCanvasContext(canvas.id)
+                : await ctx.client.v2.putCanvasContext(canvas.id, {
+                    document: await readJsonArgument(`@${requireFlag(ctx.flags, 'file')}`, '--file'),
+                    expectedVersion: parseNonNegativeIntegerFlag(ctx.flags, 'if-version'),
+                });
+            const out = getFlag(ctx.flags, 'out');
+            if (out) {
+                await mkdir(dirname(resolve(out)), { recursive: true });
+                await writeFile(resolve(out), JSON.stringify(result.projectContext.document, null, 2) + '\n', { mode: 0o600 });
+            }
+            print(result);
+        }
+        else if (subcommand === 'layout') {
+            const input = await readJsonArgument(requireFlag(ctx.flags, 'input-json'), '--input-json');
+            print(await ctx.client.v2.appendCanvasLayout(canvas.id, input));
+        }
+        else if (subcommand === 'import') {
+            const filePath = getFlag(ctx.flags, 'file');
+            const uploadId = getFlag(ctx.flags, 'upload-id');
+            const resourceId = getSourceResourceIdFlag(ctx.flags);
+            if ([filePath, uploadId, resourceId].filter(value => value != null)
+                .length !== 1 ||
+                sourceInputCount(ctx.flags) > (uploadId == null ? 1 : 0))
+                throw new Error('Provide exactly one of --file, --resource-id, or --upload-id');
+            print(await importCanvasAssetWithState({
+                client: ctx.client,
+                baseUrl: ctx.client.baseUrl,
+                ownerId: canvas.ownerId,
+                canvasId: canvas.id,
+                stateDir: stateOptions(ctx).stateDir,
+                name: getFlag(ctx.flags, 'name'),
+                ...(filePath != null
+                    ? {
+                        filePath: assertFlagHasValue(filePath, '--file <image>'),
+                        contentType: getContentTypeFlag(ctx.flags),
+                    }
+                    : {
+                        source: uploadId != null
+                            ? {
+                                uploadId: assertFlagHasValue(uploadId, '--upload-id <id>'),
+                            }
+                            : {
+                                resourceId: assertFlagHasValue(resourceId, '--resource-id <id>'),
+                            },
+                    }),
+            }));
+        }
+        else {
+            print(await writeCanvasComparison({
+                client: ctx.client,
+                canvasId: canvas.id,
+                sourceId: requireFlag(ctx.flags, 'source-id'),
+                assetId: requireFlag(ctx.flags, 'asset-id'),
+                out: requireFlag(ctx.flags, 'out'),
+                title: getFlag(ctx.flags, 'title'),
+            }));
+        }
+        return;
+    }
+    if (subcommand === 'list') {
+        print(await ctx.client.v2.listCanvases(pageOptions(ctx.flags)));
+        return;
+    }
+    const capabilities = await ctx.client.v2.getCapabilities();
+    if (capabilities.executionContext.status !== 'available')
+        throw new Error('Canvas execution history unavailable');
+    const scope = {
+        ...stateOptions(ctx),
+        baseUrl: ctx.client.baseUrl,
+        ownerId: capabilities.ownerId,
+    };
+    if (subcommand === 'create') {
+        const canvas = await ctx.client.v2.createCanvas({ name: getFlag(ctx.flags, 'name') ?? 'Agent canvas' }, { idempotencyKey: getFlag(ctx.flags, 'operation-id') ?? randomUUID() });
+        await saveCanvasSelection(scope, canvas.id);
+        print(canvas);
+        return;
+    }
+    if (!['get', 'use', 'open'].includes(subcommand ?? ''))
+        throw new Error('Use canvas create|list|get|use|open');
+    const id = positionals[2] == null
+        ? selectedCanvasId(ctx.flags)
+        : Number(positionals[2]);
+    const canvas = await resolveCanvasSelection({
+        ...scope,
+        canvasId: id,
+        create: false,
+    });
+    if (subcommand === 'use')
+        await saveCanvasSelection(scope, canvas.id);
+    if (subcommand === 'open' && stdout.isTTY) {
+        const url = canvas.url;
+        await execFileAsync(process.platform === 'darwin'
+            ? 'open'
+            : process.platform === 'win32'
+                ? 'rundll32'
+                : 'xdg-open', process.platform === 'win32'
+            ? ['url.dll,FileProtocolHandler', url]
+            : [url]);
+    }
+    print(canvas);
+};
+const commandLanguage = async (subcommand, ctx) => {
+    if (subcommand !== 'text' && subcommand !== 'vision')
+        throw new Error('Use language text|vision --input-json @<file> --operation-id <uuid>');
+    const input = await readJsonArgument(requireFlag(ctx.flags, 'input-json'), '--input-json');
+    const operationId = requireFlag(ctx.flags, 'operation-id');
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(operationId))
+        throw new Error('--operation-id must be a UUID; reuse the same ID and input after an uncertain response');
+    activeExecution.operationId = operationId;
+    const result = subcommand === 'text'
+        ? await ctx.client.v2.languageText(input, {
+            idempotencyKey: operationId,
+        })
+        : await ctx.client.v2.languageVision(input, {
+            idempotencyKey: operationId,
+        });
+    const out = getFlag(ctx.flags, 'out');
+    if (out) {
+        await mkdir(dirname(resolve(out)), { recursive: true });
+        await writeFile(resolve(out), JSON.stringify(result, null, 2) + '\n', {
+            mode: 0o600,
+        });
+    }
+    print(result);
+};
+const commandMoodboard = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'list') {
+        print(await ctx.client.v2.listMoodboards(pageOptions(ctx.flags)));
+        return;
+    }
+    if (subcommand === 'create' || subcommand === 'update') {
+        const input = (await readJsonArgument(requireFlag(ctx.flags, 'input-json'), '--input-json'));
+        if (subcommand === 'update') {
+            print(await ctx.client.v2.updateMoodboard(requirePositional(positionals, 2, 'board-id'), input));
+            return;
+        }
+        const { ownerId } = await ctx.client.v2.getCapabilities();
+        const fingerprint = createHash('sha256')
+            .update(JSON.stringify({ baseUrl: ctx.client.baseUrl, ownerId, input }))
+            .digest('hex');
+        const clientOperationId = getFlag(ctx.flags, 'operation-id') ??
+            `${fingerprint.slice(0, 8)}-${fingerprint.slice(8, 12)}-4${fingerprint.slice(13, 16)}-8${fingerprint.slice(17, 20)}-${fingerprint.slice(20, 32)}`;
+        activeExecution.operationId = clientOperationId;
+        print(await ctx.client.v2.createMoodboard({ ...input, clientOperationId }));
+        return;
+    }
+    const boardId = requirePositional(positionals, 2, 'board-id');
+    if (subcommand === 'get') {
+        print(await ctx.client.v2.getMoodboard(boardId));
+        return;
+    }
+    if (subcommand === 'archive') {
+        print(await ctx.client.v2.archiveMoodboard(boardId));
+        return;
+    }
+    if (subcommand !== 'analyze')
+        throw new Error('Use moodboard create|list|get|update|archive|analyze');
+    const timeoutMs = parsePositiveIntegerFlag(ctx.flags, 'timeout-ms', 900000);
+    const intervalMs = parsePositiveIntegerFlag(ctx.flags, 'interval-ms', 5000);
+    const deadline = Date.now() + timeoutMs;
+    let revision = await ctx.client.v2.analyzeMoodboard(boardId, { revisionId: getFlag(ctx.flags, 'revision') }, { signal: AbortSignal.timeout(timeoutMs) });
+    while (hasFlag(ctx.flags, 'wait') && revision.status === 'analyzing') {
+        stderr.write(`[moodboard] ${boardId} revision=${revision.id} analyzing job=${revision.analysisJobId ?? 'pending'}\n`);
+        if (Date.now() >= deadline)
+            throw new Error(`Moodboard analysis timeout; resume with moodboard get ${boardId}`);
+        await delay(Math.min(intervalMs, Math.max(1, deadline - Date.now())));
+        if (Date.now() >= deadline)
+            throw new Error(`Moodboard analysis timeout; resume with moodboard get ${boardId}`);
+        const board = await ctx.client.v2.getMoodboard(boardId, {
+            signal: AbortSignal.timeout(Math.max(1, deadline - Date.now())),
+        });
+        if (board.currentRevision?.id !== revision.id)
+            throw new Error('Moodboard revision changed while waiting; inspect the board before generating');
+        revision = board.currentRevision;
+    }
+    print(revision);
+    if (revision.status === 'failed')
+        process.exitCode = 1;
+};
+const commandGraph = async (subcommand, ctx) => {
+    if (!['show', 'lineage', 'export'].includes(subcommand ?? ''))
+        throw new Error('Use graph show|lineage|export');
+    const { canvas } = await canvasForRead(ctx);
+    const direction = getFlag(ctx.flags, 'direction') ?? 'both';
+    if (!['ancestors', 'descendants', 'both'].includes(direction))
+        throw new Error('--direction must be ancestors, descendants, or both');
+    const graph = await ctx.client.v2.getCanvasGraph(canvas.id, {
+        artifactId: subcommand === 'lineage'
+            ? requireFlag(ctx.flags, 'artifact')
+            : getFlag(ctx.flags, 'artifact'),
+        direction: direction,
+        depth: parsePositiveIntegerFlag(ctx.flags, 'depth', 5),
+    });
+    if (subcommand === 'export' &&
+        graph.truncated &&
+        !hasFlag(ctx.flags, 'allow-truncated'))
+        throw new Error('Graph exceeds export bounds; narrow with --artifact or explicitly use --allow-truncated');
+    const out = getFlag(ctx.flags, 'out');
+    if (subcommand === 'export' && out) {
+        await writeFile(resolve(out), JSON.stringify(graph, null, 2) + '\n', {
+            mode: 0o600,
+        });
+        print({
+            path: resolve(out),
+            revision: graph.revision,
+            truncated: graph.truncated,
+        });
+    }
+    else
+        print(graph);
+};
+const commandEvaluations = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'get') {
+        print(await ctx.client.v2.getEvaluation(requirePositional(positionals, 2, 'evaluation-id')));
+        return;
+    }
+    const { canvas } = await canvasForRead(ctx);
+    if (subcommand === 'list') {
+        print(await ctx.client.v2.listEvaluations({
+            ...pageOptions(ctx.flags),
+            canvasId: canvas.id,
+            artifactId: getFlag(ctx.flags, 'artifact'),
+        }));
+        return;
+    }
+    if (subcommand !== 'submit')
+        throw new Error('Use evaluations submit|list|get');
+    const reportArg = requireFlag(ctx.flags, 'report');
+    const report = await readJsonArgument(reportArg.startsWith('{') || reportArg.startsWith('@')
+        ? reportArg
+        : `@${reportArg}`, '--report');
+    const clientOperationId = getFlag(ctx.flags, 'operation-id') ?? randomUUID();
+    activeExecution.operationId = clientOperationId;
+    const evaluation = await ctx.client.v2.submitEvaluation({
+        canvasId: canvas.id,
+        clientOperationId,
+        artifactId: requireFlag(ctx.flags, 'artifact'),
+        runId: getFlag(ctx.flags, 'run'),
+        referenceAssetIds: [
+            ...new Set([
+                ...getFlagValues(ctx.flags, 'reference'),
+                ...(Array.isArray(report.referenceAssetIds)
+                    ? report.referenceAssetIds.filter((id) => typeof id === 'string')
+                    : []),
+            ]),
+        ],
+        evaluator: {
+            name: getFlag(ctx.flags, 'agent') ?? 'external-agent',
+            version: getFlag(ctx.flags, 'evaluator-version'),
+        },
+        report: report,
+    }, { idempotencyKey: clientOperationId });
+    print(evaluation);
+    if (hasFlag(ctx.flags, 'require-pass'))
+        process.exitCode =
+            evaluation.report.verdict === 'pass'
+                ? 0
+                : evaluation.report.verdict === 'fail'
+                    ? 1
+                    : 3;
+};
+/**
+ * `assethub runs upload <path>` — push a local artifact-graph run folder to
+ * Production Control.
+ *
+ * The wire format is `ag.registry.v1`, identical to what the Cloudflare
+ * ag-registry accepts, so the same folder can go to either destination without
+ * conversion. See src/runsUpload/ for the plan/transport split, and
+ * src/runsUpload/controlEndpoints.ts for every path and size limit.
+ */
+const commandRuns = async (subcommand, positionals, ctx) => {
+    if (subcommand === 'list') {
+        const { canvas } = await canvasForRead(ctx);
+        print(await ctx.client.v2.listCanvasRuns(canvas.id, pageOptions(ctx.flags)));
+        return;
+    }
+    if (subcommand === 'get' || subcommand === 'watch') {
+        const id = requirePositional(positionals, 2, 'run-id');
+        const execution = subcommand === 'get'
+            ? await ctx.client.v2.getRun(id)
+            : await waitForExecution(ctx.client, id, watchOptions(ctx.flags));
+        print({ execution });
+        process.exitCode = executionExitCode(execution);
+        return;
+    }
+    if (subcommand === 'resume') {
+        const result = await resumeRecorded({
+            ...stateOptions(ctx),
+            operationId: requirePositional(positionals, 2, 'operation-id'),
+        });
+        await printRecorded(ctx, result);
+        return;
+    }
+    const args = parseRunsUploadArgs(subcommand, positionals, ctx.flags);
+    const folder = await readGraphFolder(resolve(args.folderPath));
+    const plan = await buildRunUploadPlan({
+        folder,
+        graphId: args.graphId,
+        streamId: args.streamId,
+        rev: args.rev,
+        description: args.description,
+        tags: args.tags,
+    });
+    for (const warning of plan.warnings) {
+        stderr.write(`[warn] ${warning}\n`);
+    }
+    const summary = runsUploadSummary(folder.path, plan);
+    // --dry-run stops here on purpose: everything above is the validation a
+    // corrupt run folder fails, so this is how you find out before production
+    // sees it.
+    if (args.dryRun) {
+        print(runsUploadDryRunReport(summary, plan, ctx.auth.baseUrl));
+        return;
+    }
+    const result = await uploadRun({
+        plan,
+        baseUrl: ctx.auth.baseUrl,
+        apiKey: ctx.auth.apiKey,
+        skipRegister: args.skipRegister,
+        onProgress: event => {
+            if (event.kind === 'register') {
+                stderr.write(`[upload] register graph=${event.graphId}\n`);
+                return;
+            }
+            if (event.kind === 'blob') {
+                stderr.write(`[upload] blob ${event.index + 1}/${event.total} ${event.status} ` +
+                    `${event.blob.name} (${formatBytes(event.blob.size)})\n`);
+                return;
+            }
+            stderr.write(`[upload] snapshot graph=${event.graphId} rev=${event.rev}\n`);
+        },
+    });
+    print({ ...summary, ...result });
+};
+/**
+ * Everything `runs upload` decides from argv, split out from the command so the
+ * subcommand routing and flag handling are testable without a filesystem, an
+ * API key, or a network.
+ */
+export const parseRunsUploadArgs = (subcommand, positionals, flags) => {
+    if (subcommand !== 'upload') {
+        throw new Error('Unknown runs command. Use "runs upload <path>".');
+    }
+    const folderPath = positionals[2];
+    if (folderPath == null || folderPath.trim().length === 0) {
+        throw new Error('assethub runs upload needs the path to a run folder (the directory holding manifest.json, nodes.jsonl and edges.jsonl).');
+    }
+    return {
+        folderPath,
+        graphId: getFlag(flags, 'graph-id'),
+        streamId: getFlag(flags, 'stream-id'),
+        rev: parseNonNegativeIntegerFlag(flags, 'rev'),
+        description: getFlag(flags, 'description') ?? '',
+        tags: getFlagValues(flags, 'tag'),
+        dryRun: hasFlag(flags, 'dry-run'),
+        skipRegister: hasFlag(flags, 'skip-register'),
+    };
+};
+export const runsUploadSummary = (runFolder, plan) => ({
+    runFolder,
+    graphId: plan.graphId,
+    streamId: plan.streamId,
+    rev: plan.rev,
+    graphHash: plan.graphHash,
+    counts: plan.counts,
+    snapshotSize: formatBytes(plan.sizes.pushBytes),
+    blobBytes: formatBytes(plan.counts.blobBytes),
+});
+export const runsUploadDryRunReport = (summary, plan, baseUrl) => ({
+    dryRun: true,
+    ...summary,
+    warnings: plan.warnings,
+    blobs: plan.blobs.map(blob => ({
+        blobKey: blob.blobKey,
+        name: blob.name,
+        mime: blob.mime,
+        size: blob.size,
+    })),
+    wouldUpload: `${plan.blobs.length} blob(s) then 1 snapshot to ${baseUrl}`,
+});
+const parseNonNegativeIntegerFlag = (flags, name) => {
+    const raw = getFlag(flags, name);
+    if (raw == null || raw === 'true') {
+        return undefined;
+    }
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`--${name} must be a non-negative integer`);
+    }
+    return parsed;
+};
 const run = async () => {
     const parsed = parseArgs(argv.slice(2));
     if (hasFlag(parsed.flags, 'help') || parsed.positionals.length === 0) {
@@ -1653,12 +2960,96 @@ const run = async () => {
         return;
     }
     const [command, subcommand] = parsed.positionals;
+    if (command === 'project') {
+        if (subcommand !== 'ingest')
+            throw new Error('Use project ingest <source-dir> --out-dir <directory>');
+        const result = await ingestProjectSources({
+            sourceDir: requirePositional(parsed.positionals, 2, 'source-dir'),
+            outDir: requireFlag(parsed.flags, 'out-dir'),
+            excludedDirectories: getFlagValues(parsed.flags, 'exclude-dir').map(value => assertFlagHasValue(value, '--exclude-dir <relative-path>')),
+            onProgress: message => {
+                stderr.write(`[ingest] ${message}\n`);
+            },
+        });
+        print(result);
+        if (result.status !== 'complete')
+            process.exitCode = 3;
+        return;
+    }
+    if (command === 'workspace') {
+        if (!hasFlag(parsed.flags, 'internal')) {
+            throw new Error('Workspace operations currently require --internal and the AssetHub monorepo with its existing Infisical environment.');
+        }
+        const root = fileURLToPath(new URL('../../../', import.meta.url));
+        const script = join(root, 'apps/frontend/scripts/assethub-workspace.ts');
+        await readFile(script).catch(() => {
+            throw new Error('Internal workspace, moodboard and context operations require the AssetHub monorepo checkout and its native application dependencies.');
+        });
+        await new Promise((done, reject) => {
+            const child = spawn(process.execPath, [
+                '--import',
+                'tsx',
+                script,
+                ...argv.slice(3).filter(arg => arg !== '--internal'),
+            ], {
+                cwd: root,
+                env: {
+                    ...env,
+                    TSX_TSCONFIG_PATH: join(root, 'apps/frontend/tsconfig.json'),
+                },
+                stdio: 'inherit',
+            });
+            child.once('error', reject);
+            child.once('exit', code => code === 0
+                ? done()
+                : reject(new Error(`Internal workspace operation exited with ${code ?? 'a signal'}`)));
+        });
+        return;
+    }
     if (command === 'auth') {
         await commandAuth(subcommand, parsed.flags);
         return;
     }
-    const ctx = await createContext(parsed.flags);
+    // The experimental demo uses an unpublished workspace development dependency.
+    // Resolve it only for this command so standalone project commands can load.
+    if (command === 'autopilot') {
+        const { commandAutopilot } = await import('./autopilot.js').catch((error) => {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ERR_MODULE_NOT_FOUND' &&
+                error.message.includes('@assethub/autopilot-core')) {
+                throw new Error('The experimental autopilot demo requires the AssetHub monorepo with @assethub/autopilot-core installed. Standalone project workflow commands are available without it.');
+            }
+            throw error;
+        });
+        await commandAutopilot(parsed.positionals, parsed.flags);
+        return;
+    }
+    const ctx = await createContext(parsed.flags, argv.slice(2));
     switch (command) {
+        case 'language':
+            await commandLanguage(subcommand, ctx);
+            return;
+        case 'moodboard':
+            await commandMoodboard(subcommand, parsed.positionals, ctx);
+            return;
+        case 'canvas':
+            await commandCanvas(subcommand, parsed.positionals, ctx);
+            return;
+        case 'graph':
+            await commandGraph(subcommand, ctx);
+            return;
+        case 'evaluations':
+            await commandEvaluations(subcommand, parsed.positionals, ctx);
+            return;
+        case 'evaluate':
+            if (subcommand !== 'list')
+                throw new Error('Server evaluators are capability-gated. Use evaluate list, or evaluations submit for external agent reports.');
+            print((await ctx.client.v2.getCapabilities()).evaluators);
+            return;
+        case 'capabilities':
+            print(await ctx.client.v2.getCapabilities());
+            return;
         case 'models':
             await commandModels(subcommand, parsed.positionals, ctx);
             return;
@@ -1674,12 +3065,21 @@ const run = async () => {
         case 'mesh':
             await commandMesh(subcommand, ctx);
             return;
+        case 'rig':
+            await commandRig(subcommand, ctx);
+            return;
+        case 'animate':
+            await commandAnimate(subcommand, ctx);
+            return;
         case 'jobs':
             await commandJobs(subcommand, parsed.positionals, ctx);
             return;
         case 'production':
             await commandProduction(subcommand, parsed.positionals, ctx);
             return;
+        case 'runs':
+            await commandRuns(subcommand, parsed.positionals, ctx);
+            return;
         case 'parts':
             await commandParts(subcommand, ctx);
             return;
@@ -1687,15 +3087,64 @@ const run = async () => {
             throw new Error(`Unknown command: ${command}`);
     }
 };
-run().catch((error) => {
-    if (error instanceof AssetHubApiError) {
-        stderr.write(`AssetHub API error [${error.status}] ${error.code}: ${error.message}\n`);
-    }
-    else if (error instanceof Error) {
-        stderr.write(`${error.message}\n`);
+const isMainModule = (() => {
+    const entry = argv[1];
+    if (entry == null)
+        return false;
+    try {
+        return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entry);
     }
-    else {
-        stderr.write(`${String(error)}\n`);
+    catch {
+        return false;
     }
-    exit(1);
-});
+})();
+if (isMainModule) {
+    process.once('SIGINT', () => {
+        print({
+            error: {
+                code: 'INTERRUPTED',
+                message: 'Client interrupted; server execution continues',
+            },
+            ...activeExecution,
+        });
+        exit(130);
+    });
+    run().catch((error) => {
+        if (error instanceof AssetHubApiError) {
+            stderr.write(`AssetHub API error [${error.status}] ${error.code}: ${error.message}\n`);
+        }
+        else if (error instanceof Error) {
+            stderr.write(`${error.message}\n`);
+        }
+        else {
+            stderr.write(`${String(error)}\n`);
+        }
+        print({
+            error: {
+                code: error instanceof AssetHubApiError
+                    ? error.code
+                    : error instanceof CliExecutionError && error.exitCode === 3
+                        ? 'WAIT_TIMEOUT'
+                        : 'CLI_ERROR',
+                message: error instanceof Error ? error.message : String(error),
+            },
+            runId: error instanceof CliExecutionError
+                ? error.runId
+                : activeExecution.runId,
+            operationId: error instanceof CliExecutionError
+                ? error.operationId
+                : activeExecution.operationId,
+            execution: error instanceof CliExecutionError
+                ? error.execution
+                : activeExecution.execution,
+        });
+        exit(error instanceof CliExecutionError
+            ? error.exitCode
+            : error instanceof AssetHubApiError &&
+                error.status >= 500 &&
+                error.code !== 'CANVAS_EXECUTION_UNAVAILABLE' &&
+                error.code !== 'EVALUATOR_UNAVAILABLE'
+                ? 1
+                : 2);
+    });
+}