mandrel 1.93.0 → 2.0.0

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

@@ -1,369 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * story-phase.js — phase snapshot + heartbeat writer (2-tier).
- *
- * Replaces the deleted per-Task progress writer from the 4-tier era
- * (removed under #3157). `/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 `/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).
- *   --epic <id>                         Parent Epic id from the Step 0 envelope.
- *                                       When supplied, skips the readEpicIdFromStory
- *                                       GitHub read.
- *   --branch <name>                     Story branch from the Step 0 envelope.
- *                                       When supplied, skips the resolveStoryBranch
- *                                       GitHub read.
- *   --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 `/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> \\
-  [--epic <id>] [--branch <name>] [--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.
-
---epic / --branch let the caller pass the parent Epic id and Story branch
-from story-init.js's Step 0 envelope, skipping the GitHub reads
-(readEpicIdFromStory / resolveStoryBranch) that would otherwise re-fetch
-these immutable values on every phase call. Omit both for interactive use.
-`;
-
-/**
- * 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 /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.
- *
- * When `epicId` / `branch` are supplied (the `/deliver` worker passes them
- * from `story-init.js`'s Step 0 envelope), the corresponding GitHub read is
- * skipped entirely: `epicId` short-circuits `readEpicIdFromStory` and
- * `branch` short-circuits `resolveStoryBranch`. Omit both for interactive
- * use to restore the original GitHub-read resolution.
- *
- * @param {{
- *   storyId: number,
- *   phase: string,
- *   epicId?: number|null,
- *   branch?: string,
- *   noHeartbeat?: boolean,
- *   provider?: object,
- *   config?: object,
- *   ledgerPath?: string,
- *   now?: Date,
- * }} args
- */
-export async function runStoryPhase(args) {
-  const {
-    storyId,
-    phase,
-    epicId: epicIdOverride,
-    branch: branchOverride,
-    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 });
-
-  // When the Step 0 envelope supplied the branch / epicId (the /deliver
-  // worker passes them via --branch / --epic), skip the GitHub reads that
-  // would otherwise re-fetch these immutable values on every phase call.
-  const branch =
-    typeof branchOverride === 'string' && branchOverride
-      ? branchOverride
-      : await resolveStoryBranch({ provider, storyId });
-  const epicId =
-    epicIdOverride !== undefined
-      ? epicIdOverride
-      : 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' },
-      epic: { type: 'string' },
-      branch: { type: 'string' },
-      'no-heartbeat': { type: 'boolean' },
-      help: { type: 'boolean' },
-    },
-    strict: false,
-  });
-  // `--epic` absent → leave `epicId` undefined so runStoryPhase falls back to
-  // the readEpicIdFromStory GitHub read. `--branch` absent → leave `branch`
-  // undefined so it falls back to resolveStoryBranch.
-  const parsed = {
-    help: Boolean(values.help),
-    storyId: Number.parseInt(values.story ?? '', 10),
-    phase: values.phase,
-    noHeartbeat: Boolean(values['no-heartbeat']),
-  };
-  if (values.epic !== undefined) {
-    parsed.epicId = Number.parseInt(values.epic, 10);
-  }
-  if (typeof values.branch === 'string' && values.branch) {
-    parsed.branch = values.branch;
-  }
-  return parsed;
-}
-
-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/wave-tick.js

@@ -1,335 +0,0 @@
-#!/usr/bin/env node
-/* node:coverage ignore file */
-
-/**
- * wave-tick.js — thin CLI shim around `lib/wave-runner/tick.js`.
- *
- * Reads the `epic-run-state` checkpoint plus fresh Story labels and
- * prints one `WaveTickResult` envelope. The slash-command operator
- * (`/deliver`) consumes the envelope to decide whether to dispatch
- * the next wave, observe in-flight stories, or finalize the Epic.
- *
- * Usage:
- *   node .agents/scripts/wave-tick.js --epic <epicId> [--check-idle <minutes>]
- *
- * The tick is stateless — "loop until terminal" is the caller's job
- * (today: the markdown's wave loop).
- *
- * Output: one JSON object on stdout. Schema in `lib/wave-runner/tick.js`.
- */
-
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { parseArgs } from 'node:util';
-
-import { runAsCli } from './lib/cli-utils.js';
-import { epicLedgerPath } from './lib/config/temp-paths.js';
-import { resolveConfig } from './lib/config-resolver.js';
-import { Logger } from './lib/Logger.js';
-import { createProvider } from './lib/provider-factory.js';
-import { tick } from './lib/wave-runner/tick.js';
-
-const HELP = `Usage: node .agents/scripts/wave-tick.js --epic <epicId> [--check-idle <minutes>]
-
-Stateless wave-loop planner. Reads the epic-run-state checkpoint on
-Epic #<id>, evaluates the live story-label state, and prints one
-WaveTickResult envelope describing the next dispatchable action.
-
-When --check-idle <minutes> is supplied, the planner skips the normal
-WaveTickResult emit and instead scans the per-Epic lifecycle ledger
-(temp/epic-<id>/lifecycle.ndjson) for in-flight Stories whose most
-recent lifecycle event is older than the threshold. Emits a single
-JSON envelope on stdout and exits non-zero when at least one stalled
-Story is detected. The envelope shape mirrors the wave-stall
-structured-comment payload so the slash-command host can post it
-verbatim.
-`;
-
-export async function runWaveTickCli({
-  epicId,
-  cwd,
-  injectedProvider,
-  injectedConfig,
-} = {}) {
-  if (!Number.isInteger(epicId) || epicId <= 0) {
-    throw new TypeError('runWaveTickCli: --epic must be a positive integer');
-  }
-
-  const config = injectedConfig ?? resolveConfig({ cwd });
-  const provider = injectedProvider ?? createProvider(config);
-
-  const result = await tick({
-    epic: epicId,
-    collaborators: { provider },
-    ctx: { config },
-  });
-
-  return result;
-}
-
-/**
- * Scan the per-Epic lifecycle ledger and compute, per in-flight Story,
- * the timestamp of its most recent lifecycle event. A Story is
- * "in-flight" when the ledger carries a `story.dispatch.start` record
- * without a matching `story.dispatch.end`. Any other `story.*` event
- * (notably `story.heartbeat` from Story #3057) refreshes the Story's
- * last-event timestamp.
- *
- * Pure helper — exported for unit tests.
- *
- * @param {string} ledgerPath Absolute path to `lifecycle.ndjson`.
- * @returns {Map<number, string>} `storyId → ISO-8601 timestamp`. Empty
- *   when the ledger is missing, unreadable, or carries no in-flight
- *   Stories.
- */
-export function readLedgerLastEvents(ledgerPath) {
-  if (!ledgerPath || !existsSync(ledgerPath)) return new Map();
-  let raw;
-  try {
-    raw = readFileSync(ledgerPath, 'utf8');
-  } catch {
-    return new Map();
-  }
-  if (!raw) return new Map();
-  const started = new Set();
-  const ended = new Set();
-  const lastTs = new Map();
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line) continue;
-    let record;
-    try {
-      record = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (!record || record.kind !== 'emitted') continue;
-    const event = typeof record.event === 'string' ? record.event : '';
-    if (!event.startsWith('story.')) continue;
-    const storyId = record.payload?.storyId;
-    if (!Number.isInteger(storyId) || storyId <= 0) continue;
-    if (event === 'story.dispatch.start') started.add(storyId);
-    else if (event === 'story.dispatch.end') ended.add(storyId);
-    const ts = typeof record.ts === 'string' ? record.ts : null;
-    if (ts) {
-      const prior = lastTs.get(storyId);
-      if (!prior || prior < ts) lastTs.set(storyId, ts);
-    }
-  }
-  const out = new Map();
-  for (const id of started) {
-    if (ended.has(id)) continue;
-    const ts = lastTs.get(id);
-    if (ts) out.set(id, ts);
-  }
-  return out;
-}
-
-/**
- * Deterministic branch-activity resolver (Story #3900). Returns the epoch-ms
- * timestamp of the most recent commit on `story-<storyId>` via
- * `git log -1 --format=%cI`, or `null` when the branch does not exist, has no
- * commits, or git is unavailable.
- *
- * This is the secondary liveness signal the idle watchdog consults before
- * flagging a Story as stalled: a healthy long-running Story routinely exceeds
- * the heartbeat threshold during `implementing → closing` (heartbeats fire
- * only at phase transitions), but its branch keeps gaining commits. A recent
- * commit is hard, deterministic evidence of forward progress that does not
- * depend on a heartbeat landing in the ledger. Pure-ish (shells out to git)
- * and injectable so unit tests never spawn a subprocess.
- *
- * @param {number} storyId
- * @param {{ cwd?: string, exec?: typeof execFileSync }} [deps]
- * @returns {number|null} epoch-ms of the last commit, or null.
- */
-export function branchLastCommitMs(storyId, deps = {}) {
-  const exec = deps.exec ?? execFileSync;
-  const cwd = deps.cwd ?? process.cwd();
-  try {
-    const out = exec(
-      'git',
-      ['log', '-1', '--format=%cI', `story-${storyId}`, '--'],
-      { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
-    ).trim();
-    if (!out) return null;
-    const ms = Date.parse(out);
-    return Number.isFinite(ms) ? ms : null;
-  } catch {
-    // Branch absent / git unavailable — no deterministic signal.
-    return null;
-  }
-}
-
-/**
- * Build the wave-stall envelope. Pure helper — exported for unit tests.
- *
- * A Story whose latest ledger event is older than the threshold is *not*
- * flagged as stalled when its `story-<id>` branch carries a commit newer
- * than the threshold (Story #3900). Branch commits are deterministic
- * forward-progress evidence that survives the heartbeat-cadence gap during
- * `implementing → closing`, so consulting them eliminates the false-positive
- * re-dispatch hazard (two agents on one branch) the watchdog otherwise
- * manufactures for every healthy long-running Story.
- *
- * @param {object} args
- * @param {number} args.epicId
- * @param {number} args.thresholdMinutes
- * @param {Map<number, string>} args.lastEvents `storyId → ISO-8601 ts`
- *   from {@link readLedgerLastEvents}.
- * @param {Date} args.now Reference clock for the staleness comparison.
- * @param {(storyId: number) => (number|null)} [args.branchActivity]
- *   Resolver for the last commit epoch-ms on `story-<id>`. Defaults to
- *   {@link branchLastCommitMs}. Injected for tests.
- * @returns {{
- *   kind: 'wave-stall',
- *   epicId: number,
- *   thresholdMinutes: number,
- *   checkedAt: string,
- *   stalled: Array<{storyId: number, lastEventAt: string, idleMinutes: number}>,
- *   inFlight: number[]
- * }}
- */
-export function buildWaveStallEnvelope({
-  epicId,
-  thresholdMinutes,
-  lastEvents,
-  now,
-  branchActivity = branchLastCommitMs,
-}) {
-  const checkedAt = now.toISOString();
-  const thresholdMs = thresholdMinutes * 60 * 1000;
-  const stalled = [];
-  const inFlight = [];
-  for (const [storyId, ts] of lastEvents) {
-    inFlight.push(storyId);
-    const eventMs = Date.parse(ts);
-    if (!Number.isFinite(eventMs)) continue;
-    const idleMs = now.getTime() - eventMs;
-    if (idleMs < thresholdMs) continue;
-
-    // Ledger says idle — consult the branch as a deterministic liveness
-    // signal before declaring a stall. A recent commit means the Story is
-    // making progress despite the heartbeat-cadence gap.
-    const commitMs = branchActivity(storyId);
-    if (
-      typeof commitMs === 'number' &&
-      Number.isFinite(commitMs) &&
-      now.getTime() - commitMs < thresholdMs
-    ) {
-      continue;
-    }
-
-    stalled.push({
-      storyId,
-      lastEventAt: ts,
-      idleMinutes: Math.floor(idleMs / 60000),
-    });
-  }
-  inFlight.sort((a, b) => a - b);
-  stalled.sort((a, b) => a.storyId - b.storyId);
-  return {
-    kind: 'wave-stall',
-    epicId,
-    thresholdMinutes,
-    checkedAt,
-    stalled,
-    inFlight,
-  };
-}
-
-/**
- * Run the `--check-idle` path. Exported so unit tests can drive the
- * branch without spawning the CLI subprocess.
- *
- * @param {object} args
- * @param {number} args.epicId
- * @param {number} args.thresholdMinutes
- * @param {string} [args.ledgerPath] Override for tests; defaults to the
- *   canonical `temp/epic-<id>/lifecycle.ndjson`.
- * @param {Date} [args.now] Override for tests; defaults to wall clock.
- * @param {object} [args.config] Optional resolved config for tempRoot.
- * @param {(storyId: number) => (number|null)} [args.branchActivity]
- *   Branch-liveness resolver; defaults to {@link branchLastCommitMs}.
- *   Injected for tests so the watchdog never spawns git.
- * @returns {{envelope: object, stalledCount: number}}
- */
-export function runCheckIdle({
-  epicId,
-  thresholdMinutes,
-  ledgerPath,
-  now = new Date(),
-  config,
-  branchActivity = branchLastCommitMs,
-}) {
-  if (!Number.isInteger(epicId) || epicId <= 0) {
-    throw new TypeError('runCheckIdle: epicId must be a positive integer');
-  }
-  if (!Number.isInteger(thresholdMinutes) || thresholdMinutes <= 0) {
-    throw new TypeError(
-      'runCheckIdle: thresholdMinutes must be a positive integer',
-    );
-  }
-  const resolvedPath = ledgerPath ?? epicLedgerPath(epicId, config);
-  const lastEvents = readLedgerLastEvents(resolvedPath);
-  const envelope = buildWaveStallEnvelope({
-    epicId,
-    thresholdMinutes,
-    lastEvents,
-    now,
-    branchActivity,
-  });
-  return { envelope, stalledCount: envelope.stalled.length };
-}
-
-async function main(argv) {
-  const { values } = parseArgs({
-    args: argv,
-    options: {
-      epic: { type: 'string' },
-      'check-idle': { type: 'string' },
-      help: { type: 'boolean', short: 'h' },
-    },
-    strict: false,
-    allowPositionals: true,
-  });
-
-  if (values.help) {
-    process.stdout.write(`${HELP}\n`);
-    return;
-  }
-
-  const epicId = Number.parseInt(
-    String(values.epic ?? '').replace(/^#/, ''),
-    10,
-  );
-  if (!Number.isInteger(epicId) || epicId <= 0) {
-    Logger.error('wave-tick: --epic <id> is required (positive integer)');
-    process.exitCode = 2;
-    return;
-  }
-
-  if (values['check-idle'] !== undefined) {
-    const thresholdMinutes = Number.parseInt(String(values['check-idle']), 10);
-    if (!Number.isInteger(thresholdMinutes) || thresholdMinutes <= 0) {
-      Logger.error(
-        'wave-tick: --check-idle <minutes> must be a positive integer',
-      );
-      process.exitCode = 2;
-      return;
-    }
-    const { envelope, stalledCount } = runCheckIdle({
-      epicId,
-      thresholdMinutes,
-    });
-    process.stdout.write(`${JSON.stringify(envelope, null, 2)}\n`);
-    process.exitCode = stalledCount > 0 ? 1 : 0;
-    return;
-  }
-
-  const result = await runWaveTickCli({ epicId });
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-}
-
-runAsCli(import.meta.url, () => main(process.argv.slice(2)), {
-  source: 'wave-tick',
-});