quoxcli 0.0.0-stage → 0.3.1

package/LICENSE

@@ -0,0 +1,35 @@
+QUOX COMMUNITY SOURCE LICENCE 1.0
+Effective: 12 October 2026
+Copyright (c) 2025-2026 Quox LTD. All rights reserved.
+
+THIS IS A SOURCE-AVAILABLE PROPRIETARY LICENCE. IT IS NOT AN OPEN-SOURCE LICENCE.
+
+1. Scope and ownership. "Licensor" is Quox LTD ("Quox"). "You" is a person or legal entity exercising the licence. "Licensed Software" means Quox-owned source code, executables, user interface, and accompanying documentation expressly distributed with this licence. It excludes third-party components governed by their own notices, and separately licensed Quox products such as Apache-2.0 protocols and MIT SDKs. Quox retains all rights not expressly granted.
+
+2. Free self-hosting and inspection. Subject to compliance, Quox grants You a worldwide, royalty-free, non-exclusive, non-transferable, non-sublicensable licence to acquire official Quox distributions, view and inspect their source, build unmodified software as required for deployment, and install and run any number of unmodified instances for Your own personal, educational, non-profit, or commercial operations. There are no licence fees or limits on seats, installations, servers, business revenue or duration for compliant use. You may make copies reasonably needed for installation, development and test environments, backups, disaster recovery, upgrades and migration, including on infrastructure You rent or control. A version lawfully acquired under this licence may be used indefinitely unless Your licence for that version validly terminates for breach under Section 11.
+
+3. Independent extensions. You may create, use, modify, publish, distribute, license, and sell independent plugins, agents, skills, workflows, automations, themes, integrations, connectors, applications and other extensions through documented Quox APIs, plugin systems and extension points. Quox does not gain ownership of those independent works by their use with Quox. Their creators choose their licences, subject to any third-party components and any separately accepted marketplace terms. An extension must not contain or distribute Quox-owned protected core code absent separate permission. Selling Your own outputs, services or products made USING Quox is permitted; selling access to Quox itself as a platform is addressed in Section 6.
+
+4. Protected core. Unless expressly allowed by this licence or non-waivable law, You must not edit, patch, modify or create derivative distributions of Quox-owned core source or binaries, replace or bypass core security/governance/licence controls, or distribute unofficial altered builds. Documented configuration, deployment settings, ordinary build output of unmodified source, dependency installation, troubleshooting, logging, source inspection, independent interoperability and supported plugins are permitted. This section does not attempt to forbid lawful observation, testing, security research or mandatory statutory rights.
+
+5. Distribution and repackaging. You must not sublicense, mirror, redistribute, rent, sell, OEM-bundle, repackage, commercially distribute or present protected Quox software (or a substantial portion) as a product without written permission. Copies reasonably necessary for Your permitted deployment, internal company operations and backups are allowed. GitHub forks/copies permitted by GitHub's own platform terms remain permitted on that service, but grant no independent right to alter core or distribute it commercially. Independently authored installers, scripts or deployment manifests may reference official Quox downloads without bundling the Licensed Software. Do not represent unofficial software as an official Quox release.
+
+6. Hosting, managed services, and white label. You may not supply third parties with Quox platform functions as a hosted, managed, multi-customer, white-labelled, OEM or platform-as-a-service offering, or operate multiple customer Quox instances as Your branded commercial service, without a separate agreement. This does not prohibit operating Quox for Your own organisation, using generic cloud hosting, selling Your own business services or their outputs, or paying a contractor to install or maintain YOUR directly licensed official Quox instance as Your agent. A contractor must not present Quox as its own hosted product. Commercial hosted-service and white-label terms are available from Quox separately.
+
+7. Branding and attribution. The official Quox name, logo, copyright notices and existing attribution in product-owned interfaces and command-line presentation must remain visible and unaltered, except under a separate written white-label agreement. You may add branding for Your own organisations, tenants, plugins, reports, documents and content via supported configuration without obscuring Quox product identity. No Quox trade mark ownership, registration rights, or general trade mark licence is granted. Accurate descriptive references and legally permitted use are unaffected.
+
+8. Commercial exceptions. Quox may separately license core changes, redistributions, OEM integrations, managed hosting, white labels, support and commercial features. No such agreement is required for compliant free self-hosting or the development and sale of genuinely independent extensions. A commercial agreement must expressly state its granted rights.
+
+9. Third-party and statutory rights. Third-party and open-source notices govern their respective components; nothing here claims to relicense them. Nothing restricts independent interoperable software solely for communicating through Quox interfaces. Nothing excludes rights which applicable law makes non-waivable, including software backups, lawful observation and testing, interoperability and applicable consumer or security-research rights. Any conflicting restriction is limited to the extent required by law.
+
+10. No mandatory account or telemetry. This licence does not require paid activation, compulsory telemetry or a Quox-hosted account to run the free self-hosted software. You retain rights in Your data, configurations, and independent extensions. Optional online services or marketplaces may have additional separately disclosed terms.
+
+11. Breach, cure and termination. Rights depend on compliance. For a curable material breach, Quox will ordinarily provide written notice describing it and thirty (30) days to cure before termination. Deliberate, continuing misappropriation, misleading commercial distribution or unlawful circumvention may justify immediate protective action as allowed by law. Upon valid termination, cease unlicensed use/distribution of protected Quox-owned software. Termination does not transfer ownership of Your extensions or data or revoke third-party open-source rights.
+
+12. Warranty and liability. TO THE MAXIMUM EXTENT PERMITTED BY LAW, LICENSED SOFTWARE IS PROVIDED "AS IS", WITHOUT EXPRESS OR IMPLIED WARRANTIES, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. QUOX EXCLUDES LIABILITY FOR INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL AND PUNITIVE DAMAGES TO THE EXTENT LAWFUL. NOTHING EXCLUDES LIABILITY WHICH CANNOT BE EXCLUDED BY LAW, INCLUDING FRAUD OR DEATH OR PERSONAL INJURY CAUSED BY NEGLIGENCE WHERE APPLICABLE.
+
+13. Law and versions. This licence is governed by the law of England and Wales, subject to mandatory protections in Your jurisdiction. Courts of England and Wales have jurisdiction where legally permitted. Quox may offer NEW versions under revised terms. Publishing new terms does not retroactively withdraw grants validly received for earlier versions. Separately signed agreements and applicable third-party licences govern where they apply.
+
+14. Contact. For white-label, managed-hosting, OEM, redistribution or other permissions: hello@quox.ai.
+
+Copyright (c) 2025-2026 Quox LTD. All rights reserved.

package/README.md

@@ -1,3 +1,145 @@
-# Temporary Holding Version
+# Quox
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The conversational front door to your self-hosted AI agent control plane. The `quoxcli` package gives you the `quox` command: a conversational terminal and a command line for QuoxCORE.
+
+It is a client. It does not include the server.
+
+## Install
+
+```sh
+npm install -g quoxcli
+```
+
+Needs Node.js 20 or later. This installs two commands: `quox`, and `quoxon` (an alias that opens the conversation).
+
+Docs: https://cli.quox.ai/docs/start/
+
+## Prerequisite: a running QuoxCORE
+
+You need a QuoxCORE instance to talk to. Install one on a machine you control: see https://github.com/quoxai/quoxcore, or run:
+
+```sh
+curl -fsSL https://get.quox.ai | sh
+```
+
+A built-in `quox server install` is coming. It does not exist yet.
+
+## Sign in
+
+```sh
+quox login
+```
+
+You will be asked for the address of your QuoxCORE and your credentials. Use `-p <name>` to keep several profiles (for example a dev box and a production box):
+
+```sh
+quox login -p work
+quox -p work whoami
+quox -p work
+```
+
+If you do not pass `-p`, Quox picks your human profile automatically. It never falls back to an ambient service key from your environment unless you pass `--service-key`.
+
+## Talk
+
+```sh
+quox
+```
+
+Bare `quox` opens the conversation. `quoxon` is an alias for the same thing. The older menu is still there as `quox tui`.
+
+Type what you want. Quox routes it to the right agent and shows what it is doing, including any tool that is held for your approval.
+
+| Key | What it does |
+|-----|--------------|
+| Enter | Send. While Quox is working, steer the running turn. |
+| Tab | Queue the message to send after the current turn. |
+| Esc | Stop the turn. Quox waits for the server to confirm it stopped. |
+| Ctrl+C | Press twice to quit. |
+| Ctrl+J | New line in the draft. |
+| Ctrl+G | Edit the draft in your editor. |
+| `/help` | List every key and command. |
+
+`quox --demo` runs a simulated session with no server, so you can look around first. Nothing real runs.
+
+### Approvals
+
+When a tool is held for your approval, act on it with an empty draft, or press Tab. Approvals are never a single key while you are typing, so a stray keystroke cannot approve anything. `/approvals` lists what is waiting.
+
+### Project rules: QUOX.md
+
+Put a `QUOX.md` in your project and Quox follows it. It is read from the current directory up to the git root, plus `~/.quox/QUOX.md` for rules that apply everywhere. Rules are capped at 5500 characters in total.
+
+| Command | What it does |
+|---------|--------------|
+| `/rules` | Show which rules are loaded |
+| `/rules off` | Turn rules off for this session |
+
+### Skills
+
+`/skills` lists the governed skills available to you. `/skill <name>` runs one.
+
+### Running work
+
+Workflows and loops that are running appear in a roster under the status line. `/roster` shows it in full, and `/observers` shows what is watching.
+
+## Headless
+
+```sh
+quox --print "summarise what happened on the fleet today"
+echo "check the approvals queue" | quox --print
+quox --print "list my agents" --output json
+```
+
+`--output json` writes one event per line. Other flags: `--conversation <id>`, `--turn-id <id>`, `--timeout <seconds>`.
+
+| Exit code | Meaning |
+|-----------|---------|
+| 0 | Completed |
+| 1 | Error |
+| 2 | Held for approval |
+| 3 | Interrupted |
+| 4 | Not signed in, or identity problem |
+| 5 | Ended without confirmation |
+
+## Everyday commands
+
+Run `quox --help` for the full list, and `quox <command> --help` for each one.
+
+| Command | What it does |
+|---------|--------------|
+| `quox login` / `logout` / `whoami` | Sign in, sign out, show who you are |
+| `quox status` | Platform health overview |
+| `quox doctor` | Run diagnostics on the CLI and the platform |
+| `quox chat "<message>"` | Chat with CommanderQ or any agent |
+| `quox agent` | Manage agents |
+| `quox workflow` | Manage workflows |
+| `quox fleet` | Fleet monitoring and management |
+| `quox memory` | Manage memories |
+| `quox approvals` | Tool approvals held for a human decision |
+| `quox inbox` | Inbox and approval requests |
+| `quox mail` | InboxQ: connected mail accounts and triaged messages |
+| `quox calendar` | Calendar-Q: agenda and coverage |
+| `quox governance` | Policies, the WARD chain and evidence |
+| `quox config` | CLI configuration and profiles |
+
+Global options include `--json`, `-p/--profile`, `--org`, `--dry-run`, `-y/--yes` and `--debug`.
+
+## Troubleshooting
+
+**Self-signed certificate (`fetch failed`).** If your QuoxCORE uses its own certificate authority, point Node at the certificate. Do not turn TLS checking off.
+
+```sh
+export NODE_EXTRA_CA_CERTS=/path/to/your-ca.pem
+```
+
+**"Not signed in" or exit code 4.** Run `quox login` again, with the same `-p` profile you used before. Check with `quox whoami`.
+
+**Slow or no response.** Run `quox status` and `quox doctor` to see whether the server is reachable and healthy. Add `--debug` to see the HTTP calls. In headless mode, set `--timeout`.
+
+## Licence
+
+Quox Community Source Licence 1.0. This is source-available software, not open source. You may self-host and inspect it freely; redistribution and repackaging are restricted. Read the full text in the `LICENSE` file or at https://github.com/quoxai/quoxcore.
+
+Website: https://quox.ai  
+CLI home: https://cli.quox.ai

package/bin/quox.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import '../lib/core/prodEnv.js'; // first: production React unless NODE_ENV is set (before anything loads React)
+
+import v8 from 'node:v8';
+
+// QUOXON-LATENCY: a warm `claude` spare cannot carry this turn's conversation id in its
+// (fixed) env, so the collector writes it to QUOX_SESSION_ID_FILE for the turn. Surface it
+// as QUOX_SESSION_ID before any command reads it. An explicit QUOX_SESSION_ID wins.
+if (!process.env.QUOX_SESSION_ID && process.env.QUOX_SESSION_ID_FILE) {
+  // dynamic, not a static import: bin/quox.js keeps its static imports to prodEnv + node:v8 (r3early, input capture first)
+  try { process.env.QUOX_SESSION_ID = (await import('node:fs')).readFileSync(process.env.QUOX_SESSION_ID_FILE, 'utf8').trim(); } catch { /* turn ended: no session */ }
+}
+
+// CORTEX-BENCH: Node's fetch parses HTTP with a WebAssembly module, and V8
+// recompiles it at the optimising tier on a background thread; Node waits for
+// that compile before exiting, adding 350-700ms to every short command after
+// its output is already printed. The baseline tier is plenty for a CLI.
+v8.setFlagsFromString('--liftoff-only');
+
+// Bare `quox` is the conversation (CLI-QUOXON Q3, owner decision): with no
+// subcommand and only client flags, a TTY gets the QUOXON client and
+// `--print` runs headless. The old 15-item menu is `quox tui`. Decided from
+// argv alone, before config or any command module loads.
+// R3 D4: raw mode before ANY heavy module loads. The command modules below used to be static imports,
+// evaluated before this block, so keys typed in the first ~2 s echoed cooked and an Enter was lost.
+{
+  const { routesToQuoxon } = await import('../lib/quoxon/route.js');
+  const qArgv = process.argv.slice(2);
+  if (routesToQuoxon(qArgv, process.stdout.isTTY)) {
+    // QUOXON-RESTART-LEAK: the first interactive client on a terminal becomes a tiny launcher (no TUI, no polling)
+    // that runs the client as its child and re-runs it on /restart, so restarts never nest (98 deep, 15 GB, 2026-10-17).
+    const launcher = await import('../lib/quoxon/launcher.js');
+    if (launcher.shouldLaunch({ argv: qArgv })) {
+      const code = await launcher.runLauncher({ argv: qArgv });
+      if (code !== null) process.exit(code); // null: no handoff dir, so run the client in this process as before
+    }
+    launcher.takeLauncherHandoff(); // a launched client: read and drop the handoff var before anything can spawn
+    if (!qArgv.some(a => a === '--print' || a.startsWith('--print=') || a === '-h' || a === '--help')) (await import('../lib/quoxon/earlyInput.js')).captureEarlyInput();
+    try {
+      // QUOXON-LATENCY: --print runs headless without loading React / Ink / the App (~2 s cold).
+      const headless = qArgv.some(a => a === '--print' || a.startsWith('--print='))
+        && await (await import('../lib/quoxon/headless.js')).runHeadless(qArgv);
+      if (!headless) {
+        const { main: quoxonMain } = await import('../lib/quoxon/main.js');
+        await quoxonMain(qArgv);
+      }
+    } catch (err) {
+      console.error(err?.message || err);
+      process.exitCode = 1;
+    }
+    process.exit(process.exitCode || 0);
+  }
+}
+
+// The commander CLI: loaded only when the conversation client is not (see the block above).
+// `quox --update` is `quox update` (owner 2026-10-16): one updater, lib/core/selfUpdate.js.
+if (process.argv.includes('--update')) process.argv = [...process.argv.slice(0, 2), ...(await import('../lib/core/selfUpdate.js')).rewriteUpdateFlag(process.argv.slice(2))];
+const { Command } = await import('commander');
+const { loadConfig, resolveProfileFlagFromArgv } = await import('../lib/core/config.js');
+const { resolveCliVersion, BASE_VERSION } = await import('../lib/core/version.js');
+const { applyRootOptions, installFlagDeliveryHooks } = await import('../lib/core/rootOptions.js');
+const { createAuth } = await import('../lib/core/auth.js');
+const { extractActingAs } = await import('../lib/core/actingAs.js');
+const { createClient } = await import('../lib/core/client.js');
+const { handleError } = await import('../lib/core/errors.js');
+const { assertOrgOverrideSafe, commandPath } = await import('../lib/core/org-override.js');
+// QUOXIFY pass 2 (DEVSUITE phase 15): the two dev-suite members that had no
+// unified verb at all. Gripe's own definition of done named `quox gripe`.
+const { generateCompletion } = await import('../lib/core/completions.js');
+const { loadAllPlugins } = await import('../lib/plugins/loader.js');
+const { registerCommandGroups } = await import('../lib/core/lazyCommands.js');
+
+// #610: --version must reflect the ACTUAL running commit, not a frozen literal
+// (the global CLI worktree was silently 32 commits behind and --version never
+// showed it). The git-backed resolution lives in ../lib/core/version.js, shared
+// with `quox doctor` so the two never disagree. Resolving the commit needs a
+// git read, so only pay that cost when --version/-V is actually requested —
+// every other command stays zero-cost by keeping the argv guard HERE (the
+// shared resolver has none, because doctor wants the facts unconditionally).
+const versionRequested = process.argv.includes('--version') || process.argv.includes('-V');
+
+const program = new Command();
+
+program
+  .name('quox')
+  .description('QuoxCORE CLI — manage agents, workflows, memory, fleet, and more')
+  .version(versionRequested ? resolveCliVersion() : BASE_VERSION);
+// Global options live in lib/core/rootOptions.js so the safety-flag test builds this same root.
+applyRootOptions(program)
+  .addHelpText('after', '\nConversation (QUOXON client):\n  quox                                  interactive conversation (terminal only)\n  quox --print "<prompt>" [--output text|json] [--conversation <id>] [--timeout <s>]   one headless turn; exit 0 completed, 2 held for approval, 3 interrupted, 4 not signed in, 5 unconfirmed\n  quox --demo                           simulated journey, nothing real runs\n');
+
+// Wire up global flags
+program.hook('preAction', (thisCommand) => {
+  const opts = thisCommand.opts();
+  if (opts.json) opts.output = 'json';
+  if (opts.quiet) opts.output = 'quiet';
+});
+
+// A subcommand that redeclares a root flag (--yes, --org, --json, --dry-run)
+// never receives it: commander resolves against the root first and the
+// subcommand reads undefined forever. See lib/core/global-flags.js for the
+// 13 places this had already shipped, including --dry-run executing for real.
+// Also: a --dry-run the leaf cannot honour is refused, never silently dropped
+// (quox#1077 follow-up). Both hooks live in lib/core/rootOptions.js.
+installFlagDeliveryHooks(program);
+
+// #1141: `--org <slug>` (and a slug in QUOX_ORG_ID) resolves to the org ID once, here, so every verb and
+// the GRIPE-709 guard below see an ID. ID-shaped values pass through with no call. Login-type verbs are left alone.
+program.hook('preAction', async (thisCommand, actionCommand) => {
+  const { isOrgId, resolveOrgRef } = await import('../lib/core/orgResolve.js');
+  const { EXEMPT } = await import('../lib/core/org-override.js');
+  if (EXEMPT.has(commandPath(actionCommand))) return;
+  const rootOrg = thisCommand.opts().org;
+  const leafOrg = actionCommand !== thisCommand ? actionCommand.getOptionValue?.('org') : undefined;
+  const envOrg = process.env.QUOX_ORG_ID;
+  if ([rootOrg, leafOrg, envOrg].every((v) => !v || typeof v !== 'string' || isOrgId(v))) return;
+  const { resolveEndpoint } = await import('../lib/api/endpoints.js');
+  const listOrgs = async () => {
+    const ep = resolveEndpoint('orgs.list');
+    const d = await client.get(ep.path, { service: ep.service });
+    return Array.isArray(d) ? d : (d?.organizations || d?.orgs || d?.data || []);
+  };
+  const base = { profile: config.getActiveProfileName?.() || 'default', authData: config.getAuth?.() || null, listOrgs };
+  if (typeof rootOrg === 'string' && !isOrgId(rootOrg)) thisCommand.setOptionValue('org', await resolveOrgRef(rootOrg, base));
+  if (typeof leafOrg === 'string' && !isOrgId(leafOrg)) actionCommand.setOptionValue('org', await resolveOrgRef(leafOrg, base));
+  if (envOrg && !isOrgId(envOrg)) process.env.QUOX_ORG_ID = await resolveOrgRef(envOrg, { ...base, source: 'QUOX_ORG_ID' });
+});
+
+// GRIPE-709: --org must be honoured or refused, never silently ignored.
+program.hook('preAction', (thisCommand, actionCommand) => {
+  assertOrgOverrideSafe({
+    override: thisCommand.opts().org,
+    authData: config.getAuth?.() || null,
+    hasUserToken: Boolean(auth.getTokens?.()?.access_token),
+    command: commandPath(actionCommand),
+  });
+});
+
+// Handle --insecure and --no-color before anything runs
+// QUOX_INSECURE=1 is the env twin of --insecure: dev-server wrappers set it
+// because the LAN dashboard proxy serves a self-signed cert and requiring
+// --insecure on every verb is a papercut (DEVSUITE phase 8). Same warning,
+// same mechanism, so it is never silent.
+if (process.argv.includes('--insecure') || process.env.QUOX_INSECURE === '1') {
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+  console.error('\x1b[33mWARNING: TLS certificate verification disabled (--insecure)\x1b[0m');
+}
+if (process.argv.includes('--no-color') || process.env.NO_COLOR) {
+  process.env.FORCE_COLOR = '0';
+}
+
+// Build shared context
+// program.opts() is EMPTY here (parse() runs later) — the -p flag must come
+// from the argv pre-scan or it silently falls back to activeProfile.
+// quox#772: fold a global `--as <agent>` into QUOX_AS (flag wins) and strip it
+// from argv before commander sees it (linkedin/claude own their own --as).
+{
+  const acting = extractActingAs(process.argv.slice(2), process.env);
+  if (acting.name) {
+    // flag vs env matters to `whoami` only: record the origin (flag wins).
+    const fromFlag = extractActingAs(process.argv.slice(2), {}).name;
+    process.env.QUOX_AS = acting.name;
+    process.env.QUOX_AS_FLAG = fromFlag ? '1' : '0';
+  }
+  process.argv = [...process.argv.slice(0, 2), ...acting.argv];
+}
+const config = loadConfig(resolveProfileFlagFromArgv(process.argv.slice(2)));
+const auth = createAuth(config);
+const client = createClient(config, auth);
+const ctx = { config, auth, client, program };
+
+// Register all command groups
+// Command groups, in registration order. CORTEX-BENCH (quox#7xx CLI startup):
+// importing all 86 modules cost ~1s on EVERY invocation, including each
+// attached-agent `quox agent exec` tool call. They now load lazily: only the
+// module(s) that define the command being run (see lib/core/lazyCommands.js),
+// with a full load whenever the command is unknown, help is asked for, or the
+// lazy path fails. A miss can only be slower, never wrong.
+const { COMMAND_REGISTRARS, COMMAND_REGISTRARS_BASE } = await import('../lib/core/commandRegistrars.js');
+await registerCommandGroups(program, ctx, COMMAND_REGISTRARS, process.argv.slice(2), COMMAND_REGISTRARS_BASE);
+
+// TUI command
+program
+  .command('tui')
+  .argument('[screen]', 'Open directly on a screen (fleet, agents, tools, orgs, memory, brain, workflows, chat, admin, files, backups, objectives, inbox, vault, governance, health)')
+  .option('--governed', 'Run the TUI in a Quox governed tmux session (survives sleep and drops)')
+  .option('--name <name>', 'Session name for --governed (reattaches if it is already running)')
+  .option('--no-tmux', 'With --governed: skip tmux')
+  .description('Launch the classic menu TUI (bare `quox` opens the conversation)')
+  .action(async (screen, opts) => {
+    if (opts && opts.governed) {
+      const { runTuiGoverned } = await import('../lib/commands/claude.js');
+      process.exitCode = runTuiGoverned({ screen, name: opts.name, noTmux: opts.tmux === false });
+      return;
+    }
+    const { launchTUI } = await import('../lib/tui/index.js');
+    await launchTUI(ctx, { initialScreen: screen });
+  });
+
+// Shell completion command
+program
+  .command('completion <shell>')
+  .description('Generate shell completions (bash, zsh, fish)')
+  .action((shell) => {
+    process.stdout.write(generateCompletion(shell));
+  });
+
+// Load plugins (non-blocking — errors are logged, not thrown)
+try {
+  const { loaded, errors } = await loadAllPlugins(program, ctx);
+  if (program.opts().debug && loaded.length > 0) {
+    console.error(`Loaded ${loaded.length} plugin(s): ${loaded.map(p => p.name).join(', ')}`);
+  }
+  if (errors.length > 0) {
+    for (const e of errors) {
+      console.error(`Plugin "${e.name}" failed: ${e.error}`);
+    }
+  }
+} catch {
+  // Plugin loading should never crash the CLI
+}
+
+// C4: once a day, warn when this CLI and the server differ in major/minor. Never for JSON/quiet output,
+// a non-TTY stderr, or `quox server …` itself (that verb shows versions); never fails a command.
+async function warnVersionSkew() {
+  try {
+    const o = program.opts();
+    if (o.output === 'json' || o.output === 'quiet' || o.json || o.quiet || !process.stderr.isTTY || process.env.QUOX_NO_SKEW_CHECK) return;
+    const first = process.argv.slice(2).find((a) => !a.startsWith('-'));
+    if (!first || first === 'server') return;
+    const { checkSkewOncePerDay } = await import('../lib/server/skew.js');
+    const sk = await checkSkewOncePerDay({ collectorUrl: config.getServiceUrl('collector') });
+    if (sk) process.stderr.write(`\u26a0 version skew: ${sk.message}\n`);
+  } catch { /* advisory only */ }
+}
+
+// Bare `quox` in a TTY never reaches here (routed to QUOXON above); bare
+// non-TTY prints the banner so a script never hangs.
+{
+  try {
+    if (process.argv.length <= 2) {
+      // Bare `quox`: the splash, not a help dump (DEVSUITE-GLYPH).
+      const { printBanner } = await import('../lib/core/banner.js');
+      let loggedIn = true;
+      try { loggedIn = !!auth.isLoggedIn(); } catch { /* banner must never fail */ }
+      printBanner(program.version(), { loggedIn });
+      process.exit(0);
+    }
+    await program.parseAsync(process.argv);
+    await warnVersionSkew();
+  } catch (err) {
+    // #1101: Ctrl-C at any inquirer prompt is the user leaving: "Cancelled.", cursor back, exit 130, no stack.
+    const { exitOnPromptCancel } = await import('../lib/core/promptCancel.js');
+    exitOnPromptCancel(err); // exits 130 on a cancel; otherwise falls through to the normal error printer
+    // #995: tell the error printer which group failed and what verbs it has, so a 404 hint names a real one
+    let ctx = null;
+    try {
+      const word = process.argv.slice(2).find((a, i, all) => !a.startsWith('-') && !['-p', '--profile', '--org', '-o', '--output'].includes(all[i - 1]));
+      const grp = word && program.commands.find((c) => c.name() === word || c.aliases().includes(word));
+      if (grp) ctx = { group: grp.name(), subcommands: grp.commands.map((c) => c.name()) };
+    } catch { /* the hint is advisory */ }
+    handleError(err, program.opts().output, ctx);
+    process.exit(err.exitCode || 1);
+  }
+}

package/bin/quoxon.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import '../lib/core/prodEnv.js'; // first: production React unless NODE_ENV is set (before anything loads React)
+import { main } from '../lib/quoxon/main.js';
+
+main().catch((err) => {
+  console.error(err?.message || err);
+  process.exit(1);
+});

package/lib/api/endpoints/admin.js

@@ -0,0 +1,151 @@
+/**
+ * 'admin.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const admin = {
+  'admin.config.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/config`,
+    tags: ['live-safe'],
+  },
+  'admin.agent_identity.mint': {
+    method: 'POST',
+    service: 'auth',
+    path: () => '/api/admin/agent-identities',
+    tags: ['admin-write'],
+  },
+  // Instance basics after setup (app URL etc). Served by services/auth/routes/admin-instance.js.
+  'admin.instance.basics.get': {
+    method: 'GET',
+    service: 'auth',
+    path: () => '/api/admin/instance/basics',
+    tags: ['live-safe'],
+  },
+  'admin.instance.basics.set': {
+    method: 'PUT',
+    service: 'auth',
+    path: () => '/api/admin/instance/basics',
+    tags: ['admin-write'],
+  },
+  // LAN integration targets gate (allow_lan_integration_targets). Served by services/auth/routes/admin-instance.js.
+  'admin.instance.lan_targets.get': {
+    method: 'GET',
+    service: 'auth',
+    path: () => '/api/admin/instance/lan-targets',
+    tags: ['live-safe'],
+  },
+  'admin.instance.lan_targets.set': {
+    method: 'PUT',
+    service: 'auth',
+    path: () => '/api/admin/instance/lan-targets',
+    tags: ['admin-write'],
+  },
+  'admin.config.update': {
+    method: 'PATCH',
+    service: 'auth',
+    path: ({ key }) => `/api/admin/config/${key}`,
+    tags: ['live-write'],
+  },
+  // LICENSE-LAUNCH LL-6b — enforcement posture + break-glass. Served by
+  // services/auth/routes/setup.js; read is any authenticated user, both
+  // writes are instance-admin only.
+  'admin.enforcement.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/setup/enforcement`,
+    tags: ['live-safe'],
+  },
+  'admin.enforcement.break_glass.open': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/setup/enforcement/break-glass`,
+    tags: ['admin-write'],
+  },
+  'admin.enforcement.break_glass.clear': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ flag }) => `/api/setup/enforcement/break-glass/${flag}`,
+    tags: ['admin-write'],
+  },
+  'admin.email.status': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/email/status`,
+    tags: ['live-safe'],
+  },
+  'admin.email.smtp': {
+    method: 'PUT',
+    service: 'auth',
+    path: () => `/api/admin/email/smtp`,
+    tags: ['live-write'],
+  },
+  'admin.email.test': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/admin/email/test`,
+    tags: ['live-write'],
+  },
+  'admin.keys.create': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/admin/keys`,
+    tags: ['live-write'],
+  },
+  'admin.keys.delete': {
+    method: 'DELETE',
+    service: 'auth',
+    path: ({ keyId }) => `/api/admin/keys/${keyId}`,
+    tags: ['live-write'],
+  },
+  'admin.keys.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/keys`,
+    tags: ['live-safe'],
+  },
+  'admin.keys.test': {
+    method: 'POST',
+    service: 'auth',
+    path: ({ keyId }) => `/api/admin/keys/${keyId}/test`,
+    tags: ['live-write'],
+  },
+  'admin.logs.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/logs`,
+    tags: ['live-safe'],
+  },
+  'admin.retention.cleanup': {
+    method: 'POST',
+    service: 'auth',
+    path: () => `/api/admin/retention/cleanup`,
+    tags: ['live-write'],
+  },
+  'admin.retention.config.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/retention/config`,
+    tags: ['live-safe'],
+  },
+  'admin.retention.stats.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/retention/stats`,
+    tags: ['live-safe'],
+  },
+  'admin.services.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/services`,
+    tags: ['live-safe'],
+  },
+  'admin.stats.list': {
+    method: 'GET',
+    service: 'auth',
+    path: () => `/api/admin/stats`,
+    tags: ['live-safe'],
+  },
+};

package/lib/api/endpoints/aee.js

@@ -0,0 +1,38 @@
+/**
+ * 'aee.*' endpoints — extracted from the former monolithic
+ * cli/lib/api/endpoints.js as part of the per-domain fragment split.
+ * See cli/lib/api/endpoints/index.js for aggregation + the fragment convention.
+ */
+
+export const aee = {
+  'aee.conversations.list': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/aee/conversations`,
+    tags: ['live-safe'],
+  },
+  'aee.get': {
+    method: 'GET',
+    service: 'collector',
+    path: ({ id }) => `/aee/${id}`,
+    tags: ['live-safe'],
+  },
+  'aee.query.list': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/aee/query`,
+    tags: ['live-safe'],
+  },
+  'aee.stats.list': {
+    method: 'GET',
+    service: 'collector',
+    path: () => `/aee/stats`,
+    tags: ['live-safe'],
+  },
+  'aee.store': {
+    method: 'POST',
+    service: 'collector',
+    path: () => `/aee/store`,
+    tags: ['live-write'],
+  },
+};