pip install softqcos
softqcos login
softqcos doctor
softqcos status

Usage: softqcos [OPTIONS] COMMAND [ARGS]...

 SoftQCOS - SoftQuantus Quantum Circuit Orchestration System CLI

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --version  -v        Show version and exit.                                  │
│ --license            Show license information.                               │
│ --legal              Show legal information and document links.              │
│ --help               Show this message and exit.                             │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ info        Show system and environment information.                         │
│ version     Show version information.                                        │
│ doctor      Check local config and production API connectivity.              │
│ welcome     Show the SoftQuantus platform welcome screen.                    │
│ verify      Verify an evidence bundle offline.                               │
│ backends    Manage user backend credentials (BYOB)                           │
│ algorithms  QCOS Algorithms™ — Quantum algorithm execution (Shor, Grover,    │
│             QFT, QPE, QAOA…)                                                 │
│ jobs        QCOS Jobs™ — Submit, monitor & retrieve quantum jobs             │
│ circuits    QCOS Circuits™ — Circuit management, optimization & simulation   │
│ billing     QCOS ROI Engine™ — Billing, pricing & ROI analysis               │
│ admin       SoftQuantus QCOS™ Admin — Platform administration                │
│ evidence    QCOS Evidence™ Portal — Verifiable evidence & artifacts          │
│ api         QCOS API™ — Stable JSON-first commands for agents and automation │
│ extensions  Specialized QCOS domains and advanced product modules.           │
│ config      Show or update local QCOS CLI configuration.                     │
│ license     Manage your QCOS license.                                        │
│ auth        Authenticate and manage local QCOS access.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos [OPTIONS] COMMAND [ARGS]...

 ACOS-ISA™ — Quantum infrastructure certification

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ health        Check ACOS service health.                                     │
│ tiers         List certification tiers.                                      │
│ tests         List available certification tests.                            │
│ certify       Run certification on a backend.                                │
│ verify        Verify a certificate.                                          │
│ certificates  List all certificates.                                         │
│ certificate   Get certificate details.                                       │
│ evidence      Get certification evidence bundle.                             │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos certificate [OPTIONS] CERTIFICATE_ID

 Get certificate details.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│                                [required]                                    │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos certificates [OPTIONS]

 List all certificates.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos certify [OPTIONS]

 Run certification on a backend.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                   Show this message and exit.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos evidence [OPTIONS] EVIDENCE_ID

 Get certification evidence bundle.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│                             [required]                                       │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos health [OPTIONS]

 Check ACOS service health.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos tests [OPTIONS]

 List available certification tests.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos tiers [OPTIONS]

 List certification tiers.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos acos verify [OPTIONS] CERTIFICATE_ID

 Verify a certificate.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    certificate_id      TEXT  Certificate ID                                │
│                                [required]                                    │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos activate [OPTIONS]

 Activate QCOS with a license key or file.

 Examples:

     softqcos activate --license-key "QCOS-1234-ABCD-..." --customer-id
 "user@example.com"

     softqcos activate --license-file /path/to/license.lic

 Get your license at: https://platform.softquantus.com

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --license-key   -k      TEXT  License key from portal                        │
│ --license-file  -f      TEXT  Path to license file                           │
│ --customer-id           TEXT  End-customer ID or email for license           │
│                               validation                                     │
│ --help                        Show this message and exit.                    │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin [OPTIONS] COMMAND [ARGS]...

 SoftQuantus QCOS™ Admin — Platform administration

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ health            Admin service health check.                                │
│ tenants           List all tenants.                                          │
│ usage             Get usage statistics.                                      │
│ metrics           Get system metrics.                                        │
│ rate-limits       Get rate limit status.                                     │
│ circuit-breakers  Get circuit breaker status.                                │
│ backends-status   Get all backends status.                                   │
│ config            Get platform configuration overview.                       │
│ logs              Get recent admin logs.                                     │
│ audit             Get admin audit trail.                                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin audit [OPTIONS]

 Get admin audit trail.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin backends-status [OPTIONS]

 Get all backends status.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin circuit-breakers [OPTIONS]

 Get circuit breaker status.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin config [OPTIONS]

 Get platform configuration overview.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin health [OPTIONS]

 Admin service health check.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin logs [OPTIONS]

 Get recent admin logs.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --level  -l      TEXT     debug|info|warning|error                           │
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin metrics [OPTIONS]

 Get system metrics.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin rate-limits [OPTIONS]

 Get rate limit status.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin tenants [OPTIONS]

 List all tenants.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos admin usage [OPTIONS]

 Get usage statistics.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                  Show this message and exit.                          │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms [OPTIONS] COMMAND [ARGS]...

 QCOS Algorithms™ — Quantum algorithm execution (Shor, Grover, QFT, QPE, QAOA…)

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ list    List all available quantum algorithms.                               │
│ info    Show algorithm metadata and parameter schema.                        │
│ shor    Factor integer N with Shor's algorithm.                              │
│ grover  Grover's unstructured database search.                               │
│ qft     Quantum Fourier Transform.                                           │
│ qpe     Quantum Phase Estimation.                                            │
│ bv      Bernstein-Vazirani hidden linear function recovery.                  │
│ dj      Deutsch-Jozsa oracle classification (constant vs balanced).          │
│ qaoa    QAOA MaxCut approximate optimisation.                                │
│ run     Run any algorithm by name with raw JSON parameters.                  │
│ job     Get status/result of an async algorithm job.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms bv [OPTIONS] SECRET

 Bernstein-Vazirani hidden linear function recovery.


 Example:
   softqcos algorithms bv 1011

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    secret      TEXT  Secret bitstring (e.g. '1011')                        │
│                        [required]                                            │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms dj [OPTIONS]

 Deutsch-Jozsa oracle classification (constant vs balanced).


 Example:
   softqcos algorithms dj --oracle constant --qubits 4

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --oracle  -o      TEXT     constant | balanced                               │
│ --help                     Show this message and exit.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms grover [OPTIONS] TARGET

 Grover's unstructured database search.


 Example:
   softqcos algorithms grover 101

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    target      TEXT  Target bitstring to search (e.g. '101')               │
│                        [required]                                            │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --qubits  -q      INTEGER  Number of qubits (default: len(target))           │
│ --help                     Show this message and exit.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms info [OPTIONS] NAME

 Show algorithm metadata and parameter schema.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    name      TEXT  Algorithm name (shor, grover, qft, qpe, bv, dj, qaoa)   │
│                      [required]                                              │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms job [OPTIONS] JOB_ID

 Get status/result of an async algorithm job.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    job_id      TEXT  Algorithm job ID                                      │
│                        [required]                                            │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms list [OPTIONS]

 List all available quantum algorithms.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms qaoa [OPTIONS]

 QAOA MaxCut approximate optimisation.


 Example:
   softqcos algorithms qaoa --edges '[[0,1],[1,2],[0,2]]' --nodes '[0,1,2]'

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --edges  -e      TEXT     Graph edges JSON e.g. '[[0,1],[1,2],[0,2]]'     │
│                              [required]                                      │
│    --nodes  -n      TEXT     Graph nodes JSON e.g. '[0,1,2]'                 │
│    --depth  -p      INTEGER  QAOA depth (layers)                             │
│    --help                    Show this message and exit.                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms qft [OPTIONS] N_QUBITS

 Quantum Fourier Transform.


 Example:
   softqcos algorithms qft 8

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    n_qubits      INTEGER  Number of qubits for QFT                         │
│                             [required]                                       │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms qpe [OPTIONS] PHASE

 Quantum Phase Estimation.


 Example:
   softqcos algorithms qpe 0.333 --qubits 6

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    phase      FLOAT  Target phase φ ∈ [0, 1)                               │
│                        [required]                                            │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --qubits  -q      INTEGER  Precision qubits                                  │
│ --help                     Show this message and exit.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms run [OPTIONS] NAME

 Run any algorithm by name with raw JSON parameters.


 Example:
   softqcos algorithms run shor --params '{"N": 35}'
   softqcos algorithms run grover --params '{"target": "101"}'

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    name      TEXT  Algorithm name (shor, grover, qft, qpe, bv, dj, qaoa)   │
│                      [required]                                              │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --params  -p      TEXT     Algorithm params as JSON string                   │
│ --help                     Show this message and exit.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos algorithms shor [OPTIONS] N

 Factor integer N with Shor's algorithm.


 Examples:
   softqcos algorithms shor 35
   softqcos algorithms shor 34359738433 --cluster lumi --lumi-nodes 2
   softqcos algorithms shor 9999999999999937 --cluster hybrid --lumi-nodes 4

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    n      INTEGER  Integer N to factor (must be odd composite)             │
│                      [required]                                              │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --shots              -s      INTEGER  Measurement shots                      │
│ --base               -a      INTEGER  Base a for modular exponentiation      │
│ --cluster            -c      TEXT     Cluster mode: local | lumi | hybrid    │
│ --lumi-nodes         -N      INTEGER  LUMI node count (1-16)                 │
│ --lumi-host                  TEXT     SSH alias for LUMI login node          │
│ --azure-resource-id          TEXT     Azure Quantum resource ID (hybrid      │
│                                       mode)                                  │
│ --ibm-token                  TEXT     IBM Quantum token (hybrid mode)        │
│ --async                               Submit async (returns job_id)          │
│ --help                                Show this message and exit.            │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api [OPTIONS] COMMAND [ARGS]...

 QCOS API™ — Stable JSON-first commands for agents and automation

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ workspace  Workspace discovery and initialization                            │
│ circuit    Circuit validation and simulation                                 │
│ job        QCOS job validation and planning                                  │
│ run        Run QCOS jobs                                                     │
│ result     Read result summaries                                             │
│ gpu        QCOS GPU discovery, planning, and simulation                      │
│ backend    Backend planning and selection                                    │
│ hybrid     QCOS hybrid kernel and QEC planning                               │
│ qlink      QCOS low-latency QPU-GPU planning                                 │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api backend [OPTIONS] COMMAND [ARGS]...

 Backend planning and selection

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ plan     Plan the best QCOS backend: Aer, QCOS GPU statevector, tensor       │
│          network, or HPC.                                                    │
│ compare  Compare Aer, QCOS GPU statevector, tensor-network and               │
│          density-matrix suitability.                                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api backend compare [OPTIONS]

 Compare Aer, QCOS GPU statevector, tensor-network and density-matrix
 suitability.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input        -i               PATH     OpenQASM circuit file            │
│                                             [required]                       │
│    --shots                         INTEGER  Shot count for Aer smoke test    │
│    --execute-aer                            Run QCOS Aer API for baseline    │
│                                             counts and latency               │
│    --json             --no-json             Emit JSON output                 │
│    --help                                   Show this message and exit.      │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api backend plan [OPTIONS]

 Plan the best QCOS backend: Aer, QCOS GPU statevector, tensor network, or HPC.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input           -i               PATH   OpenQASM circuit file           │
│                                              [required]                      │
│    --precision                        TEXT   fp32 or fp64                    │
│    --gpu-memory-gib                   FLOAT  Override detected GPU memory    │
│    --density-matrix                          Prefer density-matrix planning  │
│    --json                --no-json           Emit JSON output                │
│    --help                                    Show this message and exit.     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api circuit [OPTIONS] COMMAND [ARGS]...

 Circuit validation and simulation

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ validate  Validate a local circuit file without executing it.                │
│ simulate  Run a local/API simulator for a circuit and return structured      │
│           JSON.                                                              │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api circuit simulate [OPTIONS]

 Run a local/API simulator for a circuit and return structured JSON.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input   -i               PATH     Circuit file                          │
│                                        [required]                            │
│    --shots                    INTEGER  Shot count                            │
│    --method                   TEXT     Simulation method                     │
│    --output  -o               PATH     Save result JSON                      │
│    --json        --no-json             Emit JSON output                      │
│    --help                              Show this message and exit.           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api circuit validate [OPTIONS]

 Validate a local circuit file without executing it.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input  -i               PATH  Circuit file                              │
│                                    [required]                                │
│    --json       --no-json          Emit JSON output                          │
│    --help                          Show this message and exit.               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu [OPTIONS] COMMAND [ARGS]...

 QCOS GPU discovery, planning, and simulation

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ detect           Detect local GPU, CUDA, and QCOS acceleration libraries.    │
│ benchmark        Run a lightweight GPU/CUDA detection and optional simulator │
│                  latency benchmark.                                          │
│ engine-detect    Detect whether QCOS GPU acceleration engines are installed. │
│ estimate-memory  Estimate GPU memory required by QCOS GPU simulation         │
│                  strategies.                                                 │
│ plan             Alias for backend planning focused on QCOS GPU engines.     │
│ simulate         Run or plan a QCOS GPU simulation with safe fallback        │
│                  semantics.                                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu benchmark [OPTIONS]

 Run a lightweight GPU/CUDA detection and optional simulator latency benchmark.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --input  -i               PATH     Optional circuit file                     │
│ --shots                   INTEGER  Shot count for optional API latency smoke │
│                                    test                                      │
│ --json       --no-json             Emit JSON output                          │
│ --help                             Show this message and exit.               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu detect [OPTIONS]

 Detect local GPU, CUDA, and QCOS acceleration libraries.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --json    --no-json      Emit JSON output                                    │
│ --help                   Show this message and exit.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu engine-detect [OPTIONS]

 Detect whether QCOS GPU acceleration engines are installed.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --json    --no-json      Emit JSON output                                    │
│ --help                   Show this message and exit.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu estimate-memory [OPTIONS]

 Estimate GPU memory required by QCOS GPU simulation strategies.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --qubits                    INTEGER RANGE [x>=1]  Number of qubits        │
│                                                      [default: <object       │
│                                                      [required]              │
│    --precision                 TEXT                  fp32 or fp64            │
│                                                      [default: <object       │
│    --method                    TEXT                  statevector or          │
│                                                      density_matrix          │
│                                                      [default: <object       │
│    --json         --no-json                          Emit JSON output        │
│                                                      [default: <object       │
│    --help                                            Show this message and   │
│                                                      exit.                   │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu plan [OPTIONS]

 Alias for backend planning focused on QCOS GPU engines.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input      -i               PATH  OpenQASM circuit file                 │
│                                        [required]                            │
│    --precision                   TEXT  fp32 or fp64                          │
│    --json           --no-json          Emit JSON output                      │
│    --help                              Show this message and exit.           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api gpu simulate [OPTIONS]

 Run or plan a QCOS GPU simulation with safe fallback semantics.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input         -i               PATH     OpenQASM circuit file           │
│                                              [required]                      │
│    --engine                         TEXT     statevector, tensornet, or      │
│                                              density_matrix                  │
│    --shots                          INTEGER  Shot count                      │
│    --precision                      TEXT     fp32 or fp64                    │
│    --fallback-aer                            Use QCOS Aer API if QCOS GPU    │
│                                              Engine is unavailable           │
│    --output        -o               PATH     Save result summary JSON        │
│    --json              --no-json             Emit JSON output                │
│    --help                                    Show this message and exit.     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api hybrid [OPTIONS] COMMAND [ARGS]...

 QCOS hybrid kernel and QEC planning

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ detect    Detect QCOS hybrid-kernel and acceleration libraries for QEC and   │
│           solvers.                                                           │
│ qec-plan  Plan a QCOS accelerated QEC workflow without executing it.         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api hybrid detect [OPTIONS]

 Detect QCOS hybrid-kernel and acceleration libraries for QEC and solvers.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --json    --no-json      Emit JSON output                                    │
│ --help                   Show this message and exit.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api hybrid qec-plan [OPTIONS]

 Plan a QCOS accelerated QEC workflow without executing it.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --code                     TEXT                  QEC code family             │
│ --distance                 INTEGER RANGE [x>=1]  Code distance               │
│ --rounds                   INTEGER RANGE [x>=1]  Syndrome rounds             │
│ --json        --no-json                          Emit JSON output            │
│ --help                                           Show this message and exit. │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api job [OPTIONS] COMMAND [ARGS]...

 QCOS job validation and planning

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ validate  Validate a QCOS job file.                                          │
│ plan      Plan a QCOS job and return risk/backend/execution metadata.        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api job plan [OPTIONS]

 Plan a QCOS job and return risk/backend/execution metadata.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input  -i               PATH  QCOS job JSON/YAML                        │
│                                    [required]                                │
│    --json       --no-json          Emit JSON output                          │
│    --help                          Show this message and exit.               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api job validate [OPTIONS]

 Validate a QCOS job file.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input  -i               PATH  QCOS job JSON/YAML                        │
│                                    [required]                                │
│    --json       --no-json          Emit JSON output                          │
│    --help                          Show this message and exit.               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api qlink [OPTIONS] COMMAND [ARGS]...

 QCOS low-latency QPU-GPU planning

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ plan-feedback-loop  Plan a QCOS low-latency QPU-GPU feedback loop. This does │
│                     not reserve hardware.                                    │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api qlink plan-feedback-loop [OPTIONS]

 Plan a QCOS low-latency QPU-GPU feedback loop. This does not reserve hardware.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --qpu                              TEXT               QPU or lab target   │
│                                                          name                │
│                                                          [default: <object   │
│                                                          object at           │
│                                                          [required]          │
│    --gpu                              TEXT               GPU target or auto  │
│                                                          [default: <object   │
│                                                          object at           │
│    --latency-budget-…                 INTEGER RANGE      Feedback latency    │
│                                       [x>=1]             budget              │
│                                                          [default: <object   │
│                                                          object at           │
│    --qec                                                 Plan for realtime   │
│                                                          QEC loop            │
│                                                          [default: <object   │
│                                                          object at           │
│    --json                --no-json                       Emit JSON output    │
│                                                          [default: <object   │
│                                                          object at           │
│    --help                                                Show this message   │
│                                                          and exit.           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api result [OPTIONS] COMMAND [ARGS]...

 Read result summaries

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ summary  Read a result summary and compute basic metrics.                    │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api result summary [OPTIONS]

 Read a result summary and compute basic metrics.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input  -i               PATH  Result summary JSON                       │
│                                    [required]                                │
│    --json       --no-json          Emit JSON output                          │
│    --help                          Show this message and exit.               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api run [OPTIONS] COMMAND [ARGS]...

 Run QCOS jobs

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ local  Validate, plan, run local simulation, and write a result artifact.    │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api run local [OPTIONS]

 Validate, plan, run local simulation, and write a result artifact.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --input       -i               PATH  QCOS job JSON/YAML                   │
│                                         [required]                           │
│    --output-dir                   PATH  Results directory                    │
│    --json            --no-json          Emit JSON output                     │
│    --help                               Show this message and exit.          │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api workspace [OPTIONS] COMMAND [ARGS]...

 Workspace discovery and initialization

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ discover  Discover QCOS manifest, jobs, circuits and artifact directories.   │
│ init      Create a minimal QCOS workspace with Bell circuit and job          │
│           template.                                                          │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api workspace discover [OPTIONS]

 Discover QCOS manifest, jobs, circuits and artifact directories.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --root                 PATH  Workspace root or any path inside it            │
│ --json    --no-json          Emit JSON output                                │
│ --help                       Show this message and exit.                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos api workspace init [OPTIONS]

 Create a minimal QCOS workspace with Bell circuit and job template.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --root                  PATH  Workspace root                                 │
│ --force                       Overwrite template files                       │
│ --json     --no-json          Emit JSON output                               │
│ --help                        Show this message and exit.                    │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos auth [OPTIONS] COMMAND [ARGS]...

 Authenticate and manage local QCOS access.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ login    Authenticate with the SoftQuantus Research Platform.                │
│ status   Show local license and API key status.                              │
│ logout   Remove the local checked-out license.                               │
│ license  Show local license status.                                          │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos auth license [OPTIONS]

 Show local license status.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos auth login [OPTIONS]

 Authenticate with the SoftQuantus Research Platform.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --api-key       -k      TEXT  QCOS API key from platform.softquantus.com     │
│ --api-url       -u      TEXT  QCOS API URL                                   │
│ --platform-url          TEXT  Platform API URL                               │
│ --no-test                     Save without testing the API URL               │
│ --help                        Show this message and exit.                    │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos auth logout [OPTIONS]

 Remove the local checked-out license.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos auth status [OPTIONS]

 Show local license and API key status.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos autopilot [OPTIONS] COMMAND [ARGS]...

 Autopilot Hybrid Orchestrator — AI QPU×GPU×CPU partitioning

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ vendors    List all available QPU, GPU and CPU devices.                      │
│ plan       Generate AI hybrid execution plan for a circuit.                  │
│ recommend  Recommend autopilot strategy for a workload.                      │
│ execute    Execute a circuit using the Autopilot Hybrid Orchestrator.        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos autopilot execute [OPTIONS]

 Execute a circuit using the Autopilot Hybrid Orchestrator.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --file      -f      TEXT     Path to .qasm file                              │
│ --help                       Show this message and exit.                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos autopilot plan [OPTIONS] NUM_QUBITS

 Generate AI hybrid execution plan for a circuit.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    num_qubits      INTEGER  Number of qubits                               │
│                               [required]                                     │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --type      -t      TEXT     vqe|qaoa|quantum_ml|shor|grover|generic         │
│ --strategy  -s      TEXT     auto|qpu_first|gpu_first|cost_opt|latency_opt   │
│ --help                       Show this message and exit.                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos autopilot recommend [OPTIONS] NUM_QUBITS

 Recommend autopilot strategy for a workload.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│                               [required]                                     │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                   Show this message and exit.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos autopilot vendors [OPTIONS]

 List all available QPU, GPU and CPU devices.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends [OPTIONS] COMMAND [ARGS]...

 Manage user backend credentials (BYOB)

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ providers  List available backend providers and their credential schemas.    │
│ list       List all stored backend credentials.                              │
│ add        Add a new backend credential.                                     │
│ show       Show details of a specific backend.                               │
│ update     Update an existing backend.                                       │
│ delete     Delete a backend.                                                 │
│ validate   Validate backend credentials against the provider API.            │
│ execute    Execute a quantum circuit using user's backend credentials.       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends add [OPTIONS]

 Add a new backend credential.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --provider     -p      TEXT  Backend provider                             │
│                                 [required]                                   │
│ *  --name         -n      TEXT  Friendly name                                │
│                                 [required]                                   │
│    --description  -d      TEXT  Description                                  │
│    --file         -f      TEXT  JSON file with credentials                   │
│    --help                       Show this message and exit.                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends delete [OPTIONS] BACKEND_ID

 Delete a backend.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    backend_id      TEXT  Backend ID                                        │
│                            [required]                                        │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --force  -f        Skip confirmation                                         │
│ --help             Show this message and exit.                               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends execute [OPTIONS]

 Execute a quantum circuit using user's backend credentials.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --backend-id  -b      TEXT     Backend or credential ID                   │
│                                   [required]                                 │
│ *  --circuit     -q      TEXT     Path to QASM file                          │
│                                   [required]                                 │
│    --shots       -s      INTEGER  Number of shots                            │
│    --json        -j               Output as JSON                             │
│    --help                         Show this message and exit.                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends list [OPTIONS]

 List all stored backend credentials.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --provider  -p      TEXT  Filter by provider                                 │
│ --json      -j            Output as JSON                                     │
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends providers [OPTIONS]

 List available backend providers and their credential schemas.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends show [OPTIONS] BACKEND_ID

 Show details of a specific backend.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    backend_id      TEXT  Backend ID                                        │
│                            [required]                                        │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends update [OPTIONS] BACKEND_ID

 Update an existing backend.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    backend_id      TEXT  Backend ID                                        │
│                            [required]                                        │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --name         -n      TEXT  New name                                        │
│ --description  -d      TEXT  New description                                 │
│ --help                       Show this message and exit.                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos backends validate [OPTIONS] BACKEND_ID

 Validate backend credentials against the provider API.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    backend_id      TEXT  Backend ID                                        │
│                            [required]                                        │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos batch [OPTIONS] COMMAND [ARGS]...

 Batch Operations™ — Parallel quantum circuit execution

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ submit   Submit a batch of circuits for parallel execution.                  │
│ status   Get batch status and progress.                                      │
│ results  Get results from all completed jobs in a batch.                     │
│ cancel   Cancel a running or pending batch.                                  │
│ list     List batches.                                                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos batch cancel [OPTIONS] BATCH_ID

 Cancel a running or pending batch.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    batch_id      TEXT  Batch ID                                            │
│                          [required]                                          │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos batch list [OPTIONS] [STATUS_FILTER]

 List batches.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│   status_filter      [STATUS_FILTER]  Filter by status                       │
│                                       (pending/running/completed)            │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --limit  -l      INTEGER  Max results                                        │
│ --json                    Output raw JSON                                    │
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos batch results [OPTIONS] BATCH_ID

 Get results from all completed jobs in a batch.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    batch_id      TEXT  Batch ID                                            │
│                          [required]                                          │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --output  -o      TEXT  Save results to file                                 │
│ --json                  Output raw JSON                                      │
│ --help                  Show this message and exit.                          │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos batch status [OPTIONS] BATCH_ID

 Get batch status and progress.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    batch_id      TEXT  Batch ID                                            │
│                          [required]                                          │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --watch  -w        Watch status live                                         │
│ --help             Show this message and exit.                               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos batch submit [OPTIONS] FILE

 Submit a batch of circuits for parallel execution.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    file      TEXT  JSON file with circuit batch                            │
│                      [required]                                              │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --backend         -b      TEXT     Backend name                              │
│ --shots           -s      INTEGER  Number of shots                           │
│ --name            -n      TEXT     Batch name                                │
│ --max-concurrent  -c      INTEGER  Max concurrent jobs                       │
│ --output          -o      TEXT     Output file for results                   │
│ --json                             Output raw JSON                           │
│ --help                             Show this message and exit.               │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench [OPTIONS] COMMAND [ARGS]...

 QCOS Bench™ — Reproducible benchmarking & evidence

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ run        Run a benchmark suite on a backend.                               │
│ suites     List available benchmark suites.                                  │
│ workloads  List available workloads.                                         │
│ report     Get a benchmark report.                                           │
│ download   Download benchmark report to a file.                              │
│ verify     Verify benchmark results integrity.                               │
│ health     Check Bench service health.                                       │
│ selftest   Run bench self-test.                                              │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench download [OPTIONS] BENCHMARK_ID

 Download benchmark report to a file.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    benchmark_id      TEXT  Benchmark ID                                    │
│                              [required]                                      │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                  Show this message and exit.                          │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench health [OPTIONS]

 Check Bench service health.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench report [OPTIONS] BENCHMARK_ID

 Get a benchmark report.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    benchmark_id      TEXT  Benchmark ID                                    │
│                              [required]                                      │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench run [OPTIONS]

 Run a benchmark suite on a backend.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --suite    -s      TEXT     Benchmark suite ID                               │
│ --help                      Show this message and exit.                      │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench selftest [OPTIONS]

 Run bench self-test.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                 Show this message and exit.                           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench suites [OPTIONS]

 List available benchmark suites.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench verify [OPTIONS] BENCHMARK_ID

 Verify benchmark results integrity.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    benchmark_id      TEXT  Benchmark ID                                    │
│                              [required]                                      │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos bench workloads [OPTIONS]

 List available workloads.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing [OPTIONS] COMMAND [ARGS]...

 QCOS ROI Engine™ — Billing, pricing & ROI analysis

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ providers     List quantum providers with current pricing.                   │
│ calculate     Calculate ROI with QCOS vs. baseline.                          │
│ pricebook     Get full pricebook with all providers.                         │
│ plans         List QCOS subscription plans.                                  │
│ compare       Compare providers side-by-side.                                │
│ scenarios     Calculate multiple ROI scenarios from a config file.           │
│ report-pdf    Generate PDF ROI report.                                       │
│ report-latex  Generate LaTeX ROI report.                                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing calculate [OPTIONS]

 Calculate ROI with QCOS vs. baseline.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                                      Show this message and exit.      │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing compare [OPTIONS]

 Compare providers side-by-side.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing plans [OPTIONS]

 List QCOS subscription plans.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing pricebook [OPTIONS]

 Get full pricebook with all providers.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing providers [OPTIONS]

 List quantum providers with current pricing.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --version  -V      TEXT  API version: v1 or v2                               │
│ --help                   Show this message and exit.                         │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing report-latex [OPTIONS]

 Generate LaTeX ROI report.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing report-pdf [OPTIONS]

 Generate PDF ROI report.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos billing scenarios [OPTIONS]

 Calculate multiple ROI scenarios from a config file.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --config  -c      PATH  JSON file with scenario configs                   │
│                            [required]                                        │
│    --help                  Show this message and exit.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration [OPTIONS] COMMAND [ARGS]...

 QCOS GlassBox™ — Calibration, devices & evidence

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ health             Check calibration service health.                         │
│ info               Get calibration service information.                      │
│ devices            List all calibrated devices.                              │
│ device             Get device state or specific qubit info.                  │
│ compile            Compile a circuit for a specific device.                  │
│ evidence-create    Create an evidence bundle.                                │
│ evidence-get       Get an evidence bundle.                                   │
│ evidence-verify    Verify an evidence bundle signature.                      │
│ evidence-sign      Sign an evidence bundle.                                  │
│ evidence-finalize  Finalize an evidence bundle (immutable).                  │
│ evidence-audit     Get evidence audit trail.                                 │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration compile [OPTIONS]

 Compile a circuit for a specific device.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --circuit             -q      PATH     Path to QASM file                  │
│                                           [required]                         │
│    --device              -d      TEXT     Target device                      │
│    --help                                 Show this message and exit.        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration device [OPTIONS] DEVICE_NAME

 Get device state or specific qubit info.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    device_name      TEXT  Device name                                      │
│                             [required]                                       │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --qubit  -q      INTEGER  Specific qubit ID                                  │
│ --help                    Show this message and exit.                        │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration devices [OPTIONS]

 List all calibrated devices.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration evidence-audit [OPTIONS] BUNDLE_ID

 Get evidence audit trail.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    bundle_id      TEXT  Evidence bundle ID                                 │
│                           [required]                                         │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration evidence-create [OPTIONS]

 Create an evidence bundle.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --job-id  -j      TEXT  Job ID                                            │
│                            [required]                                        │
│    --help                  Show this message and exit.                       │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration evidence-finalize [OPTIONS] BUNDLE_ID

 Finalize an evidence bundle (immutable).

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    bundle_id      TEXT  Evidence bundle ID                                 │
│                           [required]                                         │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration evidence-get [OPTIONS] BUNDLE_ID

 Get an evidence bundle.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    bundle_id      TEXT  Evidence bundle ID                                 │
│                           [required]                                         │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration evidence-sign [OPTIONS] BUNDLE_ID

 Sign an evidence bundle.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    bundle_id      TEXT  Evidence bundle ID                                 │
│                           [required]                                         │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration evidence-verify [OPTIONS] BUNDLE_ID

 Verify an evidence bundle signature.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    bundle_id      TEXT  Evidence bundle ID                                 │
│                           [required]                                         │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration health [OPTIONS]

 Check calibration service health.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos calibration info [OPTIONS]

 Get calibration service information.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry [OPTIONS] COMMAND [ARGS]...

 Molecular Ruler — VQE, correlation functions & chemical property predictions

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ health        Check molecular ruler service health.                          │
│ molecules     List available molecules for VQE simulation.                   │
│ vqe           Run VQE for a molecule and get ground state energy.            │
│ correlations  Compute quantum correlation functions for a molecule.          │
│ ruler         Full molecular ruler measurement: VQE + correlations +         │
│               predictions.                                                   │
│ predict       Predict chemical properties from VQE results.                  │
│ compare       Compare correlation lengths across molecules.                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry compare [OPTIONS] [MOLECULES]

 Compare correlation lengths across molecules.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│   molecules      [MOLECULES]  Comma-separated molecule IDs                   │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry correlations [OPTIONS] [MOLECULE]

 Compute quantum correlation functions for a molecule.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│   molecule      [MOLECULE]  Molecule ID                                      │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --types  -t      TEXT  Correlation types: pair, spin_spin, density_density   │
│ --help                 Show this message and exit.                           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry health [OPTIONS]

 Check molecular ruler service health.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry molecules [OPTIONS]

 List available molecules for VQE simulation.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry predict [OPTIONS] [MOLECULE]

 Predict chemical properties from VQE results.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│   molecule      [MOLECULE]  Molecule ID                                      │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                 Show this message and exit.                           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry ruler [OPTIONS] [MOLECULE]

 Full molecular ruler measurement: VQE + correlations + predictions.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│   molecule      [MOLECULE]  Molecule ID                                      │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --run-vqe      --no-vqe      Run VQE first                                   │
│ --help                       Show this message and exit.                     │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos chemistry vqe [OPTIONS] [MOLECULE]

 Run VQE for a molecule and get ground state energy.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│   molecule      [MOLECULE]  Molecule ID (H2, LiH, H2O, etc.)                 │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help                         Show this message and exit.                   │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos circuits [OPTIONS] COMMAND [ARGS]...

 QCOS Circuits™ — Circuit management, optimization & simulation

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Commands ───────────────────────────────────────────────────────────────────╮
│ submit    Register a new circuit.                                            │
│ get       Get circuit details.                                               │
│ list      List all registered circuits.                                      │
│ delete    Delete a registered circuit.                                       │
│ validate  Validate circuit syntax without submitting.                        │
│ convert   Convert circuit between formats.                                   │
│ stats     Get circuit statistics (depth, gates, qubits).                     │
│ optimize  Optimize a circuit without executing it.                           │
│ simulate  Simulate a circuit on the HPC simulator.                           │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos circuits convert [OPTIONS]

 Convert circuit between formats.

╭─ Options ────────────────────────────────────────────────────────────────────╮
│ *  --circuit  -q      PATH  Path to QASM file                                │
│                             [required]                                       │
│    --to       -t      TEXT  Target format: qasm2, qasm3, qiskit              │
│    --output   -o      PATH  Save to file                                     │
│    --help                   Show this message and exit.                      │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos circuits delete [OPTIONS] CIRCUIT_ID

 Delete a registered circuit.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    circuit_id      TEXT  Circuit ID                                        │
│                            [required]                                        │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help          Show this message and exit.                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

Usage: softqcos circuits get [OPTIONS] CIRCUIT_ID

 Get circuit details.

╭─ Arguments ──────────────────────────────────────────────────────────────────╮
│ *    circuit_id      TEXT  Circuit ID                                        │
│                            [required]                                        │
╰──────────────────────────────────────────────────────────────────────────────╯
╭─ Options ────────────────────────────────────────────────────────────────────╮
│ --help            Show this message and exit.                                │
╰──────────────────────────────────────────────────────────────────────────────╯