@astrale-os/cli 1.0.0-beta.27 → 1.0.0-beta.28

package/README.md

@@ -87,12 +87,12 @@ Install the browser driver once:
 
 ```bash
 npm install -g agent-browser && agent-browser install
-npx skills add astrale-os/cli            # installs both the astrale-cli (ops) and astrale-domain (authoring) skills
+npx skills add astrale-os/cli            # installs every Astrale skill published by this repository
 npx skills add vercel-labs/agent-browser
 ```
 
-To install just one: `npx skills add astrale-os/cli@astrale-cli` or
-`npx skills add astrale-os/cli@astrale-domain`.
+To install just one, select `astrale-cli`, `astrale-domain`, `astrale-frontend-design`, or
+`astrale-services`, for example: `npx skills add astrale-os/cli@astrale-frontend-design`.
 
 ## Updating
 
@@ -148,6 +148,29 @@ CLI state lives under `~/.astrale/`:
 - `identities.json`
 - keypairs
 - cached IdP sessions
+- `sessions/` — locally recorded work sessions (see below)
+
+### Session retention
+
+Each invocation appends one line to a local session record under
+`~/.astrale/sessions/`; `astrale session list` shows them. The store is swept
+automatically against two bounds — sessions idle past `maxAgeDays` are dropped,
+then the store is trimmed to `maxBytes`, oldest first. Both are optional:
+
+```jsonc
+// ~/.astrale/config.json
+{
+  "telemetry": {
+    "enabled": true,      // false disables recording (the sweep still runs)
+    "maxAgeDays": 30,     // default
+    "maxBytes": 52428800  // default: 50 MB
+  }
+}
+```
+
+`ASTRALE_TELEMETRY_MAX_AGE_DAYS` and `ASTRALE_TELEMETRY_MAX_BYTES` override the
+config for one invocation. Values that are not positive numbers are ignored in
+favour of the default, so a typo cannot leave the store unbounded.
 
 ## Development
 

package/dist/astrale.js

@@ -2578,7 +2578,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@astrale-os/cli",
-    version: "1.0.0-beta.27",
+    version: "1.0.0-beta.28",
     description: "Astrale CLI — connect to existing Astrale kernels",
     keywords: [
       "astrale",
@@ -41751,7 +41751,7 @@ var require_node_gyp_build_optional_packages = __commonJS(function(exports, modu
 
 // node_modules/.pnpm/msgpackr-extract@3.0.4/node_modules/msgpackr-extract/index.js
 var require_msgpackr_extract = __commonJS(function(exports, module) {
-  var __dirname = "/private/tmp/astrale-cli-beta27-a3227da/node_modules/.pnpm/msgpackr-extract@3.0.4/node_modules/msgpackr-extract";
+  var __dirname = "/home/runner/work/cli/cli/node_modules/.pnpm/msgpackr-extract@3.0.4/node_modules/msgpackr-extract";
   module.exports = require_node_gyp_build_optional_packages()(__dirname);
 });
 
@@ -82639,7 +82639,7 @@ var init_get = __esm(() => {
     description: "Get one canonical node by Path or ID",
     afterHelpText: `
 Behavior:
-  Resolves one exact Kernel V2 Path and prints the canonical Node
+  Resolves one exact Kernel Path and prints the canonical Node
   { id, class, props }. Missing and authorization-masked nodes remain
   intentionally indistinguishable. @self is expanded before dispatch.
 
@@ -83452,11 +83452,8 @@ Behavior:
   Calls the public Kernel journal syscall and emits its { records, cursor }
   page. Topic selection is exact or prefix-based; cursors and timestamps are
   opaque strings owned by the journal backend. --follow reuses one Client Session
-  and advances only with the returned cursor. Machine follow output is NDJSON:
-  one complete admitted record per line; YAML follow is unsupported.
-
-  Historical event-glob lowering and the application-specific services-domain
-  log buffer are not part of the Kernel V2 journal contract.
+  and advances only with the returned cursor. With --json, follow output is
+  NDJSON with one complete admitted record per line; YAML follow is unsupported.
 
 Examples:
   $ astrale logs -i staging --limit 50
@@ -90026,7 +90023,7 @@ async function installDirect(target2, opts, dependencies = {}) {
     }
     host = validateInstallUrl(target2);
     operation = opts.operation === undefined ? direct.createOperationId() : direct.acceptOperationId(opts.operation);
-    consentedOrigin = await ensureIdentityOverrideConsent(target2, host, opts.allowIdentityOverride ?? false);
+    consentedOrigin = await ensureIdentityOverrideConsent(target2, host, opts.allowIdentityOverride ?? false, isMachine(opts));
   } catch (e) {
     fatal(e, opts);
   }
@@ -90046,7 +90043,9 @@ async function installDirect(target2, opts, dependencies = {}) {
       log.success(`Domain ${installed.status}: ${installed.origin}@${installed.revision}`);
       log.dim(`  operation:   ${installed.operation}`);
       if (isIdentityOverride(installed.origin, host) && installed.origin !== consentedOrigin) {
-        log.warn(`Installed origin "${installed.origin}" differs from the serving host "${host}" ` + `and was not confirmed before install (the worker Publication was unavailable). ` + `Every ${installed.origin}/* call on this instance now routes to ${host}.`);
+        if (!isMachine(fmtOpts)) {
+          log.warn(`Installed origin "${installed.origin}" differs from the serving host "${host}" ` + `and was not confirmed before install (the worker Publication was unavailable). ` + `Every ${installed.origin}/* call on this instance now routes to ${host}.`);
+        }
       }
     }
   });
@@ -90070,16 +90069,20 @@ function validateInstallUrl(value3) {
 function isIdentityOverride(origin2, host) {
   return origin2.toLowerCase() !== host.toLowerCase();
 }
-async function ensureIdentityOverrideConsent(url3, host, allow) {
+async function ensureIdentityOverrideConsent(url3, host, allow, machine) {
   const origin2 = await probeDeclaredOrigin(url3);
   if (origin2 === undefined) {
-    log.warn(`Could not read a declared origin from ` + `${new URL("/.well-known/astrale/domain.json", url3).href} — ` + `skipping the pre-install identity check (the installed origin is verified after install).`);
+    if (!machine) {
+      log.warn(`Could not read a declared origin from ` + `${new URL("/.well-known/astrale/domain.json", url3).href} — ` + `skipping the pre-install identity check (the installed origin is verified after install).`);
+    }
     return;
   }
   if (!isIdentityOverride(origin2, host))
     return;
   if (allow) {
-    log.warn(`Identity override consented via --allow-identity-override: ${origin2} ← ${host}`);
+    if (!machine) {
+      log.warn(`Identity override consented via --allow-identity-override: ${origin2} ← ${host}`);
+    }
     return origin2;
   }
   const banner = source_default.red.bold("⚠  DANGER — IDENTITY OVERRIDE") + `
@@ -90558,10 +90561,9 @@ Behavior:
   its result and stores the same target-bound registration. The callable owns
   authorization; the CLI never receives installed Domain authority.
 
-  Kernel V2 Nodes have opaque identity and no caller-assigned storage path, so
-  the historical --path option no longer exists. The CLI binds the key proof
-  to the exact provision fingerprint and target Kernel audience, then caches
-  the returned (issuer, subject) for subsequent calls.
+  The Kernel assigns each Node ID; callers do not choose a storage path. The
+  CLI binds the key proof to the exact provision fingerprint and target Kernel
+  audience, then caches the returned (issuer, subject) for subsequent calls.
 
 Example:
   $ astrale identity register alice --class /:accounts.example:class.User       --props '{"accounts.example:class.User.property.name":"Alice"}' -i staging
@@ -91270,6 +91272,53 @@ function metaPath(id) {
 function markerPath(id) {
   return join19(sessionDir(id), ".analyzed");
 }
+function sessionIds() {
+  try {
+    return readdirSync2(sessionsRoot()).filter((name) => !name.startsWith("."));
+  } catch {
+    return [];
+  }
+}
+function scanSessions(now = Date.now()) {
+  return sessionIds().map((id) => {
+    let lastEventAt = null;
+    try {
+      lastEventAt = statSync3(eventsPath(id)).mtime;
+    } catch {}
+    return {
+      id,
+      lastEventAt,
+      closed: lastEventAt !== null && now - lastEventAt.getTime() > IDLE_WINDOW_MS,
+      analyzed: existsSync9(markerPath(id))
+    };
+  }).sort((a, b) => (b.lastEventAt?.getTime() ?? 0) - (a.lastEventAt?.getTime() ?? 0));
+}
+function directoryBytes(dir) {
+  let entries;
+  try {
+    entries = readdirSync2(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  let total = 0;
+  for (const entry2 of entries) {
+    const path8 = join19(dir, entry2.name);
+    if (entry2.isDirectory()) {
+      total += directoryBytes(path8);
+    } else if (entry2.isFile()) {
+      try {
+        total += statSync3(path8).size;
+      } catch {}
+    }
+  }
+  return total;
+}
+function sessionBytes(id) {
+  return directoryBytes(sessionDir(id));
+}
+function readMeta(id) {
+  return readJsonSafe(metaPath(id));
+}
 function readJsonSafe(path8) {
   try {
     return JSON.parse(readFileSync3(path8, "utf-8"));
@@ -91294,13 +91343,7 @@ function inspectSession(id, now = Date.now()) {
   };
 }
 function listSessions2(now = Date.now()) {
-  let ids;
-  try {
-    ids = readdirSync2(sessionsRoot()).filter((n) => !n.startsWith("."));
-  } catch {
-    return [];
-  }
-  return ids.map((id) => inspectSession(id, now)).filter((s) => s !== null).sort((a, b) => (b.lastEventAt?.getTime() ?? 0) - (a.lastEventAt?.getTime() ?? 0));
+  return sessionIds().map((id) => inspectSession(id, now)).filter((s) => s !== null).sort((a, b) => (b.lastEventAt?.getTime() ?? 0) - (a.lastEventAt?.getTime() ?? 0));
 }
 var IDLE_WINDOW_MS;
 var init_store = __esm(() => {
@@ -91816,25 +91859,108 @@ var init_analyze = __esm(() => {
 
 // src/telemetry/settings.ts
 import { readFileSync as readFileSync5 } from "node:fs";
+function readConfig2() {
+  try {
+    const parsed = JSON.parse(readFileSync5(createPaths().config, "utf-8"));
+    const telemetry = parsed.telemetry;
+    return typeof telemetry === "object" && telemetry !== null ? telemetry : {};
+  } catch {
+    return {};
+  }
+}
 function telemetryEnabled() {
   const env2 = process.env.ASTRALE_TELEMETRY;
   if (env2 !== undefined && OFF_VALUES.has(env2.trim().toLowerCase()))
     return false;
-  try {
-    const parsed = JSON.parse(readFileSync5(createPaths().config, "utf-8"));
-    if (parsed.telemetry?.enabled === false)
-      return false;
-  } catch {}
-  return true;
+  return readConfig2().enabled !== false;
+}
+function firstPositive(candidates) {
+  for (const candidate2 of candidates) {
+    if (candidate2 === undefined)
+      continue;
+    const n = typeof candidate2 === "string" ? Number(candidate2.trim()) : candidate2;
+    if (Number.isFinite(n) && n > 0)
+      return n;
+  }
+  return null;
 }
-var OFF_VALUES;
+function retentionBudget() {
+  const config2 = readConfig2();
+  const days = firstPositive([process.env.ASTRALE_TELEMETRY_MAX_AGE_DAYS, config2.maxAgeDays]) ?? DEFAULT_MAX_AGE_DAYS;
+  const bytes = firstPositive([process.env.ASTRALE_TELEMETRY_MAX_BYTES, config2.maxBytes]) ?? DEFAULT_MAX_BYTES;
+  return { maxAgeMs: days * 24 * 60 * 60 * 1000, maxBytes: bytes };
+}
+var OFF_VALUES, DEFAULT_MAX_AGE_DAYS = 30, DEFAULT_MAX_BYTES;
 var init_settings = __esm(() => {
   init_state();
   OFF_VALUES = new Set(["0", "false", "off"]);
+  DEFAULT_MAX_BYTES = 50 * 1024 * 1024;
+});
+
+// src/telemetry/retention.ts
+import { rmSync as rmSync2 } from "node:fs";
+function remove(id, into) {
+  try {
+    rmSync2(sessionDir(id), { recursive: true, force: true });
+    into.push(id);
+  } catch {}
+}
+function sweepByAge(sessions, options = {}) {
+  const { maxAgeMs } = options.budget ?? retentionBudget();
+  const cutoff = (options.now ?? Date.now()) - maxAgeMs;
+  const limit = options.limit ?? Number.POSITIVE_INFINITY;
+  const protect = options.protect;
+  const removed = [];
+  for (const session3 of sessions) {
+    if (removed.length >= limit)
+      break;
+    if (protect?.has(session3.id))
+      continue;
+    if (session3.lastEventAt !== null && session3.lastEventAt.getTime() < cutoff) {
+      remove(session3.id, removed);
+    }
+  }
+  return { removed };
+}
+function sweepToBudget(sessions, options = {}) {
+  const { maxBytes } = options.budget ?? retentionBudget();
+  const protect = options.protect;
+  const removed = [];
+  const sized = sessions.map((session3) => ({ session: session3, bytes: sessionBytes(session3.id) }));
+  let total = sized.reduce((sum, entry2) => sum + entry2.bytes, 0);
+  if (total <= maxBytes)
+    return { removed };
+  const evictable = sized.filter((entry2) => entry2.session.closed && !protect?.has(entry2.session.id)).sort((a, b) => (a.session.lastEventAt?.getTime() ?? 0) - (b.session.lastEventAt?.getTime() ?? 0));
+  for (const analyzedFirst of [true, false]) {
+    for (const entry2 of evictable) {
+      if (total <= maxBytes)
+        return { removed };
+      if (entry2.session.analyzed !== analyzedFirst)
+        continue;
+      const before = removed.length;
+      remove(entry2.session.id, removed);
+      if (removed.length > before)
+        total -= entry2.bytes;
+    }
+  }
+  return { removed };
+}
+function sweepStore(options = {}) {
+  const budget = options.budget ?? retentionBudget();
+  const sessions = scanSessions();
+  const byAge = sweepByAge(sessions, { ...options, budget });
+  const gone = new Set(byAge.removed);
+  const bySize = sweepToBudget(sessions.filter((session3) => !gone.has(session3.id)), { ...options, budget });
+  return { removed: [...byAge.removed, ...bySize.removed] };
+}
+var MAX_REMOVALS_ON_START = 20;
+var init_retention = __esm(() => {
+  init_settings();
+  init_store();
 });
 
 // src/telemetry/trigger.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync2, readFileSync as readFileSync6, rmSync as rmSync2, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync2, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join23 } from "node:path";
 function lockPath() {
   return join23(sessionsRoot(), ".analyzer.lock");
@@ -91849,12 +91975,12 @@ function restampLock() {
     writeFileSync3(lockPath(), JSON.stringify({ pid: process.pid, at: Date.now() }));
   } catch {}
 }
-var LOCK_STALE_MS, GC_AGE_MS;
+var LOCK_STALE_MS;
 var init_trigger = __esm(() => {
+  init_retention();
   init_settings();
   init_store();
   LOCK_STALE_MS = 30 * 60 * 1000;
-  GC_AGE_MS = 30 * 24 * 60 * 60 * 1000;
 });
 
 // src/commands/session/analyze.ts
@@ -91867,12 +91993,19 @@ var init_analyze2 = __esm(() => {
   init_source();
   init_log();
   init_analyze();
+  init_retention();
   init_store();
   init_trigger();
   analyze_default = {
     name: "analyze",
     description: "Analyze a recorded session for DX frictions (dry-run: writes report.md)",
-    arguments: [{ name: "id", description: "Session id (default: most recent closed, unanalyzed)" }],
+    arguments: [
+      {
+        name: "id",
+        description: "Session id (default: most recent closed, unanalyzed)",
+        required: false
+      }
+    ],
     options: [
       { flags: "--file", description: "File cleared findings as issues on the admin tracker" },
       { flags: "--model <model>", description: "Model for the analyzer pass" },
@@ -91882,10 +92015,10 @@ var init_analyze2 = __esm(() => {
     action: async (id, opts) => {
       if (opts.auto)
         restampLock();
+      let target2 = id;
       try {
-        let target2 = id;
         if (!target2) {
-          const candidate2 = listSessions2().find((s) => s.closed && (opts.force || !s.analyzed));
+          const candidate2 = scanSessions().find((s) => s.closed && (opts.force || !s.analyzed));
           if (!candidate2) {
             if (!opts.auto)
               log.dim("Nothing to analyze — no closed, unanalyzed session.");
@@ -91910,6 +92043,12 @@ var init_analyze2 = __esm(() => {
       } finally {
         if (opts.auto)
           releaseLock();
+        try {
+          const swept = sweepStore({ protect: new Set(target2 === undefined ? [] : [target2]) });
+          if (!opts.auto && swept.removed.length > 0) {
+            log.dim(`retention: removed ${swept.removed.length} session(s)`);
+          }
+        } catch {}
       }
     }
   };
@@ -92694,11 +92833,13 @@ function stamp(d = new Date) {
   const p = (n, w = 2) => String(n).padStart(w, "0");
   return `${p(d.getFullYear(), 4)}${p(d.getMonth() + 1)}${p(d.getDate())}${p(d.getHours())}${p(d.getMinutes())}`;
 }
-function findOpenAmbient(root) {
-  for (const s of listSessions2()) {
-    if (s.meta?.root === root && s.meta.explicit === false && !s.closed && s.analyzed === null) {
+function findOpenAmbient(root, sessions) {
+  for (const s of sessions) {
+    if (s.closed || s.analyzed)
+      continue;
+    const meta3 = readMeta(s.id);
+    if (meta3?.root === root && meta3.explicit === false)
       return s.id;
-    }
   }
   return null;
 }
@@ -92706,7 +92847,7 @@ function mintAmbientId(root) {
   const hash8 = createHash4("sha256").update(root).digest("hex").slice(0, 8);
   return `amb-${hash8}-${stamp()}`;
 }
-function resolveSession2(cwd) {
+function resolveSession2(cwd, sessions) {
   const root = findGitRoot(cwd) ?? cwd;
   const pinned = process.env.ASTRALE_SESSION;
   if (pinned) {
@@ -92714,10 +92855,11 @@ function resolveSession2(cwd) {
     if (id.length > 0)
       return { id, root, explicit: true };
   }
-  return { id: findOpenAmbient(root) ?? mintAmbientId(root), root, explicit: false };
+  const scan2 = sessions ?? scanSessions();
+  return { id: findOpenAmbient(root, scan2) ?? mintAmbientId(root), root, explicit: false };
 }
-function ensureSession(cwd) {
-  const resolved = resolveSession2(cwd);
+function ensureSession(cwd, sessions) {
+  const resolved = resolveSession2(cwd, sessions);
   const dir = sessionDir(resolved.id);
   if (!existsSync13(dir)) {
     try {
@@ -92751,7 +92893,7 @@ var HELP_VERSION = new Set([
 function isHelpOrVersion(args) {
   return args.every((a) => HELP_VERSION.has(a));
 }
-function beginInvocation(argv) {
+function beginInvocation(argv, sessions) {
   try {
     const args = argv.slice(2);
     if (!telemetryEnabled() || isHelpOrVersion(args))
@@ -92759,7 +92901,7 @@ function beginInvocation(argv) {
     const startMs = Date.now();
     const ts = new Date(startMs).toISOString();
     const cwd = process.cwd();
-    const { id, root } = ensureSession(cwd);
+    const { id, root } = ensureSession(cwd, sessions);
     return (exitCode, errorName) => {
       try {
         const event = {
@@ -92783,37 +92925,61 @@ function beginInvocation(argv) {
   }
 }
 
+// src/telemetry/store.ts
+init_state();
+import { existsSync as existsSync14, readdirSync as readdirSync5, readFileSync as readFileSync7, statSync as statSync6 } from "node:fs";
+import { join as join25 } from "node:path";
+var IDLE_WINDOW_MS2 = 30 * 60 * 1000;
+function sessionsRoot2() {
+  return join25(createPaths().home, "sessions");
+}
+function sessionDir2(id) {
+  return join25(sessionsRoot2(), id);
+}
+function eventsPath2(id) {
+  return join25(sessionDir2(id), "events.jsonl");
+}
+function markerPath2(id) {
+  return join25(sessionDir2(id), ".analyzed");
+}
+function sessionIds2() {
+  try {
+    return readdirSync5(sessionsRoot2()).filter((name) => !name.startsWith("."));
+  } catch {
+    return [];
+  }
+}
+function scanSessions2(now = Date.now()) {
+  return sessionIds2().map((id) => {
+    let lastEventAt = null;
+    try {
+      lastEventAt = statSync6(eventsPath2(id)).mtime;
+    } catch {}
+    return {
+      id,
+      lastEventAt,
+      closed: lastEventAt !== null && now - lastEventAt.getTime() > IDLE_WINDOW_MS2,
+      analyzed: existsSync14(markerPath2(id))
+    };
+  }).sort((a, b) => (b.lastEventAt?.getTime() ?? 0) - (a.lastEventAt?.getTime() ?? 0));
+}
+
 // src/telemetry/trigger.ts
+init_retention();
 init_settings();
 init_store();
 import { spawn as spawn4 } from "node:child_process";
-import { existsSync as existsSync14, mkdirSync as mkdirSync4, readFileSync as readFileSync7, rmSync as rmSync3, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync4, readFileSync as readFileSync8, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join26 } from "node:path";
 var LOCK_STALE_MS2 = 30 * 60 * 1000;
-var GC_AGE_MS2 = 30 * 24 * 60 * 60 * 1000;
-var GC_MAX_PER_RUN = 20;
-function gcOldSessions(sessions) {
-  try {
-    const cutoff = Date.now() - GC_AGE_MS2;
-    let removed = 0;
-    for (const s of sessions) {
-      if (removed >= GC_MAX_PER_RUN)
-        break;
-      if (s.analyzed !== null && s.lastEventAt !== null && s.lastEventAt.getTime() < cutoff) {
-        rmSync3(sessionDir(s.id), { recursive: true, force: true });
-        removed++;
-      }
-    }
-  } catch {}
-}
 function lockPath2() {
-  return join25(sessionsRoot(), ".analyzer.lock");
+  return join26(sessionsRoot(), ".analyzer.lock");
 }
 function claimLock() {
   const path8 = lockPath2();
   try {
-    if (existsSync14(path8)) {
-      const lock = JSON.parse(readFileSync7(path8, "utf-8"));
+    if (existsSync15(path8)) {
+      const lock = JSON.parse(readFileSync8(path8, "utf-8"));
       const stale2 = Date.now() - lock.at > LOCK_STALE_MS2;
       let alive = false;
       try {
@@ -92831,17 +92997,17 @@ function claimLock() {
     return false;
   }
 }
-function maybeTriggerAnalysis(argv) {
+function maybeTriggerAnalysis(argv, scan2) {
   try {
-    if (!telemetryEnabled())
-      return;
     if (process.env.ASTRALE_TELEMETRY_NO_TRIGGER === "1")
       return;
+    const sessions = scan2 ?? scanSessions();
+    const swept = new Set(sweepByAge(sessions, { limit: MAX_REMOVALS_ON_START }).removed);
+    if (!telemetryEnabled())
+      return;
     if (argv[2] === "session")
       return;
-    const sessions = listSessions2();
-    gcOldSessions(sessions);
-    const target2 = sessions.find((s) => s.closed && s.analyzed === null && s.lastEventAt !== null);
+    const target2 = sessions.find((s) => s.closed && !s.analyzed && s.lastEventAt !== null && !swept.has(s.id));
     if (!target2)
       return;
     if (!claimLock())
@@ -92864,11 +93030,12 @@ function overrideExits(command) {
   for (const child3 of command.commands)
     overrideExits(child3);
 }
-var finalize2 = process.argv[2] === "session" ? undefined : beginInvocation(process.argv);
+var sessions = scanSessions2();
+var finalize2 = process.argv[2] === "session" ? undefined : beginInvocation(process.argv, sessions);
 var errorName;
 if (finalize2)
   process.on("exit", (code) => finalize2(code ?? 0, errorName));
-maybeTriggerAnalysis(process.argv);
+maybeTriggerAnalysis(process.argv, sessions);
 var argv = normalizeRootVersionArgv(process.argv);
 configureInvocation(argv);
 var program4 = await buildProgram();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrale-os/cli",
-  "version": "1.0.0-beta.27",
+  "version": "1.0.0-beta.28",
   "description": "Astrale CLI — connect to existing Astrale kernels",
   "keywords": [
     "astrale",

package/src/commands/__tests__/domain-install-operation.test.ts

@@ -93,6 +93,29 @@ describe('direct domain install operation identity', () => {
     ])
   })
 
+  test('keeps identity-override consent warnings out of machine output', async () => {
+    globalThis.fetch = mock(async () => publicationResponse()) as unknown as typeof fetch
+    const originalError = console.error
+    const warnings: unknown[][] = []
+    console.error = (...args: unknown[]) => {
+      warnings.push(args)
+    }
+    try {
+      await installDirect(
+        'https://alias.test',
+        { direct: true, json: true, allowIdentityOverride: true },
+        {
+          createOperationId: () => GENERATED,
+          runKernelCommand: async () => undefined,
+        },
+      )
+    } finally {
+      console.error = originalError
+    }
+
+    expect(warnings).toEqual([])
+  })
+
   test('rejects a non-UUID operation before metadata or Kernel transport', async () => {
     const originalExit = process.exit
     const originalWrite = process.stderr.write

package/src/commands/__tests__/install-identity-override.test.ts

@@ -54,11 +54,11 @@ describe('declared-origin Publication probe', () => {
     expect(await probeDeclaredOrigin(url)).toBe('crm.acme.dev')
   })
 
-  test('does not accept the removed pre-Kernel-V2 domainName shape', async () => {
-    const legacy = servePublication(() =>
+  test('does not accept a Publication without the canonical origin field', async () => {
+    const invalid = servePublication(() =>
       Response.json({ iss: 'https://x', domainName: 'crm.acme.dev' }),
     )
-    expect(await probeDeclaredOrigin(legacy)).toBeUndefined()
+    expect(await probeDeclaredOrigin(invalid)).toBeUndefined()
   })
 
   test('degrades to undefined on invalid Publication, non-200, bad JSON, or dead host', async () => {