@knowttl/artium-axi 0.0.13 → 0.0.15

package/README.md

@@ -98,7 +98,9 @@ Replace the synthetic username with your account; login uses a hidden terminal p
 For `PASSWORD_CHANGE_REQUIRED`, run `artium-axi passwd`, then log in again.
 For SSO, use `artium-axi login --sso` and approve only the browser code matching your own terminal.
 After ordinary login, later commands, installed hooks and skills use [saved connection settings](docs/client-reference.md#client-settings).
-After a server upgrade, run `artium-axi update`, then `artium-axi --version`.
+After a server upgrade, run `artium-axi update` if your client has that command, then `artium-axi --version`.
+For clients without `update`, repeat the verified download and checksum check above to install the server's current client.
+For `CLI_OUTDATED`, the server uses the client version header to select the update hint or safe download guidance; the capability boundary is defined by `firstVersionWithUpdate` in [the version contract](src/shared/version.ts).
 The updater uses those connection settings, verifies the server download’s SHA-256, replaces the running client file and keeps the previous client beside it as `<client-file>.bak`.
 The client file and its directory must be writable.
 The Falcon read requires an enabled tool, a role grant and API permissions; choose the example from an available tool's detail view.
@@ -178,7 +180,7 @@ See [client input handling](docs/client-reference.md#command-surface-and-subcomm
 | Azure DevOps | Reviewed mutations with administrator `allowWrites: true`; raw `api` remains GET-only. |
 | AWX | Launch/cancel/relaunch, workflow approval/denial, project/inventory-source sync and notification tests with `allowWrites: true` and upstream `--confirm`; configuration, deletion and security writes stay blocked. |
 | Tenable One | Business writes and export-job creation with administrator `writes.allowWrites: true`, an explicit operations allow-list, native preview, `--execute`, exact `--confirm` and durable journaling; downloads and local configuration stay blocked. |
-| Hybrid Analysis | Sandbox submissions, YARA create/update/delete and consuming hunting matches require administrator `writes.allowWrites: true`, an explicit operations allow-list, native preview, `--execute`, exact `--confirm` and durable journaling. All downloads, including report artifacts, samples, dropped-file archives and memory dumps, are unavailable pending a separate hosted download path with its own security design; use hybrid-axi locally with its native guards and live-malware warnings. Local configuration and credential/origin overrides are blocked. |
+| Hybrid Analysis | Sandbox submissions, YARA create/update/delete, consuming hunting matches and the four reviewed archive downloads require administrator `writes.allowWrites: true`, independently selected operations, native preview, `--execute`, exact `--confirm` and durable journaling. Downloads are limited to `hash-download-bin`, `report-download-bin`, `report-download-dropped-files` and `report-download-memory`, through the [authenticated CLI verified-save path](docs/client-reference.md#hybrid-analysis-archive-saving) after the [operator prerequisites](docs/runbook.md#scope-and-prerequisites) pass. All operations default off; enabling other writes never enables downloads or grants upstream entitlement. The browser provides warnings, command guidance and metadata/save status only. Ordinary tool-run downloads, local configuration and credential/origin overrides are blocked. |
 
 Hybrid Analysis quick scans transmit the supplied sample or URL as read exceptions without a write gate; sandbox submission previews disclose that samples and reports can become visible to the community.
 Consuming hunting matches marks every returned match delivered; reconcile ambiguous outcomes using the audit ID, durable native journal and returned read-back guidance before retrying.
@@ -239,6 +241,7 @@ This summary follows the [CLI help registry](src/cli/help.ts); `artium-axi --hel
 | `tools` / `tools show <tool>` | Granted enabled tools / pinned help and first call |
 | `doctor` | Server, TLS, token, version and cached health; five-second request deadlines |
 | `update` | Update the [server-downloaded client](#verified-client) |
+| `download` | Preview and explicitly verify/save administrator-selected Hybrid Analysis archives through the local CLI. Run `artium-axi download --help` for guards and warnings. |
 | `setup --host <host>` | Install managed skills and optional Claude hook |
 | `<tool> <args>` | Run any of the nine managed tools above |
 | `--managed-session --help` | Private-pipe session protocol |
@@ -248,7 +251,9 @@ The [full client reference](docs/client-reference.md#command-surface-and-subcomm
 
 ### TOON output and errors
 Discovery and Artium errors use TOON on stdout; progress uses stderr.
-Upstream stdout, stderr and exit status pass through, with managed suggestions adapted to Artium commands.
+Upstream stdout, stderr and exit status pass through, subject to managed suggestion adaptation and hosted status filtering.
+Hosted home and authentication status omit server executable and configuration paths; secret references report only their source kind, `env` or `file`.
+Malformed or truncated hosted status output is withheld with `INVALID_RESPONSE`.
 Artium exits 0 for success, 2 for usage/configuration errors and 1 for authentication/server/transport failures.
 See the generated [error catalogue](docs/errors.md) for actionable codes and retry guidance.
 

package/bin/artium-axi.mjs

@@ -6,9 +6,9 @@ var __export = (target, all) => {
 };
 
 // src/cli/main.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 import { homedir as homedir3 } from "node:os";
-import { resolve as resolve3, relative, sep, isAbsolute } from "node:path";
+import { resolve as resolve4, relative, sep, isAbsolute as isAbsolute2 } from "node:path";
 
 // node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -5036,7 +5036,7 @@ var recursive = /* @__PURE__ */ new WeakMap();
 var NONE = 0;
 var ASSUMED = 1;
 var PROVEN = 2;
-function isRecursive(inst, stack, resolve4) {
+function isRecursive(inst, stack, resolve5) {
   const cached2 = recursive.get(inst);
   if (cached2 !== void 0)
     return cached2 ? PROVEN : NONE;
@@ -5046,7 +5046,7 @@ function isRecursive(inst, stack, resolve4) {
   let result = NONE;
   const check2 = (child) => {
     if (result !== PROVEN && child?._zod) {
-      const answer = isRecursive(child, stack, resolve4);
+      const answer = isRecursive(child, stack, resolve5);
       if (answer > result)
         result = answer;
     }
@@ -5057,7 +5057,7 @@ function isRecursive(inst, stack, resolve4) {
       const desc = Object.getOwnPropertyDescriptor(sh, key);
       if (spread && !desc.enumerable)
         continue;
-      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve4) : NONE;
+      const child = desc.get ? ASSUMED : desc.value?._zod ? isRecursive(desc.value, stack, resolve5) : NONE;
       if (child > answer)
         answer = child;
     }
@@ -5121,7 +5121,7 @@ function isRecursive(inst, stack, resolve4) {
       break;
     // `$ZodLazy` caches its inner on the def, so a resolved edge is followed exactly
     case "lazy": {
-      const inner = def._cachedInner ?? (resolve4 ? inst._zod.innerType : void 0);
+      const inner = def._cachedInner ?? (resolve5 ? inst._zod.innerType : void 0);
       merge2(inner ? isRecursive(inner, stack, false) : ASSUMED);
       break;
     }
@@ -19679,11 +19679,12 @@ function date4(params) {
 }
 
 // src/shared/errors.ts
+var cliOutdatedDownloadNext = "Download the current CLI from /cli/artium-axi.mjs on this server, verify it with the SHA-256 checksum at /cli/artium-axi.mjs.sha256, and install it as artium-axi.";
 var definitions = {
   STORE_SCHEMA_INVALID: { status: 503, message: "The store schema is unsupported by this image.", next: "Use the matching image, or restore the pre-upgrade backup into a new volume with its matching image and key." },
   BACKUP_FAILED: { status: 500, message: "Database backup did not complete.", next: "Check the source store and a writable backup directory; choose a new output file." },
   RESTORE_FAILED: { status: 500, message: "Database restore did not complete.", next: "Stop the destination server and use an empty new data volume, an intact backup and its matching master key." },
-  CLI_OUTDATED: { status: 426, message: "The CLI version is too old for this server.", next: "Run artium-axi update to install the current CLI." },
+  CLI_OUTDATED: { status: 426, message: "The CLI version is too old for this server.", next: cliOutdatedDownloadNext },
   CERTIFICATE_INVALID: { status: 503, message: "The server certificate could not be verified.", next: "Check certificate trust or set ARTIUM_AXI_CA_FILE to the trusted CA file." },
   ADMIN_REQUIRED: { status: 403, message: "Administrator capability is required.", next: "Ask an administrator to perform this operation." },
   REVISION_CONFLICT: { status: 409, message: "The record changed since it was read.", next: "Read the current record revision and retry your edit." },
@@ -19719,6 +19720,9 @@ var definitions = {
   PASSWORD_CHANGE_REQUIRED: { status: 409, message: "Change your temporary password before using tools.", next: "Run artium-axi passwd --password-stdin." },
   SERVER_UNAVAILABLE: { status: 503, message: "The CLI could not receive a server response.", next: "Check the server address and certificate trust; confirm the previous call outcome before retrying." },
   INVALID_RESPONSE: { status: 500, message: "The server returned an invalid response.", next: "Check the server URL and API version." },
+  KEY_LEVEL_RESTRICTED: { status: 403, message: "HTTP 403: restricted key cannot download.", next: "Request vetted-account download access. Administrator write settings cannot grant upstream entitlement. No other key or route was tried." },
+  PERMISSION_DENIED: { status: 403, message: "HTTP 403: download denied; key level unknown.", next: "Check upstream entitlement and request account vetting where required. Administrator write settings cannot grant upstream entitlement. No other key or route was tried." },
+  ARTIFACT_SAVE_FAILED: { status: 400, message: "The archive was not verified and saved.", next: "Check the dedicated private destination directory. Start a fresh preview and confirmation; interrupted transfers cannot be retried." },
   DEV_AUTH_INVALID: { status: 503, message: "Development authentication settings are unsupported.", next: "Remove ARTIUM_AXI_DEV and ARTIUM_AXI_DEV_TOKEN_FILE and use local sign-in." },
   PROXY_HEADERS_UNTRUSTED: { status: 400, message: "Forwarding headers came from an untrusted address.", next: "Connect through the configured trusted proxy or remove forwarding headers." },
   NOT_FOUND: { status: 404, message: "The endpoint does not exist.", next: "Use a supported API endpoint and tool name." },
@@ -19781,6 +19785,103 @@ var inputLimits = {
   totalFileBytes: 4 * 1024 * 1024,
   files: 8
 };
+var transferLimits = {
+  artifactBytes: 250 * 1024 * 1024,
+  reservationsPerUser: 1,
+  reservations: 4,
+  reservedBytes: 1024 * 1024 * 1024,
+  lifetimeMs: 10 * 60 * 1e3
+};
+var transferWarning = "Live malware: this archive may contain executable malware. Save only; do not extract or execute. Password protection is unverified; bytes are saved exactly as provided.";
+var sha256Schema = external_exports.string().regex(/^[a-f0-9]{64}$/);
+var sampleSha256Schema = external_exports.string().regex(/^[a-f0-9]{64}$/i);
+var reportIdSchema = external_exports.string().regex(/^(?:[A-Za-z0-9_-]{1,256}|[a-f0-9]{64}:\d+)$/i);
+var transferOwnerIdSchema = external_exports.string().regex(/^[A-Za-z0-9_-]{1,256}$/);
+var transferSelectionSchema = external_exports.discriminatedUnion("operation", [
+  external_exports.strictObject({ operation: external_exports.literal("hash-download-bin"), selector: sampleSha256Schema, type: external_exports.literal("bin") }),
+  external_exports.strictObject({ operation: external_exports.literal("report-download-bin"), selector: reportIdSchema, type: external_exports.literal("bin") }),
+  external_exports.strictObject({ operation: external_exports.literal("report-download-dropped-files"), selector: reportIdSchema, type: external_exports.literal("dropped-files") }),
+  external_exports.strictObject({ operation: external_exports.literal("report-download-memory"), selector: reportIdSchema, type: external_exports.literal("memory") })
+]);
+var transferPrepareSchema = external_exports.strictObject({ selection: transferSelectionSchema, targetDigest: sha256Schema });
+var transferIdSchema = external_exports.uuid();
+var transferScopeSchema = external_exports.strictObject({
+  transferId: transferIdSchema,
+  userId: transferOwnerIdSchema,
+  sessionFamilyId: transferOwnerIdSchema,
+  credentialRevision: external_exports.number().int().positive(),
+  selection: transferSelectionSchema,
+  targetDigest: sha256Schema,
+  preparedAt: external_exports.number().int().nonnegative(),
+  expiresAt: external_exports.number().int().nonnegative()
+}).refine((scope) => scope.expiresAt === scope.preparedAt + transferLimits.lifetimeMs);
+var transferPreviewSchema = external_exports.strictObject({
+  transferId: transferIdSchema,
+  expiresAt: external_exports.number().int(),
+  confirm: external_exports.string().min(1).max(64 * 1024),
+  warnings: external_exports.array(external_exports.string()),
+  targetDigest: sha256Schema
+});
+var transferExecuteSchema = external_exports.strictObject({
+  transferId: transferIdSchema,
+  selection: transferSelectionSchema,
+  targetDigest: sha256Schema,
+  execute: external_exports.literal(true),
+  confirm: external_exports.string().min(1).max(64 * 1024)
+});
+var transferRetrieveSchema = transferPrepareSchema.extend({ transferId: transferIdSchema });
+var transferOutcomeSchema = external_exports.enum([
+  "preview",
+  "denied-not-sent",
+  "native-outcome-unknown",
+  "upstream-failure",
+  "ready",
+  "delivery-completed",
+  "delivery-interrupted",
+  "expired",
+  "deleted",
+  "interrupted"
+]);
+var transferSaveOutcomeSchema = external_exports.enum(["unconfirmed", "verified-save", "save-failed"]);
+var transferArchiveSchema = external_exports.strictObject({
+  archiveBytes: external_exports.number().int().nonnegative().max(transferLimits.artifactBytes),
+  archiveSha256: sha256Schema
+});
+var transferReceiptSchema = transferRetrieveSchema.extend({
+  archive: transferArchiveSchema,
+  saveOutcome: external_exports.enum(["verified-save", "save-failed"])
+});
+var transferEvidenceSchema = external_exports.strictObject({
+  outcome: transferOutcomeSchema,
+  archive: transferArchiveSchema.nullable(),
+  saveOutcome: transferSaveOutcomeSchema
+}).refine((evidence) => !["ready", "delivery-completed"].includes(evidence.outcome) || evidence.archive !== null).refine((evidence) => !["preview", "denied-not-sent", "native-outcome-unknown", "upstream-failure"].includes(evidence.outcome) || evidence.archive === null).refine((evidence) => evidence.saveOutcome !== "verified-save" || evidence.archive !== null);
+var transferStatusSchema = transferEvidenceSchema.safeExtend({ transferId: transferIdSchema, expiresAt: external_exports.number().int() });
+var transferRoutes = {
+  prepare: { method: "POST", path: "/v1/transfers/hybrid/prepare", input: transferPrepareSchema, response: transferPreviewSchema },
+  execute: { method: "POST", path: "/v1/transfers/hybrid/execute", input: transferExecuteSchema, response: transferStatusSchema },
+  retrieve: { method: "POST", path: "/v1/transfers/hybrid/retrieve", input: transferRetrieveSchema },
+  receipt: { method: "POST", path: "/v1/transfers/hybrid/receipt", input: transferReceiptSchema },
+  cancel: { method: "POST", path: "/v1/transfers/hybrid/cancel", input: transferRetrieveSchema },
+  status: { method: "POST", path: "/v1/transfers/hybrid/status", input: transferRetrieveSchema, response: transferStatusSchema }
+};
+var transferAuditSchema = external_exports.strictObject({
+  transfer_id: transferIdSchema,
+  session_family_id: transferOwnerIdSchema,
+  transfer_operation: transferSelectionSchema.options[0].shape.operation.or(transferSelectionSchema.options[1].shape.operation).or(transferSelectionSchema.options[2].shape.operation).or(transferSelectionSchema.options[3].shape.operation),
+  artifact_type: external_exports.enum(["bin", "dropped-files", "memory"]),
+  artifact_selector: sha256Schema.or(reportIdSchema),
+  requested_target_digest: sha256Schema,
+  archive_bytes: external_exports.number().int().nonnegative().max(transferLimits.artifactBytes).nullable(),
+  archive_sha256: sha256Schema.nullable(),
+  native_audit_id: external_exports.uuid().nullable(),
+  native_journal_result: external_exports.enum(["SUCCESS", "FAILED", "NOT_SENT", "OUTCOME_UNKNOWN"]).nullable(),
+  client_save_outcome: transferSaveOutcomeSchema
+}).refine((fields) => fields.archive_bytes === null === (fields.archive_sha256 === null)).refine((fields) => transferSelectionSchema.safeParse({
+  operation: fields.transfer_operation,
+  type: fields.artifact_type,
+  selector: fields.artifact_selector
+}).success);
 var byteLength = (value) => new TextEncoder().encode(value).length;
 var passwordSchema = external_exports.string().min(1).refine((value) => byteLength(value) <= 512, "Expected at most 512 UTF-8 bytes");
 var passwordChangeSchema = external_exports.strictObject({ newPassword: external_exports.string(), currentPassword: external_exports.string().optional() });
@@ -19998,7 +20099,8 @@ var auditFiltersSchema = external_exports.strictObject({
   event: external_exports.string().min(1).max(100).optional(),
   outcome: external_exports.string().min(1).max(100).optional(),
   from: external_exports.iso.datetime().optional(),
-  to: external_exports.iso.datetime().optional()
+  to: external_exports.iso.datetime().optional(),
+  errorCode: external_exports.string().min(1).max(100).optional()
 });
 var orderedAuditRange = (input2) => !input2.from || !input2.to || Date.parse(input2.from) <= Date.parse(input2.to);
 var adminAuditQuerySchema = auditFiltersSchema.extend({
@@ -20036,7 +20138,18 @@ var adminAuditRecordSchema = external_exports.strictObject({
   error_code: external_exports.string().nullable(),
   authentication_method: external_exports.string().nullable(),
   provider_id: external_exports.string().nullable(),
-  subject: external_exports.string().nullable()
+  subject: external_exports.string().nullable(),
+  transfer_id: transferIdSchema.nullable(),
+  session_family_id: external_exports.string().nullable(),
+  transfer_operation: external_exports.string().nullable(),
+  artifact_type: external_exports.string().nullable(),
+  artifact_selector: external_exports.string().nullable(),
+  requested_target_digest: sha256Schema.nullable(),
+  archive_bytes: external_exports.number().int().nullable(),
+  archive_sha256: sha256Schema.nullable(),
+  native_audit_id: external_exports.string().nullable(),
+  native_journal_result: external_exports.string().nullable(),
+  client_save_outcome: transferSaveOutcomeSchema.nullable()
 });
 var adminAuditRoute = {
   method: "GET",
@@ -20051,13 +20164,11 @@ var falconRtrSettingsSchema = external_exports.strictObject({
   commands: external_exports.array(external_exports.enum([
     "cat",
     "cd",
-    "clear",
     "csrutil",
     "env",
     "eventlog",
     "filehash",
     "getsid",
-    "history",
     "ifconfig",
     "ipconfig",
     "ls",
@@ -20119,7 +20230,7 @@ var diagnosticSchema = external_exports.strictObject({
   credentialRevision: external_exports.number().int().nullable().optional()
 });
 var healthSchema = external_exports.strictObject({
-  status: external_exports.enum(["unconfigured", "unknown", "ok", "error", "disabled"]),
+  status: external_exports.enum(["unconfigured", "unknown", "checking", "ok", "error", "disabled"]),
   diagnostic: diagnosticSchema.optional(),
   readOnly: external_exports.boolean().default(true),
   checkedAt: external_exports.number().int().nullable(),
@@ -20577,7 +20688,7 @@ var toolsResponseSchema = external_exports.strictObject({
     name: toolSchema,
     version: external_exports.string(),
     readOnly: external_exports.boolean().default(true),
-    status: external_exports.enum(["unconfigured", "unknown", "ok", "error", "disabled"])
+    status: external_exports.enum(["unconfigured", "unknown", "checking", "ok", "error", "disabled"])
   }))
 });
 var inputFileSchema = external_exports.strictObject({
@@ -20634,7 +20745,7 @@ import { resolve } from "node:path";
 // package.json
 var package_default = {
   name: "artium-axi",
-  version: "0.0.13",
+  version: "0.0.15",
   private: true,
   license: "MIT",
   type: "module",
@@ -20823,8 +20934,8 @@ var SessionStore = class {
     while (true) {
       const watcher = watch(this.directory);
       let timer;
-      const changed = new Promise((resolve4, reject) => {
-        watcher.once("change", () => resolve4());
+      const changed = new Promise((resolve5, reject) => {
+        watcher.once("change", () => resolve5());
         watcher.once("error", () => reject(new ArtiumError("SESSION_STORAGE_UNAVAILABLE")));
         timer = setTimeout(() => reject(new ArtiumError("SESSION_BUSY")), Math.max(0, deadline - Date.now()));
       });
@@ -20872,6 +20983,10 @@ var Client = class {
   }
   managed;
   requestDeadlineMs;
+  cancellation = new AbortController();
+  cancel() {
+    this.cancellation.abort();
+  }
   serverUrl;
   serverUrlSource;
   caFile;
@@ -20881,7 +20996,7 @@ var Client = class {
     return this.storedSessions;
   }
   certificateVerified = false;
-  async request(path, method, input2, token, bytes = false) {
+  async request(path, method, input2, token, bytes = false, headers = {}) {
     this.certificateVerified = false;
     let ca;
     try {
@@ -20893,13 +21008,13 @@ var Client = class {
     const controller = new AbortController();
     const deadline = setTimeout(() => controller.abort(), this.requestDeadlineMs);
     const url2 = new URL(`${this.serverUrl}${path}`);
-    const result = await new Promise((resolve4, reject) => {
+    const result = await new Promise((resolve5, reject) => {
       const request = (url2.protocol === "https:" ? httpsRequest : httpRequest)(url2, {
         method,
         ca,
         rejectUnauthorized: true,
-        signal: controller.signal,
-        headers: { "x-artium-cli-version": cliVersion, ...token ? { authorization: `Bearer ${token}` } : {}, ...body ? { "content-type": "application/json" } : {} }
+        signal: AbortSignal.any([controller.signal, this.cancellation.signal]),
+        headers: { ...headers, "x-artium-cli-version": cliVersion, ...token ? { authorization: `Bearer ${token}` } : {}, ...body ? { "content-type": "application/json" } : {} }
       }, (response) => {
         if (response.statusCode >= 300 && response.statusCode < 400) {
           response.destroy();
@@ -20911,7 +21026,7 @@ var Client = class {
         response.on("error", () => reject(new ArtiumError("SERVER_UNAVAILABLE")));
         response.on("end", () => {
           try {
-            resolve4({
+            resolve5({
               status: response.statusCode,
               body: bytes ? Buffer.concat(chunks) : response.statusCode === 204 ? void 0 : JSON.parse(Buffer.concat(chunks).toString("utf8")),
               serverVersion: typeof response.headers["x-artium-cli-version"] === "string" ? response.headers["x-artium-cli-version"] : void 0
@@ -20975,6 +21090,70 @@ var Client = class {
     if (previous) this.reload(previous);
     return result;
   }
+  // Transfers never refresh/replay a request, including an ambiguous execute or
+  // a retrieval whose response was interrupted before headers arrived.
+  async transferSession(work) {
+    if (this.managed) return this.managed.once(work);
+    const session = this.sessions.read();
+    if (!session) throw new ArtiumError("TOKEN_INVALID");
+    if (session.status !== "authenticated") throw new ArtiumError("PASSWORD_CHANGE_REQUIRED");
+    return work(session.accessToken);
+  }
+  async artifact(path, input2, token, ticket, expiresAt, consume) {
+    let ca;
+    try {
+      if (this.caFile) ca = [...rootCertificates, readFileSync2(this.caFile, "utf8")];
+    } catch {
+      throw new ArtiumError("CLIENT_CONFIG_INVALID");
+    }
+    const url2 = new URL(`${this.serverUrl}${path}`);
+    const controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, this.cancellation.signal]);
+    const deadline = setTimeout(() => controller.abort(), Math.max(0, expiresAt - Date.now()));
+    try {
+      await new Promise((resolve5, reject) => {
+        let incoming;
+        const request = (url2.protocol === "https:" ? httpsRequest : httpRequest)(url2, {
+          method: "POST",
+          ca,
+          rejectUnauthorized: true,
+          signal,
+          headers: {
+            authorization: `Bearer ${token}`,
+            "x-artium-cli-version": cliVersion,
+            "x-artium-reauth-ticket": ticket,
+            "accept-encoding": "identity",
+            "content-type": "application/json"
+          }
+        }, (response) => {
+          incoming = response;
+          void (async () => {
+            if (response.statusCode !== 200) {
+              const chunks = [];
+              let size = 0;
+              for await (const chunk of response) {
+                size += chunk.length;
+                if (size > 64 * 1024) throw new ArtiumError("INVALID_RESPONSE");
+                chunks.push(chunk);
+              }
+              const failure2 = errorResponseSchema.safeParse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+              if (failure2.success) throw new ArtiumError(failure2.data.error.code, failure2.data.error.message, failure2.data.error.next);
+              throw new ArtiumError("INVALID_RESPONSE");
+            }
+            await consume(response, signal);
+          })().then(resolve5, reject).finally(() => response.destroy());
+        });
+        request.on("error", () => {
+          const error62 = new ArtiumError("SERVER_UNAVAILABLE");
+          if (incoming) incoming.destroy(error62);
+          else reject(error62);
+        });
+        request.end(JSON.stringify(input2));
+      });
+    } finally {
+      clearTimeout(deadline);
+    }
+  }
   // The caller holds the session lock, including the reload after acquisition.
   async refresh(previous) {
     const current = this.reload(previous);
@@ -21023,13 +21202,13 @@ async function readPassword(stdin, environmentVariable) {
   process.stdin.setRawMode(true);
   process.stdin.resume();
   try {
-    return await new Promise((resolve4, reject) => {
+    return await new Promise((resolve5, reject) => {
       let password = "";
       const keypress = (text2, key) => {
         if (key.name === "return" || key.ctrl && key.name === "c") {
           process.stdin.off("keypress", keypress);
           if (key.ctrl) reject(new ArtiumError("CANCELLED"));
-          else resolve4(password);
+          else resolve5(password);
         } else if (key.name === "backspace") password = Array.from(password).slice(0, -1).join("");
         else if (text2 && !key.ctrl && !new RegExp("\\p{Cc}", "u").test(text2)) password += text2;
       };
@@ -21048,13 +21227,13 @@ var falcon_axi_default = {
   generatedBy: "scripts/falcon-inventory.mjs",
   tool: "falcon-axi",
   repository: "https://github.com/knowttl/falcon-axi.git",
-  tag: "v0.7.1",
-  commit: "de453560f74398d0435fa5d2beadcd3e1dc8085c",
-  version: "0.7.1",
+  tag: "v0.7.2",
+  commit: "96392a6b2afeb86d5422e3ff55e5a3d5e8af769f",
+  version: "0.7.2",
   distribution: {
-    filename: "falcon_axi-0.7.1-py3-none-any.whl",
-    sha256: "d5862a46a63358af379101b0bf94b734cd6cb5c2717528a6a2ebe1d9e9b88f23",
-    provenance: "https://pypi.org/integrity/falcon-axi/0.7.1/falcon_axi-0.7.1-py3-none-any.whl/provenance"
+    filename: "falcon_axi-0.7.2-py3-none-any.whl",
+    sha256: "8b87c8047f782a6d390324a26179def0f77e6c7c5bf4212012d5802a249132b6",
+    provenance: "https://pypi.org/integrity/falcon-axi/0.7.2/falcon_axi-0.7.2-py3-none-any.whl/provenance"
   },
   parser: {
     path: "falcon_axi/cli.py",
@@ -41176,7 +41355,11 @@ var hybrid_axi_default = {
   nativeWriteSettings: {
     supportedOperations: [
       "convertQuickScan",
+      "hash-download-bin",
       "huntingMatches",
+      "report-download-bin",
+      "report-download-dropped-files",
+      "report-download-memory",
       "submitDroppedFile",
       "submitFile",
       "submitUrl",
@@ -41208,7 +41391,7 @@ var hybrid_axi_default = {
     inputs: {
       stdin: "body-file - only",
       files: "uploaded leaves only",
-      downloads: "not available through artium; use hybrid-axi locally"
+      downloads: "artium-axi download only; authenticated one-shot CLI verified save"
     },
     nativeWrites: "native preview, operation allow-list, execute, exact confirm and durable journal"
   },
@@ -41231,7 +41414,7 @@ var hybrid_axi_default = {
     example: [
       "quota"
     ],
-    help: "hybrid-axi quota\nArtium manages the API key and fixed Hybrid Analysis origin. Submissions, YARA mutations and consuming matches are off by default; administrator-enabled operations still require native preview, --execute, exact --confirm and journal. Quick scans transmit the supplied sample or URL as read exceptions. File flags accept uploaded leaves; body-file also accepts explicit stdin (-). Downloads are not available through artium; use hybrid-axi locally.\n"
+    help: "hybrid-axi quota\nArtium manages the API key and fixed Hybrid Analysis origin. Submissions, YARA mutations, consuming matches and the four reviewed archive downloads are off by default and selected independently; administrator-enabled operations still require native preview, --execute, exact --confirm and journal. Quick scans transmit the supplied sample or URL as read exceptions. File flags accept uploaded leaves; body-file also accepts explicit stdin (-). Use artium-axi download --help for authenticated one-shot CLI verified saving and live-malware warnings.\n"
   },
   suggestionFields: [
     "help"
@@ -43450,7 +43633,7 @@ function managedFlagRanges(command, tool) {
 function hostedHelp(help, tool, flags, commands2) {
   if (tool === "hybrid-axi") {
     help = help.split("\n").filter((line) => !/HYBRID_AXI_|SecretRefs|hybrid-axi (?:setup|config|profile)|--(?:config|profile|origin|output)\b/.test(line)).join("\n");
-    const guidance = "Artium manages the API key and fixed origin. Submissions, YARA mutations and consuming matches require administrator-enabled operations, native preview, execute, exact confirmation and journal. Quick scans transmit the supplied sample or URL. Downloads are not available through artium; use hybrid-axi locally.";
+    const guidance = "Artium manages the API key and fixed origin. Submissions, YARA mutations, consuming matches and four reviewed archive downloads require independently selected administrator-enabled operations, native preview, execute, exact confirmation and journal. Quick scans transmit the supplied sample or URL. Use artium-axi download --help for authenticated one-shot CLI verified saving and live-malware warnings.";
     if (commands2 && !help.includes(guidance)) help = help.trimEnd() + "\n" + guidance + "\n";
   }
   if (tool === "tenable-axi") {
@@ -43702,12 +43885,19 @@ async function doctor(createClient = (deadline) => new Client(process.env, void
     try {
       const parsed = toolsResponseSchema.safeParse(await client.authenticated("/v1/tools", "GET"));
       if (!parsed.success) throw new ArtiumError("INVALID_RESPONSE");
-      for (const tool of parsed.data.tools) line(
-        tool.name,
-        tool.status === "ok",
-        tool.status,
-        new ArtiumError(tool.status === "unconfigured" ? "CREDENTIAL_NOT_CONFIGURED" : tool.status === "error" ? "TOOL_FAILED" : tool.status === "disabled" ? "TOOL_DISABLED" : "SERVER_UNAVAILABLE")
-      );
+      for (const tool of parsed.data.tools) {
+        if (tool.status === "checking") {
+          write(`pass: ${tool.name} (checking)
+`);
+          continue;
+        }
+        line(
+          tool.name,
+          tool.status === "ok",
+          tool.status,
+          new ArtiumError(tool.status === "unconfigured" ? "CREDENTIAL_NOT_CONFIGURED" : tool.status === "error" ? "TOOL_FAILED" : tool.status === "disabled" ? "TOOL_DISABLED" : "SERVER_UNAVAILABLE")
+        );
+      }
     } catch (error62) {
       const cause = error62 instanceof ArtiumError ? error62 : new ArtiumError("INVALID_RESPONSE");
       line("tools", false, cause.code, cause);
@@ -43718,7 +43908,7 @@ async function doctor(createClient = (deadline) => new Client(process.env, void
 
 // src/cli/help.ts
 var commands = {
-  home: { usage: "artium-axi [tools [show <tool>]|whoami|login|passwd|logout|doctor|setup|update|<tool> <args>]", purpose: "Show your identity, roles and available tools.", flags: ["--version (default false; print the client package version and exit)"], example: "artium-axi" },
+  home: { usage: "artium-axi [tools [show <tool>]|whoami|login|passwd|logout|doctor|setup|update|download|<tool> <args>]", purpose: "Show your identity, roles and available tools.", flags: ["--version (default false; print the client package version and exit)"], example: "artium-axi" },
   setup: {
     usage: "artium-axi setup --host <claude|codex|opencode|pi> [--hook] [--force]",
     purpose: "Install skills for your signed-in account\u2019s granted tools and an optional Claude Code session hook.",
@@ -43743,6 +43933,24 @@ var commands = {
   logout: { usage: "artium-axi logout", purpose: "Remove local tokens and revoke the server session.", flags: [], example: "artium-axi logout" },
   doctor: { usage: "artium-axi doctor", purpose: "Check the server, certificate, token, CLI version and cached tool health.", flags: [], example: "artium-axi doctor" },
   update: { usage: "artium-axi update", purpose: "Download and verify the server\u2019s client, replace this file and keep a .bak backup. npm installations must use npm install -g @knowttl/artium-axi.", flags: [], example: "artium-axi update" },
+  download: {
+    usage: "artium-axi download --operation <operation> --selector <hash|report-id> --type <bin|dropped-files|memory> --destination <absolute-new-path> [--transfer <id> --execute --confirm <exact-confirm>] [--password-stdin|--sso]",
+    purpose: "Preview or explicitly save a hosted Hybrid Analysis archive. Operations remain unavailable until adapter enablement.",
+    flags: [
+      "--operation <hash-download-bin|report-download-bin|report-download-dropped-files|report-download-memory> (required)",
+      "--selector <hash|report-id> (required)",
+      "--type <bin|dropped-files|memory> (required)",
+      "--destination <absolute-new-path> (required; Linux private 0700 directory, no symlink components or overwrite)",
+      "--transfer <id> (required for execution; preview transfer ID)",
+      "--execute (default false)",
+      "--confirm <exact-confirm> (required for execution; unchanged native preview string)",
+      "--password-stdin (default false; otherwise terminal password)",
+      "--sso (default false; browser identity confirmation)",
+      transferWarning,
+      `Limit ${transferLimits.artifactBytes / 1024 ** 2} MiB; ${transferLimits.reservationsPerUser} reservation per user, ${transferLimits.reservations} globally, ${transferLimits.reservedBytes / 1024 ** 3} GiB total artifact capacity; absolute expiry ${transferLimits.lifetimeMs / 6e4} minutes after preview preparation, including generation and retrieval. No resume or automatic retry. Missing receipt is unconfirmed.`
+    ],
+    example: "artium-axi download --operation report-download-bin --selector synthetic-report --type bin --destination /controlled/artifacts/new-archive.bin --sso"
+  },
   "falcon-axi": {
     usage: "artium-axi falcon-axi [<args>]",
     purpose: "Run Falcon commands with your managed credentials.",
@@ -43782,7 +43990,7 @@ var commands = {
   "hybrid-axi": {
     usage: "artium-axi hybrid-axi [<args>]",
     purpose: "Investigate Hybrid Analysis with a managed API key.",
-    flags: ["Submissions, YARA mutations and consuming matches are off by default and require administrator-enabled operations, preview, --execute and exact --confirm. Downloads are unavailable through Artium."],
+    flags: ["Submissions, YARA mutations, consuming matches and four reviewed archive downloads are off by default and selected independently by an administrator. Native preview, --execute and exact --confirm remain required. Use artium-axi download --help for authenticated CLI verified saving.", transferWarning],
     example: "artium-axi hybrid-axi quota"
   },
   "az-axi": {
@@ -43855,7 +44063,7 @@ function validateArguments(args, prefixHelp) {
     start = 2;
   }
   const entry = commands[level];
-  const validFlags = ["--help", ...entry.flags.map((flag) => flag.split(" ")[0])];
+  const validFlags = ["--help", ...entry.flags.filter((flag) => flag.startsWith("--")).map((flag) => flag.split(" ")[0])];
   const choices = `Valid flags for ${level}: ${validFlags.join(", ")}.` + (level === "tools" ? " Valid subcommands: show <tool>." : level === "tools show" ? ` Valid tools: ${toolSchema.options.join(", ")}.` : "");
   let tool = false;
   const seen = /* @__PURE__ */ new Set();
@@ -43867,8 +44075,9 @@ function validateArguments(args, prefixHelp) {
     } else {
       if (!validFlags.includes(token) || seen.has(token)) fail(token, level, choices);
       seen.add(token);
-      if (token === "--username" || token === "--host") {
+      if (token === "--username" || token === "--host" || command === "download" && ["--operation", "--selector", "--type", "--destination", "--transfer", "--confirm"].includes(token)) {
         const value = args[index + 1];
+        if (!value && command === "download") fail(value, `${level} ${token}`, `Supply a value for ${token}. Use ${entry.usage}. ${choices}`);
         if (!value) fail(value, `${level} ${token}`, `Supply ${token} ${token === "--host" ? "<claude|codex|opencode|pi>" : "<username>"}. ${choices}`);
         if (token === "--host" && !["claude", "codex", "opencode", "pi"].includes(value)) fail(value, `${level} --host`, `Valid hosts: claude, codex, opencode, pi. Use ${entry.usage}.`);
         index++;
@@ -43878,6 +44087,7 @@ function validateArguments(args, prefixHelp) {
   if (level === "tools show" && !tool && !seen.has("--help") && !prefixHelp) fail(void 0, level, choices);
 }
 function helpCommand(args, prefixHelp = false) {
+  if (args[0] === "download" && args.includes("--help")) return "download";
   if (args[0] === "setup" && args.includes("--help")) {
     const path2 = args.filter((arg) => arg !== "--help");
     for (let index = 1; index < path2.length; index++) {
@@ -44281,6 +44491,10 @@ var ManagedSession = class _ManagedSession {
   checkServer(serverUrl) {
     if (this.session && this.session.serverUrl.replace(/\/$/, "") !== serverUrl) throw new ArtiumError("SESSION_SERVER_MISMATCH");
   }
+  async once(request) {
+    if (!this.session) throw new ArtiumError("TOKEN_INVALID");
+    return request(this.session.accessToken);
+  }
   async authenticated(request, refresh) {
     if (!this.session) throw new ArtiumError("TOKEN_INVALID");
     try {
@@ -44303,9 +44517,9 @@ var ManagedSession = class _ManagedSession {
     if (session.status === "authenticated") this.protect(session.accessToken, session.refreshToken);
     else this.protect(session.passwordChangeToken);
     try {
-      await new Promise((resolve4, reject) => {
+      await new Promise((resolve5, reject) => {
         this.channel.write(`${JSON.stringify({ serverUrl, ...session })}
-`, (error62) => error62 ? reject(error62) : resolve4());
+`, (error62) => error62 ? reject(error62) : resolve5());
       });
     } catch {
       throw new ArtiumError(
@@ -44318,6 +44532,12 @@ var ManagedSession = class _ManagedSession {
   write(stream, text2) {
     this.output[stream] += text2;
   }
+  // Identity approval and pre-execution notices must reach the caller before
+  // the pending operation. Tool output retains the buffered flush contract.
+  notice(text2) {
+    if (new SecretScanner(this.secrets).scan("stdout", Buffer.from(text2))) throw new ArtiumError("SECRET_IN_OUTPUT");
+    process.stdout.write(text2);
+  }
   flush() {
     this.channel.destroy();
     const scanner = new SecretScanner(this.secrets);
@@ -44359,6 +44579,255 @@ async function update() {
   return "status: updated\nnext: artium-axi --version\n";
 }
 
+// src/cli/download.ts
+import { createHash as createHash4 } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/cli/artifact-save.ts
+import { createHash as createHash3, randomUUID as randomUUID4 } from "node:crypto";
+import { constants } from "node:fs";
+import { link, open as open2, unlink } from "node:fs/promises";
+import { basename as basename2, dirname as dirname4, isAbsolute, resolve as resolve3 } from "node:path";
+async function privateParent(destination) {
+  let parent = await open2("/", constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+  try {
+    for (const component of dirname4(destination).split("/").filter(Boolean)) {
+      const child = await open2(`/proc/self/fd/${parent.fd}/${component}`, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+      await parent.close();
+      parent = child;
+    }
+    const info = await parent.stat();
+    if (info.uid !== process.getuid?.() || (info.mode & 511) !== 448) throw new ArtiumError("ARTIFACT_SAVE_FAILED");
+    return parent;
+  } catch (error62) {
+    await parent.close();
+    throw error62;
+  }
+}
+async function artifactDestination(destination) {
+  if (process.platform !== "linux" || !isAbsolute(destination) || resolve3(destination) !== destination || basename2(destination) === "") {
+    throw new ArtiumError("ARTIFACT_SAVE_FAILED");
+  }
+  let parent;
+  try {
+    parent = await privateParent(destination);
+  } catch {
+    throw new ArtiumError("ARTIFACT_SAVE_FAILED");
+  }
+  let temporary;
+  let file2;
+  let closed = false;
+  try {
+    const info = await parent.stat();
+    const target = `/proc/self/fd/${parent.fd}/${basename2(destination)}`;
+    try {
+      const existing = await open2(target, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+      await existing.close();
+      throw new ArtiumError("ARTIFACT_SAVE_FAILED");
+    } catch (error62) {
+      if (error62.code !== "ENOENT") throw error62;
+    }
+    return {
+      async save(response, archive, signal) {
+        signal.throwIfAborted();
+        if (response.headers["content-type"] !== "application/octet-stream" || response.headers["content-length"] !== String(archive.archiveBytes) || response.headers["x-artium-archive-sha256"] !== archive.archiveSha256 || response.headers["content-encoding"] || response.headers["content-range"]) throw new ArtiumError("INVALID_RESPONSE");
+        temporary = `/proc/self/fd/${parent.fd}/.artium-${randomUUID4()}.tmp`;
+        file2 = await open2(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+        const hash2 = createHash3("sha256");
+        let size = 0;
+        for await (const chunk of response) {
+          signal.throwIfAborted();
+          size += chunk.length;
+          if (size > archive.archiveBytes) throw new ArtiumError("INVALID_RESPONSE");
+          hash2.update(chunk);
+          await file2.writeFile(chunk);
+        }
+        if (size !== archive.archiveBytes || hash2.digest("hex") !== archive.archiveSha256) throw new ArtiumError("INVALID_RESPONSE");
+        await file2.sync();
+        await file2.close();
+        file2 = void 0;
+        const current = await privateParent(destination);
+        try {
+          const actual = await current.stat();
+          if (info.dev !== actual.dev || info.ino !== actual.ino) throw new ArtiumError("ARTIFACT_SAVE_FAILED");
+        } finally {
+          await current.close();
+        }
+        signal.throwIfAborted();
+        await link(temporary, target);
+      },
+      async close() {
+        if (closed) return;
+        closed = true;
+        try {
+          await file2?.close();
+        } finally {
+          try {
+            if (temporary) await unlink(temporary);
+          } finally {
+            await parent.close();
+          }
+        }
+      }
+    };
+  } catch {
+    await parent.close();
+    throw new ArtiumError("ARTIFACT_SAVE_FAILED");
+  }
+}
+
+// src/cli/download.ts
+async function download(args, output3, managed2) {
+  const announce = (value) => {
+    const text2 = encode3(value) + "\n";
+    if (managed2) managed2.notice(text2);
+    else output3(text2);
+  };
+  announce({ warning: transferWarning });
+  const flags = /* @__PURE__ */ new Map();
+  for (let index = 0; index < args.length; index++) {
+    const name = args[index];
+    if (["--execute", "--password-stdin", "--sso"].includes(name)) flags.set(name, "true");
+    else flags.set(name, args[++index]);
+  }
+  const destination = flags.get("--destination") ?? "";
+  const input2 = transferPrepareSchema.safeParse({
+    selection: {
+      operation: flags.get("--operation"),
+      selector: flags.get("--selector"),
+      type: flags.get("--type")
+    },
+    targetDigest: createHash4("sha256").update(destination).digest("hex")
+  });
+  if (!input2.success || !destination || flags.has("--sso") && flags.has("--password-stdin")) throw new ArtiumError("INVALID_INPUT");
+  const execute = flags.has("--execute");
+  if (execute !== flags.has("--transfer") || execute !== flags.has("--confirm")) throw new ArtiumError("INVALID_INPUT");
+  let execution;
+  if (execute) {
+    const parsed = transferExecuteSchema.safeParse({
+      ...input2.data,
+      transferId: flags.get("--transfer"),
+      execute: true,
+      confirm: flags.get("--confirm")
+    });
+    if (!parsed.success) throw new ArtiumError("INVALID_INPUT");
+    execution = parsed.data;
+  }
+  const client = new Client(process.env, managed2);
+  const local = await artifactDestination(destination);
+  const interrupt = () => client.cancel();
+  process.once("SIGINT", interrupt);
+  process.once("SIGTERM", interrupt);
+  try {
+    await client.transferSession(async (token) => {
+      let proof;
+      if (flags.has("--sso")) {
+        const start = deviceStartResponseSchema.parse(await client.request("/v1/auth/reauth", "POST", {}, token));
+        if (start.verificationUri !== client.serverUrl + "/device") throw new ArtiumError("INVALID_RESPONSE");
+        managed2?.protect(start.deviceCode);
+        announce({ status: "approval-required", open: start.verificationUri, code: start.userCode, expiresAt: start.expiresAt });
+        while (Date.now() < start.expiresAt) {
+          try {
+            proof = ssoReauthResponseSchema.parse(await client.request("/v1/auth/reauth", "POST", { deviceCode: start.deviceCode }, token));
+            if (reauthResponseSchema.safeParse(proof).success) break;
+          } catch (error62) {
+            if (!(error62 instanceof ArtiumError) || error62.code !== "DEVICE_POLL_LIMITED") throw error62;
+          }
+          await delay(Math.min(start.intervalMs, Math.max(0, start.expiresAt - Date.now())));
+        }
+      } else {
+        const password = await readPassword(flags.has("--password-stdin"));
+        managed2?.protect(password);
+        proof = await client.request("/v1/auth/reauth", "POST", { password }, token);
+      }
+      const { ticket } = reauthResponseSchema.parse(proof);
+      managed2?.protect(ticket);
+      const request = (path, body) => client.request(
+        path,
+        "POST",
+        body,
+        token,
+        false,
+        { "x-artium-reauth-ticket": ticket }
+      );
+      if (!execution) {
+        const preview = transferPreviewSchema.parse(await request(transferRoutes.prepare.path, input2.data));
+        if (preview.targetDigest !== input2.data.targetDigest) throw new ArtiumError("INVALID_RESPONSE");
+        announce({
+          ...input2.data.selection,
+          destination,
+          limits: transferLimits,
+          ...preview,
+          saveOutcome: "unconfirmed",
+          next: "Repeat this exact selection and destination with --transfer <transferId> --execute --confirm <exact confirm> and recent identity confirmation. No automatic retries."
+        });
+        return;
+      }
+      const retrieval = { ...input2.data, transferId: execution.transferId };
+      let archive;
+      let saved = false;
+      let receipt = "unconfirmed";
+      try {
+        const pending = transferStatusSchema.parse(await request(transferRoutes.status.path, retrieval));
+        if (pending.transferId !== execution.transferId || pending.outcome !== "preview" || pending.archive !== null) throw new ArtiumError("INVALID_RESPONSE");
+        announce({
+          ...input2.data.selection,
+          destination,
+          limits: transferLimits,
+          expiresAt: pending.expiresAt,
+          saveOutcome: "unconfirmed"
+        });
+        const status = transferStatusSchema.parse(await request(transferRoutes.execute.path, execution));
+        if (status.transferId !== execution.transferId || status.expiresAt !== pending.expiresAt || status.outcome !== "ready" || !status.archive) throw new ArtiumError("INVALID_RESPONSE");
+        archive = status.archive;
+        await client.artifact(
+          transferRoutes.retrieve.path,
+          retrieval,
+          token,
+          ticket,
+          status.expiresAt,
+          (response, signal) => local.save(response, archive, signal)
+        );
+        saved = true;
+        await local.close();
+        try {
+          await request(transferRoutes.receipt.path, { ...retrieval, archive, saveOutcome: "verified-save" });
+          receipt = "confirmed";
+        } catch {
+        }
+      } catch (error62) {
+        if (archive && !saved) {
+          try {
+            await request(transferRoutes.receipt.path, { ...retrieval, archive, saveOutcome: "save-failed" });
+          } catch {
+          }
+        }
+        try {
+          await request(transferRoutes.cancel.path, retrieval);
+        } catch {
+        }
+        throw error62;
+      } finally {
+        output3(encode3({
+          ...input2.data.selection,
+          destination,
+          archiveBytes: archive?.archiveBytes ?? null,
+          archiveSha256: archive?.archiveSha256 ?? null,
+          saveOutcome: saved ? "verified-save" : "save-failed",
+          receipt
+        }) + "\n");
+      }
+    });
+  } catch (error62) {
+    if (error62 instanceof ZodError) throw new ArtiumError("INVALID_RESPONSE");
+    throw error62;
+  } finally {
+    process.off("SIGINT", interrupt);
+    process.off("SIGTERM", interrupt);
+    await local.close();
+  }
+}
+
 // src/cli/main.ts
 var managed;
 for (const stream of [process.stdout, process.stderr]) {
@@ -44408,6 +44877,10 @@ async function main(args) {
     output2("stdout", await update());
     return;
   }
+  if (command === "download") {
+    await download(args.slice(1), (text2) => output2("stdout", text2), managed);
+    return;
+  }
   if (command === "setup") {
     output2("stdout", await setup(args.slice(1)));
     return;
@@ -44527,9 +45000,9 @@ remoteRevocation: ${verified ? "verified" : "unverified"}
     if (home) {
       const tools = toolsResponseSchema.safeParse(await client.authenticated("/v1/tools", "GET", void 0, homeSession));
       if (!tools.success) throw new ArtiumError("INVALID_RESPONSE");
-      const executable = resolve3(process.argv[1]);
+      const executable = resolve4(process.argv[1]);
       const local = relative(homedir3(), executable);
-      const bin = local && !isAbsolute(local) && !local.startsWith(`..${sep}`) && local !== ".." ? `~${sep}${local}` : executable;
+      const bin = local && !isAbsolute2(local) && !local.startsWith(`..${sep}`) && local !== ".." ? `~${sep}${local}` : executable;
       view = `bin: ${JSON.stringify(bin)}
 description: Run managed upstream tools through one local sign-in.
 ${view}${toolsView(tools.data.tools)}`;
@@ -44556,16 +45029,20 @@ ${view}${toolsView(tools.data.tools)}`;
   }
 }
 function printError(response) {
+  if (process.argv[2] === "download" || process.argv[2] === "--managed-session" && process.argv[3] === "download") {
+    output2("stdout", `warning: ${JSON.stringify(transferWarning)}
+`);
+  }
   output2("stdout", `error:
 ${Object.entries(response.error).map(([key, value]) => `  ${key}: ${JSON.stringify(value)}`).join("\n")}
 `);
   process.exitCode = errors[response.error.code].exitCode;
 }
-main(process.argv.slice(2)).catch((error62) => printError(errorResponse(error62 instanceof ArtiumError ? error62 : new ArtiumError("INTERNAL_ERROR"), randomUUID4()))).then(() => {
+main(process.argv.slice(2)).catch((error62) => printError(errorResponse(error62 instanceof ArtiumError ? error62 : new ArtiumError("INTERNAL_ERROR"), randomUUID5()))).then(() => {
   try {
     managed?.flush();
   } catch {
     managed = void 0;
-    printError(errorResponse(new ArtiumError("SECRET_IN_OUTPUT"), randomUUID4()));
+    printError(errorResponse(new ArtiumError("SECRET_IN_OUTPUT"), randomUUID5()));
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@knowttl/artium-axi",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Client CLI and embedded skill for the Artium managed tools server.",
   "license": "MIT",
   "type": "module",