mandrel 1.57.0

package/.agents/scripts/story-phase.js

@@ -0,0 +1,327 @@
+#!/usr/bin/env node
+
+/**
+ * story-phase.js — phase snapshot + heartbeat writer (3-tier).
+ *
+ * Replaces the deleted per-Task progress writer from the 4-tier era
+ * (removed under #3157). `/story-deliver` calls this CLI at each Story-
+ * level phase transition (init → implementing → closing → done, or any
+ * → blocked). Each call:
+ *
+ *   1. Renders the Story-phase snapshot for the requested phase (canonical
+ *      init/implement/validate/close progression in the `phases[]` payload)
+ *      and returns its markdown body for chat relay. Story #3909 — this no
+ *      longer posts a `story-run-progress` comment (the redundant mid-flight
+ *      progress surface was deleted); the snapshot is render-only.
+ *   2. Appends one `story.heartbeat` lifecycle record to
+ *      `temp/epic-<epicId>/lifecycle.ndjson` so `/epic-deliver`'s
+ *      §2e Idle Watchdog (`wave-tick.js --check-idle 30`) can confirm
+ *      forward progress without polling the Story comment.
+ *
+ * The heartbeat emit is best-effort: a missing/unreachable ledger,
+ * schema-validation hiccup, or absent `Epic: #N` body reference is
+ * logged and swallowed — the labels remain the source of truth, the
+ * ledger record is observability.
+ *
+ * CLI:
+ *   --story <id>                        Story ID (required).
+ *   --phase <init|implementing|closing|blocked|done>
+ *                                       Phase the Story is entering (required).
+ *   --no-heartbeat                      Suppress the lifecycle emit (tests).
+ *
+ * Stdout: a single JSON envelope
+ *   { ok: true, storyId, phase, epicId, branch, heartbeatEmitted,
+ *     ledgerPath, renderedBody }
+ *
+ * `renderedBody` is the markdown body upserted onto the Story so the
+ * caller can relay it to chat verbatim (mirrors the contract the deleted
+ * per-Task progress writer exposed and that `/story-deliver` Step 1 / 3
+ * already documents).
+ */
+
+import { parseArgs } from 'node:util';
+
+import { runAsCli } from './lib/cli-utils.js';
+import { resolveConfig } from './lib/config-resolver.js';
+import { Logger } from './lib/Logger.js';
+import {
+  defaultStoryPhases,
+  STORY_PHASE_ORDER,
+  upsertStoryRunProgress,
+} from './lib/orchestration/epic-runner/story-run-progress-writer.js';
+import { emitStoryHeartbeat } from './lib/orchestration/lifecycle/emit-story-heartbeat.js';
+import { parseFencedJsonComment } from './lib/orchestration/structured-comment-parser.js';
+import { normalizeOperatorHandle } from './lib/orchestration/ticket-lease.js';
+import { findStructuredComment } from './lib/orchestration/ticketing.js';
+import { createProvider } from './lib/provider-factory.js';
+import { resolveStoryHierarchy } from './lib/story-lifecycle.js';
+import { notify } from './notify.js';
+
+const VALID_PHASES = new Set([
+  'init',
+  'implementing',
+  'closing',
+  'blocked',
+  'done',
+]);
+
+const HELP = `Usage: node .agents/scripts/story-phase.js \\
+  --story <id> --phase <init|implementing|closing|blocked|done> \\
+  [--no-heartbeat]
+
+Renders the Story-phase snapshot for Story #<id> at the requested phase
+(returned as renderedBody for chat relay; no comment is posted) and
+(unless --no-heartbeat) appends one story.heartbeat record to the parent
+Epic's lifecycle ledger so the Idle Watchdog can confirm the Story is alive.
+`;
+
+/**
+ * Map the workflow-level `--phase` value to the canonical phases[] row
+ * progression carried in the snapshot payload (init/implement/validate/
+ * close). The mapping is monotonic: each later phase marks every earlier
+ * row `done`, the current row `in-progress` (or `done` when the workflow
+ * phase itself is `done`), and any later rows `pending`. `blocked` leaves
+ * the in-progress row marked in-progress (the blocker is reflected in the
+ * header phase, not the row table).
+ *
+ * @param {string} workflowPhase
+ * @returns {Array<{ name: string, status: string, startedAt: string|null, endedAt: string|null }>}
+ */
+export function phasesForWorkflowPhase(workflowPhase, now = new Date()) {
+  const ts = now.toISOString();
+  const phases = defaultStoryPhases();
+
+  // Anchor row that should be "current" for each workflow phase.
+  const currentByPhase = {
+    init: 'init',
+    implementing: 'implement',
+    closing: 'validate',
+    blocked: 'implement',
+    done: 'close',
+  };
+  const current = currentByPhase[workflowPhase];
+  const currentIdx = STORY_PHASE_ORDER.indexOf(current);
+
+  for (let i = 0; i < phases.length; i++) {
+    if (i < currentIdx) {
+      phases[i].status = 'done';
+      phases[i].startedAt = ts;
+      phases[i].endedAt = ts;
+    } else if (i === currentIdx) {
+      if (workflowPhase === 'done') {
+        phases[i].status = 'done';
+        phases[i].startedAt = ts;
+        phases[i].endedAt = ts;
+      } else {
+        phases[i].status = 'in-progress';
+        phases[i].startedAt = ts;
+      }
+    }
+  }
+  return phases;
+}
+
+/**
+ * Hydrate the parent Epic id off the Story ticket body. Returns null when
+ * the Story has no `Epic: #N` reference (the heartbeat emit will be
+ * skipped because there is no Epic-scoped ledger path to write to).
+ *
+ * @param {{ provider: object, storyId: number }} args
+ * @returns {Promise<number|null>}
+ */
+export async function readEpicIdFromStory({ provider, storyId }) {
+  const story = await provider.getTicket(storyId);
+  const { epicId } = resolveStoryHierarchy(story?.body ?? '');
+  return epicId ?? null;
+}
+
+/**
+ * Hydrate the prior story-run-progress branch off the Story ticket so a
+ * resumed run preserves the branch name rather than re-deriving it.
+ * Falls back to `story-<id>` when no prior snapshot exists.
+ */
+async function resolveStoryBranch({ provider, storyId }) {
+  const snapshot = await findStructuredComment(
+    provider,
+    storyId,
+    'story-run-progress',
+  );
+  if (snapshot) {
+    const parsed = parseFencedJsonComment(snapshot);
+    if (parsed && typeof parsed.branch === 'string' && parsed.branch) {
+      return parsed.branch;
+    }
+  }
+  const initComment = await findStructuredComment(
+    provider,
+    storyId,
+    'story-init',
+  );
+  if (initComment) {
+    const parsed = parseFencedJsonComment(initComment);
+    if (
+      parsed &&
+      typeof parsed.storyBranch === 'string' &&
+      parsed.storyBranch
+    ) {
+      return parsed.storyBranch;
+    }
+  }
+  return `story-${storyId}`;
+}
+
+/**
+ * Best-effort `story.heartbeat` emit for one phase transition. Resolves the
+ * lease-owner handle the SAME way the lease primitive does
+ * (`normalizeOperatorHandle(github.operatorHandle)`) and stamps it as
+ * `operator` so `latestHeartbeatForOwner({ epicId, owner })` resolves a real
+ * heartbeat — without it `isClaimLive(null)` is false and /epic-deliver
+ * silently reclaims a live foreign claim (audit #3513). The field is attached
+ * only when a handle resolves, preserving the "omit when absent" shape for
+ * repos that have not configured `github.operatorHandle`. A failed append is
+ * logged and swallowed: the heartbeat is observability, not state.
+ *
+ * @param {{ storyId: number, epicId: number, phase: string, config: object|null, ledgerPath?: string, timestamp: string }} args
+ * @returns {{ heartbeatEmitted: boolean, ledgerPath: string|null }}
+ */
+function emitHeartbeatBestEffort({
+  storyId,
+  epicId,
+  phase,
+  config,
+  ledgerPath,
+  timestamp,
+}) {
+  const operator = normalizeOperatorHandle(config?.github?.operatorHandle);
+  try {
+    const res = emitStoryHeartbeat({
+      storyId,
+      epicId,
+      phase,
+      timestamp,
+      ...(operator !== null ? { operator } : {}),
+      config: config ?? undefined,
+      ledgerPath,
+    });
+    return { heartbeatEmitted: true, ledgerPath: res.ledgerPath };
+  } catch (err) {
+    Logger.warn(
+      `[story-phase] story.heartbeat emit failed (continuing): ${err.message}`,
+    );
+    return { heartbeatEmitted: false, ledgerPath: null };
+  }
+}
+
+/**
+ * End-to-end phase writer. DI-friendly: tests pass `provider`, override
+ * the ledger path, and skip the heartbeat as needed.
+ *
+ * @param {{
+ *   storyId: number,
+ *   phase: string,
+ *   noHeartbeat?: boolean,
+ *   provider?: object,
+ *   config?: object,
+ *   ledgerPath?: string,
+ *   now?: Date,
+ * }} args
+ */
+export async function runStoryPhase(args) {
+  const {
+    storyId,
+    phase,
+    noHeartbeat = false,
+    provider: providerOverride,
+    config: configOverride,
+    ledgerPath: ledgerPathOverride,
+    now = new Date(),
+  } = args ?? {};
+
+  if (!Number.isInteger(storyId) || storyId <= 0) {
+    throw new Error('runStoryPhase: --story must be a positive integer');
+  }
+  if (!VALID_PHASES.has(phase)) {
+    throw new Error(
+      `runStoryPhase: --phase "${phase}" must be one of: ${[...VALID_PHASES].join(', ')}`,
+    );
+  }
+
+  const config = configOverride ?? (providerOverride ? null : resolveConfig());
+  const provider = providerOverride ?? createProvider(config);
+  const notifyFn = providerOverride
+    ? null
+    : (ticketId, payload, opts = {}) =>
+        notify(ticketId, payload, { config, provider, ...opts });
+
+  const branch = await resolveStoryBranch({ provider, storyId });
+  const epicId = await readEpicIdFromStory({ provider, storyId });
+  const phases = phasesForWorkflowPhase(phase, now);
+
+  const { body: renderedBody, payload: snapshot } =
+    await upsertStoryRunProgress({
+      provider,
+      storyId,
+      branch,
+      phase,
+      phases,
+      epicId: epicId ?? undefined,
+      updatedAt: now.toISOString(),
+      notify: notifyFn,
+    });
+
+  let heartbeatEmitted = false;
+  let ledgerPath = null;
+  if (!noHeartbeat && epicId) {
+    ({ heartbeatEmitted, ledgerPath } = emitHeartbeatBestEffort({
+      storyId,
+      epicId,
+      phase,
+      config,
+      ledgerPath: ledgerPathOverride,
+      timestamp: now.toISOString(),
+    }));
+  }
+
+  return {
+    ok: true,
+    storyId,
+    phase,
+    epicId,
+    branch,
+    heartbeatEmitted,
+    ledgerPath,
+    snapshot,
+    renderedBody,
+  };
+}
+
+export function parseArgv(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      story: { type: 'string' },
+      phase: { type: 'string' },
+      'no-heartbeat': { type: 'boolean' },
+      help: { type: 'boolean' },
+    },
+    strict: false,
+  });
+  return {
+    help: Boolean(values.help),
+    storyId: Number.parseInt(values.story ?? '', 10),
+    phase: values.phase,
+    noHeartbeat: Boolean(values['no-heartbeat']),
+  };
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const parsed = parseArgv(argv);
+  if (parsed.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  const envelope = await runStoryPhase(parsed);
+  process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
+}
+
+runAsCli(import.meta.url, main, { source: 'story-phase' });

package/.agents/scripts/story-plan.js

@@ -0,0 +1,284 @@
+#!/usr/bin/env node
+/* node:coverage ignore file */
+
+/**
+ * story-plan.js — Local `/story-plan` wrapper.
+ *
+ * Standalone counterpart to `/epic-plan` for Stories that do **not**
+ * attach to an Epic. The script is deliberately a thin CLI around the
+ * pure helpers in `lib/story-plan.js`:
+ *
+ *   1. `--emit-context` mode — given a `--idea`/`--from-notes` seed,
+ *      build the context envelope (seed, refine heuristic, persona,
+ *      body template, duplicate candidates, tech-stack summary) and
+ *      print it as JSON on stdout. Logs route to stderr so the
+ *      envelope is byte-clean for `JSON.parse`.
+ *   2. Persist mode — given a `--body <file>` authored by the host
+ *      LLM after operator confirmation, validate the shape and persist
+ *      via `provider.createIssue` (which also adds the new Story to
+ *      the configured Projects V2 board — Story #3822) with
+ *      `type::story` + the chosen persona label, falling back to
+ *      `gh issue create` when the provider lacks a createIssue
+ *      analogue. Prints `Next: /single-story-deliver <id>`.
+ *   3. `--dry-run` — same as persist but exits without touching
+ *      GitHub. Echoes the rendered body and the `gh` argv it would
+ *      have run.
+ *
+ * Mirrors the `/epic-plan` pattern: deterministic Node I/O wrappers
+ * with HITL gating handled by the host LLM in chat. No external LLM
+ * APIs are called from this script.
+ */
+
+import { readFile } from 'node:fs/promises';
+import { parseArgs } from 'node:util';
+import { runAsCli } from './lib/cli-utils.js';
+import { PROJECT_ROOT, resolveConfig } from './lib/config-resolver.js';
+import { exec as ghExec } from './lib/gh-exec.js';
+import { Logger, routeAllOutputToStderr } from './lib/Logger.js';
+import { TYPE_LABELS } from './lib/label-constants.js';
+import { createProvider } from './lib/provider-factory.js';
+import {
+  buildContextEnvelope,
+  loadBodyTemplate,
+  rankDuplicateCandidates,
+  readTechStackSummary,
+  shouldRefine,
+  validateStoryBody,
+} from './lib/story-plan.js';
+
+const HELP = `\
+Usage:
+  story-plan.js --emit-context (--idea "<seed>" | --from-notes <file>) \\
+    [--persona <name>] [--refine | --no-refine] [--pretty]
+
+  story-plan.js --body <file> [--persona <name>] [--dry-run]
+
+  story-plan.js --help
+
+Modes:
+  --emit-context   Build the host-LLM authoring envelope and print it as
+                   JSON on stdout. Use this first; the host LLM authors a
+                   draft body using the envelope and the body template.
+  --body <file>    Persist a pre-authored body. Validates shape (required
+                   sections, no Epic: ref, AC checklist non-empty) and
+                   calls \`gh issue create\` with type::story + persona.
+  --dry-run        With --body: print the body and the gh argv that would
+                   be invoked, then exit 0. No GitHub mutations.
+
+Options:
+  --persona <name>   Persona label (default: engineer).
+  --refine           Force the idea-refinement hint on regardless of seed
+                     length. Default heuristic: refine when seed < 200
+                     chars.
+  --no-refine        Force the idea-refinement hint off.
+  --pretty           Pretty-print the JSON envelope.
+`;
+
+/**
+ * Resolve the seed string from --idea or --from-notes. One of the two
+ * must be present in --emit-context mode.
+ */
+async function resolveSeed({ idea, fromNotes }) {
+  if (idea && fromNotes) {
+    throw new Error('Pass either --idea or --from-notes, not both.');
+  }
+  if (idea) return idea;
+  if (fromNotes) return (await readFile(fromNotes, 'utf8')).trim();
+  throw new Error(
+    '--emit-context requires --idea "<seed>" or --from-notes <file>.',
+  );
+}
+
+/**
+ * Fetch open Stories via the ticketing provider. The github provider
+ * exposes `listIssuesByLabel({ state, labels })`; other providers may
+ * not, so the call is guarded.
+ */
+async function fetchOpenStories(provider) {
+  if (typeof provider.listIssuesByLabel !== 'function') return [];
+  const issues = await provider.listIssuesByLabel({
+    state: 'open',
+    labels: TYPE_LABELS.STORY,
+  });
+  return issues.map((issue) => ({
+    id: issue.number ?? issue.id,
+    title: issue.title ?? '',
+    body: issue.body ?? '',
+    url: issue.html_url ?? issue.url ?? null,
+  }));
+}
+
+/**
+ * Render the draft body argv for `gh issue create`. Returns the argv
+ * array; the caller decides whether to execute it (persist) or print
+ * it (--dry-run).
+ */
+function renderGhArgv({ title, bodyPath, labels }) {
+  const argv = ['issue', 'create', '--title', title, '--body-file', bodyPath];
+  for (const label of labels) {
+    argv.push('--label', label);
+  }
+  return argv;
+}
+
+/**
+ * Extract the H1 title from a body. Falls back to a sensible default
+ * when the body lacks one (host LLM should always emit `# <title>`).
+ */
+export function extractTitle(body) {
+  const m = body.match(/^#\s+(.+?)\s*$/m);
+  return m ? m[1].trim() : 'Untitled standalone Story';
+}
+
+async function runEmitContext({ values, provider, projectRoot }) {
+  const seed = await resolveSeed({
+    idea: values.idea,
+    fromNotes: values['from-notes'],
+  });
+  const override = values.refine ? 'on' : values['no-refine'] ? 'off' : null;
+  const refine = shouldRefine({ seed, override });
+  const persona = values.persona ?? 'engineer';
+
+  const [bodyTemplate, openStories, techStack] = await Promise.all([
+    loadBodyTemplate(projectRoot),
+    fetchOpenStories(provider),
+    readTechStackSummary(projectRoot),
+  ]);
+
+  const duplicateCandidates = rankDuplicateCandidates({
+    seed,
+    openStories,
+  });
+
+  const envelope = buildContextEnvelope({
+    seed,
+    refine,
+    persona,
+    bodyTemplate,
+    duplicateCandidates,
+    techStack,
+  });
+
+  const json = values.pretty
+    ? JSON.stringify(envelope, null, 2)
+    : JSON.stringify(envelope);
+  process.stdout.write(`${json}\n`);
+}
+
+async function runPersist({
+  values,
+  provider,
+  dryRun,
+  // Injectable stdout port so unit tests can capture/silence the summary
+  // JSON without stubbing the process-global stream (raw stdout writes
+  // corrupt the `node --test` runner's structured report stream).
+  write = (s) => process.stdout.write(s),
+}) {
+  const bodyPath = values.body;
+  if (!bodyPath) {
+    throw new Error('--body <file> is required in persist mode.');
+  }
+  const body = await readFile(bodyPath, 'utf8');
+  const validation = validateStoryBody(body);
+  if (!validation.ok) {
+    throw new Error(
+      `Drafted body failed validation:\n  - ${validation.errors.join('\n  - ')}`,
+    );
+  }
+
+  const title = extractTitle(body);
+  const persona = values.persona ?? 'engineer';
+  const labels = [TYPE_LABELS.STORY, `persona::${persona}`];
+  const argv = renderGhArgv({ title, bodyPath, labels });
+
+  if (dryRun) {
+    Logger.info('--- DRY RUN ---');
+    Logger.info(`Title: ${title}`);
+    Logger.info(`Labels: ${labels.join(', ')}`);
+    Logger.info(`gh argv: gh ${argv.join(' ')}`);
+    Logger.info('--- BODY ---');
+    Logger.info(body);
+    write(
+      `${JSON.stringify({ dryRun: true, title, labels, argv }, null, 2)}\n`,
+    );
+    return;
+  }
+
+  // Persist via the provider when available so I/O stays inside the
+  // injected ticketing surface. The GitHub provider's `createIssue`
+  // also adds the new Story to the configured Projects V2 board via
+  // the shared `addIssueToBoard` helper (Story #3822) — idempotent,
+  // non-fatal, no-op when no project number is configured — so board
+  // membership never depends on GitHub's "Auto-add to project"
+  // built-in workflow. Fall back to `gh issue create` only when the
+  // provider doesn't expose a createIssue analogue.
+  let issueNumber;
+  if (typeof provider.createIssue === 'function') {
+    const created = await provider.createIssue({ title, body, labels });
+    issueNumber = created.number ?? created.id;
+  } else {
+    // gh-exec returns { stdout, stderr, code }; parse the issue number
+    // from the URL.
+    const { stdout } = await ghExec({ args: argv });
+    const m = stdout.match(/\/issues\/(\d+)/);
+    if (!m) {
+      throw new Error(
+        `gh issue create did not return an issue URL; stdout was: ${stdout}`,
+      );
+    }
+    issueNumber = Number(m[1]);
+  }
+
+  write(`${JSON.stringify({ issueNumber, title, labels }, null, 2)}\n`);
+  Logger.info(`Next: /single-story-deliver ${issueNumber}`);
+}
+
+/* node:coverage ignore next */
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      'emit-context': { type: 'boolean', default: false },
+      idea: { type: 'string' },
+      'from-notes': { type: 'string' },
+      body: { type: 'string' },
+      persona: { type: 'string' },
+      refine: { type: 'boolean', default: false },
+      'no-refine': { type: 'boolean', default: false },
+      pretty: { type: 'boolean', default: false },
+      'dry-run': { type: 'boolean', default: false },
+      help: { type: 'boolean', default: false },
+    },
+  });
+
+  if (values.help) {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (values.refine && values['no-refine']) {
+    throw new Error('Pass either --refine or --no-refine, not both.');
+  }
+
+  const config = resolveConfig();
+  const provider = createProvider(config);
+  const projectRoot = PROJECT_ROOT;
+
+  if (values['emit-context']) {
+    // Reserve stdout for the JSON envelope so a captured file is
+    // unconditionally parseable by `JSON.parse`. Mirrors the contract
+    // `epic-plan-spec.js` enforces for its own --emit-context mode.
+    routeAllOutputToStderr();
+    return runEmitContext({ values, provider, projectRoot });
+  }
+
+  return runPersist({
+    values,
+    provider,
+    dryRun: values['dry-run'],
+  });
+}
+
+runAsCli(import.meta.url, main, { source: 'story-plan' });
+
+// Test surface — exported so unit tests can drive the helpers
+// without importing the CLI side.
+export { fetchOpenStories, renderGhArgv, runPersist };

package/.agents/scripts/sync-agentrc.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+/**
+ * sync-agentrc.js — default-aware `.agentrc.json` reconciliation (Story #1995).
+ *
+ * Replaces the manual procedure formerly described in
+ * `.agents/workflows/helpers/agents-sync-config.md`. Invoked by
+ * `/agents-update` Step 3 after the package upgrade re-materializes `.agents/`.
+ *
+ * Contract:
+ *   - Validates the project config against the framework schema. On
+ *     failure, prints diagnostics and exits 1.
+ *   - Never auto-fills optional keys from `.agents/docs/agentrc-reference.json`.
+ *     The runtime layers framework defaults at read time, so an absent
+ *     key resolves to the framework default without being written.
+ *   - For every project leaf whose value equals the framework default,
+ *     prints an informational `[REDUNDANT]` advisory. The project file
+ *     is never modified.
+ *
+ * Exit codes:
+ *   0 — Config is valid (advisories may still appear).
+ *   1 — Config is missing, malformed, or fails schema validation.
+ *
+ * Flags:
+ *   --cwd <path>   Project root (defaults to process.cwd()).
+ *   --quiet        Suppress advisory rows (only print the status line).
+ */
+
+import { fileURLToPath } from 'node:url';
+import { formatSyncReport, syncAgentrc } from './lib/config/sync-agentrc.js';
+import { Logger } from './lib/Logger.js';
+
+function parseArgs(argv) {
+  const out = { cwd: null, quiet: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--cwd' && i + 1 < argv.length) {
+      out.cwd = argv[++i];
+    } else if (a === '--quiet') {
+      out.quiet = true;
+    }
+  }
+  return out;
+}
+
+export function main(argv = process.argv.slice(2)) {
+  const { cwd, quiet } = parseArgs(argv);
+  const projectRoot = cwd || process.cwd();
+  const result = syncAgentrc({ projectRoot });
+  const report = quiet
+    ? trimAdvisories(formatSyncReport(result))
+    : formatSyncReport(result);
+  Logger.info(report);
+  if (result.status === 'invalid' || result.status === 'missing-config') {
+    return 1;
+  }
+  return 0;
+}
+
+function trimAdvisories(report) {
+  return report
+    .split('\n')
+    .filter((line) => !line.startsWith('  [REDUNDANT]'))
+    .join('\n');
+}
+
+// cli-opt-out: synchronous CLI with explicit exit-code return.
+const isMain = process.argv[1] === fileURLToPath(import.meta.url);
+if (isMain) {
+  process.exit(main());
+}