0sec-cli 0.17.0 → 0.21.4

package/chunks/{chunk-2SANI5RH.js → chunk-BACXRTQ4.js}

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
-import { createRequire as __0secCreateRequire } from "node:module";
-const require = __0secCreateRequire(import.meta.url);
+import { createRequire as __0CreateRequire } from "node:module";
+const require = __0CreateRequire(import.meta.url);
 import {
   VERSION,
-  homeStateDir
-} from "./chunk-KKGE5RQE.js";
+  cloudStateDir
+} from "./chunk-PC6RCKQV.js";
 
 // packages/core/dist/agent/feature-presets.js
 var FP_MOAT_FLAGS = [
-  "0SEC_FEATURE_REACHABILITY_GATE",
-  "0SEC_FEATURE_MULTIMODAL",
-  "0SEC_FEATURE_PUBLISHABILITY_GATE",
-  "0SEC_FEATURE_POV_GATE",
-  "0SEC_FEATURE_POC_GEN_STATIC",
-  "0SEC_FEATURE_CONSENSUS_VERIFY"
+  "ZERO_FEATURE_REACHABILITY_GATE",
+  "ZERO_FEATURE_MULTIMODAL",
+  "ZERO_FEATURE_PUBLISHABILITY_GATE",
+  "ZERO_FEATURE_POV_GATE",
+  "ZERO_FEATURE_POC_GEN_STATIC",
+  "ZERO_FEATURE_CONSENSUS_VERIFY"
 ];
 var FEATURE_PRESETS = Object.freeze({
   "fp-moat": FP_MOAT_FLAGS
@@ -41,7 +41,7 @@ function applyFeaturePreset(preset, env2 = process.env) {
   return { preset, applied, preserved };
 }
 function applyFeaturePresetFromEnv(env2 = process.env) {
-  const raw = env2["0SEC_FEATURE_PRESET"];
+  const raw = env2["ZERO_FEATURE_PRESET"];
   if (!raw)
     return void 0;
   const preset = resolveFeaturePreset(raw);
@@ -63,73 +63,73 @@ var features = {
    *
    * Turn count is also a cost PROXY, and cost is already bounded directly by
    * the token budget, so this never was the control that kept spend in check.
-   * Enable with `0SEC_FEATURE_EARLY_STOP=1` for benchmark or A/B runs where a
+   * Enable with `ZERO_FEATURE_EARLY_STOP=1` for benchmark or A/B runs where a
    * fixed turn budget per attempt is the point.
    */
   get earlyStopRetry() {
-    return env("0SEC_FEATURE_EARLY_STOP", false);
+    return env("ZERO_FEATURE_EARLY_STOP", false);
   },
   /** Detect A-A-A and A-B-A-B loop patterns, inject warning */
   get loopDetection() {
-    return env("0SEC_FEATURE_LOOP_DETECTION", true);
+    return env("ZERO_FEATURE_LOOP_DETECTION", true);
   },
   /** Compress middle messages when context exceeds 30k tokens */
   get contextCompaction() {
-    return env("0SEC_FEATURE_CONTEXT_COMPACTION", true);
+    return env("ZERO_FEATURE_CONTEXT_COMPACTION", true);
   },
   /**
    * Re-send the opaque, model-bound Responses output item array on the next
    * turn. Default ON; set to 0 only for matched retained-reasoning A/B runs.
    */
   get retainedReasoning() {
-    return env("0SEC_FEATURE_RETAINED_REASONING", true);
+    return env("ZERO_FEATURE_RETAINED_REASONING", true);
   },
   /** Exploit script templates in shell prompt (blind SQLi, SSTI, auth chain) */
   get scriptTemplates() {
-    return env("0SEC_FEATURE_SCRIPT_TEMPLATES", true);
+    return env("ZERO_FEATURE_SCRIPT_TEMPLATES", true);
   },
   /** Dynamic vulnerability playbooks injected after recon phase */
   get dynamicPlaybooks() {
-    return env("0SEC_FEATURE_DYNAMIC_PLAYBOOKS", false);
+    return env("ZERO_FEATURE_DYNAMIC_PLAYBOOKS", false);
   },
   /** Just-in-time atomic DO/DON'T rules injected on a matching tool action */
   get ruleInjection() {
-    return env("0SEC_FEATURE_RULE_INJECTION", false);
+    return env("ZERO_FEATURE_RULE_INJECTION", false);
   },
   /** Agent writes plan/creds to disk, injected at reflection checkpoints */
   get externalMemory() {
-    return env("0SEC_FEATURE_EXTERNAL_MEMORY", false);
+    return env("ZERO_FEATURE_EXTERNAL_MEMORY", false);
   },
   /** Inject prior attempt findings when retrying (LLM-summarized progress handoff) */
   get progressHandoff() {
-    return env("0SEC_FEATURE_PROGRESS_HANDOFF", true);
+    return env("ZERO_FEATURE_PROGRESS_HANDOFF", true);
   },
   /** Allow the agent to search the web for CVE details, docs, and technique references */
   get webSearch() {
-    return env("0SEC_FEATURE_WEB_SEARCH", false);
+    return env("ZERO_FEATURE_WEB_SEARCH", false);
   },
   /** Interactive PTY sessions for exploits requiring interactivity (reverse shells, DB clients, SSH) */
   get ptySession() {
-    return env("0SEC_FEATURE_PTY_SESSION", false);
+    return env("ZERO_FEATURE_PTY_SESSION", false);
   },
   /**
    * Persistent, COMPUTE-ONLY Python REPL (`python_exec`, Phase-0). A framed
    * python3 kernel keeps state across calls for payload/parse/crypto/encode
    * work; networking is blocked at the socket source whenever an engagement is
-   * active. Default OFF — opt in via 0SEC_FEATURE_PYTHON_EXEC=1. Getter so
+   * active. Default OFF — opt in via ZERO_FEATURE_PYTHON_EXEC=1. Getter so
    * the CLI `--features` flag (set after this module is imported) is honored at
    * tool-dispatch time.
    */
   get pythonExec() {
-    return env("0SEC_FEATURE_PYTHON_EXEC", false);
+    return env("ZERO_FEATURE_PYTHON_EXEC", false);
   },
   /**
    * Expose the path-confined `analyze_binary` bridge to 0verse. Default OFF:
    * a model may request a long-running binary analysis only after an operator
-   * opts in with 0SEC_FEATURE_ZEROVERSE=1.
+   * opts in with ZERO_FEATURE_ZEROVERSE=1.
    */
   get zeroverse() {
-    return env("0SEC_FEATURE_ZEROVERSE", false);
+    return env("ZERO_FEATURE_ZEROVERSE", false);
   },
   /**
    * EGATS specialist routing (#557, HPTSA-inspired). When ON, an EGATS branch
@@ -146,22 +146,22 @@ var features = {
    * benchmark harness. Implemented as a getter so the CLI `--features` flag
    * (which sets the env var inside the command action, AFTER this module has
    * been imported) is honored at routing time. Enable via
-   * 0SEC_FEATURE_SPECIALIST_ROUTING=1.
+   * ZERO_FEATURE_SPECIALIST_ROUTING=1.
    */
   get specialistRouting() {
-    return env("0SEC_FEATURE_SPECIALIST_ROUTING", false);
+    return env("ZERO_FEATURE_SPECIALIST_ROUTING", false);
   },
   /** Self-consistency voting: run the structured verify pipeline N times and take the majority vote */
   get selfConsistencyVerify() {
-    return env("0SEC_FEATURE_CONSENSUS_VERIFY", false);
+    return env("ZERO_FEATURE_CONSENSUS_VERIFY", false);
   },
   /** Multi-modal agreement: cross-validate findings against foxguard (Rust pattern scanner) */
   get multiModalAgreement() {
-    return env("0SEC_FEATURE_MULTIMODAL", false);
+    return env("ZERO_FEATURE_MULTIMODAL", false);
   },
   /** Reachability gate: suppress findings whose sink is not reachable from an application entry point */
   get reachabilityGate() {
-    return env("0SEC_FEATURE_REACHABILITY_GATE", false);
+    return env("ZERO_FEATURE_REACHABILITY_GATE", false);
   },
   /**
    * Publishability / in-scope gate (issue #537 / #539). Decides
@@ -173,14 +173,14 @@ var features = {
    *
    * Default OFF: this gate can suppress reproducible findings, so it must be
    * explicitly opted into before any A/B claim. Disable/enable via
-   * 0SEC_FEATURE_PUBLISHABILITY_GATE.
+   * ZERO_FEATURE_PUBLISHABILITY_GATE.
    */
   get publishabilityGate() {
-    return env("0SEC_FEATURE_PUBLISHABILITY_GATE", false);
+    return env("ZERO_FEATURE_PUBLISHABILITY_GATE", false);
   },
   /** PoV gate: require a working, executable PoC per finding or downgrade to info */
   get povGate() {
-    return env("0SEC_FEATURE_POV_GATE", false);
+    return env("ZERO_FEATURE_POV_GATE", false);
   },
   /**
    * Intra-scan semantic dedupe post-pass (anchored incremental LLM
@@ -188,10 +188,10 @@ var features = {
    * Marks duplicates with a canonical mapping + cluster reason instead of
    * dropping them. Default OFF: it spends an LLM call per ≤50-finding batch
    * after the scan, so it must be explicitly opted into before any A/B
-   * claim. Toggle via 0SEC_FEATURE_SEMANTIC_DEDUPE.
+   * claim. Toggle via ZERO_FEATURE_SEMANTIC_DEDUPE.
    */
   get semanticDedupe() {
-    return env("0SEC_FEATURE_SEMANTIC_DEDUPE", false);
+    return env("ZERO_FEATURE_SEMANTIC_DEDUPE", false);
   },
   /**
    * Finding-specific remediation written by the model
@@ -207,33 +207,17 @@ var features = {
    * degrade cost, never correctness.
    */
   get llmRemediation() {
-    return env("0SEC_FEATURE_LLM_REMEDIATION", false);
-  },
-  /**
-   * Per-finding impact assessment (`assessImpact`, `triage/impact-assessment.ts`)
-   * written by the model: reachability tier, weaponizability, blast radius,
-   * business-impact tier. Default OFF — one extra LLM call per non-false-positive
-   * finding at report time.
-   *
-   * When on, the assessment feeds three things it is otherwise absent from:
-   * a real CVSS exploitability vector (AV/PR/UI from the reachability tier
-   * rather than the AV:N/severity-floor guess), the advisory's Impact +
-   * attack-prerequisites section, and the vendor-notification impact line. When
-   * off, all three fall back to today's category/severity heuristics — so this
-   * flag strictly adds fidelity, never changes the no-assessment output.
-   */
-  get impactAssessment() {
-    return env("0SEC_FEATURE_IMPACT_ASSESSMENT", false);
+    return env("ZERO_FEATURE_LLM_REMEDIATION", false);
   },
   /**
    * Incremental finding ranking post-pass (decimal-insertion between ranked
    * anchors, `triage/incremental-rank.ts`). Orders the report by comparative
    * promise (exploitability × impact × evidence strength). Default OFF: it
    * spends an LLM call per ≤50-finding batch; opt in before any A/B claim.
-   * Toggle via 0SEC_FEATURE_INCREMENTAL_RANK.
+   * Toggle via ZERO_FEATURE_INCREMENTAL_RANK.
    */
   get incrementalRank() {
-    return env("0SEC_FEATURE_INCREMENTAL_RANK", false);
+    return env("ZERO_FEATURE_INCREMENTAL_RANK", false);
   },
   /**
    * Static-finding PoC generation (#666 / EPIC #674 Part A). For findings that
@@ -247,10 +231,10 @@ var features = {
    *
    * Default OFF: it spends LLM + execution budget per static finding and must
    * be explicitly opted into before any A/B claim (A/B-able via the #656
-   * harness). Toggle via 0SEC_FEATURE_POC_GEN_STATIC.
+   * harness). Toggle via ZERO_FEATURE_POC_GEN_STATIC.
    */
   get pocGenStatic() {
-    return env("0SEC_FEATURE_POC_GEN_STATIC", false);
+    return env("ZERO_FEATURE_POC_GEN_STATIC", false);
   },
   /**
    * Inline validation / validate-on-save (#554). When ON, the native attack
@@ -268,10 +252,10 @@ var features = {
    * cost_per_flag claim. Implemented as a getter so the CLI `--features` flag
    * (which sets the env var inside the command action, AFTER this module is
    * imported) is honored at loop time. Enable via
-   * 0SEC_FEATURE_INLINE_VALIDATION=1.
+   * ZERO_FEATURE_INLINE_VALIDATION=1.
    */
   get inlineValidation() {
-    return env("0SEC_FEATURE_INLINE_VALIDATION", false);
+    return env("ZERO_FEATURE_INLINE_VALIDATION", false);
   },
   /**
    * WordPress plugin/theme fingerprinter + OSV CVE lookup.
@@ -286,7 +270,7 @@ var features = {
    * still honored at tool-dispatch time.
    */
   get wpFingerprint() {
-    return env("0SEC_FEATURE_WP_FINGERPRINT", true);
+    return env("ZERO_FEATURE_WP_FINGERPRINT", true);
   },
   /**
    * MongoDB ObjectID forge tool. Exposes the `mongo_objectid` tool to the
@@ -296,23 +280,23 @@ var features = {
    *
    * Default ON — this is a pure-computation utility with no network or
    * filesystem side effects, so there's no reason to gate it off. Disable
-   * via 0SEC_FEATURE_MONGO_OBJECTID_FORGE=0 or `--no-mongo-objectid-forge`
+   * via ZERO_FEATURE_MONGO_OBJECTID_FORGE=0 or `--no-mongo-objectid-forge`
    * for ablation. Implemented as a getter so the CLI `--features` flag
    * (which sets the env var inside the command action, AFTER this module
    * has been imported) is still honored at tool-dispatch time. Matches
    * the wpFingerprint pattern above. See packages/core/src/agent/objectid-forge.ts.
    */
   get mongoObjectIdForge() {
-    return env("0SEC_FEATURE_MONGO_OBJECTID_FORGE", true);
+    return env("ZERO_FEATURE_MONGO_OBJECTID_FORGE", true);
   },
   /**
-   * Live cloud-surface testing (0sec#925). Exposes `cloud_s3_probe` and
+   * Live cloud-surface testing (0#925). Exposes `cloud_s3_probe` and
    * `cloud_validate_credentials` to the attack agent so it can test S3 buckets
    * for public access + orphaned-bucket takeover and safely validate harvested
    * AWS credentials (read-only). All probes are anonymous or read/verify-only —
    * no writes, no data exfiltration beyond minimal proof.
    *
-   * Default OFF (opt-in via 0SEC_FEATURE_CLOUD_SURFACE=1). Probing a target
+   * Default OFF (opt-in via ZERO_FEATURE_CLOUD_SURFACE=1). Probing a target
    * org's bucket-name space or validating its harvested credentials is recon
    * AGAINST THAT ORG, so it is deny-by-default at two layers: this enablement
    * flag, AND an engagement-scope check in the tool handlers (a configured
@@ -323,7 +307,7 @@ var features = {
    * mongoObjectIdForge pattern above. See packages/core/src/agent/cloud-surface.ts.
    */
   get cloudSurface() {
-    return env("0SEC_FEATURE_CLOUD_SURFACE", false);
+    return env("ZERO_FEATURE_CLOUD_SURFACE", false);
   },
   /**
    * #978 (ADR-060) — agent fan-out. When ON, the agent gets the `start_scan`
@@ -331,11 +315,11 @@ var features = {
    * that run independently and report up the scan tree — the recursive
    * sub-agent orchestration. Default OFF: fan-out multiplies scans/cost, so it
    * stays opt-in even though the orchestrator enforces budget + a tree-level
-   * cap (max children/depth). Enable with 0SEC_FEATURE_AGENT_FANOUT=1.
+   * cap (max children/depth). Enable with ZERO_FEATURE_AGENT_FANOUT=1.
    * Getter so the CLI `--features` flag is honored at dispatch time.
    */
   get agentFanout() {
-    return env("0SEC_FEATURE_AGENT_FANOUT", false);
+    return env("ZERO_FEATURE_AGENT_FANOUT", false);
   },
   // ── Phase-2 offensive-engine feature flags (dev-live-engine-recovery) ──
   // Each gates a tool that RUNS/BUILDS untrusted code or WEAPONIZES. They are
@@ -347,21 +331,21 @@ var features = {
   /**
    * `memsafety_fuzz` — clones/builds/fuzzes a source tree (sanitizer builds +
    * a fuzz harness), executing attacker-adjacent build scripts and native
-   * fuzz targets. Default OFF; opt in via 0SEC_FEATURE_MEMSAFETY=1. Building
+   * fuzz targets. Default OFF; opt in via ZERO_FEATURE_MEMSAFETY=1. Building
    * and running an untrusted tree is code execution, so it is deny-by-default
    * behind this flag AND an engagement scope.
    */
   get memsafetyFuzz() {
-    return env("0SEC_FEATURE_MEMSAFETY", false);
+    return env("ZERO_FEATURE_MEMSAFETY", false);
   },
   /**
    * `npm_dynamic_discovery` — installs and RUNS untrusted npm packages under
    * instrumentation to observe malicious install/runtime behaviour. Executing
    * arbitrary package code is the whole point, so it is deny-by-default behind
-   * this flag AND an engagement scope. Opt in via 0SEC_FEATURE_NPM_DISCOVERY=1.
+   * this flag AND an engagement scope. Opt in via ZERO_FEATURE_NPM_DISCOVERY=1.
    */
   get npmDynamicDiscovery() {
-    return env("0SEC_FEATURE_NPM_DISCOVERY", false);
+    return env("ZERO_FEATURE_NPM_DISCOVERY", false);
   },
   /**
    * `weaponize_kernel` — the kernel-exploit weaponization ladder. It only ever
@@ -369,19 +353,19 @@ var features = {
    * present. Highest-caution capability: deny-by-default behind this flag AND
    * an engagement scope AND a runtime artifact-presence check (the handler
    * refuses when the kernel-VM assets are absent). Opt in via
-   * 0SEC_FEATURE_KERNEL_WEAPONIZE=1.
+   * ZERO_FEATURE_KERNEL_WEAPONIZE=1.
    */
   get kernelWeaponize() {
-    return env("0SEC_FEATURE_KERNEL_WEAPONIZE", false);
+    return env("ZERO_FEATURE_KERNEL_WEAPONIZE", false);
   },
   /**
    * `cve_adapt` — adapts a public CVE PoC to the target and RUNS it to confirm
    * exploitability. Running an adapted exploit is code execution against the
    * target, so it is deny-by-default behind this flag AND an engagement scope.
-   * Opt in via 0SEC_FEATURE_CVE_ADAPT=1.
+   * Opt in via ZERO_FEATURE_CVE_ADAPT=1.
    */
   get cveAdapt() {
-    return env("0SEC_FEATURE_CVE_ADAPT", false);
+    return env("ZERO_FEATURE_CVE_ADAPT", false);
   },
   /**
    * Anti-honeypot flag-shape validator. When the agent calls the `done`
@@ -392,7 +376,7 @@ var features = {
    *
    * Default ON because legitimate flags pass the shape check trivially
    * and the false-positive rate on real flags should be near zero. Turn
-   * off via `0SEC_FEATURE_DECOY_DETECTION=0` or the CLI flag
+   * off via `ZERO_FEATURE_DECOY_DETECTION=0` or the CLI flag
    * `--no-decoy-detection` for ablation/testing.
    *
    * Implemented as a getter so the CLI flag (which flips the env var
@@ -402,7 +386,7 @@ var features = {
    * packages/core/src/agent/flag-validator.ts.
    */
   get decoyDetection() {
-    return env("0SEC_FEATURE_DECOY_DETECTION", true);
+    return env("ZERO_FEATURE_DECOY_DETECTION", true);
   },
   // ── Always-on triage filters (default ON, ablatable for A/B testing) ──
   /**
@@ -411,13 +395,13 @@ var features = {
    * sink names and rejects findings that look like "the function did its job".
    *
    * Default ON because that's the existing v0.6.0 behavior. Can be disabled
-   * via 0SEC_FEATURE_HOLDING_IT_WRONG=0 to test whether this filter is
+   * via ZERO_FEATURE_HOLDING_IT_WRONG=0 to test whether this filter is
    * suppressing real signal — the ceiling-analysis from 2026-04-06 identified
    * this as the strongest candidate for the unexplained XBOW finding-density
    * collapse from 14 → 4 between `features=none` and `features=all`.
    */
   get holdingItWrong() {
-    return env("0SEC_FEATURE_HOLDING_IT_WRONG", true);
+    return env("ZERO_FEATURE_HOLDING_IT_WRONG", true);
   },
   /**
    * `evidence_completeness <= 0.5` reject (`packages/core/src/agentic-scanner.ts:591`).
@@ -425,10 +409,10 @@ var features = {
    * gather enough cross-source evidence (request + response + analysis + ...).
    *
    * Default ON because that's the existing v0.6.0 behavior. Can be disabled
-   * via 0SEC_FEATURE_EVIDENCE_GATE=0 for ablation.
+   * via ZERO_FEATURE_EVIDENCE_GATE=0 for ablation.
    */
   get evidenceGate() {
-    return env("0SEC_FEATURE_EVIDENCE_GATE", true);
+    return env("ZERO_FEATURE_EVIDENCE_GATE", true);
   },
   /**
    * Learned per-finding triage router (`packages/core/src/triage/learned-router.ts`).
@@ -439,17 +423,17 @@ var features = {
    * the scan's slice type (xbow-wb, xbow-bb, npm).
    *
    * Default OFF until the router is validated via A/B testing on xbow-bench
-   * and npm-bench. See 0sec#113 for the design doc.
+   * and npm-bench. See 0#113 for the design doc.
    */
   get learnedRouter() {
-    return env("0SEC_FEATURE_LEARNED_ROUTER", false);
+    return env("ZERO_FEATURE_LEARNED_ROUTER", false);
   },
   /**
    * Dynamic per-finding triage routing (`packages/core/src/triage/router/`).
    * When enabled, every finding is sent through a `RouterModel` that
    * decides which subset of the 11 triage layers to invoke for that
    * specific finding. v0 ships an explicit-rule router encoded from the
-   * 0sec#72 per-profile ablation; a learned classifier replaces the
+   * 0#72 per-profile ablation; a learned classifier replaces the
    * rules in a follow-up PR without touching the dispatch site.
    *
    * Distinct from `learnedRouter` above: `learnedRouter` is the XGBoost
@@ -458,25 +442,25 @@ var features = {
    * the dispatch router gates which layers run AFTER the TP/FP score
    * model has spoken.
    *
-   * Default OFF — opt in via 0SEC_FEATURE_DYNAMIC_TRIAGE=1. See
-   * 0sec#113 for the design doc and 0sec#67 for the joint paper plan.
+   * Default OFF — opt in via ZERO_FEATURE_DYNAMIC_TRIAGE=1. See
+   * 0#113 for the design doc and 0#67 for the joint paper plan.
    */
   get dynamicTriageRouting() {
-    return env("0SEC_FEATURE_DYNAMIC_TRIAGE", false);
+    return env("ZERO_FEATURE_DYNAMIC_TRIAGE", false);
   },
   /**
    * Opt-in cloud-sink webhook integration (`packages/core/src/cloud-sink.ts`).
-   * When enabled AND the user has set 0SEC_CLOUD_SINK + 0SEC_CLOUD_SCAN_ID,
+   * When enabled AND the user has set ZERO_CLOUD_SINK + ZERO_CLOUD_SCAN_ID,
    * every finding and the final scan report are POSTed to the configured
    * remote endpoint in real time.
    *
    * Default ON so the env-var trio is sufficient to enable streaming, but the
    * flag exists so operators can force-disable the integration in environments
    * where outbound HTTP from the scanner is not desired (e.g. air-gapped CI).
-   * Disable via 0SEC_FEATURE_CLOUD_SINK=0.
+   * Disable via ZERO_FEATURE_CLOUD_SINK=0.
    */
   get cloudSink() {
-    return env("0SEC_FEATURE_CLOUD_SINK", true);
+    return env("ZERO_FEATURE_CLOUD_SINK", true);
   },
   /**
    * Pre-recon CVE check (`packages/core/src/pre-recon-cve.ts`).
@@ -487,10 +471,10 @@ var features = {
    * where the agent has source access but no concrete leads.
    *
    * Default ON in white-box mode (no-op in black-box). Disable via
-   * 0SEC_FEATURE_PRE_RECON_CVE=0 for ablation.
+   * ZERO_FEATURE_PRE_RECON_CVE=0 for ablation.
    */
   get preReconCve() {
-    return env("0SEC_FEATURE_PRE_RECON_CVE", true);
+    return env("ZERO_FEATURE_PRE_RECON_CVE", true);
   },
   /**
    * Deterministic web-recon pre-pass (`packages/core/src/stages/web-recon-prepass.ts`).
@@ -501,25 +485,25 @@ var features = {
    * checks. It EMITS findings directly for what it can prove and injects a
    * "pursue these leads" block into the system prompt for what it can only hint.
    *
-   * Default ON (no-op in non-web modes). Gated behind 0SEC_FEATURE_WEB_RECON
+   * Default ON (no-op in non-web modes). Gated behind ZERO_FEATURE_WEB_RECON
    * so it can be disabled for ablation or offline runs. Implemented as a getter
    * so the CLI `--features` flag (which sets the env var inside the command
    * action, AFTER this module has been imported) is honored at stage time.
    */
   get webRecon() {
-    return env("0SEC_FEATURE_WEB_RECON", true);
+    return env("ZERO_FEATURE_WEB_RECON", true);
   },
   /**
    * Best-effort target-history preflight for source review. When a local repo
-   * path is known, 0sec infers repository/package/product hints, queries live
+   * path is known, 0 infers repository/package/product hints, queries live
    * prior-vulnerability intel, and injects a compact audit-graph summary into
    * the review prompt before the agent starts.
    *
    * Default ON for white-box/source-review modes. Disable via
-   * 0SEC_FEATURE_TARGET_HISTORY_PRESEED=0 for offline or ablation runs.
+   * ZERO_FEATURE_TARGET_HISTORY_PRESEED=0 for offline or ablation runs.
    */
   get targetHistoryPreseed() {
-    return env("0SEC_FEATURE_TARGET_HISTORY_PRESEED", true);
+    return env("ZERO_FEATURE_TARGET_HISTORY_PRESEED", true);
   },
   /**
    * Preserve credential / exploit-bearing messages verbatim during
@@ -534,15 +518,15 @@ var features = {
    * (a handful of extra messages preserved verbatim in the user
    * compaction-summary block) is small. BoxPwnr-inspired: see
    * `src/boxpwnr/solvers/single_loop_compactation.py` in 0ca/BoxPwnr,
-   * and 0sec#229 for the design discussion.
+   * and 0#229 for the design discussion.
    *
    * Implemented as a getter so the CLI `--features` flag — which sets
    * the env var inside the command action AFTER this module is imported
    * — is still honored at compaction time. Disable via
-   * 0SEC_FEATURE_PRESERVE_CRITICAL_MESSAGES=0 for ablation.
+   * ZERO_FEATURE_PRESERVE_CRITICAL_MESSAGES=0 for ablation.
    */
   get preserveCriticalMessages() {
-    return env("0SEC_FEATURE_PRESERVE_CRITICAL_MESSAGES", true);
+    return env("ZERO_FEATURE_PRESERVE_CRITICAL_MESSAGES", true);
   },
   /**
    * Two-stage budget-warning injection in the agent loop (#408).
@@ -558,14 +542,14 @@ var features = {
    * single short user-message injection at two specific turn boundaries,
    * and the win on long benchmarks (clean handoff instead of stray
    * exploration on the last turn) is well-documented in Strix's
-   * implementation. Disable via 0SEC_FEATURE_BUDGET_WARNINGS=0 for
+   * implementation. Disable via ZERO_FEATURE_BUDGET_WARNINGS=0 for
    * ablation. Implemented as a getter so the CLI `--features` flag —
    * which sets the env var inside the command action AFTER this module
    * is imported — is still honored at injection time (matches the
    * wpFingerprint / preserveCriticalMessages pattern).
    */
   get budgetWarnings() {
-    return env("0SEC_FEATURE_BUDGET_WARNINGS", true);
+    return env("ZERO_FEATURE_BUDGET_WARNINGS", true);
   },
   /**
    * Per-file orchestration for the research and audit stages (#285).
@@ -579,14 +563,14 @@ var features = {
    * Trade-off: total token spend grows roughly N × per-file budget instead
    * of capped at a single session's budget. For a 50-file package, that
    * could be a 5-10× cost increase on research. Disable via
-   * `0SEC_FEATURE_PER_ITEM_ORCHESTRATION=0` to revert to the shared-session
+   * `ZERO_FEATURE_PER_ITEM_ORCHESTRATION=0` to revert to the shared-session
    * behavior — useful for cost-bounded benchmarks.
    *
    * Implemented as a getter so the env var is honored at orchestration time
    * (matches the wpFingerprint / mongoObjectIdForge pattern).
    */
   get perItemOrchestration() {
-    return env("0SEC_FEATURE_PER_ITEM_ORCHESTRATION", true);
+    return env("ZERO_FEATURE_PER_ITEM_ORCHESTRATION", true);
   },
   /**
    * JIT skill loading (`packages/core/src/agent/skills/`).
@@ -595,20 +579,21 @@ var features = {
    * them into working context mid-scan. Skills replace the monolithic
    * playbook injection with targeted, on-demand knowledge (#410, #457).
    *
-   * Default OFF until the skill registry is validated via A/B testing.
+   * Default OFF unless an assigned cloud methodology manifest opts this run in.
+   * An explicit feature flag still takes precedence over that default.
    * Implemented as a getter so the CLI `--features` flag — which sets
    * the env var inside the command action, AFTER this module has been
    * imported — is still honored at tool-dispatch time.
    */
   get jitSkills() {
-    return env("0SEC_FEATURE_JIT_SKILLS", false);
+    return env("ZERO_FEATURE_JIT_SKILLS", Boolean(process.env["ZERO_AUDIT_SKILLS_MANIFEST"]?.trim()));
   },
   /**
    * Execution-journal shadow mode (#494, first additive slice).
    *
    * When ON, the live agent loop ALSO writes append-only journal entries
    * (`tool_call`, `tool_result`, `finding`, `done`) to
-   * `~/.0sec/runs/<scanId>/journal.jsonl` as it runs — a durable,
+   * `~/.0/runs/<scanId>/journal.jsonl` as it runs — a durable,
    * replayable trace alongside the existing in-memory conversation window.
    * This is strictly additive: the loop continues to drive off its own
    * conversation state, the journal is write-only here, and a failed
@@ -621,11 +606,11 @@ var features = {
    * moat-ablation harness before any A/B claim. Implemented as a getter so
    * the CLI `--features` flag (which sets the env var inside the command
    * action, AFTER this module has been imported) is honored at loop time.
-   * Enable via 0SEC_FEATURE_EXECUTION_JOURNAL=1 or `--features
+   * Enable via ZERO_FEATURE_EXECUTION_JOURNAL=1 or `--features
    * execution-journal`.
    */
   get executionJournal() {
-    return env("0SEC_FEATURE_EXECUTION_JOURNAL", false);
+    return env("ZERO_FEATURE_EXECUTION_JOURNAL", false);
   },
   /**
    * Execution-journal context routing (#494, slice 2).
@@ -641,7 +626,7 @@ var features = {
    * Independent of `executionJournal` (the shadow-WRITE flag) on purpose so
    * the moat-ablation harness can toggle write and route separately for a
    * clean A/B. Rehydrate is a READER, though, so it only does anything when
-   * a journal was written for the run — it reads `~/.0sec/runs/<scanId>/
+   * a journal was written for the run — it reads `~/.0/runs/<scanId>/
    * journal.jsonl` regardless of how it got there (shadow mode this slice,
    * or specialists in a later slice). When the journal is missing, empty, or
    * corrupt the loop falls back to the existing DB-blob / fresh-prompt
@@ -654,11 +639,11 @@ var features = {
    * must be explicitly opted into before any A/B claim. Implemented as a
    * getter so the CLI `--features` flag (which sets the env var inside the
    * command action, AFTER this module has been imported) is honored at loop
-   * time. Enable via 0SEC_FEATURE_JOURNAL_REHYDRATE=1 or `--features
+   * time. Enable via ZERO_FEATURE_JOURNAL_REHYDRATE=1 or `--features
    * journal-rehydrate`.
    */
   get journalRehydrate() {
-    return env("0SEC_FEATURE_JOURNAL_REHYDRATE", false);
+    return env("ZERO_FEATURE_JOURNAL_REHYDRATE", false);
   },
   /**
    * Loot / foothold ledger for opportunistic exploit chaining (#567).
@@ -678,14 +663,14 @@ var features = {
    * tool), matches the `preserveCriticalMessages` rationale — recovering a
    * credential in turn 12 that's needed in turn 38 is a large win on long-tail
    * challenges — and the cost (a short, size-capped block per turn) is small.
-   * Disable via 0SEC_FEATURE_LOOT_LEDGER=0 or `--no-loot-ledger` for
+   * Disable via ZERO_FEATURE_LOOT_LEDGER=0 or `--no-loot-ledger` for
    * ablation. Implemented as a getter so the CLI `--features` flag (which sets
    * the env var inside the command action, AFTER this module has been
    * imported) is honored at tool-dispatch / injection time — matches the
    * wpFingerprint / preserveCriticalMessages pattern.
    */
   get lootLedger() {
-    return env("0SEC_FEATURE_LOOT_LEDGER", true);
+    return env("ZERO_FEATURE_LOOT_LEDGER", true);
   },
   /**
    * Typed TODO / plan ledger (`packages/core/src/agent/task-ledger.ts`).
@@ -704,13 +689,13 @@ var features = {
    * failure mode of an unused tool is a few hundred wasted schema tokens
    * rather than wrong behavior. Note for whoever publishes benchmark numbers
    * next: this DOES change the default tool list, so re-baseline before
-   * quoting a figure across this change. Disable via 0SEC_FEATURE_AGENT_PLAN=0
+   * quoting a figure across this change. Disable via ZERO_FEATURE_AGENT_PLAN=0
    * or `--features no-agent-plan` for ablation. Getter so the CLI `--features`
    * flag (which sets the env var AFTER this module is imported) is honored at
    * tool-dispatch time.
    */
   get agentPlan() {
-    return env("0SEC_FEATURE_AGENT_PLAN", false);
+    return env("ZERO_FEATURE_AGENT_PLAN", false);
   },
   /**
    * Task-drift detection (`packages/core/src/agent/drift.ts`).
@@ -733,10 +718,10 @@ var features = {
    * to a newly-discovered lead is lexically indistinguishable from a derail.
    * Repo convention is explicit that behavior-steering features stay opt-in
    * until A/B'd, and this is squarely one. Enable via
-   * 0SEC_FEATURE_DRIFT_DETECTION=1 or `--features drift-detection`.
+   * ZERO_FEATURE_DRIFT_DETECTION=1 or `--features drift-detection`.
    */
   get driftDetection() {
-    return env("0SEC_FEATURE_DRIFT_DETECTION", false);
+    return env("ZERO_FEATURE_DRIFT_DETECTION", false);
   },
   /**
    * OAST out-of-band interaction collaborator + oracle (#659).
@@ -748,12 +733,12 @@ var features = {
    * evidence and feeds the loot ledger.
    *
    * Default OFF — the tools are inert without a deployed collaborator. Enable
-   * with 0SEC_FEATURE_OAST=1 AND point 0SEC_OAST_URL at the self-hosted
+   * with ZERO_FEATURE_OAST=1 AND point ZERO_OAST_URL at the self-hosted
    * collaborator server (see packages/core/src/oast/server.ts). Getter (not a
    * const) so the CLI `--features` flag is honored at tool-dispatch time.
    */
   get oastCollaborator() {
-    return env("0SEC_FEATURE_OAST", false);
+    return env("ZERO_FEATURE_OAST", false);
   },
   /**
    * Anthropic prompt caching (`cache_control: {type: "ephemeral"}`) over the
@@ -776,17 +761,17 @@ var features = {
    * never see an Anthropic-shaped field regardless of this flag (see
    * `providerSupportsPromptCache`).
    *
-   * Disable via 0SEC_FEATURE_PROMPT_CACHE=0 — worth doing only to isolate a
+   * Disable via ZERO_FEATURE_PROMPT_CACHE=0 — worth doing only to isolate a
    * suspected provider-side caching bug, or to measure the uncached baseline.
    * Implemented as a getter so a late env mutation (CLI `--features`, which
    * runs after this module is imported) is honoured at request-build time.
    */
   get promptCache() {
-    return env("0SEC_FEATURE_PROMPT_CACHE", true);
+    return env("ZERO_FEATURE_PROMPT_CACHE", true);
   }
 };
 function presetRaisesDefault(key) {
-  const raw = process.env["0SEC_FEATURE_PRESET"];
+  const raw = process.env["ZERO_FEATURE_PRESET"];
   if (!raw)
     return false;
   const preset = resolveFeaturePreset(raw);
@@ -884,7 +869,7 @@ function sanitizeFields(input) {
 var LEVEL_RANK = { info: 10, warn: 20, error: 30 };
 var OFF_RANK = Number.POSITIVE_INFINITY;
 function minimumRank() {
-  const raw = process.env["0SEC_DIAG_LEVEL"];
+  const raw = process.env["ZERO_DIAG_LEVEL"];
   if (!raw)
     return LEVEL_RANK.info;
   switch (raw.trim().toLowerCase()) {
@@ -904,9 +889,9 @@ function minimumRank() {
 function formatDiagnosticLine(event) {
   const keys = Object.keys(event.fields);
   if (keys.length === 0)
-    return `[0sec] ${event.message}`;
+    return `[0] ${event.message}`;
   const rendered = keys.map((k) => `${k}=${event.fields[k]}`).join(" ");
-  return `[0sec] ${event.message} (${rendered})`;
+  return `[0] ${event.message} (${rendered})`;
 }
 var stderrDiagnosticSink = {
   emit(event) {
@@ -1087,19 +1072,22 @@ function loadCloudCredentials(opts = {}) {
   const env2 = opts.env ?? process.env;
   const warn = opts.warn ?? ((m) => process.stderr.write(`${m}
 `));
-  const envTok = env2["0SEC_CLOUD_TOKEN"]?.trim();
+  const envTok = env2["ZERO_CLOUD_TOKEN"]?.trim() || env2["0SEC_CLOUD_TOKEN"]?.trim();
   if (envTok) {
-    const envHost = normaliseHost(env2["0SEC_CLOUD_HOST"]?.trim() ?? DEFAULT_CLOUD_HOST);
+    const envHost = normaliseHost(env2["ZERO_CLOUD_HOST"]?.trim() ?? env2["0SEC_CLOUD_HOST"]?.trim() ?? DEFAULT_CLOUD_HOST);
+    if (!env2["ZERO_CLOUD_TOKEN"]?.trim()) {
+      warn("[0 cloud] using legacy 0SEC_CLOUD_* credentials; re-run `0 auth login` to migrate to ZERO_CLOUD_*.");
+    }
     return { host: envHost, token: envTok, source: "env" };
   }
-  const path = join(homeStateDir(opts.homeDir), "cloud.env");
+  const path = join(cloudStateDir(opts.homeDir, env2), "cloud.env");
   let raw;
   try {
     raw = readFileSync(path, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
-      throw new CloudAuthMissingError(`0sec-cloud credentials not found. Run \`0sec auth login\` or set 0SEC_CLOUD_TOKEN in env, or create ${path} (chmod 600) with 0SEC_CLOUD_TOKEN=\u2026 (optionally 0SEC_CLOUD_HOST=\u2026).`);
+      throw new CloudAuthMissingError(`0-cloud credentials not found. Run \`${env2["ZERO_DEV_SOURCE_ROOT"]?.trim() ? "0dev" : "0"} auth login\`.`);
     }
     throw err;
   }
@@ -1107,22 +1095,25 @@ function loadCloudCredentials(opts = {}) {
     const st = statSync(path);
     const mode = st.mode & 511;
     if (mode !== 384) {
-      warn(`[0sec cloud] WARNING: ${path} mode is ${mode.toString(8).padStart(3, "0")} (expected 600). Run: chmod 600 ${path}`);
+      warn(`[0 cloud] WARNING: ${path} mode is ${mode.toString(8).padStart(3, "0")} (expected 600). Run: chmod 600 ${path}`);
     }
   } catch {
   }
   const parsed = parseEnvFile(raw);
-  const fileTok = parsed["0SEC_CLOUD_TOKEN"]?.trim();
+  const fileTok = parsed["ZERO_CLOUD_TOKEN"]?.trim() || parsed["0SEC_CLOUD_TOKEN"]?.trim();
   if (!fileTok) {
-    throw new CloudAuthMissingError(`0sec-cloud credentials in ${path} are incomplete: 0SEC_CLOUD_TOKEN is required.`);
+    throw new CloudAuthMissingError(`0-cloud credentials in ${path} are incomplete: ZERO_CLOUD_TOKEN is required.`);
+  }
+  if (!parsed["ZERO_CLOUD_TOKEN"]?.trim()) {
+    warn("[0 cloud] using legacy 0SEC_CLOUD_* credentials; re-run `0 auth login` to migrate to ZERO_CLOUD_*.");
   }
-  const fileHost = normaliseHost(parsed["0SEC_CLOUD_HOST"]?.trim() ?? DEFAULT_CLOUD_HOST);
+  const fileHost = normaliseHost(parsed["ZERO_CLOUD_HOST"]?.trim() ?? parsed["0SEC_CLOUD_HOST"]?.trim() ?? env2["ZERO_CLOUD_HOST"]?.trim() ?? env2["0SEC_CLOUD_HOST"]?.trim() ?? DEFAULT_CLOUD_HOST);
   return { host: fileHost, token: fileTok, source: "file" };
 }
 function normaliseHost(host) {
   let h = host;
   if (!/^https?:\/\//.test(h)) {
-    throw new CloudAuthMissingError(`0SEC_CLOUD_HOST must be an http(s) URL (got ${JSON.stringify(host)}).`);
+    throw new CloudAuthMissingError(`ZERO_CLOUD_HOST must be an http(s) URL (got ${JSON.stringify(host)}).`);
   }
   while (h.endsWith("/"))
     h = h.slice(0, -1);
@@ -1167,26 +1158,92 @@ var CloudError = class extends Error {
 };
 var CloudUnauthorizedError = class extends CloudError {
   constructor(path) {
-    super(`0sec-cloud auth rejected (HTTP 401) on ${path}. Run \`0sec auth login\` to refresh.`, 401, path);
+    super(`0-cloud auth rejected (HTTP 401) on ${path}. Run \`0 auth login\` to refresh.`, 401, path);
     this.name = "CloudUnauthorizedError";
   }
 };
 var CloudForbiddenError = class extends CloudError {
   constructor(path) {
-    super(`0sec-cloud forbidden (HTTP 403) on ${path}. Token lacks scope for this resource.`, 403, path);
+    super(`0-cloud forbidden (HTTP 403) on ${path}. Token lacks scope for this resource.`, 403, path);
     this.name = "CloudForbiddenError";
   }
 };
 var CloudNetworkError = class extends CloudError {
   constructor(message, path) {
-    super(`0sec-cloud network error on ${path}: ${message}`, void 0, path);
+    super(`0-cloud network error on ${path}: ${message}`, void 0, path);
     this.name = "CloudNetworkError";
   }
 };
+function isUsageAccount(raw) {
+  if (!raw || typeof raw !== "object")
+    return false;
+  const obj = raw;
+  if (obj.schemaVersion !== "usage-v2")
+    return false;
+  if (!isUtcDate(obj.snapshotAt))
+    return false;
+  if (!obj.scope || typeof obj.scope !== "object")
+    return false;
+  if (typeof obj.scope.orgId !== "string")
+    return false;
+  if (typeof obj.state !== "string")
+    return false;
+  if (!["ready", "disabled", "unavailable", "restricted"].includes(obj.state))
+    return false;
+  if (obj.reason !== null && typeof obj.reason !== "string")
+    return false;
+  const plan = obj.plan;
+  if (!plan || typeof plan !== "object")
+    return false;
+  if (typeof plan.id !== "string" && plan.id !== null)
+    return false;
+  if (plan.id !== null && !["pro", "gold", "enterprise"].includes(plan.id))
+    return false;
+  if (typeof plan.name !== "string" && plan.name !== null)
+    return false;
+  if (!isUsd(plan.monthlyPriceUsd))
+    return false;
+  const included = obj.included;
+  if (!included || typeof included !== "object")
+    return false;
+  if (typeof included.state !== "string")
+    return false;
+  if (!["active", "exhausted", "none", "unavailable"].includes(included.state))
+    return false;
+  if (included.usedPercent !== null && typeof included.usedPercent !== "number")
+    return false;
+  if (included.usedPercent !== null && (!Number.isFinite(included.usedPercent) || included.usedPercent < 0 || included.usedPercent > 100))
+    return false;
+  if (included.resetsAt !== null && !isUtcDate(included.resetsAt))
+    return false;
+  const prepaid = obj.prepaid;
+  if (!prepaid || typeof prepaid !== "object")
+    return false;
+  if (!isUsd(prepaid.balanceUsd))
+    return false;
+  if (typeof prepaid.fallbackEnabled !== "boolean")
+    return false;
+  if (typeof obj.canManageBilling !== "boolean")
+    return false;
+  const admission = obj.admission;
+  if (!admission || typeof admission !== "object")
+    return false;
+  if (typeof admission.eligible !== "boolean")
+    return false;
+  if (admission.reason !== null && typeof admission.reason !== "string")
+    return false;
+  return true;
+}
+function isUsd(value) {
+  return value === null || typeof value === "string" && /^\d+(?:\.\d{1,9})?$/.test(value);
+}
+function isUtcDate(value) {
+  return typeof value === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/.test(value) && Number.isFinite(Date.parse(value));
+}
 function healthPath(host) {
   try {
     const hostname = new URL(host).hostname.toLowerCase();
-    if (hostname === "cloud.0sec.ai" || hostname === "cloud.0.security") {
+    if (hostname === "cloud.0.ai" || hostname === "cloud.0.security") {
       return "/api/health";
     }
   } catch {
@@ -1219,25 +1276,46 @@ var CloudClient = class {
     return this.getJson("/api/inference/v1/models");
   }
   /**
-   * Fetch the organization's hosted inference credit availability. The service
-   * calculates the percentage from Autumn's current pool; holds reduce availability.
-   * Older gateways without percentage metadata remain explicitly unavailable.
+   * Fetch the organization's credit account — usage-v2 shape including
+   * plan, included allowance, prepaid balance, and admission status.
+   *
+   * Returns `null` when the response is a recognised HTTP 200 (customer is
+   * authenticated) but the payload is missing, legacy, or structurally
+   * unrecognised — not an auth failure. HTTP 401/403 still throw the
+   * existing typed errors so the caller can distinguish a credential
+   * problem from unsupported credit data.
+   *
+   * Monetary amounts are decimal strings (no Number coercion); the
+   * caller preserves them for exact display.
    */
   async getInferenceAccount() {
-    const account = await this.getJson("/api/inference/account");
-    const credits = account.credits;
-    if (!credits || typeof credits !== "object" || typeof credits.featureId !== "string" || !credits.featureId.trim() || typeof credits.remaining !== "number" || !Number.isFinite(credits.remaining) || credits.remaining < 0 || credits.granted !== null && (typeof credits.granted !== "number" || !Number.isFinite(credits.granted) || credits.granted < 0)) {
-      return { ...account, credits: null };
-    }
-    const remainingPercent = typeof credits.remainingPercent === "number" && Number.isFinite(credits.remainingPercent) && credits.remainingPercent >= 0 && credits.remainingPercent <= 100 && credits.granted !== null && credits.granted > 0 && credits.remaining <= credits.granted ? credits.remainingPercent : null;
-    const nextResetAt = typeof credits.nextResetAt === "number" && Number.isSafeInteger(credits.nextResetAt) && credits.nextResetAt > 0 && credits.nextResetAt <= 864e13 ? credits.nextResetAt : null;
-    return { ...account, credits: {
-      featureId: credits.featureId,
-      granted: credits.granted,
-      remaining: credits.remaining,
-      remainingPercent,
-      nextResetAt
-    } };
+    const raw = await this.getJson("/api/inference/account");
+    if (!isUsageAccount(raw))
+      return null;
+    const { plan, included, prepaid, admission } = raw;
+    return {
+      schemaVersion: raw.schemaVersion,
+      snapshotAt: raw.snapshotAt,
+      scope: { orgId: raw.scope.orgId },
+      state: raw.state,
+      reason: raw.reason,
+      plan: {
+        id: plan.id,
+        name: plan.name,
+        monthlyPriceUsd: plan.monthlyPriceUsd
+      },
+      included: {
+        state: included.state,
+        usedPercent: included.usedPercent,
+        resetsAt: included.resetsAt
+      },
+      prepaid: {
+        balanceUsd: prepaid.balanceUsd,
+        fallbackEnabled: prepaid.fallbackEnabled
+      },
+      canManageBilling: raw.canManageBilling,
+      admission: { eligible: admission.eligible, reason: admission.reason }
+    };
   }
   /**
    * Fetch request-level usage metadata for the operator's hosted
@@ -1247,6 +1325,114 @@ var CloudClient = class {
   async getInferenceUsage() {
     return this.getJson("/api/inference/usage");
   }
+  // ── Audit-skills helpers (#audit-skills) ──
+  /** List all audit skills for the authenticated organization. */
+  async listAuditSkills() {
+    return this.getJson("/api/audit-skills");
+  }
+  /**
+   * Get a single audit skill with its revision history and project
+   * assignments.
+   */
+  async getAuditSkill(id) {
+    return this.getJson(`/api/audit-skills/${encodeURIComponent(id)}`);
+  }
+  /** Create a new markdown-based audit skill. */
+  async createAuditSkill(input) {
+    return this.postJson("/api/audit-skills", input);
+  }
+  /** Import an audit skill from a GitHub repository. */
+  async importAuditSkillFromGithub(input) {
+    return this.postJson("/api/audit-skills/import", input);
+  }
+  /** Create a new revision of an audit skill (CAS — 409 on stale expectedRevision). */
+  async createAuditSkillRevision(id, input) {
+    return this.postJson(`/api/audit-skills/${encodeURIComponent(id)}/revisions`, input);
+  }
+  /** Re-fetch the skill from its original GitHub source. */
+  async syncAuditSkill(id, expectedRevision) {
+    return this.postJson(`/api/audit-skills/${encodeURIComponent(id)}/sync`, { expectedRevision });
+  }
+  /** Pin an audit skill revision to a project for future scans. */
+  async assignAuditSkill(id, projectId, revisionId) {
+    return this.postJson(`/api/audit-skills/${encodeURIComponent(id)}/projects/${encodeURIComponent(projectId)}`, { revisionId });
+  }
+  /** Unpin an audit skill from a project (future scans no longer use it). */
+  async unassignAuditSkill(id, projectId) {
+    return this.deleteJson(`/api/audit-skills/${encodeURIComponent(id)}/projects/${encodeURIComponent(projectId)}`);
+  }
+  /** Archive an audit skill (disables future bindings, preserves history). */
+  async archiveAuditSkill(id) {
+    await this.deleteJson(`/api/audit-skills/${encodeURIComponent(id)}`);
+  }
+  /**
+   * List audit skills available to a specific project, along with current
+   * assignments for that project. The project must belong to the caller's org.
+   */
+  async listAuditSkillsByProject(projectId) {
+    return this.getJson(`/api/audit-skills/by-project/${encodeURIComponent(projectId)}`);
+  }
+  /**
+   * Generic JSON DELETE helper with the same error mapping as getJson/postJson.
+   * Used by `0 service disconnect` to remove scan schedules.
+   */
+  async deleteJson(path) {
+    const url = `${this.host}${path}`;
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: "DELETE",
+        headers: { ...this.headers(), "Content-Type": "application/json" }
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new CloudNetworkError(this.scrub(msg), path);
+    }
+    if (!res.ok) {
+      let code;
+      try {
+        const parsed = await res.json();
+        const raw = typeof parsed?.error === "object" ? parsed.error?.code : void 0;
+        if (typeof raw === "string" && raw.length > 0)
+          code = raw;
+      } catch {
+      }
+      this.throwForStatus(res.status, path, code);
+    }
+    if (res.status === 204)
+      return void 0;
+    return await res.json();
+  }
+  /**
+   * Generic JSON POST helper with the same error mapping as getJson.
+   * Used by `0 connect` to enqueue scans and schedules.
+   */
+  async postJson(path, body) {
+    const url = `${this.host}${path}`;
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: "POST",
+        headers: { ...this.headers(), "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new CloudNetworkError(this.scrub(msg), path);
+    }
+    if (!res.ok) {
+      let code;
+      try {
+        const parsed = await res.json();
+        const raw = typeof parsed?.error === "object" ? parsed.error?.code : void 0;
+        if (typeof raw === "string" && raw.length > 0)
+          code = raw;
+      } catch {
+      }
+      this.throwForStatus(res.status, path, code);
+    }
+    return await res.json();
+  }
   /**
    * Generic JSON GET helper. Public so future modules (scans, findings)
    * can reuse the same error mapping without duplicating it. Not exported
@@ -1283,7 +1469,7 @@ var CloudClient = class {
       throw new CloudUnauthorizedError(path);
     if (status === 403)
       throw new CloudForbiddenError(path);
-    throw new CloudError(`0sec-cloud request failed (HTTP ${status}${code ? ` ${code}` : ""}) on ${path}.`, status, path, code);
+    throw new CloudError(`0-cloud request failed (HTTP ${status}${code ? ` ${code}` : ""}) on ${path}.`, status, path, code);
   }
   /**
    * Throw a typed error for non-2xx responses. Public so direct callers
@@ -1296,14 +1482,14 @@ var CloudClient = class {
       throw new CloudUnauthorizedError(path);
     if (res.status === 403)
       throw new CloudForbiddenError(path);
-    throw new CloudError(`0sec-cloud request failed (HTTP ${res.status}) on ${path}.`, res.status, path);
+    throw new CloudError(`0-cloud request failed (HTTP ${res.status}) on ${path}.`, res.status, path);
   }
   // ── internals ──
   headers() {
     return {
       Authorization: `Bearer ${this.token}`,
       Accept: "application/json",
-      "User-Agent": `0sec-cli/${VERSION}`
+      "User-Agent": `@0/cli/${VERSION}`
     };
   }
   /**
@@ -1325,6 +1511,54 @@ import { appendFileSync, existsSync, readFileSync as readFileSync2, renameSync,
 import { homedir } from "node:os";
 import { join as join2 } from "node:path";
 
+// packages/core/dist/runtime/hosted-request-queue.js
+var MAX_IN_FLIGHT = 4;
+var endpoints = /* @__PURE__ */ new Map();
+function acquireHostedRequestSlot(endpoint, token, signal) {
+  signal?.throwIfAborted();
+  let accounts = endpoints.get(endpoint);
+  if (!accounts)
+    endpoints.set(endpoint, accounts = /* @__PURE__ */ new Map());
+  let queue = accounts.get(token);
+  if (!queue)
+    accounts.set(token, queue = { active: 0, waiting: [] });
+  const accountQueues = accounts;
+  const current = queue;
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      const index = current.waiting.indexOf(waiter);
+      if (index !== -1)
+        current.waiting.splice(index, 1);
+      reject(signal.reason);
+    };
+    const waiter = { grant: () => {
+      signal?.removeEventListener("abort", abort);
+      current.active++;
+      let released = false;
+      resolve(() => {
+        if (released)
+          return;
+        released = true;
+        current.active--;
+        const next = current.waiting.shift();
+        if (next)
+          next.grant();
+        else if (current.active === 0) {
+          accountQueues.delete(token);
+          if (accountQueues.size === 0)
+            endpoints.delete(endpoint);
+        }
+      });
+    } };
+    if (current.active < MAX_IN_FLIGHT)
+      waiter.grant();
+    else {
+      current.waiting.push(waiter);
+      signal?.addEventListener("abort", abort, { once: true });
+    }
+  });
+}
+
 // packages/core/dist/runtime/prompt-cache.js
 var MAX_CACHE_BREAKPOINTS = 4;
 var MESSAGE_CACHE_BREAKPOINTS = MAX_CACHE_BREAKPOINTS - 1;
@@ -1339,7 +1573,7 @@ function providerSupportsPromptCache(provider) {
   return readExtraCacheProviders().has(provider);
 }
 function readExtraCacheProviders() {
-  const raw = process.env["0SEC_PROMPT_CACHE_EXTRA_PROVIDERS"];
+  const raw = process.env["ZERO_PROMPT_CACHE_EXTRA_PROVIDERS"];
   if (!raw)
     return /* @__PURE__ */ new Set();
   return new Set(raw.split(",").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0));
@@ -1408,7 +1642,7 @@ function isWireBlockArray(blocks) {
 }
 var azureRegionCache = /* @__PURE__ */ new Map();
 async function probeAzureRegion(baseUrl, apiKey, fetchImpl = fetch) {
-  const override = process.env["0SEC_REGION_OVERRIDE"];
+  const override = process.env["ZERO_REGION_OVERRIDE"];
   if (override && override.trim().length > 0) {
     return override.trim();
   }
@@ -1470,7 +1704,7 @@ function prettyRegion(code) {
   };
   return map[code.toLowerCase()] ?? code;
 }
-var PROVIDER_BANNER_KEY = /* @__PURE__ */ Symbol.for("0sec.core.loggedProviderStartup");
+var PROVIDER_BANNER_KEY = /* @__PURE__ */ Symbol.for("0.core.loggedProviderStartup");
 var loggedProviderStartup = (() => {
   const g = globalThis;
   if (!g[PROVIDER_BANNER_KEY])
@@ -1478,7 +1712,7 @@ var loggedProviderStartup = (() => {
   return g[PROVIDER_BANNER_KEY];
 })();
 function appendNativeTrace(record) {
-  const file = process.env["0SEC_TRACE_NATIVE_RESPONSES"];
+  const file = process.env["ZERO_TRACE_NATIVE_RESPONSES"];
   if (!file)
     return;
   try {
@@ -1488,7 +1722,7 @@ function appendNativeTrace(record) {
   }
 }
 function shouldLogProviderStartup() {
-  return process.env["0SEC_SUPPRESS_PROVIDER_STARTUP_LOG"] !== "1";
+  return process.env["ZERO_SUPPRESS_PROVIDER_STARTUP_LOG"] !== "1";
 }
 function isRetryableHttpStatus(status) {
   return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
@@ -1498,7 +1732,7 @@ var TRANSIENT_STREAM_ERROR_PATTERNS = [
   "response stream failed"
 ];
 function llmStreamMaxAttempts() {
-  const raw = process.env["0SEC_LLM_STREAM_MAX_ATTEMPTS"];
+  const raw = process.env["ZERO_LLM_STREAM_MAX_ATTEMPTS"];
   if (raw == null || raw.trim() === "")
     return 3;
   const n = Number.parseInt(raw, 10);
@@ -1545,28 +1779,28 @@ function isRetryableTransportCode(code) {
   ].includes(code);
 }
 function llmMaxRetries() {
-  const raw = process.env["0SEC_LLM_MAX_RETRIES"];
+  const raw = process.env["ZERO_LLM_MAX_RETRIES"];
   if (raw == null || raw.trim() === "")
     return 6;
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n >= 0 ? n : 6;
 }
 function llmMaxRetryWaitMs() {
-  const raw = process.env["0SEC_LLM_MAX_RETRY_WAIT_MS"];
+  const raw = process.env["ZERO_LLM_MAX_RETRY_WAIT_MS"];
   if (raw == null || raw.trim() === "")
     return 6e4;
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : 6e4;
 }
 function llm429MaxRetries() {
-  const raw = process.env["0SEC_LLM_429_MAX_RETRIES"] ?? process.env["0SEC_LLM_MAX_RETRIES"];
+  const raw = process.env["ZERO_LLM_429_MAX_RETRIES"] ?? process.env["ZERO_LLM_MAX_RETRIES"];
   if (raw == null || raw.trim() === "")
     return 12;
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n >= 0 ? n : 12;
 }
 function llm429MaxRetryWaitMs() {
-  const raw = process.env["0SEC_LLM_429_MAX_RETRY_WAIT_MS"] ?? process.env["0SEC_LLM_MAX_RETRY_WAIT_MS"];
+  const raw = process.env["ZERO_LLM_429_MAX_RETRY_WAIT_MS"] ?? process.env["ZERO_LLM_MAX_RETRY_WAIT_MS"];
   if (raw == null || raw.trim() === "")
     return 3e5;
   const n = Number.parseInt(raw, 10);
@@ -1677,12 +1911,19 @@ function parseUsageLimitReached(body) {
   return details;
 }
 function llmStreamIdleTimeoutMs() {
-  const raw = process.env["0SEC_LLM_STREAM_IDLE_TIMEOUT_MS"];
+  const raw = process.env["ZERO_LLM_STREAM_IDLE_TIMEOUT_MS"];
   if (raw == null || raw.trim() === "")
     return 12e4;
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : 12e4;
 }
+function llmStreamEventIdleTimeoutMs() {
+  const raw = process.env["ZERO_LLM_STREAM_EVENT_IDLE_TIMEOUT_MS"];
+  if (raw == null || raw.trim() === "")
+    return 24e4;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : 24e4;
+}
 function parseRetryAfterMs(headerValue) {
   if (!headerValue)
     return void 0;
@@ -1827,7 +2068,7 @@ var AZURE_FOUNDRY_DEPLOYMENT_IDS = {
   "gpt-5.6-terra": true
 };
 function parseLlmFallbackChain(env2 = process.env) {
-  const raw = env2["0SEC_LLM_FALLBACK"];
+  const raw = env2["ZERO_LLM_FALLBACK"];
   if (!raw || raw.trim().length === 0)
     return [];
   const entries = [];
@@ -1853,17 +2094,17 @@ function parseLlmFallbackChain(env2 = process.env) {
       continue;
     const colonIdx = trimmed.indexOf(":");
     if (colonIdx < 1 || colonIdx === trimmed.length - 1) {
-      diag.warn("fallback_chain_malformed_entry", `0SEC_LLM_FALLBACK: malformed entry "${trimmed}" (expected provider:model)`, { entry: trimmed, expected: "provider:model" });
+      diag.warn("fallback_chain_malformed_entry", `ZERO_LLM_FALLBACK: malformed entry "${trimmed}" (expected provider:model)`, { entry: trimmed, expected: "provider:model" });
       continue;
     }
     const provider = trimmed.slice(0, colonIdx);
     const model = trimmed.slice(colonIdx + 1).trim();
     if (!VALID_PROVIDERS[provider]) {
-      diag.warn("fallback_chain_unknown_provider", `0SEC_LLM_FALLBACK: unknown provider "${provider}" in "${trimmed}"`, { entry: trimmed, provider });
+      diag.warn("fallback_chain_unknown_provider", `ZERO_LLM_FALLBACK: unknown provider "${provider}" in "${trimmed}"`, { entry: trimmed, provider });
       continue;
     }
     if (!model) {
-      diag.warn("fallback_chain_empty_model", `0SEC_LLM_FALLBACK: empty model in "${trimmed}"`, { entry: trimmed, provider });
+      diag.warn("fallback_chain_empty_model", `ZERO_LLM_FALLBACK: empty model in "${trimmed}"`, { entry: trimmed, provider });
       continue;
     }
     entries.push({ provider, model });
@@ -1906,7 +2147,7 @@ function resolveFailoverProvider(provider, model, env2 = process.env, apiKey) {
       return { apiKey: key, baseUrl: env2.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com", wireApi: "chat_completions" };
     }
     case "chatgpt-codex": {
-      if (!env2["0SEC_CHATGPT_ACCESS_TOKEN"] && !env2["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"] && !readChatGptCodexAuthFile(env2))
+      if (!env2["ZERO_CHATGPT_ACCESS_TOKEN"] && !env2["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"] && !readChatGptCodexAuthFile(env2))
         return void 0;
       return { apiKey: "", baseUrl: CODEX_API_ENDPOINT, wireApi: "responses" };
     }
@@ -1941,13 +2182,13 @@ function resolveFailoverProvider(provider, model, env2 = process.env, apiKey) {
       return { apiKey: key, baseUrl: env2.OPENCODE_BASE_URL ?? OPENCODE_DEFAULT_BASE_URL, wireApi: opencodeWireApiForModel(model) };
     }
     case "copilot": {
-      const key = apiKey ?? env2["0SEC_COPILOT_GITHUB_TOKEN"];
+      const key = apiKey ?? env2["ZERO_COPILOT_GITHUB_TOKEN"];
       if (!key)
         return void 0;
       return { apiKey: key, baseUrl: env2.COPILOT_BASE_URL ?? COPILOT_API_BASE, wireApi: "chat_completions" };
     }
     case "google": {
-      if (!env2["0SEC_GEMINI_ACCESS_TOKEN"] && !env2["0SEC_GEMINI_OAUTH_REFRESH_TOKEN"])
+      if (!env2["ZERO_GEMINI_ACCESS_TOKEN"] && !env2["ZERO_GEMINI_OAUTH_REFRESH_TOKEN"])
         return void 0;
       return { apiKey: "", baseUrl: CODE_ASSIST_ENDPOINT, wireApi: "google_generate_content" };
     }
@@ -1973,7 +2214,7 @@ function resolveFailoverProvider(provider, model, env2 = process.env, apiKey) {
 }
 var fallbackChainCache;
 function getFallbackChain(env2) {
-  const raw = env2["0SEC_LLM_FALLBACK"];
+  const raw = env2["ZERO_LLM_FALLBACK"];
   if (!fallbackChainCache || fallbackChainCache.raw !== raw) {
     fallbackChainCache = { raw, entries: parseLlmFallbackChain(env2) };
   }
@@ -1983,7 +2224,7 @@ var ZAI_DEFAULT_BASE_URL = "https://api.z.ai/api/anthropic";
 var ZAI_DEFAULT_MODEL = "glm-5.3";
 var ZAI_DEFAULT_THINKING_BUDGET = 2048;
 function zaiThinkingBudget() {
-  const raw = process.env["0SEC_ZAI_THINKING_BUDGET"];
+  const raw = process.env["ZERO_ZAI_THINKING_BUDGET"];
   if (raw == null || raw.trim().length === 0)
     return ZAI_DEFAULT_THINKING_BUDGET;
   const n = Number.parseInt(raw, 10);
@@ -1998,18 +2239,18 @@ var CODEX_OAUTH_ISSUER = "https://auth.openai.com";
 var CODEX_OAUTH_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 var CODEX_DEFAULT_MODEL = "gpt-5.5";
 var LOOP_SERVER_COMPACTION_TOKENS = 15e4;
-var PROCESS_SESSION_ID = `0sec-${Math.random().toString(36).slice(2, 10)}-${Date.now().toString(36)}`;
+var PROCESS_SESSION_ID = `0-${Math.random().toString(36).slice(2, 10)}-${Date.now().toString(36)}`;
 var chatGptCodexAuthStates = /* @__PURE__ */ new Map();
 function codexAuthStateKey(state) {
   return JSON.stringify([state.authFilePath, state.accountId, state.refreshToken || state.accessToken]);
 }
 function readChatGptCodexEnv(env2 = process.env) {
-  const access = env2["0SEC_CHATGPT_ACCESS_TOKEN"];
-  const refresh = env2["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"];
+  const access = env2["ZERO_CHATGPT_ACCESS_TOKEN"];
+  const refresh = env2["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"];
   if ((!access || access.length === 0) && (!refresh || refresh.length === 0)) {
     return void 0;
   }
-  const accountId = env2["0SEC_CHATGPT_ACCOUNT_ID"];
+  const accountId = env2["ZERO_CHATGPT_ACCOUNT_ID"];
   return {
     accessToken: access && access.length > 0 ? access : void 0,
     refreshToken: refresh && refresh.length > 0 ? refresh : void 0,
@@ -2017,7 +2258,7 @@ function readChatGptCodexEnv(env2 = process.env) {
   };
 }
 function resolveChatGptCodexAuthPath(env2 = process.env) {
-  return env2["0SEC_CHATGPT_AUTH_FILE"] ?? join2(env2.HOME ?? homedir(), ".codex", "auth.json");
+  return env2["ZERO_CHATGPT_AUTH_FILE"] ?? join2(env2.HOME ?? homedir(), ".codex", "auth.json");
 }
 function persistChatGptCodexAuthFile(authPath, tokens, usedRefreshToken) {
   try {
@@ -2046,7 +2287,7 @@ function persistChatGptCodexAuthFile(authPath, tokens, usedRefreshToken) {
 `, { mode: 384 });
     renameSync(tmp, authPath);
   } catch (err) {
-    process.stderr.write(`[0sec] warning: could not persist rotated Codex refresh token to ${authPath}: ${err instanceof Error ? err.message : String(err)}
+    process.stderr.write(`[0] warning: could not persist rotated Codex refresh token to ${authPath}: ${err instanceof Error ? err.message : String(err)}
 `);
   }
 }
@@ -2082,6 +2323,7 @@ function accessTokenExpiryMs(accessToken) {
 }
 async function refreshChatGptCodexAccessToken(refreshToken) {
   const res = await fetch(`${CODEX_OAUTH_ISSUER}/oauth/token`, {
+    signal: AbortSignal.timeout(3e4),
     method: "POST",
     headers: { "Content-Type": "application/x-www-form-urlencoded" },
     body: new URLSearchParams({
@@ -2133,12 +2375,15 @@ function extractChatGptAccountId(tokens) {
   }
   return void 0;
 }
+async function getChatGptCodexAccessToken(env2 = process.env) {
+  return refreshChatGptCodexAuthState(resolveChatGptCodexAuthState(env2));
+}
 function resolveChatGptCodexAuthState(env2) {
   const fromEnvOnly = readChatGptCodexEnv(env2);
   const fromFile = fromEnvOnly ? void 0 : readChatGptCodexAuthFile(env2);
   const tokens = fromEnvOnly ?? fromFile;
   if (!tokens) {
-    throw new Error("ChatGPT Codex auth: neither 0SEC_CHATGPT_ACCESS_TOKEN nor 0SEC_CHATGPT_OAUTH_REFRESH_TOKEN is set. Run `codex login` and either forward the access token via worker-controller (preferred for multi-sandbox dispatch \u2014 avoids the OAuth refresh-token rotation race) or keep a valid ~/.codex/auth.json on this host.");
+    throw new Error("ChatGPT Codex auth: neither ZERO_CHATGPT_ACCESS_TOKEN nor ZERO_CHATGPT_OAUTH_REFRESH_TOKEN is set. Run `codex login` and either forward the access token via worker-controller (preferred for multi-sandbox dispatch \u2014 avoids the OAuth refresh-token rotation race) or keep a valid ~/.codex/auth.json on this host.");
   }
   const identity = {
     refreshToken: tokens.refreshToken ?? "",
@@ -2198,8 +2443,8 @@ function geminiAuthStateKey(refreshToken, accessToken) {
   return JSON.stringify([refreshToken, refreshToken ? void 0 : accessToken]);
 }
 function readGeminiCodeAssistEnv(env2 = process.env) {
-  const access = env2["0SEC_GEMINI_ACCESS_TOKEN"];
-  const refresh = env2["0SEC_GEMINI_OAUTH_REFRESH_TOKEN"];
+  const access = env2["ZERO_GEMINI_ACCESS_TOKEN"];
+  const refresh = env2["ZERO_GEMINI_OAUTH_REFRESH_TOKEN"];
   if ((!access || access.length === 0) && (!refresh || refresh.length === 0))
     return void 0;
   return {
@@ -2210,7 +2455,7 @@ function readGeminiCodeAssistEnv(env2 = process.env) {
 function resolveGeminiCodeAssistAuthState(env2) {
   const tokens = readGeminiCodeAssistEnv(env2);
   if (!tokens) {
-    throw new Error("Google Gemini Code Assist auth: neither 0SEC_GEMINI_ACCESS_TOKEN nor 0SEC_GEMINI_OAUTH_REFRESH_TOKEN is set. Sign in with your Google account (0sec connect) or forward a fresh access token.");
+    throw new Error("Google Gemini Code Assist auth: neither ZERO_GEMINI_ACCESS_TOKEN nor ZERO_GEMINI_OAUTH_REFRESH_TOKEN is set. Sign in with your Google account (0 connect) or forward a fresh access token.");
   }
   const key = geminiAuthStateKey(tokens.refreshToken ?? "", tokens.accessToken);
   const existing = geminiCodeAssistAuthStates.get(key);
@@ -2323,7 +2568,7 @@ async function resolveGeminiCodeAssistProject(state, env2, sleep = (ms) => new P
     return state.inflightProjectResolve;
   state.inflightProjectResolve = (async () => {
     try {
-      const override = firstNonEmptyEnv(env2, "GOOGLE_CLOUD_PROJECT", "0SEC_GEMINI_PROJECT");
+      const override = firstNonEmptyEnv(env2, "GOOGLE_CLOUD_PROJECT", "ZERO_GEMINI_PROJECT");
       const accessToken = await refreshGeminiCodeAssistAuthState(state);
       let load;
       try {
@@ -2335,7 +2580,7 @@ async function resolveGeminiCodeAssistProject(state, env2, sleep = (ms) => new P
         if (err.securityPolicyViolated) {
           if (override)
             return override;
-          throw new Error("Google Gemini Code Assist: this account is behind a VPC Service Controls perimeter \u2014 set GOOGLE_CLOUD_PROJECT (or 0SEC_GEMINI_PROJECT).");
+          throw new Error("Google Gemini Code Assist: this account is behind a VPC Service Controls perimeter \u2014 set GOOGLE_CLOUD_PROJECT (or ZERO_GEMINI_PROJECT).");
         }
         throw err;
       }
@@ -2447,13 +2692,13 @@ function providerForModel(model, env2) {
     return env2.OPENCODE_API_KEY ? "opencode" : void 0;
   }
   if (m.startsWith("copilot/")) {
-    return env2["0SEC_COPILOT_GITHUB_TOKEN"] ? "copilot" : void 0;
+    return env2["ZERO_COPILOT_GITHUB_TOKEN"] ? "copilot" : void 0;
   }
   if (m.startsWith("gemini") || m.startsWith("google/")) {
-    return env2["0SEC_GEMINI_ACCESS_TOKEN"] || env2["0SEC_GEMINI_OAUTH_REFRESH_TOKEN"] ? "google" : void 0;
+    return env2["ZERO_GEMINI_ACCESS_TOKEN"] || env2["ZERO_GEMINI_OAUTH_REFRESH_TOKEN"] ? "google" : void 0;
   }
   if (/^gpt-|^o[1-4](?:[-_]|$)/.test(m)) {
-    if (env2["0SEC_CHATGPT_ACCESS_TOKEN"] || env2["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"])
+    if (env2["ZERO_CHATGPT_ACCESS_TOKEN"] || env2["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"])
       return "chatgpt-codex";
     if (env2.OPENAI_API_KEY)
       return "openai";
@@ -2489,21 +2734,21 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
   if (configProvider !== void 0 && !Object.hasOwn(DEFAULT_PROVIDER_MODELS, configProvider)) {
     throw new Error(`RuntimeConfig.provider is unsupported: ${configProvider}`);
   }
-  const selectedProviderRaw = configProvider ?? env2["0SEC_SELECTED_PROVIDER"]?.trim();
-  const forcedProviderRaw = env2["0SEC_FORCE_PROVIDER"]?.trim() || void 0;
+  const selectedProviderRaw = configProvider ?? env2["ZERO_SELECTED_PROVIDER"]?.trim();
+  const forcedProviderRaw = env2["ZERO_FORCE_PROVIDER"]?.trim() || void 0;
   if (selectedProviderRaw && forcedProviderRaw && selectedProviderRaw !== forcedProviderRaw) {
-    throw new Error(`${configProvider !== void 0 ? "RuntimeConfig.provider" : "0SEC_SELECTED_PROVIDER"} conflicts with 0SEC_FORCE_PROVIDER`);
+    throw new Error(`${configProvider !== void 0 ? "RuntimeConfig.provider" : "ZERO_SELECTED_PROVIDER"} conflicts with ZERO_FORCE_PROVIDER`);
   }
-  const primaryModel = env2["0SEC_MODEL"]?.trim();
+  const primaryModel = env2["ZERO_MODEL"]?.trim();
   const selectedProviderApplies = configProvider !== void 0 || !preferredModel || !primaryModel || preferredModel === primaryModel;
   const pinnedProviderRaw = forcedProviderRaw ?? (selectedProviderApplies ? selectedProviderRaw : void 0);
   if (pinnedProviderRaw) {
-    const source = pinnedProviderRaw === forcedProviderRaw ? "0SEC_FORCE_PROVIDER" : configProvider !== void 0 ? "RuntimeConfig.provider" : "0SEC_SELECTED_PROVIDER";
+    const source = pinnedProviderRaw === forcedProviderRaw ? "ZERO_FORCE_PROVIDER" : configProvider !== void 0 ? "RuntimeConfig.provider" : "ZERO_SELECTED_PROVIDER";
     if (!Object.hasOwn(DEFAULT_PROVIDER_MODELS, pinnedProviderRaw)) {
       throw new Error(`${source} is unsupported: ${pinnedProviderRaw}`);
     }
     const provider = pinnedProviderRaw;
-    const model = preferredModel ?? env2["0SEC_MODEL"] ?? (configProvider !== void 0 || provider === "hosted" ? DEFAULT_PROVIDER_MODELS[provider] : void 0);
+    const model = preferredModel ?? env2["ZERO_MODEL"] ?? (configProvider !== void 0 || provider === "hosted" ? DEFAULT_PROVIDER_MODELS[provider] : void 0);
     if (model === void 0 || model === "" && provider !== "hosted") {
       throw new Error(`${source} requires an explicit model`);
     }
@@ -2613,7 +2858,7 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
     case "copilot":
       return {
         provider: "copilot",
-        apiKey: env2["0SEC_COPILOT_GITHUB_TOKEN"],
+        apiKey: env2["ZERO_COPILOT_GITHUB_TOKEN"],
         baseUrl: env2.COPILOT_BASE_URL ?? COPILOT_API_BASE,
         defaultModel: preferredModel ?? COPILOT_DEFAULT_MODEL,
         wireApi: "chat_completions"
@@ -2631,7 +2876,7 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
         provider: "chatgpt-codex",
         apiKey: "",
         baseUrl: CODEX_API_ENDPOINT,
-        defaultModel: env2["0SEC_MODEL"] ?? CODEX_DEFAULT_MODEL,
+        defaultModel: env2["ZERO_MODEL"] ?? CODEX_DEFAULT_MODEL,
         wireApi: "responses"
       };
     case "anthropic":
@@ -2661,8 +2906,23 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
     default:
       break;
   }
-  const chatGptAccess = env2["0SEC_CHATGPT_ACCESS_TOKEN"];
-  const chatGptRefresh = env2["0SEC_CHATGPT_OAUTH_REFRESH_TOKEN"];
+  try {
+    const hostedCreds = loadCloudCredentials({
+      env: env2,
+      warn: () => {
+      }
+    });
+    return {
+      provider: "hosted",
+      apiKey: hostedCreds.token,
+      baseUrl: `${hostedCreds.host}/api/inference/v1`,
+      defaultModel: "",
+      wireApi: "chat_completions"
+    };
+  } catch {
+  }
+  const chatGptAccess = env2["ZERO_CHATGPT_ACCESS_TOKEN"];
+  const chatGptRefresh = env2["ZERO_CHATGPT_OAUTH_REFRESH_TOKEN"];
   const chatGptAuthFile = !chatGptAccess && !chatGptRefresh ? readChatGptCodexAuthFile(env2) : void 0;
   if (chatGptAccess && chatGptAccess.length > 0 || chatGptRefresh && chatGptRefresh.length > 0 || !!chatGptAuthFile) {
     return {
@@ -2675,7 +2935,7 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
       // baseUrl is informational only — the runtime hardcodes
       // CODEX_API_ENDPOINT for this provider.
       baseUrl: CODEX_API_ENDPOINT,
-      defaultModel: env2["0SEC_MODEL"] ?? CODEX_DEFAULT_MODEL,
+      defaultModel: env2["ZERO_MODEL"] ?? CODEX_DEFAULT_MODEL,
       wireApi: "responses"
     };
   }
@@ -2771,7 +3031,7 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
       wireApi: opencodeWireApiForModel(preferredModel)
     };
   }
-  const copilotToken = env2["0SEC_COPILOT_GITHUB_TOKEN"];
+  const copilotToken = env2["ZERO_COPILOT_GITHUB_TOKEN"];
   if (copilotToken) {
     return {
       provider: "copilot",
@@ -2781,14 +3041,14 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
       wireApi: "chat_completions"
     };
   }
-  const geminiAccess = env2["0SEC_GEMINI_ACCESS_TOKEN"];
-  const geminiRefresh = env2["0SEC_GEMINI_OAUTH_REFRESH_TOKEN"];
+  const geminiAccess = env2["ZERO_GEMINI_ACCESS_TOKEN"];
+  const geminiRefresh = env2["ZERO_GEMINI_OAUTH_REFRESH_TOKEN"];
   if (geminiAccess && geminiAccess.length > 0 || geminiRefresh && geminiRefresh.length > 0) {
     return {
       provider: "google",
       apiKey: "",
       baseUrl: CODE_ASSIST_ENDPOINT,
-      defaultModel: env2["0SEC_MODEL"] ?? GEMINI_DEFAULT_MODEL,
+      defaultModel: env2["ZERO_MODEL"] ?? GEMINI_DEFAULT_MODEL,
       wireApi: "google_generate_content"
     };
   }
@@ -2802,21 +3062,6 @@ function detectProvider(configApiKey, preferredModel, env2, configProvider) {
       wireApi: "chat_completions"
     };
   }
-  try {
-    const hostedCreds = loadCloudCredentials({
-      env: env2,
-      warn: () => {
-      }
-    });
-    return {
-      provider: "hosted",
-      apiKey: hostedCreds.token,
-      baseUrl: `${hostedCreds.host}/api/inference/v1`,
-      defaultModel: "",
-      wireApi: "chat_completions"
-    };
-  } catch {
-  }
   return {
     provider: "anthropic",
     apiKey: "",
@@ -2843,7 +3088,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
   reasoningEffort;
   azureConfig;
   serverCompactionTokens;
-  /** Ordered fallback chain (0SEC_LLM_FALLBACK). Empty = no failover. */
+  /** Ordered fallback chain (ZERO_LLM_FALLBACK). Empty = no failover. */
   fallbackChain;
   /** Index into fallbackChain — which entry to try next. */
   fallbackIndex;
@@ -2919,7 +3164,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
       credentials: resolveFailoverProvider(entry.provider, entry.model, this.env)
     }));
     this.fallbackIndex = 0;
-    const detected = detectProvider(config.apiKey, config.model ?? this.env["0SEC_MODEL"], this.env, config.provider);
+    const detected = detectProvider(config.apiKey, config.model ?? this.env["ZERO_MODEL"], this.env, config.provider);
     this.provider = detected.provider;
     this.apiKey = detected.apiKey;
     this.baseUrl = detected.baseUrl;
@@ -2936,9 +3181,9 @@ var LlmApiRuntime = class _LlmApiRuntime {
         this.geminiAuthState = resolveGeminiCodeAssistAuthState(this.env);
       }
     }
-    this.reasoningEffort = this.env["0SEC_REASONING_EFFORT"] ?? detected.reasoningEffort;
+    this.reasoningEffort = this.env["ZERO_REASONING_EFFORT"] ?? detected.reasoningEffort;
     this.serverCompactionTokens = config.serverCompactionTokens !== void 0 ? Math.max(1e3, config.serverCompactionTokens) : void 0;
-    const requestedModel = config.model ?? this.env["0SEC_MODEL"];
+    const requestedModel = config.model ?? this.env["ZERO_MODEL"];
     if (requestedModel === "free" && this.provider === "openrouter") {
       this.model = FREE_OPENROUTER_MODEL;
     } else {
@@ -2951,11 +3196,50 @@ var LlmApiRuntime = class _LlmApiRuntime {
       this.model = copilotModelId(this.model);
     }
     this.applyModelWireApi();
-    if (this.apiKey && !this.env["0SEC_SKIP_PROVIDER_BANNER"]) {
+    if (this.apiKey && !this.env["ZERO_SKIP_PROVIDER_BANNER"]) {
       void logProviderStartup(this.provider, this.providerLabel, this.baseUrl, this.model, this.wireApi, this.apiKey).catch(() => {
       });
     }
   }
+  /** Discover models using this runtime's captured account, including after a separate login changes. */
+  async codexModelCatalog(signal) {
+    const state = this.codexAuthState;
+    if (this.provider !== "chatgpt-codex" || !state)
+      throw new Error("No active Codex subscription");
+    const { loadCodexModelCatalog } = await import("./codex-models-TYYV4JNN.js");
+    return loadCodexModelCatalog({ signal, resolveCredentials: () => refreshChatGptCodexAuthState(state) });
+  }
+  /** Check account admission and resolve the service model without inference.
+   * Each explicit check refreshes admission; failed discovery is never cached.
+   */
+  async prepare() {
+    while (this.provider === "hosted") {
+      const config = this.config;
+      const client = new CloudClient({
+        host: this.baseUrl.replace(/\/api\/inference\/v1$/, ""),
+        token: this.apiKey
+      });
+      try {
+        const account = await client.getInferenceAccount();
+        if (this.config !== config)
+          continue;
+        if (!account) {
+          throw new CloudError("0cloud account availability could not be read. Check again or review your account in /connect.", void 0, "/api/inference/account", "unsupported_account_data");
+        }
+        if (!account.admission.eligible) {
+          const reason = account.admission.reason ?? account.reason ?? "account_restricted";
+          throw new CloudError(account.state === "unavailable" ? `0cloud account availability could not be checked (${reason}). Check again or review your account in /connect.` : `0cloud account access is restricted (${reason}). Review your account in /connect or contact your organization owner.`, void 0, "/api/inference/account", reason);
+        }
+        await this.ensureHostedModel();
+        if (this.config === config)
+          return;
+      } catch (error) {
+        if (this.config !== config)
+          continue;
+        throw error;
+      }
+    }
+  }
   /**
    * Mutate the live selection in place so the NEXT turn (the engine reads
    * `config.runtime` per turn) and the NEXT `forkForSubagent` pick up the new
@@ -2964,11 +3248,12 @@ var LlmApiRuntime = class _LlmApiRuntime {
    */
   reconfigure(sel) {
     const providerChanged = sel.provider !== void 0 && sel.provider !== this.provider;
-    if (providerChanged) {
+    if (providerChanged || this.provider === "hosted" && (sel.env !== void 0 || sel.provider === "hosted")) {
       const merged = {
         ...this.config,
+        ...providerChanged && sel.provider === "hosted" && sel.model === void 0 ? { model: "" } : {},
         apiKey: void 0,
-        provider: sel.provider,
+        provider: sel.provider ?? this.provider,
         ...sel.model !== void 0 ? { model: sel.model } : {},
         ...sel.agentModels !== void 0 ? { agentModels: sel.agentModels } : {},
         ...sel.singleModel !== void 0 ? { singleModel: sel.singleModel } : {},
@@ -2998,6 +3283,8 @@ var LlmApiRuntime = class _LlmApiRuntime {
           this.wireApi = openAICompatibleWireApi(this.env, "AZURE_OPENAI_WIRE_API", this.azureConfig.wireApi);
         this.applyModelWireApi();
         this.reasoningEffort = void 0;
+        this.hostedCatalogPromise = null;
+        this.hostedMaxOutputTokens = void 0;
       }
     }
   }
@@ -3082,25 +3369,50 @@ var LlmApiRuntime = class _LlmApiRuntime {
   }
   /** The server catalog is authoritative even when a model was selected explicitly. */
   async ensureHostedModel() {
-    if (this.provider !== "hosted")
-      return;
-    if (!this.hostedCatalogPromise) {
-      this.hostedCatalogPromise = (async () => {
+    while (this.provider === "hosted") {
+      let pending = this.hostedCatalogPromise;
+      if (!pending) {
+        const requestedModel = this.model;
         const client = new CloudClient({
           host: this.baseUrl.replace(/\/api\/inference\/v1$/, ""),
           token: this.apiKey
         });
-        const catalog = await client.getInferenceModels();
-        const selected = this.model ? catalog.data.find((model) => model.id === this.model) : catalog.data[0];
-        if (!selected) {
-          throw new Error(this.model ? `Hosted model "${this.model}" is unavailable. Run \`0sec models\` for available models.` : "No hosted models are available. Run `0sec models` to check service availability.");
-        }
-        this.model = selected.id;
-        this.wireApi = selected.wire_api;
-        this.hostedMaxOutputTokens = selected.max_output_tokens;
-      })();
+        const request = client.getInferenceModels().then((catalog) => {
+          if (this.hostedCatalogPromise !== request)
+            return;
+          const selected = requestedModel ? catalog.data.find((model) => model.id === requestedModel) : catalog.data[0];
+          if (!selected) {
+            throw new Error(requestedModel ? `Hosted model "${requestedModel}" is unavailable. Run \`0 models\` for available models.` : "No hosted models are available. Run `0 models` to check service availability.");
+          }
+          this.model = selected.id;
+          this.wireApi = selected.wire_api;
+          this.hostedMaxOutputTokens = selected.max_output_tokens;
+        });
+        this.hostedCatalogPromise = pending = request;
+      }
+      try {
+        await pending;
+      } catch (error) {
+        if (this.hostedCatalogPromise !== pending)
+          continue;
+        this.hostedCatalogPromise = null;
+        throw error;
+      }
+      if (this.hostedCatalogPromise === pending)
+        return;
+    }
+  }
+  /** All audits and nested workers on this hosted credential share admission. */
+  async acquireHostedSlot(signal) {
+    while (this.provider === "hosted") {
+      const config = this.config;
+      const release = await acquireHostedRequestSlot(this.baseUrl, this.apiKey, signal);
+      if (this.config === config)
+        return release;
+      release();
+      await this.ensureHostedModel();
     }
-    await this.hostedCatalogPromise;
+    return void 0;
   }
   /**
    * A hard dollar ceiling needs a provider-enforced bound on the next response.
@@ -3178,8 +3490,8 @@ var LlmApiRuntime = class _LlmApiRuntime {
     if (this.provider === "chatgpt-codex") {
       return {
         "Content-Type": "application/json",
-        originator: "0sec",
-        "User-Agent": `0sec/${VERSION}`
+        originator: "0",
+        "User-Agent": `0/${VERSION}`
       };
     }
     if (this.isGeminiCodeAssist) {
@@ -3211,8 +3523,8 @@ var LlmApiRuntime = class _LlmApiRuntime {
         headers["Authorization"] = `Bearer ${this.apiKey}`;
       }
       if (this.provider === "openrouter") {
-        headers["HTTP-Referer"] = "https://0sec.ai";
-        headers["X-Title"] = "0sec Security Scanner";
+        headers["HTTP-Referer"] = "https://0.security";
+        headers["X-Title"] = "0 Security Scanner";
       }
       return headers;
     }
@@ -3236,7 +3548,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
    * happens.
    *
    * session_id is process-stable (PROCESS_SESSION_ID, randomised
-   * once at module load). A 0sec-cli invocation = one scan = one
+   * once at module load). A @0/cli invocation = one scan = one
    * session, so the process-lifetime constant is the right
    * granularity. If we ever want per-scan ids inside a long-lived
    * controller process, add a setter on the runtime; for now this
@@ -3390,7 +3702,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
   /**
    * Per-turn prompt-cache accounting line, so a run can be shown to actually
    * be hitting cache rather than assumed to be. Off unless
-   * `0SEC_DEBUG_PROMPT_CACHE` is set — this fires once per agent turn, and an
+   * `ZERO_DEBUG_PROMPT_CACHE` is set — this fires once per agent turn, and an
    * unconditional line would interleave with the TUI on every scan.
    *
    * The same numbers reach the cloud without this flag: `cachedInputTokens`
@@ -3398,7 +3710,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
    * is the durable, queryable proof. This is the local fast path.
    */
   logCacheUsage(usage) {
-    if (!usage || !process.env["0SEC_DEBUG_PROMPT_CACHE"])
+    if (!usage || !process.env["ZERO_DEBUG_PROMPT_CACHE"])
       return;
     const read = usage.cachedInputTokens ?? 0;
     const write = usage.cacheWriteTokens ?? 0;
@@ -3442,11 +3754,11 @@ var LlmApiRuntime = class _LlmApiRuntime {
       case "google":
         return "Google Gemini (Code Assist)";
       case "hosted":
-        return "0sec Cloud";
+        return "0.security Cloud";
     }
   }
   noKeyError() {
-    return "No provider credential found. Set one of:\n  env 0SEC_CHATGPT_OAUTH_REFRESH_TOKEN=... 0sec <command> (ChatGPT Codex subscription auth)\n  export OPENROUTER_API_KEY=sk-or-...   (OpenRouter \u2014 many models, one key)\n  export DEEPSEEK_API_KEY=...           (DeepSeek \u2014 direct Flash 0731 inference)\n  export ANTHROPIC_API_KEY=sk-ant-...    (Anthropic \u2014 direct Claude access)\n  export AZURE_OPENAI_API_KEY=...        (Azure OpenAI \u2014 reuse your Codex Azure provider)\n  export OPENAI_API_KEY=sk-...           (OpenAI \u2014 direct GPT access)\n  export Z_AI_API_KEY=...                (Z.ai GLM \u2014 flat-rate Coding Plan, Anthropic-compatible)\n  export KIMI_API_KEY=...                (Moonshot Kimi K3 \u2014 flat-rate coding, Anthropic-compatible)\n  export QWEN_API_KEY=...                (Alibaba Qwen \u2014 Token Plan sub, OpenAI-compatible)\n  export XAI_API_KEY=...                 (xAI Grok \u2014 OpenAI-compatible)\n  export OPENCODE_API_KEY=...            (OpenCode Zen \u2014 multi-wire gateway)\n  export 0SEC_COPILOT_GITHUB_TOKEN=...   (GitHub Copilot \u2014 device-code OAuth token)\n  Run `0sec login`                     (0sec hosted inference)";
+    return "No provider credential found. Set one of:\n  env ZERO_CHATGPT_OAUTH_REFRESH_TOKEN=... 0 <command> (ChatGPT Codex subscription auth)\n  export OPENROUTER_API_KEY=sk-or-...   (OpenRouter \u2014 many models, one key)\n  export DEEPSEEK_API_KEY=...           (DeepSeek \u2014 direct Flash 0731 inference)\n  export ANTHROPIC_API_KEY=sk-ant-...    (Anthropic \u2014 direct Claude access)\n  export AZURE_OPENAI_API_KEY=...        (Azure OpenAI \u2014 reuse your Codex Azure provider)\n  export OPENAI_API_KEY=sk-...           (OpenAI \u2014 direct GPT access)\n  export Z_AI_API_KEY=...                (Z.ai GLM \u2014 flat-rate Coding Plan, Anthropic-compatible)\n  export KIMI_API_KEY=...                (Moonshot Kimi K3 \u2014 flat-rate coding, Anthropic-compatible)\n  export QWEN_API_KEY=...                (Alibaba Qwen \u2014 Token Plan sub, OpenAI-compatible)\n  export XAI_API_KEY=...                 (xAI Grok \u2014 OpenAI-compatible)\n  export OPENCODE_API_KEY=...            (OpenCode Zen \u2014 multi-wire gateway)\n  export ZERO_COPILOT_GITHUB_TOKEN=...   (GitHub Copilot \u2014 device-code OAuth token)\n  Run `0 login`                     (0 hosted inference)";
   }
   getConfigurationDiagnostics() {
     if (!this.apiKey && this.provider !== "chatgpt-codex") {
@@ -3466,7 +3778,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
       };
     }
     const hasConfiguredBaseUrl = !!(this.env.AZURE_OPENAI_BASE_URL || this.env.OPENAI_BASE_URL || this.azureConfig.baseUrl);
-    const hasConfiguredModel = !!(this.config.model || this.env["0SEC_MODEL"] || this.env.AZURE_OPENAI_MODEL || this.azureConfig.model);
+    const hasConfiguredModel = !!(this.config.model || this.env["ZERO_MODEL"] || this.env.AZURE_OPENAI_MODEL || this.azureConfig.model);
     const missing = [];
     if (!hasConfiguredBaseUrl) {
       missing.push("AZURE_OPENAI_BASE_URL (or [model_providers.azure].base_url in ~/.codex/config.toml)");
@@ -3482,7 +3794,7 @@ var LlmApiRuntime = class _LlmApiRuntime {
         reason: "invalid_config",
         fatalError: `Azure OpenAI runtime is selected, but the configuration is incomplete.
 Missing: ${missing.join("; ")}
-0sec will not guess Azure defaults because that can silently route to the wrong endpoint or deployment.`
+0 will not guess Azure defaults because that can silently route to the wrong endpoint or deployment.`
       };
     }
     return {
@@ -3500,15 +3812,15 @@ Missing: ${missing.join("; ")}
    *
    * Two 429 classes are handled differently:
    * - per-minute rate limit → retry with the wider 429 budget
-   *   (0SEC_LLM_429_MAX_RETRIES attempts / 0SEC_LLM_429_MAX_RETRY_WAIT_MS
+   *   (ZERO_LLM_429_MAX_RETRIES attempts / ZERO_LLM_429_MAX_RETRY_WAIT_MS
    *   cumulative, defaults 12 / 5min) since the limiter resets every ~60s;
    *   `Retry-After` / `retry-after-ms` headers are honored up to a 120s cap.
    * - plan-quota exhaustion (`usage_limit_reached`, resets in hours/days) →
-   *   skips retries and immediately advances `0SEC_LLM_FALLBACK`; if no
+   *   skips retries and immediately advances `ZERO_LLM_FALLBACK`; if no
    *   configured fallback has credentials, it throws QuotaExhaustedError.
    *
    * Other retryable statuses (transient 5xx) keep the generic budget:
-   * 0SEC_LLM_MAX_RETRIES (attempts) and 0SEC_LLM_MAX_RETRY_WAIT_MS
+   * ZERO_LLM_MAX_RETRIES (attempts) and ZERO_LLM_MAX_RETRY_WAIT_MS
    * (cumulative backoff). On exhaustion it returns the last still-failing
    * Response with its body intact, so the caller's existing `!res.ok` branch
    * surfaces the clear "API error <status>" message — a rate-limit never
@@ -3519,7 +3831,7 @@ Missing: ${missing.join("; ")}
    * is fixed across attempts.
    */
   /**
-   * Try the next fallback provider in the chain (0SEC_LLM_FALLBACK).
+   * Try the next fallback provider in the chain (ZERO_LLM_FALLBACK).
    * Updates `this.provider`, `this.model`, `this.apiKey`, `this.baseUrl`,
    * `this.wireApi` to match the next valid provider. Returns `true` when a
    * valid next provider was found and switched to, `false` when the chain is
@@ -3531,7 +3843,7 @@ Missing: ${missing.join("; ")}
       this.fallbackIndex++;
       const cfg = entry.credentials;
       if (!cfg) {
-        diag.warn("failover_provider_skipped", `0SEC_LLM_FALLBACK: skipping ${entry.provider} (auth env missing)`, { provider: entry.provider, model: entry.model, cause: "auth-env-missing" });
+        diag.warn("failover_provider_skipped", `ZERO_LLM_FALLBACK: skipping ${entry.provider} (auth env missing)`, { provider: entry.provider, model: entry.model, cause: "auth-env-missing" });
         continue;
       }
       this.provider = entry.provider;
@@ -3577,7 +3889,7 @@ Missing: ${missing.join("; ")}
       } catch (error) {
         abort?.throwIfCancelled();
         if (this.provider === "hosted") {
-          throw new Error("0sec hosted request outcome is unknown. Automatic replay is disabled; check your inference usage before retrying.", { cause: error });
+          throw new Error("0 hosted request outcome is unknown. Automatic replay is disabled; check your inference usage before retrying.", { cause: error });
         }
         const cause = error instanceof Error ? error.cause : void 0;
         const causeCode = cause && typeof cause === "object" && "code" in cause && typeof cause.code === "string" ? cause.code : "unknown";
@@ -3605,12 +3917,12 @@ Missing: ${missing.join("; ")}
       if (res.ok || !isRetryableHttpStatus(res.status)) {
         return res;
       }
-      if (this.provider === "hosted" && res.status === 429 && res.headers.get("x-0sec-retry-safe") !== "1") {
+      if (this.provider === "hosted" && res.status === 429 && res.headers.get("x-0-retry-safe") !== "1") {
         return res;
       }
       if (this.provider === "hosted" && res.status >= 500) {
         await res.body?.cancel();
-        throw new Error(`0sec hosted request returned HTTP ${res.status}; its outcome may be unknown. Automatic replay is disabled; check your inference usage before retrying.`);
+        throw new Error(`0 hosted request returned HTTP ${res.status}; its outcome may be unknown. Automatic replay is disabled; check your inference usage before retrying.`);
       }
       abort?.throwIfCancelled();
       const is429 = res.status === 429;
@@ -3714,11 +4026,15 @@ Missing: ${missing.join("; ")}
       };
     }
     const systemPrompt = context?.systemPrompt ?? "";
+    let releaseHostedSlot = this.provider === "hosted" ? await this.acquireHostedSlot() : void 0;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.config.timeout || 12e4);
     try {
       let res;
       do {
+        if (this.provider === "hosted" && !releaseHostedSlot) {
+          releaseHostedSlot = await this.acquireHostedSlot(controller.signal);
+        }
         if (this.isOpenAICompat && this.wireApi === "chat_completions") {
           const messages = [];
           if (systemPrompt) {
@@ -3846,6 +4162,8 @@ Missing: ${missing.join("; ")}
         durationMs: Date.now() - start,
         error: timedOut ? `${this.providerLabel} API request timed out` : `${this.providerLabel} API error: ${msg}`
       };
+    } finally {
+      releaseHostedSlot?.();
     }
   }
   // ── Native Runtime interface (structured messages + tool_use) ──
@@ -3899,12 +4217,25 @@ Missing: ${missing.join("; ")}
     }
     if (signal?.aborted)
       return this.cancelledResult(start);
+    let releaseHostedSlot;
+    if (this.provider === "hosted") {
+      try {
+        releaseHostedSlot = await this.acquireHostedSlot(signal);
+      } catch (error) {
+        if (signal?.aborted)
+          return this.cancelledResult(start);
+        throw error;
+      }
+    }
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.config.timeout || 12e4);
     const call = composeCallAbort(controller.signal, signal);
     try {
       let res;
       do {
+        if (this.provider === "hosted" && !releaseHostedSlot) {
+          releaseHostedSlot = await this.acquireHostedSlot(call.signal);
+        }
         if (this.isOpenAICompat && this.wireApi === "chat_completions") {
           const chatMessages = [];
           chatMessages.push({ role: "system", content: system });
@@ -4095,6 +4426,7 @@ Missing: ${missing.join("; ")}
           }
           const streamed = await this.consumeResponsesStream(res, start, callbacks, {
             idleTimeoutMs: llmStreamIdleTimeoutMs(),
+            eventIdleTimeoutMs: llmStreamEventIdleTimeoutMs(),
             abort: call
           });
           clearTimeout(timer);
@@ -4402,6 +4734,7 @@ Missing: ${missing.join("; ")}
         error: timedOut ? `${this.providerLabel} API request timed out` : `${this.providerLabel} API error: ${msg}`
       };
     } finally {
+      releaseHostedSlot?.();
       call.dispose();
     }
   }
@@ -4416,10 +4749,14 @@ Missing: ${missing.join("; ")}
       };
     }
     const idleTimeoutMs = opts?.idleTimeoutMs ?? llmStreamIdleTimeoutMs();
+    const eventIdleTimeoutMs = opts?.eventIdleTimeoutMs ?? llmStreamEventIdleTimeoutMs();
+    let lastEventAt = Date.now();
     const operatorSignal = opts?.abort?.operator;
     let stalled = false;
+    let stallIdleMs = idleTimeoutMs;
     const readBounded = async () => {
       let timer;
+      let eventTimer;
       const detach = operatorSignal ? new AbortController() : void 0;
       try {
         return await Promise.race([
@@ -4427,9 +4764,22 @@ Missing: ${missing.join("; ")}
           new Promise((_resolve, reject) => {
             timer = setTimeout(() => {
               stalled = true;
+              stallIdleMs = idleTimeoutMs;
               reject(new Error("stream stalled"));
             }, idleTimeoutMs);
           }),
+          // Event-level racer: fires when no MEANINGFUL SSE event has arrived
+          // for `eventIdleTimeoutMs`, even if keep-alive bytes keep resetting
+          // the byte-level timer above. Recomputed per read, so an event that
+          // landed while the previous chunk was being parsed re-arms it.
+          new Promise((_resolve, reject) => {
+            const remainingMs = eventIdleTimeoutMs - (Date.now() - lastEventAt);
+            eventTimer = setTimeout(() => {
+              stalled = true;
+              stallIdleMs = eventIdleTimeoutMs;
+              reject(new Error("stream stalled"));
+            }, Math.max(remainingMs, 0));
+          }),
           // A real aborted `fetch` also errors the body stream, so `read()`
           // would reject on its own — but only for a live socket. This racer
           // is what makes cancellation immediate and unconditional, including
@@ -4445,16 +4795,21 @@ Missing: ${missing.join("; ")}
           ] : []
         ]);
       } finally {
-        if (timer)
-          clearTimeout(timer);
+        clearTimeout(timer);
+        clearTimeout(eventTimer);
         detach?.abort();
       }
     };
     const decoder = new TextDecoder();
     let buffer = "";
+    let trailingCR = false;
+    let receivedBytes = 0;
+    let malformedEvents = 0;
+    const eventTypes = /* @__PURE__ */ new Set();
+    const identifier = (value) => typeof value === "string" && /^[A-Za-z0-9_.:-]{1,96}$/.test(value) ? value : null;
     let completedResponse = null;
-    let openRouterStreamFailed = false;
-    let openRouterUsage;
+    let streamFailure;
+    let responseUsage;
     const streamedOutputItems = [];
     let thinkingText = "";
     let lastThinkingEmit = 0;
@@ -4477,7 +4832,7 @@ Missing: ${missing.join("; ")}
       lastThinkingLength = thinkingText.length;
       callbacks.onThinking(thinkingText);
     };
-    while (true) {
+    responses: while (true) {
       let chunk;
       try {
         chunk = await readBounded();
@@ -4494,10 +4849,10 @@ Missing: ${missing.join("; ")}
             await reader.cancel();
           } catch {
           }
-          const secs = Math.round(idleTimeoutMs / 1e3);
+          const secs = Math.round(stallIdleMs / 1e3);
           diag.warn("stream_stalled", `${this.providerLabel} stream stalled \u2014 no SSE events for ${secs}s (server hold; aborting call)`, {
             provider: this.providerLabel,
-            idle_timeout_ms: idleTimeoutMs,
+            idle_timeout_ms: stallIdleMs,
             idle_timeout_s: secs
           });
           return {
@@ -4510,9 +4865,18 @@ Missing: ${missing.join("; ")}
         throw err;
       }
       const { done, value } = chunk;
-      if (done)
+      if (done) {
+        buffer += decoder.decode();
         break;
-      buffer += decoder.decode(value, { stream: true });
+      }
+      receivedBytes += value.byteLength;
+      let decoded = decoder.decode(value, { stream: true });
+      if (decoded) {
+        if (trailingCR && decoded.startsWith("\n"))
+          decoded = decoded.slice(1);
+        trailingCR = decoded.endsWith("\r");
+        buffer += decoded.replace(/\r\n?/g, "\n");
+      }
       let boundary = buffer.indexOf("\n\n");
       while (boundary >= 0) {
         const rawChunk = buffer.slice(0, boundary);
@@ -4521,27 +4885,46 @@ Missing: ${missing.join("; ")}
         const payload = rawChunk.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n");
         if (!payload || payload === "[DONE]")
           continue;
+        lastEventAt = Date.now();
         let event;
         try {
           event = JSON.parse(payload);
+          if (!event || typeof event !== "object" || Array.isArray(event)) {
+            malformedEvents++;
+            continue;
+          }
         } catch {
+          malformedEvents++;
           continue;
         }
         const type = String(event.type ?? "");
-        if (this.provider === "openrouter" && (type === "response.done" || type === "response.failed" || type === "response.completed" || type === "response.incomplete")) {
-          const response = event.response;
-          const usage2 = response?.usage;
-          if (usage2 && typeof usage2.input_tokens === "number" && Number.isFinite(usage2.input_tokens) && usage2.input_tokens >= 0 && typeof usage2.output_tokens === "number" && Number.isFinite(usage2.output_tokens) && usage2.output_tokens >= 0) {
-            openRouterUsage = {
-              inputTokens: usage2.input_tokens,
-              outputTokens: usage2.output_tokens,
-              ...readResponsesCachedTokens(usage2)
+        if (eventTypes.size < 32)
+          eventTypes.add(identifier(type) ?? "unrecognized");
+        const terminal = type === "response.completed" || this.provider === "openrouter" && type === "response.done";
+        if (terminal || type === "response.failed" || type === "response.incomplete" || type === "error") {
+          const response = event.response && typeof event.response === "object" && !Array.isArray(event.response) ? event.response : void 0;
+          const usage = response?.usage;
+          if (usage && typeof usage.input_tokens === "number" && Number.isFinite(usage.input_tokens) && usage.input_tokens >= 0 && typeof usage.output_tokens === "number" && Number.isFinite(usage.output_tokens) && usage.output_tokens >= 0) {
+            responseUsage = {
+              inputTokens: usage.input_tokens,
+              outputTokens: usage.output_tokens,
+              ...readResponsesCachedTokens(usage)
             };
-            callbacks?.onUsage?.(openRouterUsage);
+            callbacks?.onUsage?.(responseUsage);
           }
-        }
-        if (this.provider === "openrouter" && (type === "error" || type === "response.failed" || type === "response.incomplete")) {
-          openRouterStreamFailed = true;
+          if (!terminal || !response || response.error != null || (type === "response.done" || response.status !== void 0) && response.status !== "completed") {
+            const error = response?.error ?? event.error;
+            const incomplete = response?.incomplete_details;
+            streamFailure = {
+              event: type,
+              status: identifier(response?.status),
+              code: identifier(error?.code ?? event.code),
+              errorType: identifier(error?.type),
+              reason: identifier(incomplete?.reason)
+            };
+            break responses;
+          }
+          completedResponse = response;
           continue;
         }
         if (type === "response.output_text.delta" || this.provider === "openrouter" && type === "response.content_part.delta") {
@@ -4575,33 +4958,33 @@ Missing: ${missing.join("; ")}
           }
           continue;
         }
-        if (type === "response.completed" || type === "response.incomplete" || this.provider === "openrouter" && type === "response.done") {
-          const response = event.response;
-          if (response) {
-            if (this.provider === "openrouter" && (openRouterStreamFailed || response.error != null || (type === "response.done" || response.status !== void 0) && response.status !== "completed")) {
-              openRouterStreamFailed = true;
-              continue;
-            }
-            completedResponse = response;
-            const usage2 = response.usage;
-            if (usage2 && this.provider !== "openrouter") {
-              callbacks?.onUsage?.({
-                inputTokens: Number(usage2.input_tokens ?? 0),
-                outputTokens: Number(usage2.output_tokens ?? 0)
-              });
-            }
-          }
-        }
       }
     }
     emitThinking(true);
-    if (!completedResponse || openRouterStreamFailed) {
+    if (!completedResponse || streamFailure) {
+      if (streamFailure) {
+        void reader.cancel().catch(() => {
+        });
+      }
+      appendNativeTrace({
+        kind: "native-response-stream-error",
+        provider: this.providerLabel,
+        wireApi: this.wireApi,
+        httpStatus: res.status,
+        eventStreamContentType: /^text\/event-stream(?:\s*;|$)/i.test(res.headers.get("content-type") ?? ""),
+        terminalFailure: streamFailure ?? null,
+        eventTypes: [...eventTypes],
+        receivedBytes,
+        malformedEvents,
+        trailingCharacters: buffer.length,
+        usage: responseUsage ?? null
+      });
       return {
         content: thinkingText ? [{ type: "text", text: thinkingText }] : [{ type: "text", text: "" }],
         stopReason: "error",
         durationMs: Date.now() - start,
-        ...openRouterUsage ? { usage: openRouterUsage } : {},
-        error: `${this.providerLabel} API error: ${openRouterStreamFailed ? "response stream failed" : "stream completed without final response"}`
+        ...responseUsage ? { usage: responseUsage } : {},
+        error: `${this.providerLabel} API error: ${streamFailure ? `Responses terminal failure ${JSON.stringify(streamFailure)}` : `stream completed without final response (HTTP ${res.status}; events=${[...eventTypes].join(",") || "none"}; malformed=${malformedEvents}; trailing=${buffer.length})`}`
       };
     }
     appendNativeTrace({
@@ -4654,21 +5037,10 @@ Missing: ${missing.join("; ")}
       thinkingText = reasoningSummaries.join("\n");
       emitThinking(true);
     }
-    const usageRecord = completedResponse.usage;
-    const usage = usageRecord ? {
-      inputTokens: Number(usageRecord.input_tokens ?? 0),
-      outputTokens: Number(usageRecord.output_tokens ?? 0),
-      // Responses `input_tokens` already INCLUDES the cached span (unlike
-      // Anthropic, which subtracts it), so no normalisation is needed —
-      // this is purely so cache behaviour becomes observable. Without it
-      // the Codex cache hit rate is unmeasurable: `prompt-cache.ts`
-      // instruments the Anthropic path only.
-      ...readResponsesCachedTokens(usageRecord)
-    } : void 0;
     return {
       content,
       stopReason: content.some((item) => item.type === "tool_use") ? "tool_use" : "end_turn",
-      usage,
+      usage: responseUsage,
       durationMs: Date.now() - start,
       // `outputItems` is the complete, correctly-ordered response array —
       // reasoning items with their `encrypted_content` still attached, each
@@ -4724,5 +5096,6 @@ export {
   OperatorAbortError,
   parseUsageLimitReached,
   LOOP_SERVER_COMPACTION_TOKENS,
+  getChatGptCodexAccessToken,
   LlmApiRuntime
 };