@bastani/atomic 0.9.14-alpha.1 → 0.9.14-alpha.2

package/dist/builtin/workflows/skills/impeccable/scripts/live/sveltekit-adapter.mjs

@@ -7,13 +7,38 @@
  * actual live UI remains the shared plain-DOM browser chrome.
  */
 
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
+import { resolveProjectPath, writeProjectFileAtomic } from './frameworks/detect-utils.mjs';
+import { buildLiveScriptSrc } from './frameworks/script-src.mjs';
 
 export const SVELTE_LIVE_ROOT_COMPONENT = 'src/lib/impeccable/ImpeccableLiveRoot.svelte';
 export const SVELTE_LAYOUT_MARKER_OPEN = '<!-- impeccable-live-svelte-start -->';
 export const SVELTE_LAYOUT_MARKER_CLOSE = '<!-- impeccable-live-svelte-end -->';
 export const SVELTE_ROOT_IMPORT = "import ImpeccableLiveRoot from '$lib/impeccable/ImpeccableLiveRoot.svelte';";
+// Matches the import at ANY revision (or none). [ \t]* bounds only, never
+// \s*: a greedy \s* after the statement swallowed the next line's
+// indentation on removal, leaving a formatting scar in user layouts.
+const SVELTE_ROOT_IMPORT_LINE_RE = /^[ \t]*import ImpeccableLiveRoot from '\$lib\/impeccable\/ImpeccableLiveRoot\.svelte(?:\?[^']*)?';[ \t]*\r?\n?/gm;
+
+/**
+ * The import specifier carries a token-derived revision query. The adapter
+ * component embeds the helper token, and Vite (client AND SSR) can keep
+ * serving a stale compiled module after the file is rewritten on a helper
+ * restart; the browser then requests /live.js with a rotated-out token and
+ * gets a 401 with no picker. A changed specifier is a different module id,
+ * which no cache survives.
+ */
+export function svelteRootImportLine(rev) {
+  if (!rev) return SVELTE_ROOT_IMPORT;
+  return "import ImpeccableLiveRoot from '$lib/impeccable/ImpeccableLiveRoot.svelte?impeccable-live=" + rev + "';";
+}
+
+export function svelteAdapterRev(token) {
+  if (!token) return null;
+  return crypto.createHash('sha256').update(String(token)).digest('hex').slice(0, 8);
+}
 
 export function detectSvelteKitProject(cwd = process.cwd(), config = null) {
   const appHtml = findSvelteKitAppHtml(cwd, config);
@@ -46,12 +71,11 @@ export function applySvelteKitLiveAdapter({ cwd = process.cwd(), port, token, co
   ensureSvelteLiveRootComponent(cwd, Number(port), token);
 
   const layoutRel = detected.layoutFile;
-  const layoutAbs = path.join(cwd, layoutRel);
-  fs.mkdirSync(path.dirname(layoutAbs), { recursive: true });
+  const layoutAbs = resolveProjectPath(cwd, layoutRel);
   const layoutExisted = fs.existsSync(layoutAbs);
   const before = layoutExisted ? fs.readFileSync(layoutAbs, 'utf-8') : defaultSvelteLayout();
-  const after = patchSvelteLayout(before);
-  fs.writeFileSync(layoutAbs, after, 'utf-8');
+  const after = patchSvelteLayout(before, { rev: svelteAdapterRev(token) });
+  writeProjectFileAtomic(cwd, layoutRel, after);
 
   return {
     file: layoutRel,
@@ -66,24 +90,24 @@ export function removeSvelteKitLiveAdapter({ cwd = process.cwd(), config = null
   const detected = detectSvelteKitProject(cwd, config);
   if (!detected) return null;
 
-  const layoutAbs = path.join(cwd, detected.layoutFile);
+  const layoutAbs = resolveProjectPath(cwd, detected.layoutFile, { kind: 'file' });
   let removed = false;
   if (fs.existsSync(layoutAbs)) {
     const before = fs.readFileSync(layoutAbs, 'utf-8');
     const after = unpatchSvelteLayout(before);
     if (after !== before) {
-      fs.writeFileSync(layoutAbs, after, 'utf-8');
+      writeProjectFileAtomic(cwd, detected.layoutFile, after);
       removed = true;
     }
   }
 
-  const rootAbs = path.join(cwd, SVELTE_LIVE_ROOT_COMPONENT);
-  if (fs.existsSync(rootAbs)) {
+  const rootAbs = resolveProjectPath(cwd, SVELTE_LIVE_ROOT_COMPONENT, { kind: 'file' });
+  if (fs.existsSync(rootAbs) && fs.readFileSync(rootAbs, 'utf-8').includes('impeccable-live-root')) {
     fs.rmSync(rootAbs, { force: true });
     removed = true;
   }
 
-  pruneEmptyDir(path.dirname(rootAbs), path.join(cwd, 'src'));
+  pruneEmptyDir(path.dirname(rootAbs), resolveProjectPath(cwd, 'src', { kind: 'directory' }));
 
   return {
     file: detected.layoutFile,
@@ -94,15 +118,27 @@ export function removeSvelteKitLiveAdapter({ cwd = process.cwd(), config = null
   };
 }
 
-export function patchSvelteLayout(content) {
+export function patchSvelteLayout(content, { rev = null } = {}) {
   let out = String(content || '');
-  if (!out.includes(SVELTE_ROOT_IMPORT)) {
-    const scriptMatch = out.match(/<script(?:\s[^>]*)?>/i);
-    if (scriptMatch) {
-      const insertAt = scriptMatch.index + scriptMatch[0].length;
-      out = out.slice(0, insertAt) + '\n  ' + SVELTE_ROOT_IMPORT + out.slice(insertAt);
-    } else {
-      out = `<script>\n  ${SVELTE_ROOT_IMPORT}\n</script>\n\n` + out;
+  const importLine = svelteRootImportLine(rev);
+  if (!out.includes(importLine)) {
+    // An import at an older revision is replaced in place, keeping its
+    // indentation; only a layout with no impeccable import gets an insert.
+    let replaced = false;
+    out = out.replace(SVELTE_ROOT_IMPORT_LINE_RE, (line) => {
+      if (replaced) return '';
+      replaced = true;
+      const indent = (line.match(/^[ \t]*/) || [''])[0];
+      return indent + importLine + '\n';
+    });
+    if (!replaced) {
+      const scriptMatch = out.match(/<script(?:\s[^>]*)?>/i);
+      if (scriptMatch) {
+        const insertAt = scriptMatch.index + scriptMatch[0].length;
+        out = out.slice(0, insertAt) + '\n  ' + importLine + out.slice(insertAt);
+      } else {
+        out = `<script>\n  ${importLine}\n</script>\n\n` + out;
+      }
     }
   }
 
@@ -131,21 +167,17 @@ export function unpatchSvelteLayout(content) {
     'g',
   );
   out = out.replace(blockRe, '$1');
-  out = out.replace(new RegExp('^\\s*' + escapeRegExp(SVELTE_ROOT_IMPORT) + '\\s*\\n?', 'gm'), '');
-  out = out.replace(/<script>\s*<\/script>\s*\n?/g, '');
+  out = out.replace(SVELTE_ROOT_IMPORT_LINE_RE, '');
+  out = out.replace(/<script>\s*<\/script>[ \t]*\r?\n?/g, '');
   return out.replace(/\n{3,}/g, '\n\n');
 }
 
 export function ensureSvelteLiveRootComponent(cwd, port, token) {
-  const file = path.join(cwd, SVELTE_LIVE_ROOT_COMPONENT);
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, buildSvelteLiveRootComponent(port, token), 'utf-8');
-  return file;
+  return writeProjectFileAtomic(cwd, SVELTE_LIVE_ROOT_COMPONENT, buildSvelteLiveRootComponent(port, token));
 }
 
 export function buildSvelteLiveRootComponent(port, token) {
-  const liveUrl = 'http://localhost:' + Number(port) + '/live.js'
-    + (token ? '?token=' + encodeURIComponent(token) : '');
+  const liveUrl = buildLiveScriptSrc(port, token);
   return `<script>
   import { onMount } from 'svelte';
 
@@ -193,6 +225,11 @@ export function buildSvelteLiveRootComponent(port, token) {
     script.src = LIVE_URL;
     script.async = true;
     script.dataset.impeccableLiveScript = 'true';
+    script.onerror = () => console.error(
+      '[impeccable] live.js failed to load from ' + LIVE_URL
+      + ' (helper down, or the token rotated while a stale adapter module was cached).'
+      + ' Re-run the live boot, then reload this page.'
+    );
     document.head.appendChild(script);
 
     return () => {
@@ -209,11 +246,12 @@ export function buildSvelteLiveRootComponent(port, token) {
 function findSvelteKitAppHtml(cwd, config) {
   const files = Array.isArray(config?.files) ? config.files : ['src/app.html'];
   for (const rel of files) {
-    if (rel.includes('*')) continue;
+    if (typeof rel !== 'string' || rel.includes('*')) continue;
     const normalized = rel.split(path.sep).join('/');
     if (!normalized.endsWith('app.html')) continue;
-    const abs = path.join(cwd, normalized);
-    if (fs.existsSync(abs)) return normalized;
+    try {
+      if (fs.existsSync(resolveProjectPath(cwd, normalized, { kind: 'file' }))) return normalized;
+    } catch { /* unsafe configured paths are not SvelteKit signals */ }
   }
   const fallback = 'src/app.html';
   return fs.existsSync(path.join(cwd, fallback)) ? fallback : null;

package/dist/builtin/workflows/skills/impeccable/scripts/live/tanstack-adapter.mjs

@@ -19,7 +19,8 @@
 
 import fs from 'node:fs';
 import path from 'node:path';
-import { buildLiveScriptSrc } from '../live-inject.mjs';
+import { buildLiveScriptSrc } from './frameworks/script-src.mjs';
+import { resolveProjectPath, writeProjectFileAtomic } from './frameworks/detect-utils.mjs';
 
 export const TANSTACK_MARKER_OPEN = '{/* impeccable-live-tanstack-start */}';
 export const TANSTACK_MARKER_CLOSE = '{/* impeccable-live-tanstack-end */}';
@@ -60,8 +61,8 @@ export function applyTanStackLiveAdapter({ cwd = process.cwd(), port, token, pro
     throw new Error('TanStack Start live adapter requires a numeric port');
   }
 
-  // Write the managed mount component.
-  const componentAbs = path.join(cwd, project.componentFile);
+  // Write the managed mount component inside the canonical project root.
+  const componentAbs = resolveProjectPath(cwd, project.componentFile);
   const componentBody = buildTanStackLiveRootComponent(Number(port), token);
   const componentExisted = fs.existsSync(componentAbs);
   if (componentExisted && !isManagedComponent(fs.readFileSync(componentAbs, 'utf-8'))) {
@@ -72,15 +73,14 @@ export function applyTanStackLiveAdapter({ cwd = process.cwd(), port, token, pro
       hint: `${project.componentFile} already exists and is not managed by Impeccable Live`,
     };
   }
-  fs.mkdirSync(path.dirname(componentAbs), { recursive: true });
-  fs.writeFileSync(componentAbs, componentBody, 'utf-8');
+  writeProjectFileAtomic(cwd, project.componentFile, componentBody);
 
   // Patch the root document to import + render the mount component.
-  const rootAbs = path.join(cwd, project.rootRoute);
+  const rootAbs = resolveProjectPath(cwd, project.rootRoute, { mustExist: true, kind: 'file' });
   const before = fs.readFileSync(rootAbs, 'utf-8');
   const after = patchTanStackRoot(before, project.componentImport);
   const changed = after !== before;
-  if (changed) fs.writeFileSync(rootAbs, after, 'utf-8');
+  if (changed) writeProjectFileAtomic(cwd, project.rootRoute, after);
 
   return {
     file: project.rootRoute,
@@ -95,22 +95,22 @@ export function removeTanStackLiveAdapter({ cwd = process.cwd(), project = detec
   if (!project) return { error: 'tanstack_not_detected' };
   let removed = false;
 
-  const rootAbs = path.join(cwd, project.rootRoute);
+  const rootAbs = resolveProjectPath(cwd, project.rootRoute, { kind: 'file' });
   if (fs.existsSync(rootAbs)) {
     const before = fs.readFileSync(rootAbs, 'utf-8');
     const after = unpatchTanStackRoot(before);
     if (after !== before) {
-      fs.writeFileSync(rootAbs, after, 'utf-8');
+      writeProjectFileAtomic(cwd, project.rootRoute, after);
       removed = true;
     }
   }
 
-  const componentAbs = path.join(cwd, project.componentFile);
-  if (fs.existsSync(componentAbs)) {
+  const componentAbs = resolveProjectPath(cwd, project.componentFile, { kind: 'file' });
+  if (fs.existsSync(componentAbs) && isManagedComponent(fs.readFileSync(componentAbs, 'utf-8'))) {
     fs.rmSync(componentAbs, { force: true });
     removed = true;
   }
-  pruneEmptyDir(path.dirname(componentAbs), path.join(cwd, 'src'));
+  pruneEmptyDir(path.dirname(componentAbs), resolveProjectPath(cwd, 'src', { kind: 'directory' }));
 
   return {
     file: project.rootRoute,

package/dist/builtin/workflows/skills/impeccable/scripts/live/ui-surfaces.mjs

@@ -0,0 +1,75 @@
+/**
+ * Canonical inventory of the Live overlay's UI surfaces: one entry per piece of
+ * chrome Live mounts on the user's page, with the element ids that make it up.
+ *
+ * Single source of truth, consumed by:
+ *   - skill/scripts/live/browser-script-parts.mjs — serializes this into
+ *     window.__IMPECCABLE_LIVE_UI_SURFACES__ in the /live.js prelude.
+ *   - skill/scripts/live-browser.js — publishes it on
+ *     window.__IMPECCABLE_LIVE_CHROME_CORE__ for adapters and E2E probes. That
+ *     file is served raw and injected as a classic <script>, so it cannot
+ *     import this module at runtime; it reads the injected global instead, the
+ *     same path live/vocabulary.mjs already takes for the command palette.
+ *   - the private impeccable-site repo — site/components/LiveUiGallery.astro
+ *     and tests/live-ui-lab.test.mjs import LIVE_UI_SURFACES at build time and
+ *     fail the site build when the Live UI lab has no snapshot for a surface
+ *     defined here. That guard only guards if it reads this list rather than a
+ *     copy the site keeps, so this module must stay importable from Node.
+ *     Renaming a key or the module is a breaking change for that build; the
+ *     list was briefly inlined into live-browser.js and the site had to parse
+ *     it back out with a regex.
+ *
+ * Add a surface here and both the browser bundle and the site lab follow.
+ */
+
+/** Id prefix every Live chrome element carries. Mirrored by PREFIX in live-browser.js. */
+export const LIVE_UI_PREFIX = 'impeccable-live';
+
+const id = (suffix) => `${LIVE_UI_PREFIX}-${suffix}`;
+
+/**
+ * The mount contract every Live chrome adapter (DOM, Svelte, ...) satisfies.
+ * Published alongside the surfaces on __IMPECCABLE_LIVE_CHROME_CORE__.
+ */
+export const LIVE_CHROME_MOUNT_CONTRACT = Object.freeze(['root', 'transport', 'state', 'actions']);
+
+export const LIVE_UI_SURFACES = Object.freeze([
+  {
+    key: 'global-bottom-bar',
+    ids: [
+      id('global-bar'), id('global-bar-brand'), id('pick-toggle'), id('insert-toggle'),
+      id('detect-toggle'), id('detect-badge'), id('design-toggle'), id('page-chat'),
+      id('page-chat-input'), id('page-chat-voice'), id('page-chat-send'),
+    ],
+  },
+  { key: 'pending-copy-edit-dock', ids: [id('pending-dock')] },
+  {
+    key: 'element-selection-chrome',
+    ids: [
+      id('highlight'), id('tooltip'), id('bar'), id('selection-pill'), id('input'),
+      id('configure-voice'), id('configure-bar-tooltip'),
+    ],
+  },
+  { key: 'action-picker', ids: [id('picker')] },
+  { key: 'edit-chrome', ids: [id('edit-badge')] },
+  { key: 'generating-row', ids: [id('bar'), id('shader')] },
+  { key: 'variant-cycling-row', ids: [id('bar'), id('params-panel')] },
+  { key: 'variant-params-panel', ids: [id('params-panel')] },
+  { key: 'saving-confirmed-rows', ids: [id('bar')] },
+  {
+    key: 'insert-mode-chrome',
+    ids: [
+      id('insert-line'), id('insert-placeholder'), id('placeholder-resize'), id('insert-input'),
+      id('insert-voice'), id('insert-create'), id('insert-create-tooltip'),
+    ],
+  },
+  { key: 'annotation-chrome', ids: [id('annot'), id('annot-svg'), id('annot-pins'), id('annot-clear')] },
+  { key: 'design-system-panel', ids: [id('design-host')] },
+  { key: 'toasts-and-errors', ids: [id('toast'), id('mount-error')] },
+  { key: 'css-isolation-boundary', ids: [id('root')] },
+].map((surface) => Object.freeze({ ...surface, ids: Object.freeze(surface.ids) })));
+
+/** Every id any surface owns, de-duplicated, in surface order. */
+export const LIVE_UI_COMPONENT_IDS = Object.freeze([
+  ...new Set(LIVE_UI_SURFACES.flatMap((surface) => surface.ids)),
+]);

package/dist/builtin/workflows/skills/impeccable/scripts/live/vocabulary.mjs

@@ -34,3 +34,138 @@ export const LIVE_COMMANDS = [
 
 // Action values accepted by the live event protocol, in palette order.
 export const VISUAL_ACTIONS = LIVE_COMMANDS.map((c) => c.value);
+
+/*
+ * ---------------------------------------------------------------------------
+ * Protocol vocabulary
+ * ---------------------------------------------------------------------------
+ * The enums below are the wire contract between the browser overlay, the live
+ * helper server, and the durable session journal. They live here rather than in
+ * the modules that use them so a value cannot be added to the validator without
+ * the store and the server seeing it too.
+ *
+ * live-browser.js still cannot import this file (it is served raw and injected
+ * as an IIFE), so its local phase table repeats the agent-phase names. Anything
+ * the server can broadcast must appear in AGENT_PHASES here first.
+ */
+
+/**
+ * Phases the live server broadcasts as `agent_phase`, in lifecycle order.
+ * Every one of these is emitted by `recordAgentPhase()` in live-server.mjs;
+ * the validator rejects anything else, so a typo in a phase name fails loudly
+ * instead of quietly ranking as an unknown phase in the browser's progress bar.
+ */
+export const AGENT_PHASES = Object.freeze([
+  'picked_up',
+  'scaffolding',
+  'source_ready',
+  'scaffold_fallback',
+  'generation_ready',
+  'first_reviewable',
+  'second_reviewable',
+  'all_variants_ready',
+]);
+
+/** Event types the helper server accepts from the browser over POST /events. */
+export const CLIENT_EVENT_TYPES = Object.freeze([
+  'generate',
+  'accept',
+  'discard',
+  'checkpoint',
+  'agent_phase',
+  'variant_mounted',
+  'variant_mount_failed',
+  'exit',
+  'prefetch',
+  'manual_edits',
+  'steer',
+  'carbonize_cleanup',
+]);
+
+/**
+ * Event types the durable journal applies. A superset of CLIENT_EVENT_TYPES:
+ * the agent-side helpers (live-poll, live-complete) and the server itself
+ * append the rest. An event type missing here lands as `unknown_event_type`
+ * in the snapshot diagnostics.
+ */
+export const JOURNAL_EVENT_TYPES = Object.freeze([
+  'generate',
+  'variant_plan',
+  'detector_waivers',
+  'agent_phase',
+  'variants_ready',
+  'agent_done',
+  'variant_mounted',
+  'variant_mount_failed',
+  'checkpoint',
+  'accept',
+  'accept_intent',
+  'manual_edit_apply',
+  'steer',
+  'steer_done',
+  'carbonize_cleanup',
+  'discard',
+  'discarded',
+  'complete',
+  'agent_error',
+]);
+
+/** Phases the session store assigns to a snapshot. */
+export const SESSION_PHASES = Object.freeze([
+  'new',
+  'generate_requested',
+  'variants_ready',
+  'carbonize_required',
+  'carbonize_cleanup_requested',
+  'manual_edit_apply_requested',
+  'steer_requested',
+  'steer_done',
+  'accept_requested',
+  'discard_requested',
+  'discarded',
+  'completed',
+  'agent_error',
+]);
+
+/** Phases that retire a session from the active list. */
+export const COMPLETED_SESSION_PHASES = Object.freeze(['completed', 'discarded']);
+
+/**
+ * Phases after which a late generation write is a ghost from a canceled cycle.
+ * The store journals such an event as a diagnostic instead of applying it.
+ */
+export const GENERATION_FENCED_SESSION_PHASES = Object.freeze([
+  'accept_requested',
+  'discard_requested',
+  'carbonize_required',
+  'completed',
+  'discarded',
+]);
+
+/**
+ * `reason` values carried on checkpoint events. Not validated (an unknown
+ * reason is journaled, never rejected) because the reason is diagnostic
+ * breadcrumb, not control flow. Two exceptions drive behavior and are split
+ * out below.
+ */
+export const CHECKPOINT_REASONS = Object.freeze([
+  'generate_started',
+  'variants_progress',
+  'variants_ready',
+  'browser_resumed',
+  'browser_resumed_svelte_component',
+  'param_changed',
+  'variant_anchor_missing',
+  'component_preview_anchor_missing',
+  'steer_input_focused',
+  'steer_submitted',
+  'steer_send_failed',
+  'steer_done',
+  'steer_error',
+]);
+
+/** Checkpoint reasons the server reads as variant-publication progress. */
+export const VARIANT_PROGRESS_CHECKPOINT_REASONS = Object.freeze([
+  'variants_progress',
+  'variants_ready',
+]);

package/dist/builtin/workflows/skills/impeccable/scripts/live-accept.mjs

@@ -27,6 +27,7 @@ import {
   inlineSvelteComponentAccept,
   removeSvelteComponentSession,
 } from './live/svelte-component.mjs';
+import { enterLiveRoot } from './live/roots.mjs';
 
 const ACCEPT_LOCK_WAIT_MS = 1_000;
 // Mirrors VARIANT_ID_PATTERN in live/event-validation.mjs, which gates the same
@@ -169,51 +170,35 @@ Output (JSON):
   }
 
   if (svelteComponentManifest) {
-    if (isDiscard) {
-      let result;
-      try {
-        result = withSourceLockSync(
-          path.resolve(process.cwd(), svelteComponentManifest.sourceFile),
-          'discard:' + id,
-          () => {
-            removeSvelteComponentSession(id, process.cwd());
-            return { handled: true };
-          },
-          { waitMs: ACCEPT_LOCK_WAIT_MS },
+    const { sourceFile, componentDir } = svelteComponentManifest;
+    const resultContext = {
+      file: sourceFile,
+      ...(isDiscard ? { carbonize: false } : { sourceFile }),
+      previewMode: 'svelte-component',
+      componentDir,
+    };
+    const runOperation = isDiscard
+      ? () => {
+          removeSvelteComponentSession(id, process.cwd());
+          return { handled: true, ...resultContext };
+        }
+      : () => inlineSvelteComponentAccept(
+          svelteComponentManifest,
+          variantNum,
+          paramValues,
+          process.cwd(),
         );
-      } catch (err) {
-        result = operationFailure(err);
-      }
-      emitResult({
-        ...result,
-        file: svelteComponentManifest.sourceFile,
-        carbonize: false,
-        previewMode: 'svelte-component',
-        componentDir: svelteComponentManifest.componentDir,
-      });
-      return;
-    }
 
     let result;
     try {
       result = withSourceLockSync(
-        path.resolve(process.cwd(), svelteComponentManifest.sourceFile),
-        'accept:' + id,
-        () => inlineSvelteComponentAccept(
-          svelteComponentManifest,
-          variantNum,
-          paramValues,
-          process.cwd(),
-        ),
+        path.resolve(process.cwd(), sourceFile),
+        requestedOperation + ':' + id,
+        runOperation,
         { waitMs: ACCEPT_LOCK_WAIT_MS },
       );
     } catch (err) {
-      result = operationFailure(err, {
-        file: svelteComponentManifest.sourceFile,
-        sourceFile: svelteComponentManifest.sourceFile,
-        previewMode: 'svelte-component',
-        componentDir: svelteComponentManifest.componentDir,
-      });
+      result = operationFailure(err, resultContext);
     }
     if (result.carbonize) {
       result.todo = 'REQUIRED before next poll: carbonize cleanup in ' + result.file + '. See reference/live.md "Required after accept".';
@@ -969,6 +954,7 @@ function argVal(args, flag) {
 // Auto-execute when run directly
 const _running = process.argv[1];
 if (_running?.endsWith('live-accept.mjs') || _running?.endsWith('live-accept.mjs/')) {
+  enterLiveRoot();
   acceptCli();
 }