@ashlr/hub 3.5.1 → 3.7.0

package/CHANGELOG.md

@@ -339,6 +339,115 @@ superseded, not a setup procedure. Use [runtime activation authority](docs/RUNTI
 and the [current architecture boundary](docs/ARCHITECTURE.md#legacy-fleet-activation-boundary).
 Neither the historical record nor a successful test activates a resident fleet.
 
+## [3.7.0] — 2026-09-23 UTC — The console you can actually navigate, and a fleet that can be bounded
+
+### Verse
+
+- **The rail expands** (⌘\), with labels and ⌘-digits. Hover used to show the
+  *native browser tooltip* — unstyled, mouse-only, clipping against the sidebar.
+  There is now a real portalled Tooltip primitive, and adopting it fixed a live
+  accessibility defect: `aria-describedby` sat on a wrapper rather than the
+  focusable child, so nothing was ever announced. A **disabled** trigger emits no
+  pointer events, so its tooltip could never open — precisely the tooltip that
+  matters, since it explains why the control is disabled.
+- **The header earns its height.** It held one toggle floating at the right edge
+  with nothing anchoring the left, because the sidebar toggle only rendered while
+  the sidebar was collapsed.
+- **Display size** — Default / Large / Extra large, scaling type *and* spacing as
+  a multiplier rather than a second table of literals, because density and scale
+  have identical CSS specificity and two literal tables would let file order
+  decide what "Compact + Large" means. Rail width and strip height are pinned so
+  the traffic-light clearance cannot regress.
+- **Pane resizing** that survives a real drag: widths are a desired/effective
+  pair, so a wide sidebar narrows on a small window and springs back. It also
+  turned out the resize handle was eating 4px of the macOS window drag strip.
+- **Saved projects and a native folder picker**, and the MCP section is mounted.
+
+### Autonomy
+
+- **A bounded run window** — until paused, at a wall-clock time, or after N
+  iterations. The window is an absolute instant, never a countdown, so a host
+  suspended at 01:00 and opened at 09:00 finds its 07:00 window expired.
+- **The post-merge halt.** The pre-merge gate was already strict; *nothing re-ran
+  the suite after a merge*, so a regression merged at 01:00 compounded all night.
+  A dirty working tree halts too, as **unprovable** rather than *regressed* — a
+  run that measured uncommitted edits has proven nothing. Ignored files are not
+  dirt, or it would halt every night.
+
+### Corrections
+
+- A test guard was red, and a red guard protects nothing. The Anthropic shim is a
+  request normaliser, not a transport — its one `/chat/completions` is in a doc
+  comment recording a measurement.
+- `VerseApp.test.tsx` had been passing by luck of file ordering; the first test to
+  mount the shell paid ChatSection's cold transform cost inside its own 1000ms
+  assertion window.
+
+## [3.6.0] — 2026-09-23 UTC — Open any project, from a real picker
+
+Verse could already drive any folder on the machine — the API accepted an
+unenrolled path and both Grok and local seats ran in it. What it could not do was
+let you *choose* one. The only way in was typing an absolute path into a text
+box, and a folder you typed vanished from the list until a chat existed on it.
+This release is the door.
+
+### Any folder, from a native chooser
+
+- **A real macOS directory picker.** "Choose folder…" opens `NSOpenPanel`
+  through the Tauri dialog plugin. Detection is a call-time feature probe of the
+  injected shell global, not a build flag, because the same bundle is served
+  inside the desktop app and as a plain web UI — in a browser the button is
+  absent and the absolute-path input remains, which is never removed.
+- **Saved projects the console can actually create.** `createVerseWorkspace`,
+  `updateVerseWorkspace`, `deleteVerseWorkspace`, `setVerseRootPriority` and
+  `setVerseFocusSection` all existed with **zero callers**, so
+  `~/.ashlr/verse/workspaces.json` could only be written by hand. There is now a
+  Projects section in the sidebar: save, rename, add and remove folders, reorder
+  (the first folder is the primary — its directory is the chat's working
+  directory), and forget behind a two-step confirm that states existing chats
+  are untouched.
+- **Interactive and autonomous stay separate registries.** Saving a folder to
+  work in never enrols it for unattended work. A saved project can be *offered*
+  to the autonomous lane, but only by ticking that box.
+- **The Grok caveat travels with a saved project.** Grok takes no extra roots,
+  so a multi-root project picked with a Grok seat now says its extra folders are
+  unreachable. That case previously had no warning at all.
+
+### The MCP section exists again
+
+`McpSection.tsx` was complete — query layer, tested contract, complete server
+side — and unreachable: absent from `VERSE_SECTIONS`, no `'mcp'` member on
+`VerseSectionId`, and outside the glob that mounts sections. It is now ⌘6.
+⌘1–⌘5 keep their meanings.
+
+It also discloses a footgun nothing named before: Codex and Grok inherit MCP
+from their native profile config, so a turn on an unenrolled folder can reach an
+`ashlr__*` write tool and be refused by the enrollment gate — the turn fails on
+policy, not on the model. Claude and local seats are unaffected, because the
+adapter passes an empty `--mcp-config` under `--strict-mcp-config`.
+
+### One capability was widened, deliberately
+
+`dialog:allow-open` is granted to the remote Verse origin in
+`capabilities/verse-remote.json`, whose note said not to widen the list. It is
+the narrowest dialog permission: it shows a chooser the user must confirm and
+returns a path, reads no file contents, and no `fs:*` permission is granted
+anywhere in the app. `allow-save`, `allow-message`, `allow-ask` and
+`allow-confirm` stay ungranted so page code cannot forge a native prompt.
+
+It had to go in that file rather than `main.json`: the Verse window loads a
+remote origin, and a Tauri 2 capability without a `remote` block never reaches
+one — the grant would have looked correct in review and failed silently at
+runtime.
+
+### Verified in the built app, not only in tests
+
+The picker was driven end to end in a real build: the button renders inside the
+shell, `NSOpenPanel` opens, the chosen path lands in the field, "Start chat"
+enables, "Save as a project" persists and appears in the sidebar, and forget
+removes it. Separately, `POST /api/verse/workspaces` was confirmed against a
+live server to create a record on disk and list it back.
+
 ## [3.5.1] — 2026-09-23 UTC — The dependency backlog, landed rather than deferred
 
 Four dependency PRs had been sitting open. None was a version bump; each needed

package/README.md

@@ -7,6 +7,9 @@
 **[verse.ashlr.ai](https://verse.ashlr.ai)** — Ashlr Verse, the operator console: every account you own
 behind one surface, plus a local model that keeps working after the quota runs out.
 
+
+![Ashlr Verse — the operator console: an expandable section rail, a project sidebar, and every connected account with its live usage windows](docs/images/verse-console.png)
+
 [![npm](https://img.shields.io/npm/v/@ashlr/hub.svg?logo=npm&label=%40ashlr%2Fhub&color=cb3837)](https://www.npmjs.com/package/@ashlr/hub)
 [![npm downloads](https://img.shields.io/npm/dm/@ashlr/hub.svg?color=cb3837)](https://www.npmjs.com/package/@ashlr/hub)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)

package/dist/build-identity.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "packageVersion": "3.5.1",
-  "revision": "5bbb2454b7238f8db83acc7b7b8b9635bd89d2da",
+  "packageVersion": "3.7.0",
+  "revision": "5f128f3a22e379862642a9f8837673baafd95a53",
   "dirty": false,
   "provenance": "git"
 }

package/dist/cli/activation.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `ashlr activation` — operator authority for the autonomous fleet (M470).
+ *
+ * The daemon, goal/simple conductors, and resident-service install are all
+ * held shut by hard-coded denials until an operator EXPLICITLY grants
+ * authority here. Doing nothing keeps today's exact behavior: everything
+ * denied. This command group is how an operator opts in, on their own
+ * terms, with a real signed/expiring/revocable authorization trail.
+ *
+ * Subcommands:
+ *   activation init [--label <text>] [--force] [--yes] [--json]
+ *       Generate an Ed25519 keypair on this machine (private key never
+ *       leaves it) and register the public half as a trust root. Grants
+ *       NOTHING by itself — run `activation grant` next.
+ *   activation status [--json]
+ *       Trust roots, pending one-shot permit, standing grants, and what is
+ *       currently authorized, right now, and why.
+ *   activation grant <scope...> [--ttl <duration>] [--yes] [--json]
+ *       Mint a scoped, signed, expiring authorization. `once`/`resident`
+ *       mint a single-use permit for `ashlr daemon start`, good for a fixed
+ *       2-minute window; any of `residentStanding`/`conductor`/`automerge`/
+ *       `repair`/`deploy`/`install`/`proposalOnly` mint a standing grant
+ *       checked on every use until it expires (30d cap) or is revoked.
+ *       `residentStanding` is what lets a resident daemon started by
+ *       launchd/systemd/Task Scheduler after a reboot authorize itself with
+ *       no operator present — grant it once, ahead of time, alongside
+ *       whichever of `automerge`/`repair`/`deploy` the resident loop should
+ *       also carry for its whole run.
+ *   activation revoke --root <keyId> | --grant <grantId> [--yes] [--json]
+ *       Immediately invalidate a trust root or a standing grant.
+ *
+ * Every subcommand supports --help. Mutating subcommands (init/grant/revoke)
+ * refuse to run unattended in a non-TTY session without --yes — the same
+ * confirm-gate convention as `ashlr inbox approve`.
+ */
+/**
+ * `ashlr activation [init|status|grant|revoke] [flags]`
+ *
+ * Returns a process exit code (0 = success, non-zero = error/usage).
+ */
+export declare function cmdActivation(args: string[]): Promise<number>;

package/dist/cli/activation.js

@@ -0,0 +1,485 @@
+/**
+ * `ashlr activation` — operator authority for the autonomous fleet (M470).
+ *
+ * The daemon, goal/simple conductors, and resident-service install are all
+ * held shut by hard-coded denials until an operator EXPLICITLY grants
+ * authority here. Doing nothing keeps today's exact behavior: everything
+ * denied. This command group is how an operator opts in, on their own
+ * terms, with a real signed/expiring/revocable authorization trail.
+ *
+ * Subcommands:
+ *   activation init [--label <text>] [--force] [--yes] [--json]
+ *       Generate an Ed25519 keypair on this machine (private key never
+ *       leaves it) and register the public half as a trust root. Grants
+ *       NOTHING by itself — run `activation grant` next.
+ *   activation status [--json]
+ *       Trust roots, pending one-shot permit, standing grants, and what is
+ *       currently authorized, right now, and why.
+ *   activation grant <scope...> [--ttl <duration>] [--yes] [--json]
+ *       Mint a scoped, signed, expiring authorization. `once`/`resident`
+ *       mint a single-use permit for `ashlr daemon start`, good for a fixed
+ *       2-minute window; any of `residentStanding`/`conductor`/`automerge`/
+ *       `repair`/`deploy`/`install`/`proposalOnly` mint a standing grant
+ *       checked on every use until it expires (30d cap) or is revoked.
+ *       `residentStanding` is what lets a resident daemon started by
+ *       launchd/systemd/Task Scheduler after a reboot authorize itself with
+ *       no operator present — grant it once, ahead of time, alongside
+ *       whichever of `automerge`/`repair`/`deploy` the resident loop should
+ *       also carry for its whole run.
+ *   activation revoke --root <keyId> | --grant <grantId> [--yes] [--json]
+ *       Immediately invalidate a trust root or a standing grant.
+ *
+ * Every subcommand supports --help. Mutating subcommands (init/grant/revoke)
+ * refuse to run unattended in a non-TTY session without --yes — the same
+ * confirm-gate convention as `ashlr inbox approve`.
+ */
+import { makeColors } from './ui.js';
+import { DAEMON_ACTIVATION_SCOPE_KEYS, DEFAULT_STANDING_GRANT_VALIDITY_MS, EMPTY_DAEMON_ACTIVATION_SCOPE, MAX_STANDING_GRANT_VALIDITY_MS, daemonActivationDiagnosePendingPermitBindings, daemonActivationDirPath, daemonActivationGrantStatus, daemonActivationInit, daemonActivationMintOneShotPermit, daemonActivationMintStandingGrant, daemonActivationPermitPath, daemonActivationRevokeGrant, daemonActivationRevokeTrustRoot, daemonActivationScopeGranted, daemonActivationTrustRootStatus, inspectDaemonActivationPermit, } from '../core/daemon/activation-permit.js';
+const ACTIVATION_SUBCOMMANDS = new Set(['init', 'status', 'grant', 'revoke']);
+const ONE_SHOT_SCOPE_KEYS = new Set(['once', 'resident']);
+const ACTIVATION_USAGE = {
+    init: 'Usage: ashlr activation init [--label <text>] [--force] [--yes] [--json]',
+    status: 'Usage: ashlr activation status [--json]',
+    grant: `Usage: ashlr activation grant <scope...> [--ttl <duration>] [--yes] [--json]\n` +
+        `   scopes: ${DAEMON_ACTIVATION_SCOPE_KEYS.join(', ')}\n` +
+        `   duration: <n>s | <n>m | <n>h | <n>d (default: 24h; hard cap: 30d; standing grants only)`,
+    revoke: 'Usage: ashlr activation revoke (--root <keyId> | --grant <grantId>) [--yes] [--json]',
+};
+const ACTIVATION_TOP_LEVEL_USAGE = `Usage: ashlr activation [subcommand] [flags]
+
+Everything here is denied by default. Run \`activation init\` then
+\`activation grant <scope...>\` to explicitly opt this machine's fleet into
+real authority — nothing else changes anything on its own.
+
+Subcommands:
+  init      Generate an operator keypair and register the trust root
+  status    Show what is granted, by whom, when, and current eligibility
+  grant     Mint a scoped, signed, expiring permit or standing grant
+  revoke    Immediately invalidate a trust root or a standing grant
+
+Run \`ashlr activation <subcommand> --help\` for subcommand usage.`;
+function isHelpFlag(arg) {
+    return arg === '--help' || arg === '-h';
+}
+function isActivationSubcommand(value) {
+    return ACTIVATION_SUBCOMMANDS.has(value);
+}
+function printActivationUsage(subcommand) {
+    console.log(subcommand ? ACTIVATION_USAGE[subcommand] : ACTIVATION_TOP_LEVEL_USAGE);
+}
+function printActivationUsageError(message, subcommand) {
+    const col = makeColors(process.stdout.isTTY === true);
+    console.error(col.red('error: ') + message);
+    console.error(col.dim(subcommand ? ACTIVATION_USAGE[subcommand] : ACTIVATION_TOP_LEVEL_USAGE));
+    return 2;
+}
+function parseDurationMs(text) {
+    const match = /^(\d+)(s|m|h|d)?$/u.exec(text.trim());
+    if (!match)
+        return null;
+    const value = Number(match[1]);
+    if (!Number.isFinite(value) || value <= 0)
+        return null;
+    const unit = match[2] ?? 'h';
+    const multiplier = unit === 's' ? 1_000 : unit === 'm' ? 60_000 : unit === 'h' ? 3_600_000 : 86_400_000;
+    return value * multiplier;
+}
+async function importConfig() {
+    try {
+        const mod = (await import('../core/config.js'));
+        return mod.loadConfigReadOnlyStrict;
+    }
+    catch {
+        return null;
+    }
+}
+/** Non-TTY without --yes refuses — no silently-automated grants, matching `inbox approve`. */
+function refuseUnattended(yes, jsonMode, action) {
+    const tty = process.stdout.isTTY === true;
+    if (tty || yes)
+        return false;
+    const col = makeColors(false);
+    const msg = `non-TTY: activation ${action} requires --yes to prevent silent, unattended authorization`;
+    if (jsonMode) {
+        console.log(JSON.stringify({ ok: false, error: msg }));
+    }
+    else {
+        console.error(col.red('error: ') + msg);
+        console.error(col.dim(`  Use \`ashlr activation ${action} ... --yes\` in non-interactive environments.`));
+    }
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Subcommand: init
+// ---------------------------------------------------------------------------
+async function cmdActivationInit(args) {
+    const jsonMode = args.includes('--json');
+    const force = args.includes('--force');
+    const yes = args.includes('--yes');
+    const labelIndex = args.indexOf('--label');
+    const label = labelIndex !== -1 ? args[labelIndex + 1] : undefined;
+    const known = new Set(['--json', '--force', '--yes', '--label', label].filter((v) => v !== undefined));
+    const unknown = args.find((a, i) => !known.has(a) && !(args[i - 1] === '--label'));
+    if (unknown)
+        return printActivationUsageError(`Unknown flag: ${unknown}`, 'init');
+    if (labelIndex !== -1 && label === undefined) {
+        return printActivationUsageError('--label requires a value', 'init');
+    }
+    const col = makeColors(process.stdout.isTTY === true);
+    if (!jsonMode) {
+        console.log('');
+        console.log(col.bold('  ashlr activation init'));
+        console.log(col.dim('  Generates an Ed25519 keypair on THIS machine and registers the public\n'
+            + '  half as a trust root. The private key never leaves this machine, is\n'
+            + '  written 0600 under an 0700 directory, and is the ONLY thing that can\n'
+            + '  sign a future `activation grant`. This step grants no capability by\n'
+            + '  itself — the fleet stays exactly as denied as it is today until you\n'
+            + '  run `ashlr activation grant <scope...>`.'));
+        console.log('');
+    }
+    if (refuseUnattended(yes, jsonMode, 'init'))
+        return 2;
+    const result = daemonActivationInit({ label, force });
+    if (!result.ok) {
+        const msg = `activation init refused: ${result.reason}`;
+        if (jsonMode)
+            console.log(JSON.stringify({ ok: false, error: result.reason }));
+        else
+            console.error(col.red('error: ') + msg);
+        return 1;
+    }
+    if (jsonMode) {
+        console.log(JSON.stringify({
+            ok: true,
+            keyId: result.keyId,
+            publicKeyPem: result.publicKeyPem,
+            rotated: result.rotated,
+            trustRootsPath: daemonActivationDirPath(),
+        }));
+    }
+    else {
+        console.log(col.green('ok: ') + `trust root registered (keyId=${result.keyId}${result.rotated ? ', rotated' : ''}).`);
+        console.log(col.dim(`  store: ${daemonActivationDirPath()}`));
+        console.log(col.dim('  Next: `ashlr activation grant <scope...>` to actually authorize something.'));
+    }
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Subcommand: status
+// ---------------------------------------------------------------------------
+async function cmdActivationStatus(args) {
+    const jsonMode = args.includes('--json');
+    const unknown = args.find((a) => a !== '--json');
+    if (unknown)
+        return printActivationUsageError(`Unknown flag: ${unknown}`, 'status');
+    const col = makeColors(process.stdout.isTTY === true);
+    const trustRoots = daemonActivationTrustRootStatus();
+    const grants = daemonActivationGrantStatus();
+    const loadConfig = await importConfig();
+    let cfg = null;
+    try {
+        cfg = loadConfig ? loadConfig() : null;
+    }
+    catch {
+        cfg = null;
+    }
+    const onceReadiness = cfg ? inspectDaemonActivationPermit(cfg, { once: true, dryRun: false }) : null;
+    const residentReadiness = cfg ? inspectDaemonActivationPermit(cfg, { once: false, dryRun: false }) : null;
+    const bindingMismatch = onceReadiness?.reason === 'permit-runtime-binding-mismatch'
+        || residentReadiness?.reason === 'permit-runtime-binding-mismatch';
+    const bindingDiagnosis = cfg && bindingMismatch
+        ? daemonActivationDiagnosePendingPermitBindings(cfg)
+        : null;
+    const nowMs = Date.now();
+    const grantSummaries = grants.ok
+        ? grants.records.map((record) => ({
+            grantId: record.grantId,
+            keyId: record.keyId,
+            scope: DAEMON_ACTIVATION_SCOPE_KEYS.filter((key) => record.scope[key]),
+            issuedAt: record.issuedAt,
+            expiresAt: record.expiresAt,
+            revoked: record.revokedAt !== null,
+            expired: Date.parse(record.expiresAt) <= nowMs,
+        }))
+        : [];
+    if (jsonMode) {
+        console.log(JSON.stringify({
+            ok: true,
+            store: daemonActivationDirPath(),
+            trustRoots: trustRoots.ok
+                ? trustRoots.records.map((r) => ({
+                    keyId: r.keyId, label: r.label, createdAt: r.createdAt, revoked: r.revokedAt !== null,
+                }))
+                : null,
+            trustRootStoreError: trustRoots.ok ? null : trustRoots.reason,
+            grants: grants.ok ? grantSummaries : null,
+            grantStoreError: grants.ok ? null : grants.reason,
+            pendingOneShotPermitPath: daemonActivationPermitPath(),
+            onceEligibility: onceReadiness,
+            residentEligibility: residentReadiness,
+            bindingMismatchDiagnosis: bindingDiagnosis,
+        }, null, 2));
+        return 0;
+    }
+    console.log('');
+    console.log(col.bold('  ashlr activation status'));
+    console.log(col.dim(`  store: ${daemonActivationDirPath()}`));
+    console.log('');
+    console.log(col.bold('  Trust roots'));
+    if (!trustRoots.ok) {
+        console.log(col.yellow(`    unreadable/unsafe (${trustRoots.reason}) — treated as NO authority.`));
+    }
+    else if (trustRoots.records.length === 0) {
+        console.log(col.dim('    none — run `ashlr activation init`.'));
+    }
+    else {
+        for (const root of trustRoots.records) {
+            const state = root.revokedAt !== null ? col.red(`revoked ${root.revokedAt}`) : col.green('active');
+            console.log(`    ${root.keyId}  ${state}  ${root.label ? `"${root.label}"` : ''}  (created ${root.createdAt})`);
+        }
+    }
+    console.log('');
+    console.log(col.bold('  Standing grants'));
+    if (!grants.ok) {
+        console.log(col.yellow(`    unreadable/unsafe (${grants.reason}) — treated as NO authority.`));
+    }
+    else if (grantSummaries.length === 0) {
+        console.log(col.dim('    none.'));
+    }
+    else {
+        for (const g of grantSummaries) {
+            const state = g.revoked ? col.red('revoked') : g.expired ? col.yellow('expired') : col.green('active');
+            console.log(`    ${g.grantId}  ${state}  scope=[${g.scope.join(', ')}]  keyId=${g.keyId}  expires ${g.expiresAt}`);
+        }
+    }
+    console.log('');
+    console.log(col.bold('  Currently granted, right now'));
+    for (const scopeKey of DAEMON_ACTIVATION_SCOPE_KEYS) {
+        if (ONE_SHOT_SCOPE_KEYS.has(scopeKey))
+            continue;
+        const check = daemonActivationScopeGranted(scopeKey);
+        console.log(`    ${scopeKey.padEnd(12)} ${check.granted ? col.green('granted') : col.dim('denied')}  (${check.reason})`);
+    }
+    console.log('');
+    console.log(col.bold('  One-shot permit (ashlr daemon start)'));
+    console.log(`    pending file: ${daemonActivationPermitPath()}`);
+    if (onceReadiness) {
+        console.log(`    --once:       ${onceReadiness.state === 'ready' ? col.green('ready') : col.dim(onceReadiness.state)}  (${onceReadiness.reason})`);
+    }
+    if (residentReadiness) {
+        console.log(`    resident:     ${residentReadiness.state === 'ready' ? col.green('ready') : col.dim(residentReadiness.state)}  (${residentReadiness.reason})`);
+    }
+    if (bindingDiagnosis) {
+        console.log('');
+        if (bindingDiagnosis.ok || !bindingDiagnosis.mismatches) {
+            console.log(col.dim(`    binding diagnosis: ${bindingDiagnosis.reason}`));
+        }
+        else {
+            console.log(col.yellow('    binding mismatch — field(s) that differ between the signed permit and right now:'));
+            for (const [field, { signed, current }] of Object.entries(bindingDiagnosis.mismatches)) {
+                console.log(`      ${col.bold(field)}:`);
+                console.log(`        signed:  ${formatBindingValue(signed)}`);
+                console.log(`        current: ${formatBindingValue(current)}`);
+            }
+        }
+    }
+    console.log('');
+    return 0;
+}
+function formatBindingValue(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if ('sha256' in value) {
+        const binding = value;
+        return `${binding.path}  sha256:${binding.sha256}`;
+    }
+    return JSON.stringify(value);
+}
+// ---------------------------------------------------------------------------
+// Subcommand: grant
+// ---------------------------------------------------------------------------
+async function cmdActivationGrant(args) {
+    const jsonMode = args.includes('--json');
+    const yes = args.includes('--yes');
+    const ttlIndex = args.indexOf('--ttl');
+    const ttlText = ttlIndex !== -1 ? args[ttlIndex + 1] : undefined;
+    const flagsConsumed = new Set(['--json', '--yes', '--ttl', ttlText].filter((v) => v !== undefined));
+    const scopeArgs = args.filter((a, i) => !flagsConsumed.has(a) && args[i - 1] !== '--ttl');
+    const unknownFlag = args.find((a) => a.startsWith('--') && !['--json', '--yes', '--ttl'].includes(a));
+    if (unknownFlag)
+        return printActivationUsageError(`Unknown flag: ${unknownFlag}`, 'grant');
+    if (ttlIndex !== -1 && ttlText === undefined)
+        return printActivationUsageError('--ttl requires a value', 'grant');
+    if (scopeArgs.length === 0) {
+        return printActivationUsageError('At least one scope is required.', 'grant');
+    }
+    const invalidScope = scopeArgs.find((s) => !DAEMON_ACTIVATION_SCOPE_KEYS.includes(s));
+    if (invalidScope) {
+        return printActivationUsageError(`Unknown scope: ${invalidScope} (expected one of: ${DAEMON_ACTIVATION_SCOPE_KEYS.join(', ')})`, 'grant');
+    }
+    const scopeKeys = [...new Set(scopeArgs)];
+    const scope = { ...EMPTY_DAEMON_ACTIVATION_SCOPE };
+    for (const key of scopeKeys)
+        scope[key] = true;
+    const isOneShot = scopeKeys.some((key) => ONE_SHOT_SCOPE_KEYS.has(key));
+    let ttlMs = DEFAULT_STANDING_GRANT_VALIDITY_MS;
+    if (ttlText !== undefined) {
+        if (isOneShot) {
+            return printActivationUsageError('--ttl only applies to standing grants (not once/resident, which use a fixed 2-minute window).', 'grant');
+        }
+        const parsed = parseDurationMs(ttlText);
+        if (parsed === null || parsed > MAX_STANDING_GRANT_VALIDITY_MS) {
+            return printActivationUsageError(`Invalid --ttl (expected <n>s|m|h|d, max ${MAX_STANDING_GRANT_VALIDITY_MS / 86_400_000}d): ${ttlText}`, 'grant');
+        }
+        ttlMs = parsed;
+    }
+    const col = makeColors(process.stdout.isTTY === true);
+    if (!jsonMode) {
+        console.log('');
+        console.log(col.bold('  ashlr activation grant') + col.dim(` — scope=[${scopeKeys.join(', ')}]`));
+        console.log(col.dim(isOneShot
+            ? '  Mints a SINGLE-USE, signed permit for `ashlr daemon start`. Consumed and\n'
+                + '  deleted the moment the daemon starts; expires in 2 minutes if unused.'
+            : `  Mints a standing, signed grant valid for ${Math.round(ttlMs / 3_600_000)}h, checked on every\n`
+                + '  use until it expires or you run `ashlr activation revoke`.'));
+        console.log('');
+    }
+    if (refuseUnattended(yes, jsonMode, 'grant'))
+        return 2;
+    if (isOneShot) {
+        const loadConfig = await importConfig();
+        if (!loadConfig) {
+            console.error(col.red('error: ') + 'activation grant requires src/core/config.ts.');
+            return 1;
+        }
+        let cfg;
+        try {
+            cfg = loadConfig();
+        }
+        catch (e) {
+            console.error(col.red('error: ') + 'Failed to load config: ' + (e instanceof Error ? e.message : String(e)));
+            return 1;
+        }
+        const result = daemonActivationMintOneShotPermit({ cfg, scope });
+        if (!result.ok) {
+            if (jsonMode)
+                console.log(JSON.stringify({ ok: false, error: result.reason }));
+            else
+                console.error(col.red('error: ') + `activation grant refused: ${result.reason}`);
+            return 1;
+        }
+        if (jsonMode) {
+            console.log(JSON.stringify({ kind: 'one-shot-permit', ...result }));
+        }
+        else {
+            console.log(col.green('ok: ') + `one-shot permit minted (permitId=${result.permitId}, expires ${result.expiresAt}).`);
+            console.log(col.dim(`  ${result.permitPath}`));
+            console.log(col.dim('  Run `ashlr daemon start' + (scope.once ? ' --once' : '') + '` now — the permit is single-use.'));
+        }
+        return 0;
+    }
+    const result = daemonActivationMintStandingGrant({ scope, ttlMs });
+    if (!result.ok) {
+        if (jsonMode)
+            console.log(JSON.stringify({ ok: false, error: result.reason }));
+        else
+            console.error(col.red('error: ') + `activation grant refused: ${result.reason}`);
+        return 1;
+    }
+    if (jsonMode) {
+        console.log(JSON.stringify({ ok: true, kind: 'standing-grant', record: result.record }));
+    }
+    else {
+        console.log(col.green('ok: ') + `standing grant minted (grantId=${result.record.grantId}, expires ${result.record.expiresAt}).`);
+        console.log(col.dim(`  scope=[${scopeKeys.join(', ')}]`));
+    }
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Subcommand: revoke
+// ---------------------------------------------------------------------------
+async function cmdActivationRevoke(args) {
+    const jsonMode = args.includes('--json');
+    const yes = args.includes('--yes');
+    const rootIndex = args.indexOf('--root');
+    const grantIndex = args.indexOf('--grant');
+    const rootId = rootIndex !== -1 ? args[rootIndex + 1] : undefined;
+    const grantId = grantIndex !== -1 ? args[grantIndex + 1] : undefined;
+    const known = new Set(['--json', '--yes', '--root', '--grant', rootId, grantId].filter((v) => v !== undefined));
+    const unknown = args.find((a, i) => !known.has(a) && args[i - 1] !== '--root' && args[i - 1] !== '--grant');
+    if (unknown)
+        return printActivationUsageError(`Unknown flag: ${unknown}`, 'revoke');
+    if ((rootIndex === -1) === (grantIndex === -1)) {
+        return printActivationUsageError('Specify exactly one of --root <keyId> or --grant <grantId>.', 'revoke');
+    }
+    if (rootIndex !== -1 && rootId === undefined)
+        return printActivationUsageError('--root requires a value', 'revoke');
+    if (grantIndex !== -1 && grantId === undefined)
+        return printActivationUsageError('--grant requires a value', 'revoke');
+    const col = makeColors(process.stdout.isTTY === true);
+    if (!jsonMode) {
+        console.log('');
+        console.log(col.bold('  ashlr activation revoke'));
+        console.log(col.dim(rootId
+            ? `  Immediately invalidates trust root ${rootId}. Every permit and standing\n`
+                + '  grant signed by it stops verifying from this instant on.'
+            : `  Immediately invalidates standing grant ${grantId}. Every guard that\n`
+                + '  consults it denies from this instant on.'));
+        console.log('');
+    }
+    if (refuseUnattended(yes, jsonMode, 'revoke'))
+        return 2;
+    const result = rootId !== undefined
+        ? daemonActivationRevokeTrustRoot(rootId)
+        : daemonActivationRevokeGrant(grantId);
+    if (!result.ok) {
+        if (jsonMode)
+            console.log(JSON.stringify({ ok: false, error: result.reason }));
+        else
+            console.error(col.red('error: ') + `activation revoke refused: ${result.reason}`);
+        return 1;
+    }
+    if (jsonMode)
+        console.log(JSON.stringify({ ok: true }));
+    else
+        console.log(col.green('ok: ') + 'revoked.');
+    return 0;
+}
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+/**
+ * `ashlr activation [init|status|grant|revoke] [flags]`
+ *
+ * Returns a process exit code (0 = success, non-zero = error/usage).
+ */
+export async function cmdActivation(args) {
+    const requestedSub = args[0];
+    if (requestedSub !== undefined && isHelpFlag(requestedSub)) {
+        printActivationUsage();
+        return 0;
+    }
+    if (requestedSub !== undefined && !isActivationSubcommand(requestedSub)) {
+        const message = requestedSub.startsWith('-')
+            ? `Unknown flag: ${requestedSub}`
+            : `Unknown activation subcommand: ${requestedSub}`;
+        return printActivationUsageError(message);
+    }
+    const sub = requestedSub ?? 'status';
+    const rest = args.slice(1);
+    if (rest.some(isHelpFlag)) {
+        printActivationUsage(sub);
+        return 0;
+    }
+    switch (sub) {
+        case 'init':
+            return cmdActivationInit(rest);
+        case 'status':
+            return cmdActivationStatus(rest);
+        case 'grant':
+            return cmdActivationGrant(rest);
+        case 'revoke':
+            return cmdActivationRevoke(rest);
+    }
+}
+//# sourceMappingURL=activation.js.map