@intutic/cli 1.10.0 → 1.10.1

package/dist/cli.js

@@ -32,6 +32,26 @@ program
     const { runInit } = await import('./commands/init.js');
     await runInit(opts);
 });
+// ── Cohort setup wizard (LLD #70) ────────────────────────────────────────
+program
+    .command('setup')
+    .description('Guided setup: detect harnesses, configure a provider credential, verify it, and (optionally) a judge model')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runSetup } = await import('./commands/setup.js');
+    await runSetup(opts);
+});
+const judgeCmd = program
+    .command('judge')
+    .description('Configure the LLM-as-judge path');
+judgeCmd
+    .command('configure')
+    .description('Generate local artifacts (litellm_config.yaml, env, Helm values) for an on-prem judge — never a remote API call')
+    .option('--out <path>', 'Where to write litellm_config.yaml', './litellm_config.yaml')
+    .action(async (opts) => {
+    const { runJudgeConfigure } = await import('./commands/judge.js');
+    await runJudgeConfigure(opts);
+});
 program
     .command('login')
     .description('Authenticate with the Intutic control plane')
@@ -62,14 +82,45 @@ program
     const { runDoctor } = await import('./commands/doctor.js');
     await runDoctor();
 });
+program
+    .command('rollback')
+    .description('List or restore pre-images captured when a guard flagged a file-writing call')
+    .option('--list', 'List captured pre-images (the default with no --id)')
+    .option('--id <id>', 'Restore the named pre-image')
+    .action(async (opts) => {
+    const { runRollback } = await import('./commands/rollback.js');
+    await runRollback(opts);
+});
 program
     .command('budget')
     .description('Check remaining daily/monthly budget and list active loops')
     .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .option('--watch', 'Continuously print machine-local and workspace spend, one line per tick')
+    .option('--interval <seconds>', 'Tick interval in seconds for --watch', String(5))
     .action(async (opts) => {
+    if (opts.watch) {
+        const { runBudgetWatch } = await import('./commands/budget.js');
+        await runBudgetWatch(opts);
+        return;
+    }
     const { runBudget } = await import('./commands/budget.js');
     await runBudget(opts);
 });
+program
+    .command('predict-cost')
+    .description('Pre-flight cost estimate for a prompt/task before it runs (POST /api/v1/predict-cost). ' +
+    'Estimates output tokens from the workspace baseline and prices with the same rate table ' +
+    'every other cost figure in the control plane uses.')
+    .requiredOption('--model <model>', 'Model to estimate against (e.g. claude-sonnet-4-5)')
+    .option('--task-type <type>', 'Task type used to pick the baseline bucket', 'coding')
+    .option('--tokens <n>', 'Input token count (mutually exclusive with --file)')
+    .option('--file <path>', 'File whose contents size the input (mutually exclusive with --tokens)')
+    .option('--json', 'Output as JSON instead of a report')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runPredictCost } = await import('./commands/predict-cost.js');
+    await runPredictCost(opts);
+});
 const sopsCmd = program
     .command('sops')
     .description('Manage local and global SOP rules');
@@ -77,10 +128,44 @@ sopsCmd
     .command('push <name>')
     .description('Push a local offline SOP folder to the central workspace')
     .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .option('--org', "Push as an org-wide floor (LLD #65 follow-up) instead of a workspace SOP -- applies to every workspace under the caller's org, in addition to that workspace's own SOPs")
     .action(async (name, opts) => {
     const { runSopsPush } = await import('./commands/sops.js');
     await runSopsPush(name, opts);
 });
+sopsCmd
+    .command('pull')
+    .description('Pull every workspace SOP from the control plane into .intutic/sops/<slug>.md')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .option('--force', 'Overwrite locally-modified files instead of refusing them')
+    .action(async (opts) => {
+    const { runSopsPull } = await import('./commands/sops.js');
+    await runSopsPull(opts);
+});
+sopsCmd
+    .command('status')
+    .description('Show drift between .intutic/sops/*.md and the control plane, read-only')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runSopsStatus } = await import('./commands/sops.js');
+    await runSopsStatus(opts);
+});
+sopsCmd
+    .command('org-list')
+    .description("List org-wide SOP floors for the caller's own org (LLD #65 follow-up)")
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runSopsOrgList } = await import('./commands/sops.js');
+    await runSopsOrgList(opts);
+});
+sopsCmd
+    .command('org-rm <orgSopId>')
+    .description('Remove (soft-delete) an org-wide SOP floor')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (orgSopId, opts) => {
+    const { runSopsOrgRm } = await import('./commands/sops.js');
+    await runSopsOrgRm(orgSopId, opts);
+});
 const policyCmd = program
     .command('policy')
     .description('Manage compliance and safety policies');
@@ -109,6 +194,17 @@ policyCmd
     const { runPolicyRollback } = await import('./commands/policy.js');
     await runPolicyRollback(policyId, opts);
 });
+policyCmd
+    .command('snapshot')
+    .description('Compile workspace policy to ~/.intutic/hooks/policy-snapshot.rules — the file every gate reads.\n' +
+    '\n' +
+    '  Does only that. \'intutic connect\' writes it too, but as one step of\n' +
+    '  starting the full sync daemon; this arms the gates without one.')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runPolicySnapshot } = await import('./commands/policy.js');
+    await runPolicySnapshot(opts);
+});
 policyCmd
     .command('export')
     .description('Export compliance policies to stdout')
@@ -130,9 +226,12 @@ policyCmd
 policyCmd
     .command('compile')
     .description('Compile an AssemblyScript rule to WASM (wraps asc)')
-    .option('--src <path>', 'Rule source entry file', 'assembly/index.ts')
-    .option('--out <path>', 'Output .wasm path', 'build/rule.wasm')
+    .option('--src <path>', 'Rule source entry file (default: assembly/index.ts)')
+    .option('--out <path>', 'Output .wasm path (default: build/rule.wasm, or build/<candidate>.wasm with --candidate)')
     .option('--debug', 'Include debug info and source maps')
+    .option('--candidate <id>', 'Compile a rule candidate from its source of record on the control plane (fetched and hash-verified; not with --src)')
+    .option('--upload', 'With --candidate: upload the bundle to the candidate with its source hash and print the gate results')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
     .action(async (opts) => {
     const { runPolicyCompile } = await import('./commands/policy.js');
     await runPolicyCompile(opts);
@@ -154,6 +253,217 @@ policyCmd
     const { runPolicyListLocal } = await import('./commands/policy.js');
     await runPolicyListLocal();
 });
+policyCmd
+    .command('replay <ruleId>')
+    .description("Replay a rule (installed or not) against this workspace's own recent traffic and report " +
+    'what it would have done, without touching enforcement.')
+    .option('--limit <n>', 'Max sampled contexts to replay against (default 500, capped at 5000)')
+    .option('--since <duration>', 'Only contexts at or after this time — relative ("7d", "24h") or ISO 8601')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (ruleId, opts) => {
+    const { runPolicyReplay } = await import('./commands/policy.js');
+    await runPolicyReplay(ruleId, opts);
+});
+// Policy Clause Ledger (LLD #71). `intutic policy` is the WASM loop and
+// `intutic sops` is files on disk; this namespace is the cited guardrails
+// extracted from policy documents and their shadow -> promote lifecycle.
+const guardrailsCmd = program
+    .command('guardrails')
+    .description('Policy documents, cited clauses and the guardrails compiled from them');
+const guardrailsSourcesCmd = guardrailsCmd
+    .command('sources')
+    .description('Policy sources (Notion, Confluence, GitHub, Google Docs) feeding the ledger');
+guardrailsSourcesCmd
+    .command('list')
+    .description('List configured policy sources and their last sync')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsSourcesList } = await import('./commands/guardrails.js');
+    await runGuardrailsSourcesList(opts);
+});
+guardrailsSourcesCmd
+    .command('add <provider>')
+    .description('Connect a policy source; the credential is read from --token or --token-file, never echoed')
+    .requiredOption('--name <name>', 'Display name for the source')
+    .option('--token <token>', 'Provider credential (integration token or API key)')
+    .option('--token-file <path>', 'Read the credential from a file (a Google service-account key JSON)')
+    .option('--config <json>', 'Provider-specific settings as a JSON object (gdrive: {"folder_id": "…"})')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (provider, opts) => {
+    const { runGuardrailsSourcesAdd } = await import('./commands/guardrails.js');
+    await runGuardrailsSourcesAdd(provider, opts);
+});
+guardrailsSourcesCmd
+    .command('sync <connectorId>')
+    .description('Pull the source now instead of waiting for the next cron pass')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (connectorId, opts) => {
+    const { runGuardrailsSourcesSync } = await import('./commands/guardrails.js');
+    await runGuardrailsSourcesSync(connectorId, opts);
+});
+const guardrailsDocsCmd = guardrailsCmd
+    .command('docs')
+    .description('Ingested policy documents and their citable passages');
+guardrailsDocsCmd
+    .command('list')
+    .description('List ingested policy documents')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsDocsList } = await import('./commands/guardrails.js');
+    await runGuardrailsDocsList(opts);
+});
+guardrailsDocsCmd
+    .command('show <docId>')
+    .description('Show a document, its passages and the clauses extracted from them')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (docId, opts) => {
+    const { runGuardrailsDocsShow } = await import('./commands/guardrails.js');
+    await runGuardrailsDocsShow(docId, opts);
+});
+guardrailsDocsCmd
+    .command('extract <docId>')
+    .description('Propose cited guardrails from a document (every proposal is re-validated deterministically)')
+    .option('--no-llm', 'Only lift existing SOP front matter; do not call the extraction model')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (docId, opts) => {
+    const { runGuardrailsDocsExtract } = await import('./commands/guardrails.js');
+    await runGuardrailsDocsExtract(docId, { ...opts, noLlm: opts.llm === false });
+});
+guardrailsCmd
+    .command('search <token>')
+    .description('Which passages and guardrails mention a tool or action token (e.g. Bash, terraform); with --text, which passages use these words')
+    .option('--text', 'Full-text search over the words of every live passage instead of an exact token')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (token, opts) => {
+    const { runGuardrailsSearch } = await import('./commands/guardrails.js');
+    await runGuardrailsSearch(token, opts);
+});
+guardrailsCmd
+    .command('list')
+    .description('List guardrails with their status and shadow evidence')
+    .option('--status <status>', 'PROPOSED | SHADOW | ENFORCING | REJECTED | RETIRED')
+    .option('--target <target>', 'hook_rule | sop_front_matter | wasm_rule')
+    .option('--doc <docId>', 'Only guardrails cited from this document')
+    .option('--limit <n>', 'Max rows (default 50, capped at 200)')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsList } = await import('./commands/guardrails.js');
+    await runGuardrailsList(opts);
+});
+guardrailsCmd
+    .command('show <guardrailId>')
+    .description('Show a guardrail: cited passage, rendered artifact, validation checks and readiness')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsShow } = await import('./commands/guardrails.js');
+    await runGuardrailsShow(guardrailId, opts);
+});
+guardrailsCmd
+    .command('approve-shadow <guardrailId>')
+    .description('Ship a proposed guardrail in shadow: it reports, never blocks')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsApproveShadow } = await import('./commands/guardrails.js');
+    await runGuardrailsApproveShadow(guardrailId, opts);
+});
+guardrailsCmd
+    .command('promote <guardrailId>')
+    .description('Promote a shadow guardrail to enforcing once the server says it is ready')
+    .option('--acknowledge-no-traffic', 'Promote a rule that no observed traffic exercised')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsPromote } = await import('./commands/guardrails.js');
+    await runGuardrailsPromote(guardrailId, opts);
+});
+guardrailsCmd
+    .command('reject <guardrailId>')
+    .description('Reject a guardrail; the reason is recorded on its authority chain')
+    .requiredOption('--reason <reason>', 'Why it is rejected')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsReject } = await import('./commands/guardrails.js');
+    await runGuardrailsReject(guardrailId, opts);
+});
+guardrailsCmd
+    .command('retire <guardrailId>')
+    .description('Retire a shadow or enforcing guardrail; it stops being projected')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsRetire } = await import('./commands/guardrails.js');
+    await runGuardrailsRetire(guardrailId, opts);
+});
+guardrailsCmd
+    .command('reconfirm <guardrailId>')
+    .description('Confirm a guardrail whose cited passage changed upstream still holds')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsReconfirm } = await import('./commands/guardrails.js');
+    await runGuardrailsReconfirm(guardrailId, opts);
+});
+guardrailsCmd
+    .command('replay <guardrailId>')
+    .description('Run a guardrail over captured calls and report how many it would have fired on')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (guardrailId, opts) => {
+    const { runGuardrailsReplay } = await import('./commands/guardrails.js');
+    await runGuardrailsReplay(guardrailId, opts);
+});
+guardrailsCmd
+    .command('conflicts')
+    .description('List guardrails that contradict each other, with both quotes')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsConflicts } = await import('./commands/guardrails.js');
+    await runGuardrailsConflicts(opts);
+});
+guardrailsCmd
+    .command('impact')
+    .description('What a change to a document or passage reaches: passages within five computed edges, the clauses citing them, their guardrails')
+    .option('--doc <docId>', 'Start from every live passage of this document')
+    .option('--passage <passageId>', 'Start from one passage')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsImpact } = await import('./commands/guardrails.js');
+    await runGuardrailsImpact(opts);
+});
+guardrailsCmd
+    .command('duplicates')
+    .description('Overlapping passage pairs (with their Jaccard arithmetic) and the same rule cited from more than one passage')
+    .option('--min-jaccard <n>', 'Only pairs at or above this Jaccard (never below the recorded 0.70)')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsDuplicates } = await import('./commands/guardrails.js');
+    await runGuardrailsDuplicates(opts);
+});
+guardrailsCmd
+    .command('pull')
+    .description('Write the SHADOW and ENFORCING front-matter guardrails to .intutic/sops/guardrail-<id>.md, for a proxy that reads SOPs from disk')
+    .option('--force', 'Overwrite a locally-modified guardrail file instead of refusing it')
+    .option('--prune', 'Remove guardrail files that are no longer served (unmodified ones only)')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGuardrailsPull } = await import('./commands/guardrails.js');
+    await runGuardrailsPull(opts);
+});
 program
     .command('whoami')
     .description('Show current authenticated identity')
@@ -172,6 +482,83 @@ program
     const { runStart } = await import('./commands/start.js');
     await runStart(opts);
 });
+// L2 mandatory egress firewall (LLD #63 §5). Makes the governing proxy
+// non-optional: default-deny host egress to everything except the proxy, DNS,
+// and declared infra. apply/remove need root; generate/status do not.
+const enforceCmd = program
+    .command('enforce')
+    .description('Manage the mandatory default-deny egress firewall (forces all traffic through the proxy)');
+for (const [action, desc] of [
+    ['apply', 'Apply the default-deny egress firewall (root). All egress except the proxy, DNS and --allow infra is dropped.'],
+    ['remove', 'Remove the Intutic egress firewall (root).'],
+    ['status', 'Report whether the egress firewall is currently applied.'],
+    ['generate', 'Print the platform ruleset without applying it (no privilege).'],
+]) {
+    enforceCmd
+        .command(action)
+        .description(desc)
+        .option('--port <port>', "The proxy's listener port to permit", '4000')
+        .option('--uid <uid>', 'uid the proxy runs as, exempted from the deny (defaults to current user)')
+        .option('--allow <cidrs>', 'Comma-separated extra destination CIDRs to permit (control plane, registries, …)')
+        .option('--no-dns', 'Also deny outbound DNS (only if a local resolver serves the host)')
+        .option('--platform <os>', 'Target ruleset platform: linux | macos | windows (defaults to current OS)')
+        .action(async (opts) => {
+        const { runEnforce } = await import('./commands/enforce.js');
+        await runEnforce(action, opts);
+    });
+}
+enforceCmd
+    .command('report')
+    .description('Report locally recorded enforcement state (firewall/CA-trust/system-hooks) to the control plane. ' +
+    'No privilege needed — for when apply/remove ran elevated and could not reach stored credentials.')
+    .action(async () => {
+    const { runEnforce } = await import('./commands/enforce.js');
+    await runEnforce('report', {});
+});
+// CA-trust rollout, Cursor system hooks, and Jamf/Intune MDM manifest
+// generation for a managed fleet. Deliberately named `enterprise install`,
+// not the old hyphenated `enterprise-install` — that name collides with
+// tools/scripts/intutic-enterprise-install.sh, an unrelated air-gapped
+// docker-compose installer. Does not touch the host firewall; see `enforce`.
+const enterpriseCmd = program
+    .command('enterprise')
+    .description('Enterprise fleet rollout: CA trust, Cursor system hooks, MDM manifests');
+enterpriseCmd
+    .command('install')
+    .description('Generate MDM manifests, and (if privileged) install system CA trust + Cursor system hooks')
+    .option('--proxy-url <url>', 'Proxy base URL embedded in generated hooks (default: $INTUTIC_PROXY_URL or http://localhost:4000)')
+    .option('--generate-mdm-only', 'Only write the MDM manifests; skip CA trust and system hooks (no privilege needed)')
+    .option('--mdm-output-dir <dir>', 'Directory to write generated MDM manifests to', './intutic-mdm')
+    .option('--skip-ca', 'Skip system-wide CA trust installation')
+    .option('--skip-hooks', 'Skip system-level Cursor hooks installation')
+    .option('--dev', 'Use local control plane (http://localhost:3001) when resolving workspace context')
+    .option('--cli-binary-path <path>', 'Absolute path to the intutic CLI binary on TARGET machines, embedded in the firewall-deployment manifests (default: /usr/local/bin/intutic — override if your fleet installs elsewhere)')
+    .action(async (opts) => {
+    const { runEnterpriseInstall } = await import('./commands/enterprise.js');
+    await runEnterpriseInstall(opts);
+});
+const envCmd = program
+    .command('env')
+    .description('Persist or clear the proxy base-URL environment variables');
+envCmd
+    .command('persist')
+    .description('Write ANTHROPIC_BASE_URL / OPENAI_BASE_URL at the OS level so they survive a restart.\n' +
+    '  macOS: launchctl setenv    Linux: ~/.bashrc    Windows: setx\n' +
+    '\n' +
+    '  Opt-in on purpose: on macOS this reaches every GUI app you launch afterwards.\n' +
+    '  For a single command instead, use \'intutic exec\'.')
+    .option('--proxy-url <url>', 'Proxy base URL to point the variables at', 'http://localhost:4000')
+    .action(async (opts) => {
+    const { runEnvPersist } = await import('./commands/env.js');
+    await runEnvPersist({ proxyUrl: opts.proxyUrl });
+});
+envCmd
+    .command('clear')
+    .description('Remove the variables written by \'intutic env persist\'')
+    .action(async () => {
+    const { runEnvClear } = await import('./commands/env.js');
+    await runEnvClear();
+});
 program
     .command('connect')
     .description('Start sync daemon — bidirectional config sync with control plane (requires an account)')
@@ -194,13 +581,49 @@ program
     const { runSyncContext } = await import('./commands/syncContext.js');
     await runSyncContext(opts);
 });
+program
+    .command('decisions-log-refresh')
+    .description('One-shot refresh of the governed decisions log (.intutic/DECISIONS.md + the claude-code ' +
+    'harness config section) — no-ops if decisionsLogEnabled is off. Invoked by the optional ' +
+    'post-merge hook (see gitHooks.ts); safe to run manually.')
+    .action(async () => {
+    const { refreshDecisionsLog } = await import('./lib/decisionsLogRefresh.js');
+    const result = await refreshDecisionsLog(process.cwd());
+    if (!result.refreshed && result.reason) {
+        const { log } = await import('./lib/logger.js');
+        log.dim(`Decisions log not refreshed: ${result.reason}`);
+    }
+});
 program
     .command('exec')
     .description('Execute a command wrapped with Intutic proxy environment variables')
     .argument('[command...]', 'Command and arguments to execute (e.g. -- claude)')
-    .action(async (commandAndArgs) => {
+    // Run the agent inside an isolated sandbox whose ONLY egress is the proxy
+    // (LLD #63 §6): cap-drop, no-new-privileges, read-only rootfs, resource caps,
+    // and a default-deny egress firewall the agent cannot undo.
+    .option('--sandbox [kind]', 'Run the agent in an isolated sandbox (kind: oci | firecracker; default oci)')
+    .option('--sandbox-image <image>', 'Sandbox image (must contain the agent + nftables + capsh)', 'intutic/sandbox:latest')
+    .option('--sandbox-memory <size>', 'Sandbox memory cap (e.g. 2g)', '2g')
+    .option('--sandbox-cpus <n>', 'Sandbox CPU cap', '2')
+    .option('--sandbox-pids <n>', 'Sandbox max process count', '512')
+    .option('--sandbox-allow <cidrs>', 'Comma-separated extra destination CIDRs the sandbox may reach')
+    .action(async (commandAndArgs, opts) => {
     const { runExec } = await import('./commands/exec.js');
-    await runExec(commandAndArgs);
+    if (opts.sandbox) {
+        await runExec(commandAndArgs, {
+            kind: typeof opts.sandbox === 'string' ? opts.sandbox : 'oci',
+            image: opts.sandboxImage,
+            memory: opts.sandboxMemory,
+            cpus: opts.sandboxCpus,
+            pidsLimit: Number.parseInt(opts.sandboxPids, 10),
+            allow: opts.sandboxAllow
+                ? String(opts.sandboxAllow).split(',').map((s) => s.trim()).filter(Boolean)
+                : [],
+        });
+    }
+    else {
+        await runExec(commandAndArgs);
+    }
 });
 const traces = program
     .command('traces')
@@ -211,7 +634,8 @@ traces
     .description('List execution traces for the workspace')
     .option('--limit <n>', 'Number of traces to show (default: 20, max: 100)')
     .option('--since <duration>', 'Time window, e.g. "24h", "7d", "30m" (default: "24h")')
-    .option('--action <type>', 'Filter by enforcement action (BYPASS|ENHANCE|HIJACK|KILL)')
+    .option('--action <type>', 'Filter by enforcement action (BYPASS|ENHANCE|HIJACK|KILL) — connected mode only')
+    .option('--verdict <type>', 'Filter by verdict (allowed|killed|upstream_error|reasked|hijacked) — local mode only')
     .option('--model <name>', 'Filter by model name')
     .option('--json', 'Output as JSON instead of table')
     .option('--dev', 'Use local control plane (http://localhost:3001)')
@@ -227,10 +651,115 @@ traces
     const { runTracesInspect } = await import('./commands/traces.js');
     await runTracesInspect(traceId, opts);
 });
+// ── Findings (detector_findings adjudication) ───────────────────────────────
+const findings = program
+    .command('findings')
+    .description('Query and adjudicate detector findings — the TP/FP labeling surface');
+findings
+    .command('list')
+    .description('List detector findings for the workspace')
+    .option('--unadjudicated', "Only show findings nobody has ruled on yet (the route's own default is to show all)")
+    .option('--detector <id>', 'Filter by detector_id (e.g. response_injection:override-instructions)')
+    .option('--limit <n>', 'Max rows to return (default: 100, max: 500)')
+    .option('--json', 'Output as JSON instead of table')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runFindingsList } = await import('./commands/findings.js');
+    await runFindingsList(opts);
+});
+findings
+    .command('adjudicate <findingId>')
+    .description('Record a human ruling (true/false positive) on one finding')
+    .option('--true-positive', 'Mark this finding a true positive')
+    .option('--false-positive', 'Mark this finding a false positive')
+    .option('--note <text>', 'Optional note recorded with the ruling')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (findingId, opts) => {
+    const { runFindingsAdjudicate } = await import('./commands/findings.js');
+    await runFindingsAdjudicate(findingId, opts);
+});
+findings
+    .command('stats')
+    .description('Per-detector false-positive rate, computed over adjudicated findings only')
+    .option('--json', 'Output as JSON instead of table')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runFindingsStats } = await import('./commands/findings.js');
+    await runFindingsStats(opts);
+});
+findings
+    .command('echo-report')
+    .description('Response-injection echo measurement report — per-pattern false-positive rate')
+    .option('--since <date>', 'ISO date — window start (route default: trailing 7 days)')
+    .option('--until <date>', 'ISO date — window end (route default: now)')
+    .option('--json', 'Output as JSON instead of table')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runFindingsEchoReport } = await import('./commands/findings.js');
+    await runFindingsEchoReport(opts);
+});
+// ── Trace integrity ────────────────────────────────────────────────────────
+const integrity = program
+    .command('integrity')
+    .description('Verify sealed trace roots — list, re-derive, walk the root chain, and walk the config snapshot chain');
+integrity
+    .command('roots')
+    .description('List sealed Merkle roots for the workspace, newest first')
+    .option('--loop-run <id>', 'Only roots sealed for this loop run')
+    .option('--json', 'Output as JSON instead of table')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runIntegrityRoots } = await import('./commands/integrity.js');
+    await runIntegrityRoots(opts);
+});
+integrity
+    .command('verify <root_id>')
+    .description('Re-derive a root from the live traces and check its signature (exit 1 on mismatch)')
+    .option('--json', 'Output as JSON instead of a report')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (rootId, opts) => {
+    const { runIntegrityVerify } = await import('./commands/integrity.js');
+    await runIntegrityVerify(rootId, opts);
+});
+integrity
+    .command('chain')
+    .description('Walk the previous_root chain and report deleted roots (exit 1 on a break)')
+    .option('--json', 'Output as JSON instead of a report')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runIntegrityChain } = await import('./commands/integrity.js');
+    await runIntegrityChain(opts);
+});
+integrity
+    .command('config-chain')
+    .description('Walk the harness config snapshot chain and re-hash each stored body ' +
+    '(exit 1 on a break or a content mismatch)')
+    .option('--json', 'Output as JSON instead of a report')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runIntegrityConfigChain } = await import('./commands/integrity.js');
+    await runIntegrityConfigChain(opts);
+});
+// ── Routing reports ─────────────────────────────────────────────────────────
+const routing = program
+    .command('routing')
+    .description('Read-only reports for the routing subsystem');
+routing
+    .command('adoption-report')
+    .description('Mirror-test adoption report for one candidate model — win/loss/tie, fault-rate delta, ' +
+    'cost delta, latency delta (Phase 7b: GET /api/v1/routing/mirror-adoption-report). ' +
+    'A reported signal for human review, not an automatic gate.')
+    .requiredOption('--candidate-model <model>', 'The mirror-tested candidate model to report on')
+    .option('--json', 'Output as JSON instead of a report')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runRoutingAdoptionReport } = await import('./commands/routing.js');
+    await runRoutingAdoptionReport(opts);
+});
 // ── Daemon persistence (WS-5 — Q3 Layer 4) ─────────────────────────────────
 const daemon = program
     .command('daemon')
-    .description('Manage the Intutic sync-daemon system service (LaunchAgent / systemd)');
+    .description('Manage the Intutic sync-daemon, MCP daemon and standalone proxy system services (LaunchAgent / systemd)');
 daemon
     .command('install')
     .alias('install-daemon') // top-level alias for discoverability
@@ -238,17 +767,52 @@ daemon
     '  macOS: ~/Library/LaunchAgents/ai.intutic.sync-daemon.plist (KeepAlive: true)\n' +
     '  Linux: ~/.config/systemd/user/intutic-sync-daemon.service (Restart=always)\n' +
     '\n' +
+    '  --proxy installs the standalone intutic-proxy binary instead (no workspace or key needed):\n' +
+    '  macOS: ~/Library/LaunchAgents/ai.intutic.proxy.plist\n' +
+    '  Linux: ~/.config/systemd/user/intutic-proxy.service\n' +
+    '\n' +
     '  NOTE: To stop the daemon you MUST use \'intutic daemon uninstall\' or \'launchctl unload\'.\n' +
     '  \'intutic disconnect\' alone will NOT stop a daemon-installed service. (TD-154)')
-    .requiredOption('--workspace-id <id>', 'Workspace ID (e.g. wk_xxxx)')
-    .requiredOption('--api-key <key>', 'Workspace API key (e.g. vk_xxxx)')
+    .option('--workspace-id <id>', 'Workspace ID (e.g. wk_xxxx) — required unless --proxy')
+    .option('--api-key <key>', 'Workspace API key (e.g. vk_xxxx) — required unless --proxy')
     .option('--control-plane-url <url>', 'Control plane URL', 'https://api.intutic.ai')
-    .option('--binary-path <path>', 'Path to intutic CLI binary (defaults to current process)')
+    .option('--binary-path <path>', 'Path to intutic CLI binary (defaults to current process); with --proxy, absolute path to intutic-proxy')
     .option('--dry-run', 'Print what would be done without writing files')
     .option('--system', 'Install as a system-level service (LaunchDaemon on macOS, systemd system unit on Linux)')
-    .action(async (opts) => {
-    const { installDaemon } = await import('./commands/install-daemon.js');
-    await installDaemon({
+    .option('--mcp', 'Install the MCP proxy daemon instead of the sync-daemon')
+    .option('--proxy', 'Install the standalone intutic-proxy binary as a service (TD-465)')
+    .option('--port <port>', 'With --proxy: proxy listen port', '4000')
+    .option('--valkey-url <url>', 'With --proxy: Valkey URL to attach to; omit to run standalone (INTUTIC_STANDALONE=1)')
+    .option('--upstream-url <url>', 'With --proxy: upstream LLM provider base URL')
+    .action(async (opts, cmd) => {
+    if (opts.proxy) {
+        // The standalone proxy has no control plane, so no workspace or key.
+        // Its unit carries the same environment `intutic start` sets, fixed at
+        // install time rather than probed at launch (TD-465).
+        const { installProxyService } = await import('./commands/install-daemon.js');
+        await installProxyService({
+            port: opts.port,
+            valkeyUrl: opts.valkeyUrl,
+            upstreamUrl: opts.upstreamUrl,
+            binaryPath: opts.binaryPath,
+            dryRun: opts.dryRun,
+            system: opts.system,
+        });
+        return;
+    }
+    // Required for the two daemons; commander's `requiredOption` cannot express
+    // "unless --proxy", so the check lives here with the same wording.
+    if (!opts.workspaceId)
+        cmd.error("error: required option '--workspace-id <id>' not specified");
+    if (!opts.apiKey)
+        cmd.error("error: required option '--api-key <key>' not specified");
+    // `installMcpDaemon` and `buildMcpPlist` were written, tested and exported,
+    // and then nothing called them: every route into install-daemon.ts landed
+    // on `installDaemon`, so the MCP proxy daemon could not be installed by any
+    // command the CLI offered (TD-153). This flag is that missing route.
+    const { installDaemon, installMcpDaemon } = await import('./commands/install-daemon.js');
+    const install = opts.mcp ? installMcpDaemon : installDaemon;
+    await install({
         workspaceId: opts.workspaceId,
         apiKey: opts.apiKey,
         controlPlaneUrl: opts.controlPlaneUrl,
@@ -263,30 +827,48 @@ daemon
     .description('Remove the sync-daemon system service and stop it permanently.')
     .option('--dry-run', 'Print what would be done without writing files')
     .option('--system', 'Uninstall the system-level service')
+    .option('--mcp', 'Uninstall the MCP proxy daemon instead of the sync-daemon')
+    .option('--proxy', 'Uninstall the standalone intutic-proxy service instead of the sync-daemon')
     .action(async (opts) => {
-    const { uninstallDaemon } = await import('./commands/install-daemon.js');
-    await uninstallDaemon({ dryRun: opts.dryRun, system: opts.system });
+    const { uninstallDaemon, uninstallMcpDaemon, uninstallProxyService } = await import('./commands/install-daemon.js');
+    const uninstall = opts.proxy ? uninstallProxyService : opts.mcp ? uninstallMcpDaemon : uninstallDaemon;
+    await uninstall({ dryRun: opts.dryRun, system: opts.system });
 });
 daemon
     .command('status')
-    .description('Show sync-daemon system service status.')
-    .action(async () => {
-    const { daemonStatus } = await import('./commands/install-daemon.js');
-    await daemonStatus();
+    .description('Show sync-daemon system service status (or the standalone proxy service with --proxy).')
+    .option('--proxy', 'Show the standalone intutic-proxy service instead of the sync-daemon')
+    .option('--mcp', 'Show the MCP proxy daemon instead of the sync-daemon')
+    .action(async (opts) => {
+    // `mcpDaemonStatus` was exported and never called by any command until the
+    // reachability test widened to the status/stop/start verbs (TD-153's
+    // shape, one more time).
+    const { daemonStatus, proxyServiceStatus, mcpDaemonStatus } = await import('./commands/install-daemon.js');
+    await (opts.proxy ? proxyServiceStatus() : opts.mcp ? mcpDaemonStatus() : daemonStatus());
 });
 daemon
     .command('stop')
-    .description('Stop and unload the sync-daemon system service.')
-    .action(async () => {
-    const { daemonStop } = await import('./commands/install-daemon.js');
-    await daemonStop();
+    .description('Stop and unload the sync-daemon system service (or the standalone proxy service with --proxy).')
+    .option('--proxy', 'Stop the standalone intutic-proxy service instead of the sync-daemon')
+    .option('--mcp', 'Stop the MCP proxy daemon instead of the sync-daemon')
+    .action(async (opts) => {
+    // `mcpDaemonStop` was exported and never called by any command until the
+    // reachability test widened to the status/stop/start verbs (TD-153's
+    // shape, one more time).
+    const { daemonStop, proxyServiceStop, mcpDaemonStop } = await import('./commands/install-daemon.js');
+    await (opts.proxy ? proxyServiceStop() : opts.mcp ? mcpDaemonStop() : daemonStop());
 });
 daemon
     .command('start')
-    .description('Start and load the sync-daemon system service.')
-    .action(async () => {
-    const { daemonStart } = await import('./commands/install-daemon.js');
-    await daemonStart();
+    .description('Start and load the sync-daemon system service (or the standalone proxy service with --proxy).')
+    .option('--proxy', 'Start the standalone intutic-proxy service instead of the sync-daemon')
+    .option('--mcp', 'Start the MCP proxy daemon instead of the sync-daemon')
+    .action(async (opts) => {
+    // `mcpDaemonStart` was exported and never called by any command until the
+    // reachability test widened to the status/stop/start verbs (TD-153's
+    // shape, one more time).
+    const { daemonStart, proxyServiceStart, mcpDaemonStart } = await import('./commands/install-daemon.js');
+    await (opts.proxy ? proxyServiceStart() : opts.mcp ? mcpDaemonStart() : daemonStart());
 });
 // Top-level shortcuts (for discoverability)
 program
@@ -314,9 +896,12 @@ program
     .description('Shortcut for \'intutic daemon uninstall\'')
     .option('--dry-run', 'Print what would be done without writing files')
     .option('--system', 'Uninstall the system-level service')
+    .option('--mcp', 'Uninstall the MCP proxy daemon instead of the sync-daemon')
+    .option('--proxy', 'Uninstall the standalone intutic-proxy service instead of the sync-daemon')
     .action(async (opts) => {
-    const { uninstallDaemon } = await import('./commands/install-daemon.js');
-    await uninstallDaemon({ dryRun: opts.dryRun, system: opts.system });
+    const { uninstallDaemon, uninstallMcpDaemon, uninstallProxyService } = await import('./commands/install-daemon.js');
+    const uninstall = opts.proxy ? uninstallProxyService : opts.mcp ? uninstallMcpDaemon : uninstallDaemon;
+    await uninstall({ dryRun: opts.dryRun, system: opts.system });
 });
 // ── Skill commands ─────────────────────────────────────────────────────────
 const skillCmd = program
@@ -332,9 +917,19 @@ skillCmd
 skillCmd
     .command('audit')
     .description('Audit local rules/skills for security leakage or unsafe command patterns')
-    .action(async () => {
+    .option('--sarif', 'Output findings as a SARIF 2.1.0 document (for GitHub Code Scanning / CI interop) instead of the human-readable report')
+    .option('--engine <engine>', "Scanning engine: 'native' (default, always runs) or 'cisco' to also run the opt-in Cisco " +
+    "skill-scanner integration (requires the 'skill-scanner' binary on PATH — pipx install cisco-ai-skill-scanner)", 'native')
+    .action(async (opts) => {
     const { runSkillAudit } = await import('./commands/skill.js');
-    await runSkillAudit();
+    await runSkillAudit({ sarif: opts.sarif, engine: opts.engine });
+});
+skillCmd
+    .command('scan-staged')
+    .description('Warn-only content scan of staged skill-surface additions (.agents/skills, .claude/skills) — used by the pre-commit hook, never blocks the commit')
+    .action(async () => {
+    const { runSkillScanStaged } = await import('./commands/skill.js');
+    await runSkillScanStaged();
 });
 // ── Loop commands ──────────────────────────────────────────────────────────
 const loopCmd = program
@@ -368,6 +963,17 @@ loopCmd
     const { runLoopKill } = await import('./commands/skill.js');
     await runLoopKill(loopRunId, opts);
 });
+loopCmd
+    .command('review <loopRunId>')
+    .description('Approve or reject a loop run held for human review')
+    .option('--approve', 'Release the hold; the run resumes')
+    .option('--reject', 'Refuse the hold; the run is killed')
+    .option('--note <note>', 'Why, recorded against the run')
+    .option('--dev', 'Target the local control plane')
+    .action(async (loopRunId, opts) => {
+    const { runLoopReview } = await import('./commands/skill.js');
+    await runLoopReview(loopRunId, opts);
+});
 loopCmd
     .command('list')
     .description('List loop runs and cost accounting details for the workspace')
@@ -389,5 +995,237 @@ loopCmd
     const { runLoopExec } = await import('./commands/skill.js');
     await runLoopExec(commandAndArgs, opts);
 });
+// ── Decision commands ────────────────────────────────────────────────────
+//
+// The real front door for a review_before hold. See commands/decision.ts's
+// module doc for why `intutic loop review` was never the right command for
+// this — it addresses a different id space (Loop Runs, not decisions).
+const decisionCmd = program
+    .command('decision')
+    .description('Approve or reject a decision (e.g. a review_before hold) held for human review');
+decisionCmd
+    .command('approve <holdId>')
+    .description('Approve a held decision; may also unblock the exact retried call, if the workspace opted in')
+    .option('--reason <reason>', 'Why, recorded against the decision')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (holdId, opts) => {
+    const { runDecisionApprove } = await import('./commands/decision.js');
+    await runDecisionApprove(holdId, opts);
+});
+decisionCmd
+    .command('reject <holdId>')
+    .description('Reject a held decision')
+    .option('--reason <reason>', 'Why, recorded against the decision')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (holdId, opts) => {
+    const { runDecisionReject } = await import('./commands/decision.js');
+    await runDecisionReject(holdId, opts);
+});
+// ── Gateway commands (LLD #66) ───────────────────────────────────────────
+//
+// Self-hosted gateway registration/management. Previously reachable only by
+// hand-written curl against services/control-plane/src/routes/gateways.ts —
+// see commands/gateway.ts's module doc.
+const gatewayCmd = program
+    .command('gateway')
+    .description('Manage self-hosted gateway registrations (Docker / Kubernetes / bare-metal)');
+gatewayCmd
+    .command('register')
+    .description('Register a new self-hosted gateway and print its one-time gwk_ token')
+    .requiredOption('--name <name>', 'Display name for this gateway')
+    .requiredOption('--target <docker|kubernetes|bare_metal>', 'Deployment target')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGatewayRegister } = await import('./commands/gateway.js');
+    await runGatewayRegister(opts);
+});
+gatewayCmd
+    .command('list')
+    .description("List the org's registered gateways")
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGatewayList } = await import('./commands/gateway.js');
+    await runGatewayList(opts);
+});
+gatewayCmd
+    .command('status <gateway_id>')
+    .description('Live heartbeat-derived status for one gateway')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (gatewayId, opts) => {
+    const { runGatewayStatus } = await import('./commands/gateway.js');
+    await runGatewayStatus(gatewayId, opts);
+});
+gatewayCmd
+    .command('rotate <gateway_id>')
+    .description('Issue a new gwk_ token; the old one keeps working during the rotation grace period')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (gatewayId, opts) => {
+    const { runGatewayRotate } = await import('./commands/gateway.js');
+    await runGatewayRotate(gatewayId, opts);
+});
+gatewayCmd
+    .command('revoke <gateway_id>')
+    .description('Revoke a gateway immediately (kills any active rotation grace period too)')
+    .option('--reason <text>', 'Recorded in the audit log')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (gatewayId, opts) => {
+    const { runGatewayRevoke } = await import('./commands/gateway.js');
+    await runGatewayRevoke(gatewayId, opts);
+});
+const gatewayConfigCmd = gatewayCmd
+    .command('config')
+    .description('Manage a gateway\'s remote config (requireVk, requireProvisionedKey)');
+gatewayConfigCmd
+    .command('set <gateway_id>')
+    .description('Update one or both config flags on a gateway')
+    .option('--require-vk <true|false>', 'Refuse non-vk_ bearer tokens at this gateway')
+    .option('--require-provisioned-key <true|false>', 'Refuse workspaces with no provisioned upstream key')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (gatewayId, opts) => {
+    const { runGatewayConfigSet } = await import('./commands/gateway.js');
+    await runGatewayConfigSet(gatewayId, opts);
+});
+gatewayCmd
+    .command('assign')
+    .description('Assign (or clear) the gateway this workspace or org defaults to')
+    .option('--gateway <gateway_id>', 'Gateway to assign')
+    .option('--clear', 'Clear the current assignment instead of setting one')
+    .option('--org <org_id>', 'Set the ORG default instead of this workspace\'s own override')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGatewayAssign } = await import('./commands/gateway.js');
+    await runGatewayAssign(opts);
+});
+gatewayCmd
+    .command('resolve')
+    .description('Show which gateway this workspace currently resolves to (own override, org default, or shared)')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runGatewayResolve } = await import('./commands/gateway.js');
+    await runGatewayResolve(opts);
+});
+// ── Provider credentials (LLD #64 §4, LLD #67) ───────────────────────────
+//
+// Provision a workspace's own upstream provider keys — the BYO-key wizard's
+// API, previously dashboard-only. See commands/credentials.ts's module doc.
+const credentialsCmd = program
+    .command('credentials')
+    .description('Manage this workspace\'s own upstream provider API keys (BYO-key)');
+credentialsCmd
+    .command('list')
+    .description('Provisioning status for every registry provider')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runCredentialsList } = await import('./commands/credentials.js');
+    await runCredentialsList(opts);
+});
+credentialsCmd
+    .command('set <provider>')
+    .description('Provision or rotate a provider credential (e.g. --field apiKey=sk-ant-...)')
+    .option('--field <key=value>', 'A credential field; repeat for multi-field providers', (v, prev) => [...prev, v], [])
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (provider, opts) => {
+    const { runCredentialsSet } = await import('./commands/credentials.js');
+    await runCredentialsSet(provider, opts);
+});
+credentialsCmd
+    .command('unset <provider>')
+    .description('Remove a provisioned provider credential')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (provider, opts) => {
+    const { runCredentialsUnset } = await import('./commands/credentials.js');
+    await runCredentialsUnset(provider, opts);
+});
+// ── DCT Token Attenuation (LLD #19 §2.1, HLD §5.6 Patent Family A) ───────
+//
+// "CLI mints, dashboard audits": this is the mint/inspect half. See
+// commands/attenuate.ts's module doc.
+const attenuateCmd = program
+    .command('attenuate')
+    .description('Attenuate an API key to a narrower child key (capability subset + optional TTL)')
+    .option('--parent-key <keyId>', 'Parent API key ID to attenuate')
+    .option('--caps <caps>', 'Comma-separated capability subset to grant the child key')
+    .option('--ttl <seconds>', 'Child key TTL in seconds (server default 14400, max 86400)')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runAttenuate } = await import('./commands/attenuate.js');
+    await runAttenuate(opts);
+});
+attenuateCmd
+    .command('chain <chainId>')
+    .description('Resolve the full delegation lineage for an attenuation chain')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (chainId, opts) => {
+    const { runAttenuateChain } = await import('./commands/attenuate.js');
+    await runAttenuateChain(chainId, opts);
+});
+// ── Org signup + team management (LLD #65) ───────────────────────────────
+const orgCmd = program
+    .command('org')
+    .description('Create and manage orgs');
+orgCmd
+    .command('create')
+    .description('Create a real org (paid tier, 30-day trial) with a default team and workspace. ' +
+    'Requires `intutic login` first and DNS domain-ownership verification.')
+    .option('--org-name <orgName>', 'Organization name (prompted if omitted)')
+    .option('--domain <domain>', 'Domain to verify ownership of (prompted if omitted)')
+    .option('--region <region>', "Gateway cell region (e.g. 'us', 'eu'); server-validated, defaults to the deployment's home region")
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runOrgCreate } = await import('./commands/org.js');
+    await runOrgCreate(opts);
+});
+const teamCmd = program
+    .command('team')
+    .description('Manage teams and workspaces under an org');
+teamCmd
+    .command('list')
+    .description("List an org's teams")
+    .requiredOption('--org <org_id>', 'Org ID')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runTeamList } = await import('./commands/team.js');
+    await runTeamList(opts);
+});
+teamCmd
+    .command('create')
+    .description('Create a new team under an org')
+    .requiredOption('--org <org_id>', 'Org ID')
+    .requiredOption('--name <name>', 'Team name')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (opts) => {
+    const { runTeamCreate } = await import('./commands/team.js');
+    await runTeamCreate(opts);
+});
+teamCmd
+    .command('workspaces <team_id>')
+    .description('List the workspaces under a team')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (teamId, opts) => {
+    const { runTeamWorkspaces } = await import('./commands/team.js');
+    await runTeamWorkspaces(teamId, opts);
+});
+teamCmd
+    .command('create-workspace <team_id>')
+    .description('Create a new workspace under a team; you become its OWNER')
+    .requiredOption('--name <name>', 'Workspace name')
+    .option('--json', 'Output as JSON')
+    .option('--dev', 'Use local control plane (http://localhost:3001)')
+    .action(async (teamId, opts) => {
+    const { runTeamCreateWorkspace } = await import('./commands/team.js');
+    await runTeamCreateWorkspace(teamId, opts);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map