@oiioii/cli 0.1.0 → 0.1.1

package/dist/cli.js

@@ -1,19 +1,24 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command14, CommanderError } from "commander";
+import { Command as Command15, CommanderError } from "commander";
 
 // src/commands/workspace.ts
-import { Command } from "commander";
+import { Command as Command2 } from "commander";
 
 // src/config/config_store.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync2, chmodSync as chmodSync2 } from "fs";
 import { join as join3 } from "path";
 
 // src/config/build_environment.ts
+var BUILD_ENVIRONMENT_URL_VARIABLES = {
+  production: "OIIOII_PRODUCTION_BASE_URL",
+  test: "OIIOII_TEST_BASE_URL",
+  local: void 0
+};
 var BUILD_ENVIRONMENT_URLS = {
   production: "https://api.oiioii.ai",
-  test: "https://api-hoe.oiioii.tv",
+  test: void 0,
   local: "http://localhost:4000"
 };
 var RELEASE_CHANNELS = {
@@ -31,15 +36,24 @@ function injectedBuildBaseUrl() {
   const value = true ? "https://api.oiioii.ai" : process.env["OIIOII_BUILD_BASE_URL"];
   return value?.trim() || void 0;
 }
+function environmentBuildBaseUrl(environment) {
+  const variable = BUILD_ENVIRONMENT_URL_VARIABLES[environment];
+  return variable ? process.env[variable]?.trim() || void 0 : void 0;
+}
 function getBuildEnvironment() {
-  const value = injectedBuildEnvironment() ?? "test";
-  return isBuildEnvironment(value) ? value : "test";
+  const value = injectedBuildEnvironment() ?? "local";
+  return isBuildEnvironment(value) ? value : "local";
 }
 function getBuildEnvironmentConfig() {
   const environment = getBuildEnvironment();
+  const baseUrl = injectedBuildBaseUrl() ?? environmentBuildBaseUrl(environment) ?? BUILD_ENVIRONMENT_URLS[environment];
+  if (!baseUrl) {
+    const variable = BUILD_ENVIRONMENT_URL_VARIABLES[environment] ?? "OIIOII_BUILD_BASE_URL";
+    throw new Error(`${variable} is required for ${environment} builds.`);
+  }
   return {
     environment,
-    baseUrl: injectedBuildBaseUrl() ?? BUILD_ENVIRONMENT_URLS[environment]
+    baseUrl
   };
 }
 function getDefaultBaseUrl() {
@@ -454,13 +468,18 @@ var FileConfigStore = class {
   /**
    * Merge partial updates into the existing config.
    */
-  update(partial) {
+  update(partial, options = {}) {
     this._ensureDir();
     withFileLock(`${this.configPath}.lock`, () => {
       const current = this.load();
-      this._write({ ...current, ...partial });
+      const next = { ...current, ...partial };
+      if (options.resetBaseUrl) delete next.baseUrl;
+      this._write(next);
+    });
+    logFeatureStep("config_store", "config.updated", {
+      fields: Object.keys(partial),
+      reset_base_url: options.resetBaseUrl === true
     });
-    logFeatureStep("config_store", "config.updated", { fields: Object.keys(partial) });
   }
   /** Ensure the config directory exists. */
   _ensureDir() {
@@ -496,6 +515,7 @@ var ErrorCode = {
   RECORD_NOT_FOUND: "RECORD_NOT_FOUND",
   // Local tasks
   TASK_NOT_FOUND: "TASK_NOT_FOUND",
+  TASK_RETRY_REQUIRED: "TASK_RETRY_REQUIRED",
   TASK_TIMEOUT: "TASK_TIMEOUT",
   // Quota
   QUOTA_EXCEEDED: "QUOTA_EXCEEDED",
@@ -618,6 +638,78 @@ function startApiCall(context2, logger = createDefaultLogger()) {
   return new ApiCallSpan(logger, context2);
 }
 
+// src/app/version.ts
+var CLI_VERSION = true ? "0.1.1" : process.env["OIIOII_CLI_VERSION"] ?? "0.1.1";
+var CLI_NPM_PACKAGE_NAME = true ? "@oiioii/cli" : process.env["OIIOII_NPM_PACKAGE_NAME"] ?? "@oiioii/cli";
+
+// src/clients/client_context.ts
+var HOGI_CLIENT_CONTEXT_HEADERS = {
+  clientType: "x-hogi-client-type",
+  clientVersion: "x-hogi-client-version",
+  clientOS: "x-hogi-client-os"
+};
+function normalizeClientOS(platform) {
+  if (platform === "win32") return "windows";
+  if (platform === "darwin") return "mac";
+  return platform;
+}
+function buildCliClientContext() {
+  return {
+    clientType: "cli",
+    clientVersion: CLI_VERSION,
+    clientOS: normalizeClientOS(process.platform)
+  };
+}
+function withClientContextHeaders(headers) {
+  const context2 = buildCliClientContext();
+  return {
+    ...headers,
+    ...Object.fromEntries(
+      Object.entries(HOGI_CLIENT_CONTEXT_HEADERS).map(([field, header]) => [
+        header,
+        context2[field]
+      ])
+    )
+  };
+}
+
+// src/clients/request_timeout.ts
+var DEFAULT_HTTP_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_HTTP_TRANSFER_TIMEOUT_MS = 5 * 6e4;
+var HttpRequestTimeoutError = class extends Error {
+  constructor(operation, timeoutMs) {
+    super(`${operation} timed out after ${timeoutMs}ms`);
+    this.operation = operation;
+    this.timeoutMs = timeoutMs;
+    this.name = "HttpRequestTimeoutError";
+  }
+  operation;
+  timeoutMs;
+};
+async function withRequestTimeout(params) {
+  const timeoutMs = params.timeoutMs ?? DEFAULT_HTTP_REQUEST_TIMEOUT_MS;
+  const controller = new AbortController();
+  let timer;
+  const timeout = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      reject(new HttpRequestTimeoutError(params.operation, timeoutMs));
+    }, timeoutMs);
+  });
+  timer?.unref();
+  try {
+    return await Promise.race([params.run(controller.signal), timeout]);
+  } catch (error2) {
+    if (error2 instanceof HttpRequestTimeoutError) throw error2;
+    if (controller.signal.aborted) {
+      throw new HttpRequestTimeoutError(params.operation, timeoutMs);
+    }
+    throw error2;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 // src/clients/hogi_workspace_client.ts
 function asObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -654,10 +746,11 @@ async function parseEnvelope(response) {
 }
 function mapWorkspaceError(status, envelope) {
   const backendCode = envelope.error?.code;
-  const message = envelope.error?.message ?? `Workspace creation failed: HTTP ${status}`;
+  const message = envelope.error?.message ?? `Workspace request failed: HTTP ${status}`;
   const details = { status, ...backendCode ? { code: backendCode } : {} };
   if (status === 401) return new CliError(ErrorCode.API_KEY_INVALID, message, details);
   if (status === 403) return new CliError(ErrorCode.WORKSPACE_FORBIDDEN, message, details);
+  if (status === 404) return new CliError(ErrorCode.WORKSPACE_NOT_FOUND, message, details);
   if (status === 400 || status === 422) return new CliError(ErrorCode.INVALID_ARGUMENT, message, details);
   if (status === 429) return new CliError(ErrorCode.QUOTA_EXCEEDED, message, details);
   return new CliError(ErrorCode.SERVER_ERROR, message, details);
@@ -675,16 +768,45 @@ function parseCreateResult(envelope) {
   }
   return { workspaceId, name };
 }
+function parseRenameResult(envelope) {
+  if (envelope.ok === false) throw mapWorkspaceError(400, envelope);
+  const data = asObject(envelope.data);
+  const workspaceId = data?.workspace_id;
+  const name = data?.name;
+  if (typeof workspaceId !== "string" || !workspaceId.trim()) {
+    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid workspace rename response: missing workspace_id");
+  }
+  if (typeof name !== "string" || !name.trim()) {
+    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid workspace rename response: missing name");
+  }
+  return { workspaceId, name };
+}
+function parseWorkspaceAssets(envelope) {
+  if (envelope.ok === false) throw mapWorkspaceError(400, envelope);
+  const data = asObject(envelope.data);
+  if (!Array.isArray(data?.asset)) {
+    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid workspace detail response: missing asset list");
+  }
+  return data.asset.map((value, index) => {
+    const asset = asObject(value);
+    if (!asset || typeof asset.assetId !== "string" || typeof asset.type !== "string" || typeof asset.uri !== "string") {
+      throw new CliError(ErrorCode.SERVER_ERROR, `Invalid workspace asset at index ${index}`);
+    }
+    return asset;
+  });
+}
 var HogiWorkspaceClient = class {
   baseUrl;
   apiKey;
   _fetch;
   logger;
+  timeoutMs;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
     this._fetch = options.fetch ?? globalThis.fetch;
     this.logger = options.logger;
+    this.timeoutMs = options.timeoutMs;
   }
   async createWorkspace(request) {
     const apiLog = startApiCall({
@@ -696,19 +818,43 @@ var HogiWorkspaceClient = class {
     }, this.logger);
     let response;
     try {
-      response = await this._fetch(`${this.baseUrl}/v1/workspace/create`, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${this.apiKey}`,
-          "content-type": "application/json",
-          accept: "application/json"
-        },
-        body: JSON.stringify({
-          ...request.name !== void 0 ? { name: request.name } : {},
-          ...request.language !== void 0 ? { language: request.language } : {}
-        })
+      return await withRequestTimeout({
+        operation: "Workspace creation request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(`${this.baseUrl}/v1/workspace/create`, {
+            method: "POST",
+            headers: withClientContextHeaders({
+              authorization: `Bearer ${this.apiKey}`,
+              "content-type": "application/json",
+              accept: "application/json"
+            }),
+            body: JSON.stringify({
+              ...request.name !== void 0 ? { name: request.name } : {},
+              ...request.language !== void 0 ? { language: request.language } : {}
+            }),
+            signal
+          });
+          const envelope = await parseEnvelope(response);
+          if (!response.ok) throw mapWorkspaceError(response.status, envelope);
+          const result = parseCreateResult(envelope);
+          apiLog.success(response.status, { workspace_id: result.workspaceId });
+          return result;
+        }
       });
     } catch (error2) {
+      if (error2 instanceof HttpRequestTimeoutError) {
+        const timeoutError = new CliError(ErrorCode.NETWORK_ERROR, error2.message, {
+          retryable: true,
+          timeout_ms: error2.timeoutMs
+        });
+        apiLog.failure(timeoutError, response?.status);
+        throw timeoutError;
+      }
+      if (error2 instanceof CliError) {
+        apiLog.failure(error2, response?.status);
+        throw error2;
+      }
       const networkError = new CliError(
         ErrorCode.NETWORK_ERROR,
         `Network error: ${error2 instanceof Error ? error2.message : String(error2)}`
@@ -716,17 +862,98 @@ var HogiWorkspaceClient = class {
       apiLog.failure(networkError);
       throw networkError;
     }
+  }
+  async renameWorkspace(workspaceId, name) {
+    const path = "/v1/workspace/rename";
+    const apiLog = startApiCall({
+      source: "hogi_workspace_client",
+      operation: "workspace.rename",
+      method: "POST",
+      path,
+      metadata: { workspace_id: workspaceId }
+    }, this.logger);
+    let response;
     try {
-      const envelope = await parseEnvelope(response);
-      if (!response.ok) throw mapWorkspaceError(response.status, envelope);
-      const result = parseCreateResult(envelope);
-      apiLog.success(response.status, { workspace_id: result.workspaceId });
-      return result;
+      return await withRequestTimeout({
+        operation: "Workspace rename request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(`${this.baseUrl}${path}`, {
+            method: "POST",
+            headers: {
+              authorization: `Bearer ${this.apiKey}`,
+              "content-type": "application/json",
+              accept: "application/json"
+            },
+            body: JSON.stringify({ workspace_id: workspaceId, name }),
+            signal
+          });
+          const envelope = await parseEnvelope(response);
+          if (!response.ok) throw mapWorkspaceError(response.status, envelope);
+          const result = parseRenameResult(envelope);
+          apiLog.success(response.status, { workspace_id: result.workspaceId });
+          return result;
+        }
+      });
     } catch (error2) {
-      apiLog.failure(error2, response.status);
-      throw error2;
+      throw this.mapRequestError(error2, "Workspace rename request", apiLog, response);
+    }
+  }
+  async listAssets(workspaceId) {
+    const path = "/v1/workspace/detail";
+    const apiLog = startApiCall({
+      source: "hogi_workspace_client",
+      operation: "workspace.assets.list",
+      method: "GET",
+      path,
+      metadata: { workspace_id: workspaceId }
+    }, this.logger);
+    const params = new URLSearchParams({ workspace_id: workspaceId, relateTypes: "asset" });
+    let response;
+    try {
+      return await withRequestTimeout({
+        operation: "Workspace asset list request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(`${this.baseUrl}${path}?${params.toString()}`, {
+            method: "GET",
+            headers: {
+              authorization: `Bearer ${this.apiKey}`,
+              accept: "application/json"
+            },
+            signal
+          });
+          const envelope = await parseEnvelope(response);
+          if (!response.ok) throw mapWorkspaceError(response.status, envelope);
+          const assets = parseWorkspaceAssets(envelope);
+          apiLog.success(response.status, { workspace_id: workspaceId, asset_count: assets.length });
+          return assets;
+        }
+      });
+    } catch (error2) {
+      throw this.mapRequestError(error2, "Workspace asset list request", apiLog, response);
     }
   }
+  mapRequestError(error2, operation, apiLog, response) {
+    if (error2 instanceof HttpRequestTimeoutError) {
+      const timeoutError = new CliError(ErrorCode.NETWORK_ERROR, error2.message, {
+        retryable: true,
+        timeout_ms: error2.timeoutMs
+      });
+      apiLog.failure(timeoutError, response?.status);
+      return timeoutError;
+    }
+    if (error2 instanceof CliError) {
+      apiLog.failure(error2, response?.status);
+      return error2;
+    }
+    const networkError = new CliError(
+      ErrorCode.NETWORK_ERROR,
+      `${operation} failed: ${error2 instanceof Error ? error2.message : String(error2)}`
+    );
+    apiLog.failure(networkError);
+    return networkError;
+  }
 };
 
 // src/app/command_context.ts
@@ -751,6 +978,21 @@ function requireApiKeyAuth(rootOptions, configStore) {
   const baseUrl = typeof baseUrlOption === "string" && baseUrlOption ? baseUrlOption : config.baseUrl;
   return { apiKey, baseUrl };
 }
+function resolveWorkspaceId(rootOptions, configStore, explicitWorkspaceId) {
+  const explicit = explicitWorkspaceId?.trim();
+  if (explicitWorkspaceId !== void 0 && !explicit) {
+    throw new CliError(ErrorCode.INVALID_ARGUMENT, "Workspace ID must not be empty");
+  }
+  const rootOverride = typeof rootOptions.workspace === "string" ? rootOptions.workspace.trim() : "";
+  const workspaceId = explicit || rootOverride || configStore.loadResolved().defaultWorkspaceId?.trim();
+  if (!workspaceId) {
+    throw new CliError(
+      ErrorCode.WORKSPACE_REQUIRED,
+      "No workspace set. Pass a workspace ID, use --workspace <id>, set OIIOII_WORKSPACE_ID, or set an active workspace."
+    );
+  }
+  return workspaceId;
+}
 
 // src/telemetry/event_registry.ts
 var DOMAIN_EVENTS = {
@@ -779,6 +1021,9 @@ var BUSINESS_COMMAND_REGISTRY = {
   "workspace.create": definition("workspace", "create"),
   "workspace.set": definition("workspace", "set"),
   "workspace.current": definition("workspace", "current"),
+  "workspace.rename": definition("workspace", "rename"),
+  "workspace.assets.list": definition("workspace", "assets_list"),
+  "workspace.assets.download": definition("workspace", "asset_download"),
   "image.text": definition("generation", "image_text"),
   "image.edit": definition("generation", "image_edit"),
   "video.text": definition("generation", "video_text"),
@@ -789,6 +1034,7 @@ var BUSINESS_COMMAND_REGISTRY = {
   "audio.suno": definition("generation", "audio_suno"),
   "upload.file": definition("upload", "file"),
   "task.list": definition("task", "list"),
+  "task.retry": definition("task", "retry"),
   "task.status": definition("task", "status"),
   "task.wait": definition("task", "wait"),
   "record.get": definition("record", "get"),
@@ -814,10 +1060,6 @@ function getBusinessCommandDefinition(command) {
 // src/telemetry/telemetry_manager.ts
 import { randomBytes as randomBytes4 } from "crypto";
 
-// src/app/version.ts
-var CLI_VERSION = true ? "0.1.0" : process.env["OIIOII_CLI_VERSION"] ?? "0.1.0";
-var CLI_NPM_PACKAGE_NAME = true ? "@oiioii/cli" : process.env["OIIOII_NPM_PACKAGE_NAME"] ?? "@oiioii/cli";
-
 // src/telemetry/telemetry_context.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var telemetryContextStorage = new AsyncLocalStorage2();
@@ -948,7 +1190,7 @@ function defaultCommonParams() {
   const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
   return {
     schema_version: 1,
-    app_env: environment === "local" ? "dev" : environment === "production" ? "prod" : "hoe",
+    app_env: environment === "local" ? "dev" : environment === "production" ? "prod" : "test",
     app_name: "oiioii_cli",
     cli_version: CLI_VERSION,
     os: process.platform,
@@ -1101,7 +1343,7 @@ function telemetryResourceType(uri) {
 }
 
 // src/clients/hogi_mcp_client.ts
-import { Agent } from "undici";
+import { Agent, fetch as undiciFetch } from "undici";
 function errorFromMcpToolResult(result, fallback) {
   const backendCode = typeof result.errorCode === "string" ? result.errorCode : void 0;
   const text = (result.content ?? []).filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text.trim()).filter(Boolean).join("\n");
@@ -1156,7 +1398,19 @@ function errorFromJsonRpc(error2) {
   if (Number(error2.code) === -32601) {
     return new CliError(ErrorCode.MODEL_NOT_SUPPORTED, message, details);
   }
-  return new CliError(ErrorCode.GENERATION_FAILED, message, error2);
+  if (Number(error2.code) === -32700 || Number(error2.code) === -32600) {
+    return new CliError(ErrorCode.SERVER_ERROR, message, {
+      ...error2,
+      category: "protocol",
+      retryable: false
+    });
+  }
+  return new CliError(ErrorCode.SERVER_ERROR, message, {
+    ...error2,
+    category: "server",
+    retryable: true,
+    request_outcome: "unknown"
+  });
 }
 var nextJsonRpcId = 1;
 async function errorForHttpResponse(response) {
@@ -1201,10 +1455,25 @@ async function errorForHttpResponse(response) {
       retryable: false
     });
   }
-  if (response.status >= 500) return new CliError(ErrorCode.SERVER_ERROR, backendMessage ?? `Server error: ${response.statusText || response.status}`, details);
+  if (response.status >= 500) {
+    return new CliError(ErrorCode.SERVER_ERROR, backendMessage ?? `Server error: ${response.statusText || response.status}`, {
+      ...details,
+      category: "server",
+      retryable: true,
+      request_outcome: "unknown"
+    });
+  }
   return new CliError(ErrorCode.GENERATION_FAILED, backendMessage ?? `Request failed: ${response.statusText || response.status}`, details);
 }
-function parseSseJson(text) {
+function responseProtocolError(message, status) {
+  return new CliError(ErrorCode.SERVER_ERROR, message, {
+    ...status !== void 0 ? { status } : {},
+    category: "response_protocol",
+    retryable: true,
+    response_protocol: true
+  });
+}
+function parseSseJson(text, status) {
   const dataLines = [];
   for (const line of text.split(/\r?\n/)) {
     if (line.startsWith("data:")) {
@@ -1212,46 +1481,68 @@ function parseSseJson(text) {
     }
   }
   if (dataLines.length === 0) {
-    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid SSE response from server");
+    throw responseProtocolError("Invalid SSE response from server", status);
   }
   try {
     return JSON.parse(dataLines.join("\n"));
   } catch {
-    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid JSON in SSE response from server");
+    throw responseProtocolError("Invalid JSON in SSE response from server", status);
   }
 }
 async function parseJsonOrSseResponse(response) {
   const text = await response.text();
   const trimmed = text.trim();
   if (!trimmed) {
-    throw new CliError(ErrorCode.SERVER_ERROR, "Empty response from server", { status: response.status });
+    throw responseProtocolError("Empty response from server", response.status);
   }
   if (trimmed.startsWith("event:") || trimmed.startsWith("data:")) {
-    return parseSseJson(trimmed);
+    return parseSseJson(trimmed, response.status);
   }
   try {
     return JSON.parse(trimmed);
   } catch {
-    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid JSON response from server", { status: response.status });
+    throw responseProtocolError("Invalid JSON response from server", response.status);
   }
 }
-function asJsonRpcResponse(payload) {
+function asJsonRpcResponse(payload, status) {
   if (!payload || typeof payload !== "object") {
-    throw new CliError(ErrorCode.SERVER_ERROR, "Invalid MCP response from server");
+    throw responseProtocolError("Invalid MCP response from server", status);
   }
   return payload;
 }
+function undiciErrorCode(error2) {
+  if (!error2 || typeof error2 !== "object") return void 0;
+  if ("code" in error2 && typeof error2.code === "string") return error2.code;
+  if ("cause" in error2) return undiciErrorCode(error2.cause);
+  return void 0;
+}
+function isRequestTimeoutError(error2) {
+  if (error2 instanceof Error && error2.name === "AbortError") return true;
+  return [
+    "UND_ERR_HEADERS_TIMEOUT",
+    "UND_ERR_BODY_TIMEOUT",
+    "UND_ERR_CONNECT_TIMEOUT"
+  ].includes(undiciErrorCode(error2) ?? "");
+}
+function createMcpDispatcher(timeoutMs) {
+  return new Agent({
+    headersTimeout: timeoutMs,
+    bodyTimeout: timeoutMs
+  });
+}
 var HogiMcpClient = class {
   baseUrl;
   apiKey;
   timeoutMs;
   _fetch;
+  usesDefaultUndiciTransport;
   logger;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
     this.timeoutMs = options.timeoutMs ?? 3e5;
-    this._fetch = options.fetch ?? globalThis.fetch;
+    this.usesDefaultUndiciTransport = options.fetch === void 0;
+    this._fetch = options.fetch ?? undiciFetch;
     this.logger = options.logger;
   }
   async callTool(toolName, args, options = {}) {
@@ -1267,7 +1558,7 @@ var HogiMcpClient = class {
       { tool_name: toolName }
     );
     if (!result || typeof result !== "object") {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Invalid MCP tool result from server");
+      throw responseProtocolError("Invalid MCP tool result from server");
     }
     return result;
   }
@@ -1288,58 +1579,56 @@ var HogiMcpClient = class {
     try {
       response = await this._fetch(`${this.baseUrl}/mcp/${serverName}/sse`, {
         method: "POST",
-        headers: {
+        headers: withClientContextHeaders({
           "content-type": "application/json",
           "accept": "application/json, text/event-stream",
           "x-hogi-api-key": this.apiKey,
           "x-oiioii-cli-version": CLI_VERSION
-        },
+        }),
         body: JSON.stringify({
           jsonrpc: "2.0",
           id: nextJsonRpcId++,
           method,
           params
         }),
-        // Node's built-in fetch uses undici, whose default headers/body timeouts are 300s.
-        // Long-running video MCP calls intentionally wait up to timeoutMs, so keep undici
-        // aligned with the CLI AbortController timeout instead of failing early at 300s.
-        dispatcher: new Agent({
-          headersTimeout: this.timeoutMs,
-          bodyTimeout: this.timeoutMs
-        }),
+        // Undici defaults headers/body timeouts to 300s. Long-running video MCP calls
+        // intentionally wait up to timeoutMs, so align the default transport with the
+        // CLI AbortController instead of failing early at 300s.
+        ...this.usesDefaultUndiciTransport ? {
+          dispatcher: createMcpDispatcher(this.timeoutMs)
+        } : {},
         signal: controller.signal
       });
-    } catch (error2) {
-      if (error2 instanceof Error && error2.name === "AbortError") {
-        const timeoutError = new CliError(ErrorCode.GENERATION_TIMEOUT, `Request timed out after ${this.timeoutMs}ms`);
-        apiLog.failure(timeoutError);
-        throw timeoutError;
+      if (!response.ok) {
+        throw await errorForHttpResponse(response);
       }
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      const networkError = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${message}`);
-      apiLog.failure(networkError);
-      throw networkError;
-    } finally {
-      clearTimeout(timer);
-    }
-    if (!response.ok) {
-      const httpError = await errorForHttpResponse(response);
-      apiLog.failure(httpError, response.status);
-      throw httpError;
-    }
-    try {
-      const jsonRpc = asJsonRpcResponse(await parseJsonOrSseResponse(response));
+      const jsonRpc = asJsonRpcResponse(await parseJsonOrSseResponse(response), response.status);
       if (jsonRpc.error) {
         throw errorFromJsonRpc(jsonRpc.error);
       }
       if (jsonRpc.result === void 0) {
-        throw new CliError(ErrorCode.SERVER_ERROR, "Missing MCP result from server");
+        throw responseProtocolError("Missing MCP result from server", response.status);
       }
       apiLog.success(response.status);
       return jsonRpc.result;
     } catch (error2) {
-      apiLog.failure(error2, response.status);
-      throw error2;
+      let mappedError = error2;
+      if (controller.signal.aborted || isRequestTimeoutError(error2)) {
+        mappedError = new CliError(ErrorCode.GENERATION_TIMEOUT, `Request timed out after ${this.timeoutMs}ms`, {
+          retryable: true,
+          ...undiciErrorCode(error2) ? { cause_code: undiciErrorCode(error2) } : {}
+        });
+      } else if (!(error2 instanceof CliError)) {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        mappedError = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${message}`, {
+          retryable: true,
+          ...undiciErrorCode(error2) ? { cause_code: undiciErrorCode(error2) } : {}
+        });
+      }
+      apiLog.failure(mappedError, response?.status);
+      throw mappedError;
+    } finally {
+      clearTimeout(timer);
     }
   }
 };
@@ -1476,6 +1765,267 @@ ${title}`);
   console.log("\u2500".repeat(title.length));
 }
 
+// src/commands/workspace_assets.ts
+import { Command } from "commander";
+
+// src/clients/hogi_res_client.ts
+import { mkdir, writeFile } from "fs/promises";
+import { existsSync as existsSync3, statSync as statSync3 } from "fs";
+import { basename, dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+function assertHogiUri(uri) {
+  if (!uri || !uri.startsWith("hogi://")) {
+    throw new CliError(
+      ErrorCode.INVALID_ARGUMENT,
+      `Invalid hogi URI: "${uri}". Expected format: hogi://image/<id> or hogi://video/<id>`
+    );
+  }
+}
+function filenameFromUri(uri) {
+  try {
+    const parsed = new URL(uri);
+    const name = basename(parsed.pathname);
+    if (name && name !== "." && name !== "/") return name;
+  } catch {
+  }
+  return "resource.bin";
+}
+function resolveOutputPath(uri, output) {
+  const fallbackName = filenameFromUri(uri);
+  if (!output) return resolve2(process.cwd(), fallbackName);
+  const resolved = resolve2(output);
+  if (existsSync3(resolved) && statSync3(resolved).isDirectory()) {
+    return join4(resolved, fallbackName);
+  }
+  return resolved;
+}
+function looksLikeJsonError(contentType, buffer) {
+  if (contentType?.toLowerCase().includes("application/json")) return true;
+  const prefix = buffer.subarray(0, 128).toString("utf8").trimStart();
+  return prefix.startsWith("{") && (prefix.includes('"error"') || prefix.includes('"code"'));
+}
+var HogiResClient = class {
+  baseUrl;
+  apiKey;
+  _fetch;
+  logger;
+  timeoutMs;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this._fetch = options.fetch ?? globalThis.fetch;
+    this.logger = options.logger;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_HTTP_TRANSFER_TIMEOUT_MS;
+  }
+  getReadUrl(uri, options = {}) {
+    assertHogiUri(uri);
+    const params = new URLSearchParams();
+    params.set("uri", uri);
+    if (options.filename) params.set("filename", options.filename);
+    if (typeof options.watermark === "boolean") params.set("wm", options.watermark ? "1" : "0");
+    return `${this.baseUrl}/v1/res/read_file?${params.toString()}`;
+  }
+  async download(uri, options = {}) {
+    assertHogiUri(uri);
+    const url = this.getReadUrl(uri, options);
+    const outputPath = resolveOutputPath(uri, options.output);
+    const apiLog = startApiCall({
+      source: "hogi_res_client",
+      operation: "resource.read",
+      method: "GET",
+      path: "/v1/res/read_file"
+    }, this.logger);
+    let response;
+    let downloaded;
+    try {
+      downloaded = await withRequestTimeout({
+        operation: "Resource download request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(url, {
+            method: "GET",
+            redirect: "follow",
+            headers: withClientContextHeaders({
+              "x-hogi-api-key": this.apiKey,
+              "accept": "image/*,video/*,application/octet-stream,application/json;q=0.5,*/*;q=0.1"
+            }),
+            signal
+          });
+          if (response.status === 401) throw new CliError(ErrorCode.API_KEY_INVALID, "Invalid API key", { status: 401 });
+          if (response.status === 404) {
+            throw new CliError(ErrorCode.RECORD_NOT_FOUND, `Resource not found for URI: ${uri}`, { status: 404 });
+          }
+          if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new CliError(ErrorCode.SERVER_ERROR, `HTTP ${response.status}: ${text || response.statusText}`, {
+              status: response.status
+            });
+          }
+          const contentType = response.headers.get("content-type");
+          const buffer = Buffer.from(await response.arrayBuffer());
+          if (looksLikeJsonError(contentType, buffer)) {
+            let message = "Resource read failed";
+            try {
+              const body = JSON.parse(buffer.toString("utf8"));
+              message = body.message ?? body.error ?? body.code ?? message;
+            } catch {
+            }
+            throw new CliError(ErrorCode.SERVER_ERROR, message);
+          }
+          return { contentType, buffer };
+        }
+      });
+    } catch (err) {
+      if (err instanceof HttpRequestTimeoutError) {
+        const timeoutError = new CliError(ErrorCode.NETWORK_ERROR, err.message, {
+          retryable: true,
+          timeout_ms: err.timeoutMs
+        });
+        apiLog.failure(timeoutError, response?.status);
+        throw timeoutError;
+      }
+      if (err instanceof CliError) {
+        apiLog.failure(err, response?.status);
+        throw err;
+      }
+      const msg = err instanceof Error ? err.message : String(err);
+      const error2 = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${msg}`);
+      apiLog.failure(error2);
+      throw error2;
+    }
+    apiLog.success(response.status, { bytes: downloaded.buffer.byteLength, mime_type: downloaded.contentType });
+    await mkdir(dirname2(outputPath), { recursive: true });
+    await writeFile(outputPath, downloaded.buffer);
+    logFeatureStep("record", "resource.saved", { bytes: downloaded.buffer.byteLength, mime_type: downloaded.contentType });
+    return {
+      path: outputPath,
+      bytes: downloaded.buffer.byteLength,
+      mimeType: downloaded.contentType,
+      uri
+    };
+  }
+};
+
+// src/commands/workspace_assets.ts
+function createClients(rootOptions, deps) {
+  const configStore = deps.configStore ?? new FileConfigStore();
+  const auth = requireApiKeyAuth(rootOptions, configStore);
+  return {
+    auth,
+    configStore,
+    workspaceClient: new HogiWorkspaceClient({
+      baseUrl: auth.baseUrl,
+      apiKey: auth.apiKey,
+      ...deps.fetch ? { fetch: deps.fetch } : {}
+    })
+  };
+}
+async function executeWorkspaceAssetsList(params, rootOptions, deps = {}) {
+  const { configStore, workspaceClient } = createClients(rootOptions, deps);
+  const workspaceId = resolveWorkspaceId(rootOptions, configStore, params.workspaceId);
+  const assets = await workspaceClient.listAssets(workspaceId);
+  logFeatureStep("workspace_assets", "assets.listed", { workspace_id: workspaceId, count: assets.length });
+  return { workspace_id: workspaceId, count: assets.length, assets };
+}
+function assetIdFromReference(reference) {
+  return reference.startsWith("hogi://asset/") ? reference.slice("hogi://asset/".length) : reference;
+}
+function resolveDownloadAsset(assets, reference) {
+  const assetId = assetIdFromReference(reference.trim());
+  const asset = assets.find((item) => item.assetId === assetId);
+  if (!asset) {
+    throw new CliError(ErrorCode.RECORD_NOT_FOUND, `Workspace asset not found: ${reference}`, {
+      asset_reference: reference
+    });
+  }
+  if (asset.status) {
+    throw new CliError(ErrorCode.INVALID_ARGUMENT, `Workspace asset ${asset.assetId} is not ready for download (status: ${asset.status}).`, {
+      asset_id: asset.assetId,
+      status: asset.status
+    });
+  }
+  if (!asset.uri.startsWith("hogi://") || asset.uri.startsWith("hogi://asset/")) {
+    throw new CliError(ErrorCode.INVALID_ARGUMENT, `Workspace asset ${asset.assetId} has no downloadable resource URI.`, {
+      asset_id: asset.assetId,
+      uri: asset.uri
+    });
+  }
+  return asset;
+}
+async function executeWorkspaceAssetDownload(params, rootOptions, deps = {}) {
+  const reference = params.asset.trim();
+  if (!reference) throw new CliError(ErrorCode.INVALID_ARGUMENT, "Asset ID is required");
+  const { auth, configStore, workspaceClient } = createClients(rootOptions, deps);
+  const workspaceId = resolveWorkspaceId(rootOptions, configStore, params.workspaceId);
+  const asset = resolveDownloadAsset(await workspaceClient.listAssets(workspaceId), reference);
+  const downloaded = await new HogiResClient({
+    baseUrl: auth.baseUrl,
+    apiKey: auth.apiKey,
+    ...deps.fetch ? { fetch: deps.fetch } : {}
+  }).download(asset.uri, {
+    ...params.output ? { output: params.output } : {},
+    ...params.filename ? { filename: params.filename } : {},
+    ...params.watermark !== void 0 ? { watermark: params.watermark } : {}
+  });
+  logFeatureStep("workspace_assets", "asset.downloaded", {
+    workspace_id: workspaceId,
+    asset_id: asset.assetId,
+    bytes: downloaded.bytes
+  });
+  return {
+    workspace_id: workspaceId,
+    asset_id: asset.assetId,
+    uri: asset.uri,
+    path: downloaded.path,
+    bytes: downloaded.bytes,
+    mime_type: downloaded.mimeType
+  };
+}
+function handleError(error2, jsonMode, type) {
+  const cliError = error2 instanceof CliError ? error2 : new CliError(ErrorCode.SERVER_ERROR, error2 instanceof Error ? error2.message : String(error2));
+  if (jsonMode) printJson(errorJson(type, cliError.code, cliError.message, cliError.details));
+  else error(cliError.message);
+  process.exitCode = 1;
+}
+function createWorkspaceAssetsCommand(deps = {}) {
+  const assets = new Command("assets").description("List and download workspace assets");
+  assets.command("list").description("List assets in a workspace").argument("[workspace_id]", "Workspace ID; defaults to the active workspace").action(async (workspaceId, _opts, cmd) => {
+    const jsonMode = isJsonOutput(cmd);
+    try {
+      const result = await executeWorkspaceAssetsList({ workspaceId }, getRootOptions(cmd), deps);
+      setTelemetryWorkspaceId(result.workspace_id);
+      recordTelemetryBusinessInfo({ asset_count: result.count });
+      if (jsonMode) {
+        printJson(successJson("workspace_assets_list", result));
+      } else {
+        heading(`Workspace assets (${result.count})`);
+        for (const asset of result.assets) {
+          info(`  ${asset.assetId}  ${asset.type}  ${asset.status ?? "ready"}  ${asset.uri || "-"}`);
+        }
+      }
+    } catch (error2) {
+      handleError(error2, jsonMode, "workspace_assets_list");
+    }
+  });
+  assets.command("download").description("Download a workspace asset by asset ID or hogi://asset URI").argument("<asset>", "Workspace asset ID or hogi://asset/<id>").option("-o, --output <path>", "Output file or directory path").option("--filename <name>", "Download filename hint passed to backend").option("--wm", "Request watermarked asset").action(async (asset, opts, cmd) => {
+    const jsonMode = isJsonOutput(cmd);
+    try {
+      const result = await executeWorkspaceAssetDownload({
+        asset,
+        ...opts.output ? { output: opts.output } : {},
+        ...opts.filename ? { filename: opts.filename } : {},
+        ...opts.wm !== void 0 ? { watermark: opts.wm } : {}
+      }, getRootOptions(cmd), deps);
+      setTelemetryWorkspaceId(result.workspace_id);
+      recordTelemetryBusinessInfo({ resource_type: new URL(result.uri).hostname, size_bytes: result.bytes });
+      if (jsonMode) printJson(successJson("workspace_asset_download", result));
+      else success(`Downloaded workspace asset ${result.asset_id}: ${result.path}`);
+    } catch (error2) {
+      handleError(error2, jsonMode, "workspace_asset_download");
+    }
+  });
+  return assets;
+}
+
 // src/commands/workspace.ts
 function getWorkspaceOverride(cmd) {
   let root = cmd;
@@ -1521,6 +2071,21 @@ async function executeWorkspaceCreate(params, rootOptions, deps = {}) {
     set_current: params.setCurrent === true
   };
 }
+async function executeWorkspaceRename(params, rootOptions, deps = {}) {
+  const name = params.name.trim();
+  if (!name) throw new CliError(ErrorCode.INVALID_ARGUMENT, "--name must not be empty");
+  if (name.length > 100) throw new CliError(ErrorCode.INVALID_ARGUMENT, "--name must not exceed 100 characters");
+  const configStore = deps.configStore ?? new FileConfigStore();
+  const auth = requireApiKeyAuth(rootOptions, configStore);
+  const workspaceId = resolveWorkspaceId(rootOptions, configStore, params.workspaceId);
+  const result = await new HogiWorkspaceClient({
+    baseUrl: auth.baseUrl,
+    apiKey: auth.apiKey,
+    ...deps.fetch ? { fetch: deps.fetch } : {}
+  }).renameWorkspace(workspaceId, name);
+  logFeatureStep("workspace", "workspace.renamed", { workspace_id: result.workspaceId });
+  return { workspace_id: result.workspaceId, name: result.name };
+}
 function handleWorkspaceError(error2, jsonMode, type) {
   const cliError = error2 instanceof CliError ? error2 : new CliError(ErrorCode.SERVER_ERROR, error2 instanceof Error ? error2.message : String(error2));
   if (jsonMode) printJson(errorJson(type, cliError.code, cliError.message, cliError.details));
@@ -1528,7 +2093,7 @@ function handleWorkspaceError(error2, jsonMode, type) {
   process.exitCode = 1;
 }
 function createWorkspaceCommand(deps = {}) {
-  const ws = new Command("workspace").description("Workspace management");
+  const ws = new Command2("workspace").description("Workspace management");
   ws.command("create").description("Create a new workspace").option("--name <name>", "Workspace name").option("--language <language>", "Workspace language: en, zh, zh-Hant, or ja").option("--set-current", "Set the created workspace as the active workspace").action(async (opts, cmd) => {
     const jsonMode = isJsonOutput(cmd);
     try {
@@ -1614,22 +2179,41 @@ function createWorkspaceCommand(deps = {}) {
       info(`  Source: ${source}`);
     }
   });
+  ws.command("rename").description("Rename a workspace").argument("[workspace_id]", "Workspace ID; defaults to the active workspace").requiredOption("--name <name>", "New workspace name").action(async (workspaceId, opts, cmd) => {
+    const jsonMode = isJsonOutput(cmd);
+    try {
+      const result = await executeWorkspaceRename({ workspaceId, name: opts.name }, getRootOptions(cmd), deps);
+      setTelemetryWorkspaceId(result.workspace_id);
+      if (jsonMode) printJson(successJson("workspace_renamed", result));
+      else success(`Workspace renamed to: ${result.name}`);
+    } catch (error2) {
+      handleWorkspaceError(error2, jsonMode, "workspace_renamed");
+    }
+  });
+  ws.addCommand(createWorkspaceAssetsCommand(deps));
   return ws;
 }
 
 // src/commands/image.ts
-import { Command as Command2, Option } from "commander";
+import { Command as Command3, Option } from "commander";
 
 // src/clients/hogi_async_generation_client.ts
 var DEFAULT_ASYNC_GENERATION_REQUEST_TIMEOUT_MS = 3e4;
+function responseProtocolError2(message) {
+  return new CliError(ErrorCode.SERVER_ERROR, message, {
+    category: "response_protocol",
+    retryable: true,
+    response_protocol: true
+  });
+}
 function textPayload(result, fallback) {
   if (result.isError) throw errorFromMcpToolResult(result, fallback);
   const text = (result.content ?? []).filter((item) => item?.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n").trim();
-  if (!text) throw new CliError(ErrorCode.SERVER_ERROR, `${fallback}: empty response`);
+  if (!text) throw responseProtocolError2(`${fallback}: empty response`);
   try {
     return JSON.parse(text);
   } catch {
-    throw new CliError(ErrorCode.SERVER_ERROR, `${fallback}: invalid JSON response`);
+    throw responseProtocolError2(`${fallback}: invalid JSON response`);
   }
 }
 function isRecord(value) {
@@ -1639,11 +2223,11 @@ function assertStatus(value) {
   if (value === "pending" || value === "processing" || value === "succeeded" || value === "failed" || value === "cancelled") {
     return value;
   }
-  throw new CliError(ErrorCode.SERVER_ERROR, `Invalid backend async task status: ${String(value)}`);
+  throw responseProtocolError2(`Invalid backend async task status: ${String(value)}`);
 }
 function assertMediaType(value) {
   if (value === "image" || value === "video" || value === "audio") return value;
-  throw new CliError(ErrorCode.SERVER_ERROR, `Invalid backend async media type: ${String(value)}`);
+  throw responseProtocolError2(`Invalid backend async media type: ${String(value)}`);
 }
 var HogiAsyncGenerationClient = class {
   constructor(mcp) {
@@ -1668,7 +2252,7 @@ var HogiAsyncGenerationClient = class {
     });
     const payload = textPayload(result, "Async generation submission failed");
     if (!isRecord(payload) || typeof payload.taskId !== "string" || payload.taskId.length === 0 || typeof payload.assetId !== "string" || payload.assetId.length === 0 || typeof payload.workspaceId !== "string" || payload.workspaceId.length === 0 || typeof payload.reused !== "boolean") {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Invalid async generation submission response");
+      throw responseProtocolError2("Invalid async generation submission response");
     }
     const submission = {
       assetId: payload.assetId,
@@ -1680,7 +2264,7 @@ var HogiAsyncGenerationClient = class {
       workspaceId: payload.workspaceId
     };
     if (submission.workspaceId !== params.workspaceId || submission.mediaType !== params.mediaType) {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Async generation submission response does not match the request");
+      throw responseProtocolError2("Async generation submission response does not match the request");
     }
     logFeatureStep("async_generation", "submission.accepted", {
       task_id: submission.taskId,
@@ -1699,16 +2283,16 @@ var HogiAsyncGenerationClient = class {
     const payload = textPayload(result, "Async generation query failed");
     const task = isRecord(payload) && isRecord(payload.task) ? payload.task : void 0;
     if (!task || typeof task.taskId !== "string" || typeof task.workspaceId !== "string" || !Array.isArray(task.outputUris)) {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Invalid async generation query response");
+      throw responseProtocolError2("Invalid async generation query response");
     }
     if (!task.outputUris.every((uri) => typeof uri === "string")) {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Invalid async generation output URI list");
+      throw responseProtocolError2("Invalid async generation output URI list");
     }
     if (typeof task.progress !== "number" || !Number.isFinite(task.progress)) {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Invalid async generation progress");
+      throw responseProtocolError2("Invalid async generation progress");
     }
     if (task.error !== null && task.error !== void 0 && (!isRecord(task.error) || typeof task.error.code !== "string" || typeof task.error.message !== "string")) {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Invalid async generation error payload");
+      throw responseProtocolError2("Invalid async generation error payload");
     }
     const outputUris = task.outputUris;
     const response = {
@@ -1724,7 +2308,7 @@ var HogiAsyncGenerationClient = class {
       workspaceId: task.workspaceId
     };
     if (response.taskId !== taskId || response.workspaceId !== workspaceId) {
-      throw new CliError(ErrorCode.SERVER_ERROR, "Async generation query response does not match the requested task");
+      throw responseProtocolError2("Async generation query response does not match the requested task");
     }
     logFeatureStep("async_generation", "query.completed", {
       task_id: taskId,
@@ -1743,11 +2327,13 @@ var HogiModelCatalogClient = class {
   apiKey;
   _fetch;
   logger;
+  timeoutMs;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
     this._fetch = options.fetch ?? globalThis.fetch;
     this.logger = options.logger;
+    this.timeoutMs = options.timeoutMs;
   }
   async listModels() {
     const apiLog = startApiCall({
@@ -1758,55 +2344,61 @@ var HogiModelCatalogClient = class {
     }, this.logger);
     let response;
     try {
-      response = await this._fetch(`${this.baseUrl}/points/mcp_model_pricings`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "accept": "application/json",
-          "connection": "close",
-          "x-hogi-api-key": this.apiKey
-        },
-        body: "{}"
+      return await withRequestTimeout({
+        operation: "Model catalog request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(`${this.baseUrl}/points/mcp_model_pricings`, {
+            method: "POST",
+            headers: withClientContextHeaders({
+              "content-type": "application/json",
+              "accept": "application/json",
+              "connection": "close",
+              "x-hogi-api-key": this.apiKey
+            }),
+            body: "{}",
+            signal
+          });
+          if (response.status === 401) throw new CliError(ErrorCode.API_KEY_INVALID, "Invalid API key", { status: 401 });
+          if (!response.ok) {
+            throw new CliError(
+              ErrorCode.SERVER_ERROR,
+              `Model catalog request failed: HTTP ${response.status}`,
+              { status: response.status }
+            );
+          }
+          let body;
+          try {
+            body = await response.json();
+          } catch {
+            throw new CliError(ErrorCode.SERVER_ERROR, "Invalid JSON response from model catalog");
+          }
+          const pricings = body.data?.pricings;
+          if (body.code !== "SUCCESS" || !Array.isArray(pricings) || pricings.some((item) => !isBackendModelPricing(item))) {
+            throw new CliError(ErrorCode.SERVER_ERROR, body.error ?? "Invalid model catalog response from server");
+          }
+          apiLog.success(response.status, { model_count: pricings.length });
+          return pricings;
+        }
       });
     } catch (error2) {
+      if (error2 instanceof HttpRequestTimeoutError) {
+        const timeoutError = new CliError(ErrorCode.NETWORK_ERROR, error2.message, {
+          retryable: true,
+          timeout_ms: error2.timeoutMs
+        });
+        apiLog.failure(timeoutError, response?.status);
+        throw timeoutError;
+      }
+      if (error2 instanceof CliError) {
+        apiLog.failure(error2, response?.status);
+        throw error2;
+      }
       const message = error2 instanceof Error ? error2.message : String(error2);
       const networkError = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${message}`);
       apiLog.failure(networkError);
       throw networkError;
     }
-    if (response.status === 401) {
-      const authError = new CliError(ErrorCode.API_KEY_INVALID, "Invalid API key", { status: 401 });
-      apiLog.failure(authError, response.status);
-      throw authError;
-    }
-    if (!response.ok) {
-      const serverError = new CliError(
-        ErrorCode.SERVER_ERROR,
-        `Model catalog request failed: HTTP ${response.status}`,
-        { status: response.status }
-      );
-      apiLog.failure(serverError, response.status);
-      throw serverError;
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      const parseError = new CliError(ErrorCode.SERVER_ERROR, "Invalid JSON response from model catalog");
-      apiLog.failure(parseError, response.status);
-      throw parseError;
-    }
-    const pricings = body.data?.pricings;
-    if (body.code !== "SUCCESS" || !Array.isArray(pricings) || pricings.some((item) => !isBackendModelPricing(item))) {
-      const shapeError = new CliError(
-        ErrorCode.SERVER_ERROR,
-        body.error ?? "Invalid model catalog response from server"
-      );
-      apiLog.failure(shapeError, response.status);
-      throw shapeError;
-    }
-    apiLog.success(response.status, { model_count: pricings.length });
-    return pricings;
   }
 };
 function isBackendModelPricing(value) {
@@ -2143,8 +2735,8 @@ function selectionCliArgs(selection) {
 }
 
 // src/core/task_store.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync3, chmodSync as chmodSync3 } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, existsSync as existsSync4, chmodSync as chmodSync3 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
 import { randomBytes as randomBytes5 } from "crypto";
 function generateTaskId() {
   return "task_" + randomBytes5(8).toString("hex");
@@ -2154,7 +2746,7 @@ var TaskStore = class {
   tasksPath;
   constructor(options) {
     this.configDir = options?.configDir ?? resolveConfigDir();
-    this.tasksPath = join4(this.configDir, "tasks.jsonl");
+    this.tasksPath = join5(this.configDir, "tasks.jsonl");
   }
   /** Return the local state directory shared by tasks and preview bundles. */
   getConfigDir() {
@@ -2172,6 +2764,10 @@ var TaskStore = class {
       command: params.command,
       toolName: params.toolName,
       inputArgs: params.inputArgs,
+      ...params.pendingSubmission ? { pendingSubmission: params.pendingSubmission } : {},
+      ...params.credentialFingerprint ? { credentialFingerprint: params.credentialFingerprint } : {},
+      ...params.backendBaseUrl ? { backendBaseUrl: params.backendBaseUrl.replace(/\/+$/, "") } : {},
+      ...params.mediaType ? { mediaType: params.mediaType } : {},
       status: "created",
       resourceUris: [],
       createdAt: now,
@@ -2254,7 +2850,7 @@ var TaskStore = class {
   }
   /** Internal: read all tasks from the JSONL file. */
   _readAll() {
-    if (!existsSync3(this.tasksPath)) return [];
+    if (!existsSync4(this.tasksPath)) return [];
     try {
       const raw = readFileSync3(this.tasksPath, "utf-8");
       const lines = raw.trim().split("\n").filter((l) => l.trim() !== "");
@@ -2272,8 +2868,8 @@ var TaskStore = class {
   }
   /** Ensure the parent directory exists. */
   _ensureDir() {
-    const dir = dirname2(this.tasksPath);
-    if (!existsSync3(dir)) {
+    const dir = dirname3(this.tasksPath);
+    if (!existsSync4(dir)) {
       mkdirSync3(dir, { recursive: true, mode: 448 });
     }
     chmodSync3(dir, 448);
@@ -2281,8 +2877,8 @@ var TaskStore = class {
 };
 
 // src/core/preview_store.ts
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync4, readdirSync, chmodSync as chmodSync4 } from "fs";
-import { join as join5 } from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync5, readdirSync, chmodSync as chmodSync4 } from "fs";
+import { join as join6 } from "path";
 import { randomBytes as randomBytes6 } from "crypto";
 function generateBundleId() {
   return "preview_" + randomBytes6(8).toString("hex");
@@ -2325,7 +2921,7 @@ var PreviewStore = class {
   previewsDir;
   constructor(options) {
     this.configDir = options?.configDir ?? resolveConfigDir();
-    this.previewsDir = join5(this.configDir, "previews");
+    this.previewsDir = join6(this.configDir, "previews");
   }
   /** Return the local state directory shared by previews and task history. */
   getConfigDir() {
@@ -2337,13 +2933,13 @@ var PreviewStore = class {
    */
   createBundle(params) {
     const bundleId = generateBundleId();
-    const bundleDir = join5(this.previewsDir, bundleId);
+    const bundleDir = join6(this.previewsDir, bundleId);
     mkdirSync4(bundleDir, { recursive: true, mode: 448 });
-    mkdirSync4(join5(bundleDir, "artifacts"), { recursive: true, mode: 448 });
+    mkdirSync4(join6(bundleDir, "artifacts"), { recursive: true, mode: 448 });
     chmodSync4(this.configDir, 448);
     chmodSync4(this.previewsDir, 448);
     chmodSync4(bundleDir, 448);
-    chmodSync4(join5(bundleDir, "artifacts"), 448);
+    chmodSync4(join6(bundleDir, "artifacts"), 448);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const manifest = {
       schema_version: 1,
@@ -2384,8 +2980,8 @@ var PreviewStore = class {
       agent_summary: agentSummary,
       next: nextCommands
     };
-    const manifestPath = join5(bundleDir, "manifest.json");
-    const summaryPath = join5(bundleDir, "summary.json");
+    const manifestPath = join6(bundleDir, "manifest.json");
+    const summaryPath = join6(bundleDir, "summary.json");
     writeFileSync4(manifestPath, JSON.stringify(manifest, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
     writeFileSync4(summaryPath, JSON.stringify(summary, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
     chmodSync4(manifestPath, 384);
@@ -2402,10 +2998,10 @@ var PreviewStore = class {
    * Get a bundle by its bundle ID.
    */
   getBundle(bundleId) {
-    const bundleDir = join5(this.previewsDir, bundleId);
-    const manifestPath = join5(bundleDir, "manifest.json");
-    const summaryPath = join5(bundleDir, "summary.json");
-    if (!existsSync4(manifestPath) || !existsSync4(summaryPath)) {
+    const bundleDir = join6(this.previewsDir, bundleId);
+    const manifestPath = join6(bundleDir, "manifest.json");
+    const summaryPath = join6(bundleDir, "summary.json");
+    if (!existsSync5(manifestPath) || !existsSync5(summaryPath)) {
       logFeatureStep("preview_store", "preview.read", { bundle_id: bundleId, found: false });
       return void 0;
     }
@@ -2455,13 +3051,13 @@ var PreviewStore = class {
    * Scan the previews directory and read all manifest.json files.
    */
   _scanBundles() {
-    if (!existsSync4(this.previewsDir)) return [];
+    if (!existsSync5(this.previewsDir)) return [];
     const entries = readdirSync(this.previewsDir, { withFileTypes: true });
     const manifests = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const manifestPath = join5(this.previewsDir, entry.name, "manifest.json");
-      if (!existsSync4(manifestPath)) continue;
+      const manifestPath = join6(this.previewsDir, entry.name, "manifest.json");
+      if (!existsSync5(manifestPath)) continue;
       try {
         const manifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
         manifests.push(manifest);
@@ -2519,6 +3115,46 @@ function localStatusForBackend(status) {
 function isTerminalTask(task) {
   return task.status === "succeeded" || task.status === "failed" || task.status === "cancelled";
 }
+function isAmbiguousSubmissionError(error2) {
+  if (!(error2 instanceof CliError)) return false;
+  if (error2.code === ErrorCode.NETWORK_ERROR || error2.code === ErrorCode.GENERATION_TIMEOUT) return true;
+  const details = errorDetails(error2);
+  return details.response_protocol === true || details.request_outcome === "unknown";
+}
+function errorDetails(error2) {
+  return error2.details && typeof error2.details === "object" && !Array.isArray(error2.details) ? error2.details : {};
+}
+function persistAsyncSubmissionCommandError(params) {
+  if (params.taskStore.get(params.task.id)?.backendTaskId) return params.error;
+  const code = params.error instanceof CliError ? params.error.code : ErrorCode.GENERATION_FAILED;
+  const message = params.error instanceof Error ? params.error.message : String(params.error);
+  if (isAmbiguousSubmissionError(params.error)) {
+    params.taskStore.update(params.task.id, {
+      status: "submitting",
+      error: { code, message }
+    });
+    return new CliError(code, message, {
+      ...errorDetails(params.error),
+      submission_outcome: "unknown",
+      local_task_id: params.task.id,
+      task_status: "submitting",
+      retry_command: `oiioii task retry ${params.task.id}`
+    });
+  }
+  const failedTask = params.taskStore.update(params.task.id, {
+    status: "failed",
+    error: { code, message }
+  }) ?? params.task;
+  createGenerationPreview({
+    taskStore: params.taskStore,
+    previewStore: params.previewStore,
+    task: failedTask,
+    resources: [],
+    status: "failed",
+    error: { code, message }
+  });
+  return params.error;
+}
 function assertTaskOutputUris(task) {
   const prefix = URI_PREFIX[task.mediaType];
   const mismatched = task.outputUris.find((uri) => !uri.startsWith(prefix));
@@ -2604,6 +3240,38 @@ async function submitAsyncGeneration(params) {
   }
   return { submission, ...synced };
 }
+async function retryAsyncGenerationSubmission(params) {
+  if (params.task.backendTaskId) {
+    throw new CliError(ErrorCode.INVALID_ARGUMENT, `Task ${params.task.id} has already been accepted by the backend.`);
+  }
+  if (params.task.status !== "submitting" || !params.task.pendingSubmission || !params.task.error) {
+    throw new CliError(
+      ErrorCode.INVALID_ARGUMENT,
+      `Task ${params.task.id} is not an ambiguous submission that can be retried.`
+    );
+  }
+  const pending = params.task.pendingSubmission;
+  try {
+    return await submitAsyncGeneration({
+      client: params.client,
+      taskStore: params.taskStore,
+      previewStore: params.previewStore,
+      task: params.task,
+      mediaType: pending.mediaType,
+      prompt: pending.prompt,
+      ...pending.model ? { model: pending.model } : {},
+      backendBaseUrl: params.backendBaseUrl,
+      input: pending.input
+    });
+  } catch (error2) {
+    throw persistAsyncSubmissionCommandError({
+      taskStore: params.taskStore,
+      previewStore: params.previewStore,
+      task: params.task,
+      error: error2
+    });
+  }
+}
 async function syncAsyncGenerationTask(params) {
   if (!params.task.backendTaskId) {
     if (isTerminalTask(params.task)) return { task: params.task };
@@ -2650,6 +3318,12 @@ async function syncAsyncGenerationTask(params) {
   return { task: updated, ...previewWarning ? { previewWarning } : {} };
 }
 
+// src/core/credential_fingerprint.ts
+import { createHash } from "crypto";
+function credentialFingerprint(apiKey) {
+  return `sha256:${createHash("sha256").update("oiioii-cli-task-credential-v1\0").update(apiKey).digest("hex")}`;
+}
+
 // src/core/video_model_contract.ts
 var VIDEO_GENERATE_MODES = [
   "text2Video",
@@ -3238,6 +3912,12 @@ async function executeImageText(params, workspaceId, apiKey, baseUrl, deps = {})
     ...prepared.args,
     workspace_id: workspaceId
   };
+  const pendingSubmission = {
+    mediaType: "image",
+    prompt: params.prompt,
+    model: selection.variant,
+    input: buildAsyncImageInput(prepared.args)
+  };
   const commandStr = `oiioii image text --prompt "${params.prompt}" ${selectionCliArgs(selection)}${params.aspectRatio ? ` --aspect-ratio ${params.aspectRatio}` : ""}${params.size ? ` --size ${params.size}` : ""}${params.resolution ? ` --resolution ${params.resolution}` : ""}`;
   const task = taskStore.create({
     workspaceId,
@@ -3256,7 +3936,11 @@ async function executeImageText(params, workspaceId, apiKey, baseUrl, deps = {})
         size: toolArgs.size,
         resolution: toolArgs.resolution
       }
-    }
+    },
+    pendingSubmission,
+    credentialFingerprint: credentialFingerprint(apiKey),
+    backendBaseUrl: baseUrl,
+    mediaType: "image"
   });
   taskStore.update(task.id, { status: "submitting" });
   const client = new HogiMcpClient({
@@ -3275,7 +3959,7 @@ async function executeImageText(params, workspaceId, apiKey, baseUrl, deps = {})
       prompt: params.prompt,
       model: selection.variant,
       backendBaseUrl: baseUrl,
-      input: buildAsyncImageInput(prepared.args)
+      input: pendingSubmission.input
     });
     const artifacts = submitted.task.resourceUris.map((uri) => ({ type: "image", uri, mime_type: "image/jpeg" }));
     const warnings = submitted.previewWarning ? [submitted.previewWarning] : [];
@@ -3297,13 +3981,8 @@ async function executeImageText(params, workspaceId, apiKey, baseUrl, deps = {})
     };
   } catch (err) {
     const errCode = err instanceof CliError ? err.code : ErrorCode.GENERATION_FAILED;
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (!taskStore.get(task.id)?.backendTaskId) {
-      taskStore.update(task.id, { status: "failed", error: { code: errCode, message: errMsg } });
-      createGenerationPreview({ taskStore, previewStore: deps.previewStore, task, resources: [], status: "failed", error: { code: errCode, message: errMsg } });
-    }
     logFeatureStep("image", "generation.command_failed", { task_id: task.id, backend_task_cached: taskStore.get(task.id)?.backendTaskId !== void 0, error_code: errCode }, "error");
-    throw err;
+    throw persistAsyncSubmissionCommandError({ taskStore, previewStore: deps.previewStore, task, error: err });
   }
 }
 async function executeImageEdit(params, workspaceId, apiKey, baseUrl, deps = {}) {
@@ -3322,6 +4001,12 @@ async function executeImageEdit(params, workspaceId, apiKey, baseUrl, deps = {})
     ...prepared.args,
     workspace_id: workspaceId
   };
+  const pendingSubmission = {
+    mediaType: "image",
+    prompt: params.prompt,
+    model: selection.variant,
+    input: buildAsyncImageInput(prepared.args)
+  };
   const commandStr = `oiioii image edit --image ${params.image} --prompt "${params.prompt}" ${selectionCliArgs(selection)}${params.aspectRatio ? ` --aspect-ratio ${params.aspectRatio}` : ""}${params.size ? ` --size ${params.size}` : ""}${params.resolution ? ` --resolution ${params.resolution}` : ""}`;
   const task = taskStore.create({
     workspaceId,
@@ -3342,7 +4027,11 @@ async function executeImageEdit(params, workspaceId, apiKey, baseUrl, deps = {})
         size: toolArgs.size,
         resolution: toolArgs.resolution
       }
-    }
+    },
+    pendingSubmission,
+    credentialFingerprint: credentialFingerprint(apiKey),
+    backendBaseUrl: baseUrl,
+    mediaType: "image"
   });
   taskStore.update(task.id, { status: "submitting" });
   const client = new HogiMcpClient({
@@ -3361,7 +4050,7 @@ async function executeImageEdit(params, workspaceId, apiKey, baseUrl, deps = {})
       prompt: params.prompt,
       model: selection.variant,
       backendBaseUrl: baseUrl,
-      input: buildAsyncImageInput(prepared.args)
+      input: pendingSubmission.input
     });
     const artifacts = submitted.task.resourceUris.map((uri) => ({ type: "image", uri, mime_type: "image/jpeg" }));
     const warnings = submitted.previewWarning ? [submitted.previewWarning] : [];
@@ -3383,17 +4072,12 @@ async function executeImageEdit(params, workspaceId, apiKey, baseUrl, deps = {})
     };
   } catch (err) {
     const errCode = err instanceof CliError ? err.code : ErrorCode.GENERATION_FAILED;
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (!taskStore.get(task.id)?.backendTaskId) {
-      taskStore.update(task.id, { status: "failed", error: { code: errCode, message: errMsg } });
-      createGenerationPreview({ taskStore, previewStore: deps.previewStore, task, resources: [], status: "failed", error: { code: errCode, message: errMsg } });
-    }
     logFeatureStep("image", "generation.command_failed", { task_id: task.id, backend_task_cached: taskStore.get(task.id)?.backendTaskId !== void 0, error_code: errCode }, "error");
-    throw err;
+    throw persistAsyncSubmissionCommandError({ taskStore, previewStore: deps.previewStore, task, error: err });
   }
 }
 function createImageCommand(deps = {}) {
-  const image = new Command2("image").description("Image generation commands");
+  const image = new Command3("image").description("Image generation commands");
   image.command("text").description("Generate image from text prompt").requiredOption("--prompt <text>", "Image description").option("--model <model>", "Model name", DEFAULT_IMAGE_MODEL).option("--model-id <id>", "Exact model ID from inspect models").option("--variant <variant>", "Exact model variant from inspect models").option("--aspect-ratio <ratio>", "Image aspect ratio (defaults to the selected model catalog)").addOption(new Option("--size <size>", "Deprecated <width>x<height> compatibility option").hideHelp()).option("--resolution <resolution>", "Image resolution (defaults to the selected model catalog)").option("--dry-run", "Validate and preview the resolved request without submitting").action(async (opts, cmd) => {
     const jsonMode = isJsonMode(cmd);
     const rootOpts = getRootOpts(cmd);
@@ -3584,7 +4268,7 @@ function createImageCommand(deps = {}) {
 }
 
 // src/commands/video.ts
-import { Command as Command3 } from "commander";
+import { Command as Command4 } from "commander";
 var GROK_IMAGINE_TOOL_NAME = "generate_video_grok_imagine";
 var isJsonMode2 = isJsonOutput;
 var getRootOpts2 = getRootOptions;
@@ -3742,6 +4426,12 @@ async function executeVideoText(params, workspaceId, apiKey, baseUrl, deps = {})
     ...prepared.args,
     workspace_id: workspaceId
   };
+  const pendingSubmission = {
+    mediaType: "video",
+    prompt: params.prompt,
+    model: selection.variant,
+    input: buildAsyncVideoInput(prepared.args)
+  };
   const commandStr = `oiioii video text --prompt "${params.prompt}" ${selectionCliArgs(selection)} --duration ${duration} --aspect-ratio ${aspectRatio} --resolution ${resolution}`;
   const task = taskStore.create({
     workspaceId,
@@ -3758,7 +4448,11 @@ async function executeVideoText(params, workspaceId, apiKey, baseUrl, deps = {})
       aspectRatio,
       duration,
       toolArgs
-    }
+    },
+    pendingSubmission,
+    credentialFingerprint: credentialFingerprint(apiKey),
+    backendBaseUrl: baseUrl,
+    mediaType: "video"
   });
   taskStore.update(task.id, { status: "submitting" });
   const client = new HogiMcpClient({
@@ -3777,7 +4471,7 @@ async function executeVideoText(params, workspaceId, apiKey, baseUrl, deps = {})
       prompt: params.prompt,
       model: selection.variant,
       backendBaseUrl: baseUrl,
-      input: buildAsyncVideoInput(prepared.args)
+      input: pendingSubmission.input
     });
     const artifacts = submitted.task.resourceUris.map((uri) => ({ type: "video", uri, mime_type: "video/mp4" }));
     const warnings = submitted.previewWarning ? [submitted.previewWarning] : [];
@@ -3800,13 +4494,8 @@ async function executeVideoText(params, workspaceId, apiKey, baseUrl, deps = {})
     };
   } catch (err) {
     const errCode = err instanceof CliError ? err.code : ErrorCode.GENERATION_FAILED;
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (!taskStore.get(task.id)?.backendTaskId) {
-      taskStore.update(task.id, { status: "failed", error: { code: errCode, message: errMsg } });
-      createGenerationPreview({ taskStore, previewStore: deps.previewStore, task, resources: [], status: "failed", error: { code: errCode, message: errMsg } });
-    }
     logFeatureStep("video", "generation.command_failed", { task_id: task.id, backend_task_cached: taskStore.get(task.id)?.backendTaskId !== void 0, error_code: errCode }, "error");
-    throw err;
+    throw persistAsyncSubmissionCommandError({ taskStore, previewStore: deps.previewStore, task, error: err });
   }
 }
 async function executeVideoImage(params, workspaceId, apiKey, baseUrl, deps = {}) {
@@ -3829,6 +4518,12 @@ async function executeVideoImage(params, workspaceId, apiKey, baseUrl, deps = {}
     ...prepared.args,
     workspace_id: workspaceId
   };
+  const pendingSubmission = {
+    mediaType: "video",
+    prompt: params.prompt,
+    model: selection.variant,
+    input: buildAsyncVideoInput(prepared.args)
+  };
   const referenceArgs = [
     ...preparedReferences.references.images.map((uri) => `--image ${uri}`),
     ...preparedReferences.references.videos.map((uri) => `--video ${uri}`),
@@ -3854,7 +4549,11 @@ async function executeVideoImage(params, workspaceId, apiKey, baseUrl, deps = {}
       workspaceId,
       duration,
       toolArgs
-    }
+    },
+    pendingSubmission,
+    credentialFingerprint: credentialFingerprint(apiKey),
+    backendBaseUrl: baseUrl,
+    mediaType: "video"
   });
   taskStore.update(task.id, { status: "submitting" });
   const client = new HogiMcpClient({
@@ -3873,7 +4572,7 @@ async function executeVideoImage(params, workspaceId, apiKey, baseUrl, deps = {}
       prompt: params.prompt,
       model: selection.variant,
       backendBaseUrl: baseUrl,
-      input: buildAsyncVideoInput(prepared.args)
+      input: pendingSubmission.input
     });
     const artifacts = submitted.task.resourceUris.map((uri) => ({ type: "video", uri, mime_type: "video/mp4" }));
     const warnings = submitted.previewWarning ? [submitted.previewWarning] : [];
@@ -3896,17 +4595,12 @@ async function executeVideoImage(params, workspaceId, apiKey, baseUrl, deps = {}
     };
   } catch (err) {
     const errCode = err instanceof CliError ? err.code : ErrorCode.GENERATION_FAILED;
-    const errMsg = err instanceof Error ? err.message : String(err);
-    if (!taskStore.get(task.id)?.backendTaskId) {
-      taskStore.update(task.id, { status: "failed", error: { code: errCode, message: errMsg } });
-      createGenerationPreview({ taskStore, previewStore: deps.previewStore, task, resources: [], status: "failed", error: { code: errCode, message: errMsg } });
-    }
     logFeatureStep("video", "generation.command_failed", { task_id: task.id, backend_task_cached: taskStore.get(task.id)?.backendTaskId !== void 0, error_code: errCode }, "error");
-    throw err;
+    throw persistAsyncSubmissionCommandError({ taskStore, previewStore: deps.previewStore, task, error: err });
   }
 }
 function createVideoCommand(deps = {}) {
-  const video = new Command3("video").description("Video generation commands");
+  const video = new Command4("video").description("Video generation commands");
   video.command("text").description("Generate video from text prompt").requiredOption("--prompt <text>", "Video description").option("--model <model>", "Model name", DEFAULT_VIDEO_MODEL).option("--model-id <id>", "Exact model ID from inspect models").option("--variant <variant>", "Exact model variant from inspect models").option("--duration <seconds>", "Duration in seconds (defaults to the selected model catalog)").option("--aspect-ratio <ratio>", "Aspect ratio (defaults to the selected model catalog)").option("--resolution <resolution>", "Video resolution (defaults to the selected model catalog)").option("--dry-run", "Validate and preview the resolved request without submitting").action(async (opts, cmd) => {
     const jsonMode = isJsonMode2(cmd);
     const rootOpts = getRootOpts2(cmd);
@@ -4193,9 +4887,10 @@ function createVideoCommand(deps = {}) {
 }
 
 // src/commands/audio.ts
-import { Command as Command4 } from "commander";
+import { Command as Command5 } from "commander";
 var SEED_AUDIO_TOOL = "generate_music_seed_audio";
 var SUNO_TOOL = "generate_music_suno";
+var SUNO_VARIANTS = ["chirp-v4-5", "chirp-v5", "chirp-v5-5"];
 var AUDIO_FORMATS = ["wav", "mp3", "pcm", "ogg_opus"];
 function requireWorkspace3(rootOpts, configStore) {
   const flag = rootOpts.workspace;
@@ -4275,8 +4970,8 @@ function buildAudioToolArgs(toolName, params, variant, workspaceId) {
     };
   }
   if (toolName === SUNO_TOOL) {
-    if (variant && variant !== "chirp-v4-5" && variant !== "chirp-v5") {
-      throw audioConstraint(`Suno only supports variants chirp-v4-5 and chirp-v5, received ${variant}.`, { field: "variant", received: variant, supported: ["chirp-v4-5", "chirp-v5"] });
+    if (variant && !SUNO_VARIANTS.some((supportedVariant) => supportedVariant === variant)) {
+      throw audioConstraint(`Suno only supports variants ${SUNO_VARIANTS.join(", ")}, received ${variant}.`, { field: "variant", received: variant, supported: [...SUNO_VARIANTS] });
     }
     if (audioUrls.length || referenceImages.length || params.format || params.enableSubtitle !== void 0 || params.loudnessRate !== void 0 || params.pitchRate !== void 0 || params.sampleRate !== void 0 || params.speechRate !== void 0) {
       throw audioConstraint("Reference and audio configuration options are only valid for Seed Audio.", { field: "seed_audio_options" });
@@ -4290,8 +4985,8 @@ function buildAudioToolArgs(toolName, params, variant, workspaceId) {
     return {
       args: {
         custom,
-        // HOE currently validates `prompt` as required even though the backend
-        // source schema marks it optional for description mode. Send the
+        // The backend validates `prompt` as required even though its source
+        // schema marks it optional for description mode. Send the
         // user prompt in both fields for compatibility; current backends use
         // gptDescriptionPrompt when custom=false and safely ignore prompt.
         prompt,
@@ -4381,6 +5076,12 @@ async function executeAudioGenerate(params, workspaceId, apiKey, baseUrl, deps =
   });
   const commandName = expectedFamily ?? "generate";
   const command = `oiioii audio ${commandName} --prompt "${params.prompt}" ${selectionCliArgs(selection)}`;
+  const pendingSubmission = {
+    mediaType: "audio",
+    prompt: params.prompt,
+    model: selection.variant,
+    input: prepared.args
+  };
   const task = taskStore.create({
     workspaceId,
     command,
@@ -4402,7 +5103,11 @@ async function executeAudioGenerate(params, workspaceId, apiKey, baseUrl, deps =
         custom: params.custom,
         instrumental: params.instrumental
       }
-    }
+    },
+    pendingSubmission,
+    credentialFingerprint: credentialFingerprint(apiKey),
+    backendBaseUrl: baseUrl,
+    mediaType: "audio"
   });
   taskStore.update(task.id, { status: "submitting" });
   const client = new HogiMcpClient({
@@ -4421,7 +5126,7 @@ async function executeAudioGenerate(params, workspaceId, apiKey, baseUrl, deps =
       prompt: params.prompt,
       model: selection.variant,
       backendBaseUrl: baseUrl,
-      input: prepared.args
+      input: pendingSubmission.input
     });
     const artifacts = submitted.task.resourceUris.map((uri) => ({ type: "audio", uri, mime_type: "audio/mpeg" }));
     const warnings = submitted.previewWarning ? [submitted.previewWarning] : [];
@@ -4442,13 +5147,8 @@ async function executeAudioGenerate(params, workspaceId, apiKey, baseUrl, deps =
     };
   } catch (error2) {
     const code = error2 instanceof CliError ? error2.code : ErrorCode.GENERATION_FAILED;
-    const message = error2 instanceof Error ? error2.message : String(error2);
-    if (!taskStore.get(task.id)?.backendTaskId) {
-      taskStore.update(task.id, { status: "failed", error: { code, message } });
-      createGenerationPreview({ taskStore, previewStore: deps.previewStore, task, resources: [], status: "failed", error: { code, message } });
-    }
     logFeatureStep("audio", "generation.command_failed", { task_id: task.id, backend_task_cached: taskStore.get(task.id)?.backendTaskId !== void 0, error_code: code }, "error");
-    throw error2;
+    throw persistAsyncSubmissionCommandError({ taskStore, previewStore: deps.previewStore, task, error: error2 });
   }
 }
 function optionalNumber(value, name) {
@@ -4563,7 +5263,7 @@ function addSunoOptions(command) {
   return command.option("--model-id <id>", "Exact Suno model ID from inspect models").option("--variant <variant>", "Exact Suno variant from inspect models").option("--custom", "Use custom lyrics/style mode").option("--tags <text>", "Custom-mode music style tags").option("--instrumental", "Generate instrumental music").option("--auto-generate-video", "Ask Suno to also generate its provider-side video").option("--dry-run", "Validate and preview the resolved request without submitting");
 }
 function createAudioCommand(deps = {}) {
-  const audio = new Command4("audio").description("Audio and music generation commands");
+  const audio = new Command5("audio").description("Audio and music generation commands");
   audio.command("generate").description("Generate audio with Seed Audio or Suno").requiredOption("--prompt <text>", "Audio description; interpreted as lyrics in Suno custom mode").option("--model <model>", "Model name (seed-audio or suno)", DEFAULT_AUDIO_MODEL).option("--model-id <id>", "Exact model ID from inspect models").option("--variant <variant>", "Exact model variant from inspect models").option("--audio <uri...>", "Seed Audio reference audio URIs (maximum 3)").option("--image <uri...>", "Seed Audio reference image URI (maximum 1)").option("--format <format>", `Seed Audio output format (${AUDIO_FORMATS.join(", ")})`).option("--subtitle", "Request Seed Audio subtitle metadata").option("--loudness-rate <number>", "Seed Audio loudness adjustment (-50 to 100)").option("--pitch-rate <number>", "Seed Audio pitch adjustment (-12 to 12)").option("--sample-rate <number>", "Seed Audio output sample rate").option("--speech-rate <number>", "Seed Audio speech rate adjustment (-50 to 100)").option("--custom", "Use Suno custom lyrics/style mode").option("--tags <text>", "Suno custom-mode music style tags").option("--instrumental", "Generate instrumental music with Suno").option("--auto-generate-video", "Ask Suno to also generate its provider-side video").option("--dry-run", "Validate and preview the resolved request without submitting").action(async (opts, cmd) => await runAudioCommand(opts, cmd, deps));
   addSeedAudioOptions(audio.command("seed-audio").description("Generate speech or audio with Seed Audio").requiredOption("--prompt <text>", "Audio description")).action(async (opts, cmd) => await runAudioCommand(opts, cmd, deps, "seed-audio"));
   addSunoOptions(audio.command("suno").description("Generate music with Suno").requiredOption("--prompt <text>", "Music description; interpreted as lyrics in custom mode")).action(async (opts, cmd) => await runAudioCommand(opts, cmd, deps, "suno"));
@@ -4571,7 +5271,7 @@ function createAudioCommand(deps = {}) {
 }
 
 // src/commands/task.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
 function parsePositiveInteger(value, label) {
   const parsed = Number(value);
   if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -4582,6 +5282,24 @@ function parsePositiveInteger(value, label) {
 function printTask(task) {
   info(`${task.backendTaskId ?? task.id}  ${task.status}  ${task.toolName}  ${task.updatedAt}`);
 }
+function taskForOutput(task) {
+  const visible = { ...task };
+  delete visible.credentialFingerprint;
+  return visible;
+}
+function taskRetryRequiredError(task) {
+  return new CliError(
+    ErrorCode.TASK_RETRY_REQUIRED,
+    `Task ${task.id} has an unknown submission outcome. Retry it with the original idempotency key.`,
+    {
+      retryable: true,
+      local_task_id: task.id,
+      task_status: task.status,
+      retry_command: `oiioii task retry ${task.id}`,
+      ...task.error ? { last_error: task.error } : {}
+    }
+  );
+}
 function handleTaskError(error2, jsonMode, type) {
   const cliError = error2 instanceof CliError ? error2 : new CliError(ErrorCode.SERVER_ERROR, error2 instanceof Error ? error2.message : String(error2));
   reportFeatureFailure(cliError.code, cliError.message);
@@ -4589,21 +5307,21 @@ function handleTaskError(error2, jsonMode, type) {
   else error(cliError.message);
   process.exitCode = 1;
 }
-function createAsyncClient(cmd, deps, backendBaseUrl) {
+function createAsyncClient(cmd, deps, backendBaseUrl, requestTimeoutMs = 3e4) {
   const configStore = deps.configStore ?? new FileConfigStore();
   const auth = requireApiKeyAuth(getRootOptions(cmd), configStore);
   return new HogiAsyncGenerationClient(new HogiMcpClient({
     baseUrl: backendBaseUrl ?? auth.baseUrl,
     apiKey: auth.apiKey,
     fetch: deps.fetch,
-    timeoutMs: 3e4
+    timeoutMs: requestTimeoutMs
   }));
 }
-async function refreshTask(taskItem, cmd, deps) {
+async function refreshTask(taskItem, cmd, deps, requestTimeoutMs) {
   if (!taskItem.backendTaskId || isTerminalTask(taskItem)) return taskItem;
   const taskStore = deps.taskStore ?? new TaskStore();
   const result = await syncAsyncGenerationTask({
-    client: createAsyncClient(cmd, deps, taskItem.backendBaseUrl),
+    client: createAsyncClient(cmd, deps, taskItem.backendBaseUrl, requestTimeoutMs),
     taskStore,
     previewStore: deps.previewStore,
     task: taskItem
@@ -4611,7 +5329,7 @@ async function refreshTask(taskItem, cmd, deps) {
   return result.task;
 }
 function createTaskCommand(deps = {}) {
-  const task = new Command5("task").description("Generation task management");
+  const task = new Command6("task").description("Generation task management");
   task.command("list").description("List recent tasks").option("--limit <count>", "Maximum tasks to return", "20").action((opts, cmd) => {
     const jsonMode = isJsonOutput(cmd);
     try {
@@ -4619,7 +5337,7 @@ function createTaskCommand(deps = {}) {
       const tasks = (deps.taskStore ?? new TaskStore()).list(limit);
       recordTelemetryBusinessInfo({ task_count: tasks.length, limit });
       logFeatureStep("task", "task.listed", { count: tasks.length, limit });
-      if (jsonMode) printJson(successJson("task_list", { tasks, count: tasks.length }));
+      if (jsonMode) printJson(successJson("task_list", { tasks: tasks.map(taskForOutput), count: tasks.length }));
       else {
         heading("Recent Tasks");
         for (const taskItem of tasks) printTask(taskItem);
@@ -4638,12 +5356,56 @@ function createTaskCommand(deps = {}) {
       taskItem = await refreshTask(taskItem, cmd, { ...deps, taskStore: store });
       recordTelemetryBusinessInfo({ task_status: taskItem.status });
       logFeatureStep("task", "task.status_read", { task_id: id, status: taskItem.status });
-      if (jsonMode) printJson(successJson("task_status", { task: taskItem }));
+      if (jsonMode) printJson(successJson("task_status", { task: taskForOutput(taskItem) }));
       else printTask(taskItem);
     } catch (error2) {
       handleTaskError(error2, jsonMode, "task_status");
     }
   });
+  task.command("retry").description("Retry an ambiguous generation submission with its original idempotency key").argument("<task_id>", "Local task ID").action(async (id, _opts, cmd) => {
+    const jsonMode = isJsonOutput(cmd);
+    try {
+      const store = deps.taskStore ?? new TaskStore();
+      const taskItem = store.get(id);
+      if (!taskItem) throw new CliError(ErrorCode.TASK_NOT_FOUND, `Task not found: ${id}`);
+      const configStore = deps.configStore ?? new FileConfigStore();
+      const auth = requireApiKeyAuth(getRootOptions(cmd), configStore);
+      if (!taskItem.credentialFingerprint || taskItem.credentialFingerprint !== credentialFingerprint(auth.apiKey)) {
+        throw new CliError(
+          ErrorCode.AUTH_INVALID,
+          `The current API key does not match the credential used to submit task ${taskItem.id}.`,
+          {
+            retryable: false,
+            local_task_id: taskItem.id,
+            reason: taskItem.credentialFingerprint ? "credential_mismatch" : "credential_binding_missing"
+          }
+        );
+      }
+      const backendBaseUrl = taskItem.backendBaseUrl ?? auth.baseUrl;
+      const result = await retryAsyncGenerationSubmission({
+        client: new HogiAsyncGenerationClient(new HogiMcpClient({
+          baseUrl: backendBaseUrl,
+          apiKey: auth.apiKey,
+          fetch: deps.fetch
+        })),
+        taskStore: store,
+        previewStore: deps.previewStore,
+        task: taskItem,
+        backendBaseUrl
+      });
+      recordTelemetryBusinessInfo({ task_status: result.task.status });
+      logFeatureStep("task", "task.submission_retried", {
+        local_task_id: result.task.id,
+        backend_task_id: result.task.backendTaskId,
+        status: result.task.status,
+        reused: result.submission.reused
+      });
+      if (jsonMode) printJson(successJson("task_retry", { task: taskForOutput(result.task), reused: result.submission.reused }));
+      else printTask(result.task);
+    } catch (error2) {
+      handleTaskError(error2, jsonMode, "task_retry");
+    }
+  });
   task.command("wait").description("Wait for a task to complete").argument("<task_id>", "Task ID").option("--timeout <seconds>", "Max wait time", "300").action(async (id, opts, cmd) => {
     const jsonMode = isJsonOutput(cmd);
     try {
@@ -4652,8 +5414,19 @@ function createTaskCommand(deps = {}) {
       const deadline = Date.now() + timeoutSeconds * 1e3;
       let taskItem = store.getByAnyId(id);
       if (!taskItem) throw new CliError(ErrorCode.TASK_NOT_FOUND, `Task not found: ${id}`);
+      if (!taskItem.backendTaskId && taskItem.status === "submitting" && taskItem.pendingSubmission && taskItem.error) {
+        throw taskRetryRequiredError(taskItem);
+      }
       while (!isTerminalTask(taskItem) && Date.now() < deadline) {
-        taskItem = await refreshTask(taskItem, cmd, { ...deps, taskStore: store });
+        const requestTimeoutMs = Math.max(1, Math.min(3e4, deadline - Date.now()));
+        try {
+          taskItem = await refreshTask(taskItem, cmd, { ...deps, taskStore: store }, requestTimeoutMs);
+        } catch (error2) {
+          if (Date.now() >= deadline && error2 instanceof CliError && error2.code === ErrorCode.GENERATION_TIMEOUT) {
+            throw new CliError(ErrorCode.TASK_TIMEOUT, `Timed out waiting for task ${id} after ${timeoutSeconds}s.`);
+          }
+          throw error2;
+        }
         if (!isTerminalTask(taskItem)) {
           const remainingMs = Math.max(0, deadline - Date.now());
           await new Promise((resolve5) => setTimeout(resolve5, Math.min(deps.pollIntervalMs ?? 2e3, remainingMs)));
@@ -4662,9 +5435,21 @@ function createTaskCommand(deps = {}) {
       if (!isTerminalTask(taskItem)) {
         throw new CliError(ErrorCode.TASK_TIMEOUT, `Timed out waiting for task ${id} after ${timeoutSeconds}s.`);
       }
+      if (taskItem.status === "failed" || taskItem.status === "cancelled") {
+        throw new CliError(
+          ErrorCode.GENERATION_FAILED,
+          taskItem.error?.message ?? `Generation task ${taskItem.backendTaskId ?? taskItem.id} ${taskItem.status}.`,
+          {
+            task_id: taskItem.backendTaskId ?? taskItem.id,
+            local_task_id: taskItem.id,
+            backend_status: taskItem.status,
+            ...taskItem.error ? { backend_error: taskItem.error } : {}
+          }
+        );
+      }
       recordTelemetryBusinessInfo({ task_status: taskItem.status, timeout_seconds: timeoutSeconds });
       logFeatureStep("task", "task.wait_completed", { task_id: id, status: taskItem.status });
-      if (jsonMode) printJson(successJson("task_wait", { task: taskItem }));
+      if (jsonMode) printJson(successJson("task_wait", { task: taskForOutput(taskItem) }));
       else printTask(taskItem);
     } catch (error2) {
       handleTaskError(error2, jsonMode, "task_wait");
@@ -4674,7 +5459,7 @@ function createTaskCommand(deps = {}) {
 }
 
 // src/commands/record.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 import { spawn } from "child_process";
 
 // src/clients/hogi_genai_record_client.ts
@@ -4683,11 +5468,13 @@ var HogiGenAIRecordClient = class {
   apiKey;
   _fetch;
   logger;
+  timeoutMs;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
     this._fetch = options.fetch ?? globalThis.fetch;
     this.logger = options.logger;
+    this.timeoutMs = options.timeoutMs;
   }
   /**
    * Fetch a generation record by hogi:// URI.
@@ -4713,190 +5500,57 @@ var HogiGenAIRecordClient = class {
     }, this.logger);
     let response;
     try {
-      response = await this._fetch(url, {
-        method: "GET",
-        headers: {
-          "x-hogi-api-key": this.apiKey
-        }
-      });
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      const error2 = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${msg}`);
-      apiLog.failure(error2);
-      throw error2;
-    }
-    if (response.status === 400) {
-      const error2 = new CliError(ErrorCode.INVALID_ARGUMENT, "URI parameter is required");
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    if (response.status === 401) {
-      const error2 = new CliError(ErrorCode.API_KEY_INVALID, "Invalid API key", { status: 401 });
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    if (response.status === 404) {
-      const error2 = new CliError(
-        ErrorCode.RECORD_NOT_FOUND,
-        `No generation record found for URI: ${uri}`
-      );
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const error2 = new CliError(
-        ErrorCode.SERVER_ERROR,
-        `HTTP ${response.status}: ${text || response.statusText}`,
-        { status: response.status }
-      );
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      const error2 = new CliError(ErrorCode.SERVER_ERROR, "Invalid JSON response from server");
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    if (!body.success || !body.data) {
-      const error2 = new CliError(
-        ErrorCode.SERVER_ERROR,
-        body.error ?? "Unexpected response structure from record API"
-      );
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    apiLog.success(response.status, { record_type: body.data.type, success: body.data.success });
-    return body.data;
-  }
-};
-
-// src/clients/hogi_res_client.ts
-import { mkdir, writeFile } from "fs/promises";
-import { existsSync as existsSync5, statSync as statSync3 } from "fs";
-import { basename, dirname as dirname3, join as join6, resolve as resolve2 } from "path";
-function assertHogiUri(uri) {
-  if (!uri || !uri.startsWith("hogi://")) {
-    throw new CliError(
-      ErrorCode.INVALID_ARGUMENT,
-      `Invalid hogi URI: "${uri}". Expected format: hogi://image/<id> or hogi://video/<id>`
-    );
-  }
-}
-function filenameFromUri(uri) {
-  try {
-    const parsed = new URL(uri);
-    const name = basename(parsed.pathname);
-    if (name && name !== "." && name !== "/") return name;
-  } catch {
-  }
-  return "resource.bin";
-}
-function resolveOutputPath(uri, output) {
-  const fallbackName = filenameFromUri(uri);
-  if (!output) return resolve2(process.cwd(), fallbackName);
-  const resolved = resolve2(output);
-  if (existsSync5(resolved) && statSync3(resolved).isDirectory()) {
-    return join6(resolved, fallbackName);
-  }
-  return resolved;
-}
-function looksLikeJsonError(contentType, buffer) {
-  if (contentType?.toLowerCase().includes("application/json")) return true;
-  const prefix = buffer.subarray(0, 128).toString("utf8").trimStart();
-  return prefix.startsWith("{") && (prefix.includes('"error"') || prefix.includes('"code"'));
-}
-var HogiResClient = class {
-  baseUrl;
-  apiKey;
-  _fetch;
-  logger;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
-    this.apiKey = options.apiKey;
-    this._fetch = options.fetch ?? globalThis.fetch;
-    this.logger = options.logger;
-  }
-  getReadUrl(uri, options = {}) {
-    assertHogiUri(uri);
-    const params = new URLSearchParams();
-    params.set("uri", uri);
-    if (options.filename) params.set("filename", options.filename);
-    if (typeof options.watermark === "boolean") params.set("wm", options.watermark ? "1" : "0");
-    return `${this.baseUrl}/v1/res/read_file?${params.toString()}`;
-  }
-  async download(uri, options = {}) {
-    assertHogiUri(uri);
-    const url = this.getReadUrl(uri, options);
-    const outputPath = resolveOutputPath(uri, options.output);
-    const apiLog = startApiCall({
-      source: "hogi_res_client",
-      operation: "resource.read",
-      method: "GET",
-      path: "/v1/res/read_file"
-    }, this.logger);
-    let response;
-    try {
-      response = await this._fetch(url, {
-        method: "GET",
-        redirect: "follow",
-        headers: {
-          "x-hogi-api-key": this.apiKey,
-          "accept": "image/*,video/*,application/octet-stream,application/json;q=0.5,*/*;q=0.1"
+      return await withRequestTimeout({
+        operation: "Generation record request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(url, {
+            method: "GET",
+            headers: withClientContextHeaders({ "x-hogi-api-key": this.apiKey }),
+            signal
+          });
+          if (response.status === 400) throw new CliError(ErrorCode.INVALID_ARGUMENT, "URI parameter is required");
+          if (response.status === 401) throw new CliError(ErrorCode.API_KEY_INVALID, "Invalid API key", { status: 401 });
+          if (response.status === 404) {
+            throw new CliError(ErrorCode.RECORD_NOT_FOUND, `No generation record found for URI: ${uri}`);
+          }
+          if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            throw new CliError(ErrorCode.SERVER_ERROR, `HTTP ${response.status}: ${text || response.statusText}`, {
+              status: response.status
+            });
+          }
+          let body;
+          try {
+            body = await response.json();
+          } catch {
+            throw new CliError(ErrorCode.SERVER_ERROR, "Invalid JSON response from server");
+          }
+          if (!body.success || !body.data) {
+            throw new CliError(ErrorCode.SERVER_ERROR, body.error ?? "Unexpected response structure from record API");
+          }
+          apiLog.success(response.status, { record_type: body.data.type, success: body.data.success });
+          return body.data;
         }
       });
     } catch (err) {
+      if (err instanceof HttpRequestTimeoutError) {
+        const timeoutError = new CliError(ErrorCode.NETWORK_ERROR, err.message, {
+          retryable: true,
+          timeout_ms: err.timeoutMs
+        });
+        apiLog.failure(timeoutError, response?.status);
+        throw timeoutError;
+      }
+      if (err instanceof CliError) {
+        apiLog.failure(err, response?.status);
+        throw err;
+      }
       const msg = err instanceof Error ? err.message : String(err);
       const error2 = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${msg}`);
       apiLog.failure(error2);
       throw error2;
     }
-    if (response.status === 401) {
-      const error2 = new CliError(ErrorCode.API_KEY_INVALID, "Invalid API key", { status: 401 });
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    if (response.status === 404) {
-      const error2 = new CliError(ErrorCode.RECORD_NOT_FOUND, `Resource not found for URI: ${uri}`, { status: 404 });
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    if (!response.ok) {
-      const text = await response.text().catch(() => "");
-      const error2 = new CliError(
-        ErrorCode.SERVER_ERROR,
-        `HTTP ${response.status}: ${text || response.statusText}`,
-        { status: response.status }
-      );
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    const contentType = response.headers.get("content-type");
-    const buffer = Buffer.from(await response.arrayBuffer());
-    if (looksLikeJsonError(contentType, buffer)) {
-      let message = "Resource read failed";
-      try {
-        const body = JSON.parse(buffer.toString("utf8"));
-        message = body.message ?? body.error ?? body.code ?? message;
-      } catch {
-      }
-      const error2 = new CliError(ErrorCode.SERVER_ERROR, message);
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
-    apiLog.success(response.status, { bytes: buffer.byteLength, mime_type: contentType });
-    await mkdir(dirname3(outputPath), { recursive: true });
-    await writeFile(outputPath, buffer);
-    logFeatureStep("record", "resource.saved", { bytes: buffer.byteLength, mime_type: contentType });
-    return {
-      path: outputPath,
-      bytes: buffer.byteLength,
-      mimeType: contentType,
-      uri
-    };
   }
 };
 
@@ -4919,7 +5573,7 @@ function openFile(path) {
   }
 }
 function createRecordCommand() {
-  const record = new Command6("record").description("GenAI record queries");
+  const record = new Command7("record").description("GenAI record queries");
   record.command("get").description("Get generation record by hogi:// URI").argument("<uri>", "hogi:// URI (e.g. hogi://image/abc123)").action(async (uri, _opts, cmd) => {
     const jsonMode = isJsonMode3(cmd);
     try {
@@ -5037,7 +5691,7 @@ function createRecordCommand() {
 }
 
 // src/commands/inspect.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 var MODEL_SELECTION_CONTRACT = {
   preferred: "model_id",
   generation_flag: "--model-id",
@@ -5138,7 +5792,7 @@ function isJsonMode4(cmd) {
   return root.opts().json === true;
 }
 function createInspectCommand(deps = {}) {
-  const inspect = new Command7("inspect").description("Inspect backend capabilities");
+  const inspect = new Command8("inspect").description("Inspect backend capabilities");
   inspect.command("capabilities").description("List available GenAI capabilities").action((_opts, cmd) => {
     const jsonMode = isJsonMode4(cmd);
     const caps = getCapabilities();
@@ -5215,7 +5869,7 @@ function createInspectCommand(deps = {}) {
 }
 
 // src/commands/preview.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 function createBundleFromTerminalTask(store, task) {
   if (task.status !== "succeeded" && task.status !== "failed") return void 0;
   const mediaType = task.mediaType ?? (task.toolName.includes("video") ? "video" : task.toolName.includes("music") || task.toolName.includes("audio") ? "audio" : "image");
@@ -5331,7 +5985,7 @@ function printPreviewHuman(data) {
   }
 }
 function createPreviewCommand(deps = {}) {
-  const preview = new Command8("preview").description("Preview bundles for generation results");
+  const preview = new Command9("preview").description("Preview bundles for generation results");
   preview.command("latest").description("Show the most recent preview bundle").action((_opts, cmd) => {
     const jsonMode = isJsonMode5(cmd);
     const result = executePreviewLatest(deps);
@@ -5400,7 +6054,7 @@ function createPreviewCommand(deps = {}) {
 }
 
 // src/commands/upload.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 import { basename as basename2, resolve as resolve3 } from "path";
 import { readFile, stat } from "fs/promises";
 
@@ -5514,11 +6168,13 @@ var HogiResUploadClient = class {
   apiKey;
   _fetch;
   logger;
+  timeoutMs;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
     this._fetch = options.fetch ?? globalThis.fetch;
     this.logger = options.logger;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_HTTP_TRANSFER_TIMEOUT_MS;
   }
   async uploadFile(request) {
     const fileType = normalizeFileType(request.fileType);
@@ -5537,33 +6193,47 @@ var HogiResUploadClient = class {
     }, this.logger);
     let response;
     try {
-      response = await this._fetch(`${this.baseUrl}/v1/workspace/uploadAsset?${params.toString()}`, {
-        method: "POST",
-        headers: { "x-hogi-api-key": this.apiKey, "content-type": "application/octet-stream", "accept": "application/json" },
-        body: request.buffer
+      return await withRequestTimeout({
+        operation: "Workspace file upload request",
+        timeoutMs: this.timeoutMs,
+        run: async (signal) => {
+          response = await this._fetch(`${this.baseUrl}/v1/workspace/uploadAsset?${params.toString()}`, {
+            method: "POST",
+            headers: withClientContextHeaders({ "x-hogi-api-key": this.apiKey, "content-type": "application/octet-stream", "accept": "application/json" }),
+            body: request.buffer,
+            signal
+          });
+          const envelope = await parseJsonResponse(response);
+          if (!response.ok) throw mapUploadError(response.status, envelope);
+          const result = parseUploadResult(envelope);
+          if (result.workspaceId !== request.workspaceId) throw new CliError(ErrorCode.SERVER_ERROR, "Upload API returned unexpected workspace_id");
+          if (result.type !== type) throw new CliError(ErrorCode.SERVER_ERROR, "Upload API returned unexpected asset type");
+          apiLog.success(response.status, { asset_id: result.assetId, type: result.type });
+          return result;
+        }
       });
     } catch (err) {
+      if (err instanceof HttpRequestTimeoutError) {
+        const timeoutError = new CliError(ErrorCode.NETWORK_ERROR, err.message, {
+          retryable: true,
+          timeout_ms: err.timeoutMs
+        });
+        apiLog.failure(timeoutError, response?.status);
+        throw timeoutError;
+      }
+      if (err instanceof CliError) {
+        apiLog.failure(err, response?.status);
+        throw err;
+      }
       const error2 = new CliError(ErrorCode.NETWORK_ERROR, `Network error: ${err instanceof Error ? err.message : String(err)}`);
       apiLog.failure(error2);
       throw error2;
     }
-    try {
-      const envelope = await parseJsonResponse(response);
-      if (!response.ok) throw mapUploadError(response.status, envelope);
-      const result = parseUploadResult(envelope);
-      if (result.workspaceId !== request.workspaceId) throw new CliError(ErrorCode.SERVER_ERROR, "Upload API returned unexpected workspace_id");
-      if (result.type !== type) throw new CliError(ErrorCode.SERVER_ERROR, "Upload API returned unexpected asset type");
-      apiLog.success(response.status, { asset_id: result.assetId, type: result.type });
-      return result;
-    } catch (error2) {
-      apiLog.failure(error2, response.status);
-      throw error2;
-    }
   }
 };
 
 // src/clients/hogi_vod_upload_client.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { createReadStream } from "fs";
 
 // src/core/vod_upload_contract.ts
@@ -5921,7 +6591,7 @@ async function readJson(response, operation) {
   return envelope;
 }
 async function md5File(filePath) {
-  const hash = createHash("md5");
+  const hash = createHash2("md5");
   for await (const chunk of createReadStream(filePath)) hash.update(chunk);
   return hash.digest("hex");
 }
@@ -5941,6 +6611,7 @@ var HogiVodUploadClient = class {
   directUpload;
   pollIntervalMs;
   timeoutMs;
+  requestTimeoutMs;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/+$/, "");
     this.apiKey = options.apiKey;
@@ -5949,14 +6620,31 @@ var HogiVodUploadClient = class {
     this.directUpload = options.directUpload ?? uploadFileDirectlyToVod;
     this.pollIntervalMs = options.pollIntervalMs ?? 3e3;
     this.timeoutMs = options.timeoutMs ?? 10 * 60 * 1e3;
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_HTTP_REQUEST_TIMEOUT_MS;
   }
   headers(json = false) {
-    return { "x-hogi-api-key": this.apiKey, accept: "application/json", ...json ? { "content-type": "application/json" } : {} };
+    return withClientContextHeaders({
+      "x-hogi-api-key": this.apiKey,
+      accept: "application/json",
+      ...json ? { "content-type": "application/json" } : {}
+    });
   }
-  async request(url, init, operation) {
+  async requestJson(url, init, operation, timeoutMs = this.requestTimeoutMs) {
     try {
-      return await this.fetch(url, init);
+      return await withRequestTimeout({
+        operation,
+        timeoutMs,
+        run: async (signal) => readJson(await this.fetch(url, { ...init, signal }), operation)
+      });
     } catch (error2) {
+      if (error2 instanceof HttpRequestTimeoutError) {
+        throw new CliError(ErrorCode.NETWORK_ERROR, error2.message, {
+          retryable: true,
+          request_timeout: true,
+          timeout_ms: error2.timeoutMs
+        });
+      }
+      if (error2 instanceof CliError) throw error2;
       throw new CliError(ErrorCode.NETWORK_ERROR, `${operation} network error: ${error2 instanceof Error ? error2.message : String(error2)}`);
     }
   }
@@ -5982,12 +6670,11 @@ var HogiVodUploadClient = class {
     }, this.logger);
     try {
       const query = new URLSearchParams({ workspaceId: request.workspaceId, fileSize: String(request.fileSize) });
-      const tokenResponse = await this.request(
+      const tokenEnvelope = await this.requestJson(
         `${this.baseUrl}/media/vod/upload_token?${query}`,
         { method: "GET", headers: this.headers() },
         "VOD upload_token"
       );
-      const tokenEnvelope = await readJson(tokenResponse, "VOD upload_token");
       const token = tokenEnvelope.data;
       if (!isVodUploadToken(token)) {
         throw new CliError(ErrorCode.SERVER_ERROR, "Invalid VOD upload_token response");
@@ -6004,7 +6691,7 @@ var HogiVodUploadClient = class {
         }),
         md5File(request.filePath)
       ]);
-      const commitResponse = await this.request(`${this.baseUrl}/media/vod/commit_upload`, {
+      const commitEnvelope = await this.requestJson(`${this.baseUrl}/media/vod/commit_upload`, {
         method: "POST",
         headers: this.headers(true),
         body: JSON.stringify({
@@ -6015,7 +6702,6 @@ var HogiVodUploadClient = class {
           contentMd5
         })
       }, "VOD commit_upload");
-      const commitEnvelope = await readJson(commitResponse, "VOD commit_upload");
       const commit = asObject4(commitEnvelope.data);
       if (typeof commit?.assetId !== "string" || typeof commit.taskId !== "string") {
         throw new CliError(ErrorCode.SERVER_ERROR, "Invalid VOD commit_upload response");
@@ -6038,19 +6724,30 @@ var HogiVodUploadClient = class {
     const deadline = Date.now() + this.timeoutMs;
     while (Date.now() < deadline) {
       const query = new URLSearchParams({ taskId, workspaceId });
-      const response = await this.request(
-        `${this.baseUrl}/media/vod/transcode_status?${query}`,
-        { method: "GET", headers: this.headers() },
-        "VOD transcode_status"
-      );
-      const envelope = await readJson(response, "VOD transcode_status");
+      const remainingMs = Math.max(1, deadline - Date.now());
+      let envelope;
+      try {
+        envelope = await this.requestJson(
+          `${this.baseUrl}/media/vod/transcode_status?${query}`,
+          { method: "GET", headers: this.headers() },
+          "VOD transcode_status",
+          Math.min(this.requestTimeoutMs, remainingMs)
+        );
+      } catch (error2) {
+        const details = error2 instanceof CliError && error2.details && typeof error2.details === "object" ? error2.details : void 0;
+        if (details?.request_timeout === true) {
+          if (Date.now() >= deadline) break;
+          continue;
+        }
+        throw error2;
+      }
       const data = asObject4(envelope.data);
       if (!data || typeof data.status !== "string") throw new CliError(ErrorCode.SERVER_ERROR, "Invalid VOD transcode_status response");
       if ((data.status === "completed" || data.status === "finished") && typeof data.outputUri === "string" && data.outputUri.startsWith("hogi://video/")) return data;
       if (data.status === "failed" || data.status === "cancelled") {
         throw new CliError(ErrorCode.SERVER_ERROR, data.errorMessage || data.errorCode || `VOD transcode ${data.status}`);
       }
-      await sleep(this.pollIntervalMs);
+      await sleep(Math.min(this.pollIntervalMs, Math.max(0, deadline - Date.now())));
     }
     throw new CliError(ErrorCode.TASK_TIMEOUT, `VOD transcode timed out after ${this.timeoutMs}ms`, { task_id: taskId });
   }
@@ -6167,7 +6864,7 @@ async function executeUploadFile(params, rootOpts = {}, deps = {}) {
   };
 }
 function createUploadCommand(deps = {}) {
-  const upload = new Command9("upload").description("Upload local files to Hogi resources");
+  const upload = new Command10("upload").description("Upload local files to Hogi resources");
   upload.command("file").description("Upload an image, video, or audio file").argument("<path>", "Local file path").option("--type <ext>", "File extension override, e.g. png/mp4/mp3").option("--name <name>", "Original filename stored for display").option("--after-asset-id <asset_id>", "Insert after an existing workspace asset").option("--vod", "Force the VOD direct-upload flow for a video").option("--attach", "Deprecated compatibility flag; uploads are always attached").action(async (path, opts, cmd) => {
     const jsonMode = isJsonMode6(cmd);
     const rootOpts = getRootOpts3(cmd);
@@ -6219,7 +6916,7 @@ function createUploadCommand(deps = {}) {
 }
 
 // src/commands/logs.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 function rootJsonMode(cmd) {
   let root = cmd;
   while (root.parent) root = root.parent;
@@ -6258,14 +6955,14 @@ function parseFilter(opts) {
 function addFilterOptions(command) {
   return command.option("--level <level>", "Filter by debug/info/warn/error").option("--source <source>", "Filter by exact source name").option("--category <category>", "Filter by application/api").option("--trace <trace_id>", "Filter by feature trace ID").option("--feature <name>", "Filter by feature name, e.g. image.text").option("--since <timestamp>", "Filter entries at or after an ISO timestamp").option("--limit <count>", "Maximum number of newest entries");
 }
-function handleError(error2, jsonMode, type) {
+function handleError2(error2, jsonMode, type) {
   const cliError = error2 instanceof CliError ? error2 : new CliError(ErrorCode.CONFIG_ERROR, error2 instanceof Error ? error2.message : String(error2));
   if (jsonMode) printJson(errorJson(type, cliError.code, cliError.message, cliError.details));
   else error(cliError.message);
   process.exitCode = 1;
 }
 function createLogsCommand(deps = {}) {
-  const logs = new Command10("logs").description("Local structured log management");
+  const logs = new Command11("logs").description("Local structured log management");
   addFilterOptions(logs.command("list").description("List locally stored log entries")).action((opts, cmd) => {
     const jsonMode = rootJsonMode(cmd);
     try {
@@ -6289,7 +6986,7 @@ function createLogsCommand(deps = {}) {
         }
       }
     } catch (error2) {
-      handleError(error2, jsonMode, "logs_list");
+      handleError2(error2, jsonMode, "logs_list");
     }
   });
   addFilterOptions(
@@ -6315,7 +7012,7 @@ function createLogsCommand(deps = {}) {
       if (jsonMode) printJson(successJson("logs_export", result));
       else success(`Exported ${result.count} log entries to ${result.path}`);
     } catch (error2) {
-      handleError(error2, jsonMode, "logs_export");
+      handleError2(error2, jsonMode, "logs_export");
     }
   });
   logs.command("path").description("Show the local log file path").action((_opts, cmd) => {
@@ -6329,7 +7026,7 @@ function createLogsCommand(deps = {}) {
 }
 
 // src/commands/points.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 function context(rootOpts, deps) {
   const configStore = deps.configStore ?? new FileConfigStore();
   const auth = requireApiKeyAuth(rootOpts, configStore);
@@ -6384,14 +7081,14 @@ function numberOption(value, name, allowZero = false) {
   }
   return parsed;
 }
-function handleError2(error2, jsonMode, type) {
+function handleError3(error2, jsonMode, type) {
   const cliError = error2 instanceof CliError ? error2 : new CliError(ErrorCode.SERVER_ERROR, error2 instanceof Error ? error2.message : String(error2));
   if (jsonMode) printJson(errorJson(type, cliError.code, cliError.message, cliError.details));
   else error(cliError.message);
   process.exitCode = 1;
 }
 function createPointsCommand(deps = {}) {
-  const points = new Command11("points").description("Inspect points balance, estimates, and actual generation charges");
+  const points = new Command12("points").description("Inspect points balance, estimates, and actual generation charges");
   points.command("balance").description("Show current points balance and membership tier").action(async (_opts, cmd) => {
     const jsonMode = isJsonOutput(cmd);
     try {
@@ -6403,7 +7100,7 @@ function createPointsCommand(deps = {}) {
         info(`  Tier: ${result.tier}`);
       }
     } catch (error2) {
-      handleError2(error2, jsonMode, "points_balance");
+      handleError3(error2, jsonMode, "points_balance");
     }
   });
   points.command("cost").description("Query actual charged points for generated resource URIs").argument("<uris...>", "1-20 hogi:// generation URIs").action(async (uris, _opts, cmd) => {
@@ -6422,7 +7119,7 @@ function createPointsCommand(deps = {}) {
         if (entry.pricingExplanation) info(`  ${entry.pricingExplanation}`);
       }
     } catch (error2) {
-      handleError2(error2, jsonMode, "points_cost");
+      handleError3(error2, jsonMode, "points_cost");
     }
   });
   points.command("quote").description("Estimate generation points from the current backend model catalog").option("--model-id <id>", "Exact model ID from inspect models").option("--model <model>", "Model key from inspect models").option("--variant <variant>", "Exact model variant from inspect models; requires --model").option("--duration <seconds>", "Requested generation duration").option("--resolution <resolution>", "Requested output resolution").option("--quality <quality>", "Requested quality tier").option("--reference-video-duration <seconds>", "Referenced video duration", "0").action(async (opts, cmd) => {
@@ -6454,14 +7151,14 @@ function createPointsCommand(deps = {}) {
         warn(result.caveat);
       }
     } catch (error2) {
-      handleError2(error2, jsonMode, "points_quote");
+      handleError3(error2, jsonMode, "points_quote");
     }
   });
   return points;
 }
 
 // src/commands/auth.ts
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 function validBaseUrl(value) {
   try {
     const url = new URL(value);
@@ -6471,8 +7168,8 @@ function validBaseUrl(value) {
   }
 }
 function createAuthCommand(deps = {}) {
-  const auth = new Command12("auth").description("Authentication configuration");
-  auth.command("login").description("Persist an API key in the local CLI configuration").option("--api-key <key>", "Oiioii API key; falls back to OIIOII_API_KEY").option("--base-url <url>", "Persist the backend base URL with the API key").action((opts, cmd) => {
+  const auth = new Command13("auth").description("Authentication configuration");
+  auth.command("login").description("Persist an API key in the local CLI configuration").option("--api-key <key>", "Oiioii API key; falls back to OIIOII_API_KEY").option("--base-url <url>", "Persist the backend base URL with the API key").option("--reset-base-url", "Remove the persisted backend override and use this build's default").action((opts, cmd) => {
     const jsonMode = isJsonOutput(cmd);
     const apiKey = opts.apiKey?.trim() || process.env["OIIOII_API_KEY"]?.trim();
     if (!apiKey) {
@@ -6484,6 +7181,13 @@ function createAuthCommand(deps = {}) {
     }
     const rootBaseUrl = getRootOptions(cmd).baseUrl;
     const baseUrl = (opts.baseUrl ?? (typeof rootBaseUrl === "string" ? rootBaseUrl : void 0))?.trim();
+    if (baseUrl && opts.resetBaseUrl) {
+      const message = "--base-url and --reset-base-url cannot be used together.";
+      if (jsonMode) printJson(errorJson("auth_login", ErrorCode.INVALID_ARGUMENT, message));
+      else error(message);
+      process.exitCode = 1;
+      return;
+    }
     if (baseUrl && !validBaseUrl(baseUrl)) {
       const message = "--base-url must be an HTTP(S) origin without a path, query, or fragment.";
       if (jsonMode) printJson(errorJson("auth_login", ErrorCode.INVALID_ARGUMENT, message));
@@ -6492,7 +7196,10 @@ function createAuthCommand(deps = {}) {
       return;
     }
     const configStore = deps.configStore ?? new FileConfigStore();
-    configStore.update({ apiKey, ...baseUrl ? { baseUrl: baseUrl.replace(/\/$/, "") } : {} });
+    configStore.update(
+      { apiKey, ...baseUrl ? { baseUrl: baseUrl.replace(/\/$/, "") } : {} },
+      { resetBaseUrl: opts.resetBaseUrl === true }
+    );
     const persisted = configStore.load();
     const configPath = configStore.getConfigPath();
     if (jsonMode) {
@@ -6510,7 +7217,7 @@ function createAuthCommand(deps = {}) {
 }
 
 // src/commands/cli_version.ts
-import { Command as Command13 } from "commander";
+import { Command as Command14 } from "commander";
 
 // src/core/npm_cli_manager.ts
 import crossSpawn from "cross-spawn";
@@ -6818,17 +7525,17 @@ function printOperation(type, result, command) {
   else success(`oiioii ${result.version} is already installed.`);
 }
 function createUpdateCommand() {
-  return new Command13("update").description("Update oiioii from the npm channel for this build environment").option("--check", "Check for an update without installing it").option("--force", "Reinstall the channel version even when already current").action(async (options, command) => {
+  return new Command14("update").description("Update oiioii from the npm channel for this build environment").option("--check", "Check for an update without installing it").option("--force", "Reinstall the channel version even when already current").action(async (options, command) => {
     printOperation("cli_update", await updateCli(options), command);
   });
 }
 function createInstallCommand() {
-  return new Command13("install").description("Install one exact oiioii version from npm").argument("<version>", "Exact stable or prerelease version allowed by this build environment").action(async (version, _options, command) => {
+  return new Command14("install").description("Install one exact oiioii version from npm").argument("<version>", "Exact stable or prerelease version allowed by this build environment").action(async (version, _options, command) => {
     printOperation("cli_install", await installCliVersion(version), command);
   });
 }
 function createVersionsCommand() {
-  return new Command13("versions").description("List npm versions available to this build environment").action(async (_options, command) => {
+  return new Command14("versions").description("List npm versions available to this build environment").action(async (_options, command) => {
     const result = await listCliVersions();
     if (isJsonOutput(command)) {
       printJson(successJson("cli_versions", result));
@@ -6845,7 +7552,7 @@ import { fileURLToPath } from "url";
 import { resolve as resolve4 } from "path";
 import { realpathSync } from "fs";
 function createProgram() {
-  const program = new Command14();
+  const program = new Command15();
   program.name("oiioii").description("Agent-native CLI for Oiioii / Hogi GenAI capabilities").version(CLI_VERSION, "-V, --version", "Output the current version").option("--json", "Output machine-readable JSON").option("--base-url <url>", "Hogi backend base URL").option("--workspace <id>", "Workspace ID override").option("--verbose", "Enable verbose/debug output").option("--no-color", "Disable colored output");
   program.addCommand(createAuthCommand());
   program.addCommand(createWorkspaceCommand());