elanous 0.2.17 → 0.2.18

package/samples/workflows/templates/scheduled-daily-digest.yaml

@@ -0,0 +1,30 @@
+name: scheduled-daily-digest
+description: |
+  Daily 9am Seoul-time digest workflow.
+  Triggers: schedule cron 0 9 * * * Asia/Seoul.
+  Does: crawls a fixed search term → omni-digest summary → saves to Obsidian.
+  Edit this template to swap the search term / Obsidian target.
+
+_meta:
+  template:
+    title: Daily digest
+    description: Cron 9am → crawl → summarize → save
+    tags: [schedule, daily, digest]
+
+nodes:
+  - id: tick
+    scheduleTrigger:
+      type: cron
+      cron: 0 9 * * *
+      timezone: Asia/Seoul
+      enabled: true
+
+  - id: crawl
+    skill: omni-crawl
+    arguments: "latest AI agent news"
+    depends_on: [tick]
+
+  - id: save
+    skill: omni-digest
+    arguments: $crawl.output
+    depends_on: [crawl]

package/samples/workflows/templates/webhook-deploy-hook.yaml

@@ -0,0 +1,27 @@
+name: webhook-deploy-hook
+description: |
+  Production deploy webhook receiver. CI posts to /hooks/deploy with
+  the build artifact id; the workflow builds, runs tests, and notifies
+  on Slack/Discord depending on result.
+
+_meta:
+  template:
+    title: Webhook deploy hook
+    description: POST /hooks/deploy → build → notify
+    tags: [webhook, deploy, ci]
+
+nodes:
+  - id: receive
+    webhookTrigger:
+      method: POST
+      path: /hooks/deploy
+
+  - id: build
+    bash: |
+      echo "building $ARGUMENTS" && sleep 1 && echo ok
+    depends_on: [receive]
+
+  - id: notify
+    bash: |
+      echo "deploy result: $build.output"
+    depends_on: [build]

package/scripts/ci-public-export-import-gate.ts

@@ -88,9 +88,14 @@ export async function exportImportCheck(changedFiles: readonly string[], root: s
   const tracked = trackedFiles(root);
   if (!tracked) return { measured: false, hits: [], unseen: 0, detail: 'git ls-files 실패' };
   let included: Set<string>;
+  let present: Set<string>;
   try {
     const { loadExportConfig, selectExportFiles } = await exportSelectors();
-    included = new Set(selectExportFiles(tracked, loadExportConfig(root)));
+    const config = loadExportConfig(root);
+    included = new Set(selectExportFiles(tracked, config));
+    // An import target also exists in the export when `replace` writes a public file at that path. Only targets use
+    // this — a replaced private original is not shipped, so it is not scanned as an importer.
+    present = new Set([...included, ...Object.keys(config.replace ?? {})]);
   } catch (error) {
     return { measured: false, hits: [], unseen: 0, detail: error instanceof Error ? error.message : '매니페스트를 못 읽었다' };
   }
@@ -108,7 +113,7 @@ export async function exportImportCheck(changedFiles: readonly string[], root: s
       const resolvedSpec = resolveSpecifier(file, specifier);
       if (!resolvedSpec) return;
       const target = candidatePaths(resolvedSpec).find((candidate) => trackedSet.has(candidate));
-      if (!target || included.has(target)) return;
+      if (!target || present.has(target)) return;
       const key = `${index}\0${target}`;
       if (seen.has(key)) return;
       seen.add(key);

package/scripts/ci-typecheck-changed.ts

@@ -1032,14 +1032,29 @@ export function runGate(io: Partial<GateIo> = {}): void {
 //   ⭐ 그래서 막는 자리는 «여기»뿐이다 — 인-프로세스 호출자(`pr-cli.ts`·`seams.ts`)는
 //      argv 를 안 넘기고, 만약 여기서 `process.argv` 를 «읽으면» 형제 게이트가 경고한 그 사고가 난다
 //      (`elanous pr land` 의 인자를 자기 인자로 읽는다 — `src/cli/pr-cli.ts` 의 `args: []` 주석).
-if (import.meta.main) {
-  const cliArgs = process.argv.slice(2);
-  if (cliArgs.length > 0) {
-    console.error(`[tsc-gate] ⛔ 이 게이트는 인자를 받지 않는다 — 준 인자 ${cliArgs.length}개를 «조용히 삼키지 않고» 막는다: ${cliArgs.join(' ')}`);
+if (import.meta.main) void (async () => {
+  // GATE-REMOTE (10-06): the only accepted arguments are the dispatch flags `--remote [host]` / `--local` — they choose
+  //   «where» the same commit is measured, never «what» (the base stays merge-base(origin/main) on both sides).
+  const { extractGateRemoteFlags, dispatchHeavyCheck } = await import('../src/self-implement/gate-remote.js');
+  const flags = extractGateRemoteFlags(process.argv.slice(2));
+  const cliArgs = flags.rest;
+  if (cliArgs.length > 0 || flags.error) {
+    if (flags.error) console.error(`[tsc-gate] ⛔ ${flags.error}`);
+    if (cliArgs.length > 0) console.error(`[tsc-gate] ⛔ 이 게이트는 인자를 받지 않는다(--remote/--local 제외) — 준 인자 ${cliArgs.length}개를 «조용히 삼키지 않고» 막는다: ${cliArgs.join(' ')}`);
     console.error('[tsc-gate]   기준은 언제나 merge-base(origin/main) 다. 다른 기준으로 재려면 «그 트리에 서서» 돌려라:');
     console.error('[tsc-gate]     git worktree add --detach <경로> <커밋> && cd <경로> && bun run scripts/ci-typecheck-changed.ts');
     console.error('[tsc-gate]   ⇒ 그러면 merge-base 가 그때와 «같아진다». 이것이 재현의 유일한 길이다.');
     process.exit(2);
   }
-  runGate();
-}
+  const repo = sh('git rev-parse --show-toplevel').trim();
+  const baseRef = process.env.TSC_BASE_REF;
+  const passEnv = (sha: (ref: string) => string) => (['NODE_OPTIONS', 'TSC_BASE_REF', 'TSC_HEAP_MB'] as const).filter((key) => process.env[key])
+    .map((key) => `${key}=${key === 'TSC_BASE_REF' && baseRef !== 'origin/main' ? sha(baseRef!) : process.env[key]}`);
+  // exitCode, not exit(): piped stdout/stderr drain before the process ends.
+  process.exitCode = await dispatchHeavyCheck({
+    tool: 'ci-typecheck-changed', repo, flags,
+    remoteArgv: (sha) => { const vars = passEnv(sha); return [...(vars.length ? ['env', ...vars] : []), 'bun', 'run', 'scripts/ci-typecheck-changed.ts', '--local']; },
+    refs: baseRef ? [baseRef] : [],
+    runLocal: () => { runGate(); return 0; },
+  });
+})();

package/scripts/discord-seat-probe.ts

@@ -56,7 +56,8 @@ export async function probeDiscordSeatWork(text: string, options: ProbeOptions =
       open: () => { const db = new Database(':memory:'); return { db, close: () => db.close() } as unknown as MsgStore; },
       dispatch: async (seatId, forwarded) => {
         capture('ask', seatId, forwarded);
-        return { channel: 'unknown', reply: '마른 실행 — 질문을 맡기지 않았습니다.' };
+        // Since #24523 a seat *task* also travels this ask path (so the answer can come back) — the wording covers both.
+        return { channel: 'unknown', reply: `마른 실행 — ${seatId}에 맡길 예정 (실제 맡김 없음).` };
       },
       send: async () => { throw new Error('dry Discord delivery unavailable'); },
     },
@@ -76,7 +77,7 @@ export async function probeDiscordSeatWork(text: string, options: ProbeOptions =
       ...options.liveDeps?.askDeps,
       dispatch: async (seatId, forwarded, deps, extra) => {
         capture('ask', seatId, forwarded);
-        return (options.liveDeps?.askDeps?.dispatch ?? dispatchCeoTask)(seatId, forwarded, deps, extra);
+        return (options.liveDeps?.askDeps?.dispatch ?? options.liveDeps?.dispatch ?? dispatchCeoTask)(seatId, forwarded, deps, extra);
       },
       // This CLI has no Discord transport: even live mode must not post to Discord.
       send: async () => { throw new Error('probe does not send Discord messages'); },

package/scripts/docs/generate-cli-anatomy.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+/** DOC-GEN — src/cli/ 의 정적 Commander 명령을 실행 없이 TypeScript AST 로 읽는다. */
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+import { readCommit } from './generate-graph-anatomy.js';
+
+export interface RenderCliAnatomyInput {
+  readonly cliRoot: string;
+  readonly repoRoot: string;
+  readonly commit: string;
+  readonly generatedAt: string;
+}
+
+interface CommandRow {
+  readonly name: string;
+  readonly description: string;
+  readonly file: string;
+}
+
+function propertyCall(expression: ts.Expression, method: string): expression is ts.CallExpression & { expression: ts.PropertyAccessExpression } {
+  return ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression)
+    && expression.expression.name.text === method;
+}
+
+function literal(expression: ts.Expression | undefined): string | undefined {
+  return expression && (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression))
+    ? expression.text : undefined;
+}
+
+function descriptionOf(command: ts.CallExpression): string {
+  let current: ts.Expression = command;
+  while (ts.isPropertyAccessExpression(current.parent) && current.parent.expression === current
+    && ts.isCallExpression(current.parent.parent) && current.parent.parent.expression === current.parent) {
+    const property = current.parent;
+    const call = current.parent.parent;
+    if (property.name.text === 'description') return literal(call.arguments[0]) ?? '';
+    if (property.name.text === 'command') break;
+    current = call;
+  }
+  return '';
+}
+
+function rowsInFile(source: string, file: string): CommandRow[] {
+  const ast = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  interface Scope {
+    readonly owner: ts.Node;
+    readonly parent?: Scope;
+    readonly bindings: Map<string, ts.VariableDeclaration | null>;
+  }
+  const scopes = new Map<ts.Node, Scope>();
+  const gather = (node: ts.Node, outer?: Scope): void => {
+    const createsScope = ts.isSourceFile(node) || ts.isBlock(node) || ts.isModuleBlock(node)
+      || ts.isCaseBlock(node) || ts.isCatchClause(node) || ts.isFunctionLike(node)
+      || ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node);
+    const scope: Scope = createsScope ? { owner: node, parent: outer, bindings: new Map() } : outer!;
+    scopes.set(node, scope);
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+      const list = node.parent;
+      const isVar = ts.isVariableDeclarationList(list) && (list.flags & ts.NodeFlags.BlockScoped) === 0;
+      let target = scope;
+      if (isVar) {
+        while (target.parent && !ts.isSourceFile(target.owner) && !ts.isFunctionLike(target.owner)) {
+          target = target.parent;
+        }
+      }
+      target.bindings.set(node.name.text, node);
+    }
+    if (ts.isFunctionLike(node)) {
+      for (const parameter of node.parameters) {
+        if (ts.isIdentifier(parameter.name)) scope.bindings.set(parameter.name.text, null);
+      }
+    }
+    if (ts.isCatchClause(node) && node.variableDeclaration && ts.isIdentifier(node.variableDeclaration.name)) {
+      scope.bindings.set(node.variableDeclaration.name.text, null);
+    }
+    ts.forEachChild(node, (child) => gather(child, scope));
+  };
+  gather(ast);
+
+  const commandName = (expression: ts.Expression, seen: ReadonlySet<ts.VariableDeclaration> = new Set()): string => {
+    if (ts.isParenthesizedExpression(expression)) return commandName(expression.expression, seen);
+    if (ts.isIdentifier(expression)) {
+      let scope = scopes.get(expression);
+      while (scope && !scope.bindings.has(expression.text)) scope = scope.parent;
+      const declaration = scope?.bindings.get(expression.text);
+      if (!declaration || !declaration.initializer || seen.has(declaration)) return '';
+      return commandName(declaration.initializer, new Set([...seen, declaration]));
+    }
+    if (propertyCall(expression, 'command')) {
+      const name = literal(expression.arguments[0]);
+      if (name === undefined) return '';
+      const parent = commandName(expression.expression.expression, seen);
+      return parent ? `${parent} ${name}` : name;
+    }
+    if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression)) {
+      return commandName(expression.expression.expression, seen);
+    }
+    return '';
+  };
+
+  const rows: CommandRow[] = [];
+  const visit = (node: ts.Node): void => {
+    if (ts.isCallExpression(node) && propertyCall(node, 'command')) {
+      const name = literal(node.arguments[0]);
+      if (name !== undefined) rows.push({ name: commandName(node), description: descriptionOf(node), file });
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(ast);
+  return rows;
+}
+
+function cell(value: string): string {
+  return value.replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+/** 지정된 src/cli/ 바로 아래 .ts 만 읽으며 import/명령을 실행하지 않는다. */
+export function renderCliAnatomy(input: RenderCliAnatomyInput): string {
+  const rows = readdirSync(input.cliRoot, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name.endsWith('.ts')
+      && !entry.name.endsWith('.test.ts') && !entry.name.endsWith('.spec.ts'))
+    .flatMap((entry) => {
+      const abs = join(input.cliRoot, entry.name);
+      return rowsInFile(readFileSync(abs, 'utf8'), relative(input.repoRoot, abs).replace(/\\/g, '/'));
+    })
+    .sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : a.file < b.file ? -1 : a.file > b.file ? 1 : 0);
+  return [
+    '# CLI anatomy',
+    '',
+    '> 이 문서는 생성물이다 — 손으로 고치지 마라',
+    '',
+    `- generatedAt: ${input.generatedAt}`,
+    `- commit: ${input.commit}`,
+    '',
+    '| 명령 | 설명 | 정의 파일 |',
+    '| --- | --- | --- |',
+    ...rows.map((row) => `| ${cell(row.name)} | ${cell(row.description)} | ${cell(row.file)} |`),
+    '',
+  ].join('\n');
+}
+
+export function defaultOutputPath(repoRoot: string): string {
+  return join(repoRoot, 'docs', 'generated', 'cli-anatomy.md');
+}
+
+function main(): void {
+  const repoRoot = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+  const argv = process.argv.slice(2);
+  const index = argv.indexOf('--out');
+  const outArg = index < 0 ? undefined : argv[index + 1];
+  if (index >= 0 && (!outArg || outArg.startsWith('--'))) throw new Error('--out 에는 경로가 필요하다');
+  const out = outArg ?? defaultOutputPath(repoRoot);
+  const markdown = renderCliAnatomy({ cliRoot: join(repoRoot, 'src', 'cli'), repoRoot,
+    commit: readCommit(repoRoot), generatedAt: new Date().toISOString() });
+  mkdirSync(dirname(out), { recursive: true });
+  writeFileSync(out, markdown);
+  process.stdout.write(`${out}\n`);
+}
+
+if (import.meta.main) main();

package/scripts/goals/authoring-metrics.ts

@@ -0,0 +1,73 @@
+#!/usr/bin/env bun
+import { readFileSync } from 'node:fs';
+import { inspectAskMarkers } from '../ask-marker-check.js';
+
+export interface AuthoringMeasurement {
+  readonly path: string;
+  readonly chars: number;
+  readonly bytes: number;
+  readonly sections: number;
+  readonly markerAxes: number;
+  readonly markerFailed: number;
+}
+
+type UnreadableMeasurement = { readonly path: string; readonly error: 'unreadable' };
+type AuthoringRow = AuthoringMeasurement | UnreadableMeasurement;
+
+export function measureAuthoring(path: string, text: string): AuthoringMeasurement {
+  const axes = inspectAskMarkers(text);
+  return {
+    path,
+    chars: text.length,
+    bytes: Buffer.byteLength(text, 'utf8'),
+    sections: text.split(/\r?\n/).filter((line) => /^#{1,6}\s/u.test(line)).length,
+    markerAxes: axes.length,
+    markerFailed: axes.filter((axis) => !(axis.marker && axis.extracted)).length,
+  };
+}
+
+export function median(numbers: readonly number[]): number | null {
+  if (numbers.length === 0) return null;
+  const sorted = [...numbers].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1
+    ? sorted[middle]!
+    : (sorted[middle - 1]! + sorted[middle]!) / 2;
+}
+
+function main(argv: readonly string[]): number {
+  const json = argv.includes('--json');
+  const paths = argv.filter((argument) => argument !== '--json');
+  const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+  const rows: AuthoringRow[] = paths.map((path) => {
+    let text: string;
+    try {
+      text = decoder.decode(readFileSync(path));
+    } catch {
+      return { path, error: 'unreadable' };
+    }
+    return measureAuthoring(path, text);
+  });
+  const measured = rows.filter((row): row is AuthoringMeasurement => !('error' in row));
+  const summary = {
+    files: measured.length,
+    medianChars: median(measured.map((row) => row.chars)),
+    medianBytes: median(measured.map((row) => row.bytes)),
+  };
+
+  if (json) {
+    for (const row of rows) console.log(JSON.stringify(row));
+    console.log(JSON.stringify(summary));
+  } else {
+    console.log('path\tchars\tbytes\tsections\tmarkerAxes\tmarkerFailed\terror');
+    for (const row of rows) {
+      console.log('error' in row
+        ? `${row.path}\t\t\t\t\t\t${row.error}`
+        : `${row.path}\t${row.chars}\t${row.bytes}\t${row.sections}\t${row.markerAxes}\t${row.markerFailed}\t`);
+    }
+    console.log(`files\t${summary.files}\tmedianChars\t${summary.medianChars ?? '—'}\tmedianBytes\t${summary.medianBytes ?? '—'}`);
+  }
+  return rows.some((row) => 'error' in row) ? 1 : 0;
+}
+
+if (import.meta.main) process.exitCode = main(process.argv.slice(2));

package/scripts/landing-heal/must-fix-match.ts

@@ -1,4 +1,4 @@
-import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse } from '../../src/agent-substrate/pr-comment-meta.js';
 
 export type MustFixVerdict = 'resolved' | 'unresolved' | 'unknown';
 export interface ReviewRoundMatch {
@@ -12,12 +12,12 @@ export interface ReviewRoundMatch {
 const MUST_FIX_ROUND = /^Round \d+: reviewer requested \d+ must-fix change\(s\)\.$/m;
 
 export function classifyReviewRounds(comments: Array<{ body?: string }>): ReviewRoundMatch[] {
-  const reviews = comments.flatMap(({ body }) => {
-    if (!body) return [];
-    const meta = parse(body);
-    return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
-      ? [{ body, run: meta.run, round: meta.round }] : [];
-  });
+  const reviews = comments.flatMap(({ body }) =>
+    body ? expandRecords(body).flatMap((record) => {
+      const meta = parse(record);
+      return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
+        ? [{ body: record, run: meta.run, round: meta.round }] : [];
+    }) : []);
   // 항목은 «must-fix 요청» 라운드에서만 센다 — «review completed (warn)» 의 요약 본문에도 «- » 글머리가 들어 있다(#21983 실물).
   return reviews.flatMap(({ body, run, round }) => !MUST_FIX_ROUND.test(body) ? [] :
     [...body.matchAll(/^- (.+)$/gm)].map((item) => ({

package/scripts/landing-heal/run-mission.ts

@@ -5,7 +5,7 @@ import { dirname, join, resolve } from 'node:path';
 import { githubAutomationToken } from '../../src/auth/github-app-token.js';
 import { debug } from '../../src/debug/log.js';
 import { emitDecision } from '../../src/live/detail-switch.js';
-import { parse } from '../../src/agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse } from '../../src/agent-substrate/pr-comment-meta.js';
 import { classifyReviewRounds, matchMustFix, type MustFixVerdict } from './must-fix-match.js';
 import { verifyCleanCheckout, type CheckoutResult } from './clean-checkout.js';
 
@@ -116,7 +116,8 @@ export function runMission(mission: string, ctx: GraphContext, run: RunCommand =
         const pages = JSON.parse(run(['api', `repos/{owner}/{repo}/pulls/${pr.number}/comments`, '--paginate', '--slurp'])) as Array<Array<{ body?: string }>>;
         if (!Array.isArray(pages) || !pages.every(Array.isArray)) throw new Error(`invalid review comments for PR #${pr.number}`);
         const inline = pages.flat();
-        const comments = [...(details.reviews ?? []), ...(details.comments ?? []), ...inline];
+        const comments = [...(details.reviews ?? []), ...(details.comments ?? []), ...inline]
+          .flatMap((comment) => comment.body ? expandRecords(comment.body).map((body) => ({ ...comment, body })) : [comment]);
         const reviewRounds = comments.filter(({ body }) => {
           const meta = body ? parse(body) : null;
           return meta?.role === 'reviewer' && !!meta.run && meta.round !== undefined;

package/scripts/public-export-test-run.ts

@@ -4,7 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { run as exportRun } from './public-export.js';
+import { privateRedactionsPath, run as exportRun } from './public-export.js';
 
 export interface Comparison {
   exportOnly: string[];
@@ -118,4 +118,39 @@ export function run(argv: readonly string[], root = resolve(import.meta.dir, '..
   }
 }
 
-if (import.meta.main) process.exit(run(process.argv.slice(2)));
+// GATE-REMOTE (10-06): `--remote [host]` runs the same commit on that host and prints its result (JSON gains host · remote:true);
+//   `--local` forces this machine. Without either, a busy machine (1-min load > gateRemote.loadThreshold) dispatches on its own.
+if (import.meta.main) void (async () => {
+  const { extractGateRemoteFlags, dispatchHeavyCheck, unreproducibleArgs, relativizeArgs } = await import('../src/self-implement/gate-remote.js');
+  const flags = extractGateRemoteFlags(process.argv.slice(2));
+  if (flags.error) { console.error(flags.error); process.exit(2); }
+  const repo = resolve(import.meta.dir, '..');
+  // The private redaction table changes exported file contents — the remote export must use the same one or the comparison differs.
+  const table = privateRedactionsPath();
+  const payloadFiles = existsSync(table) ? [{ env: 'ELANOUS_EXPORT_REDACTIONS', content: readFileSync(table, 'utf8') }] : [];
+  // File arguments, the --files list and its entries resolve against the repository root (as run() does).
+  const paths = flags.rest.filter((arg) => !arg.startsWith('--'));
+  const listIndex = flags.rest.indexOf('--files');
+  const list = listIndex >= 0 ? flags.rest[listIndex + 1] : undefined;
+  // List entries reach the host verbatim (only positional arguments are rewritten), so an absolute entry is not portable.
+  const absoluteEntries: string[] = [];
+  if (list) {
+    try {
+      const entries = readFileSync(resolve(repo, list), 'utf8').split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+      absoluteEntries.push(...entries.filter((entry) => isAbsolute(entry)));
+      paths.push(...entries);
+    } catch { /* run() reports it */ }
+  }
+  process.exitCode = await dispatchHeavyCheck({
+    payloadFiles,
+    localOnlyReason: (() => {
+      // Each must be a tracked file inside the repository, or the remote checkout would measure something else.
+      const bad = [...new Set([...absoluteEntries, ...unreproducibleArgs(paths, repo)])];
+      return bad.length ? `file argument not reproducible on the host (outside the repository or not tracked at HEAD): ${bad.join(' ')}` : undefined;
+    })(),
+    tool: 'public-export-test-run', repo, flags, json: flags.rest.includes('--json'),
+    installPwa: paths.some((arg) => arg.includes('apps/pwa')),
+    remoteArgv: ['bun', 'scripts/public-export-test-run.ts', '--local', ...relativizeArgs(flags.rest, repo)],
+    runLocal: () => run(flags.rest),
+  });
+})();

package/scripts/release-loop/checklist-gate-node.ts

@@ -1,24 +1,25 @@
 #!/usr/bin/env bun
-import { checklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
+import { cutChecklistGate, listChecklist, summarizeChecklist } from '../../src/release-loop/checklist.js';
 import * as store from '../../src/release-loop/feature-store.js';
 import { getSchedule } from '../../src/release-loop/release-schedule.js';
 import { debug } from '../../src/debug/log.js';
+import { prereleaseKind } from './release-version.js';
 import { emitNodeResult, errorResult, readGraphContext, type GraphContext } from './node-verdict.js';
 
+/** RELEASE-REHEARSAL-RC: a prerelease rehearses the pipeline; it must not judge or carry the stable version's cells. */
+export function prereleaseChecklistSkip(context: GraphContext) {
+  const version = context.input.version;
+  if (prereleaseKind(version) === null) return null;
+  debug.log('release-loop.checklist-gate', 'skipped', { version, reason: 'prerelease' });
+  return { outcome: 'ok' as const, verdict: 'pass' as const, summary: `checklist gate skipped — ${version} is a prerelease rehearsal`, skipped: 'prerelease' };
+}
+
 export function runChecklistGate(context: GraphContext = readGraphContext(), now: Date = new Date()) {
   const version = context.input.version;
   const data = listChecklist(version);
   const schedule = getSchedule(version);
   const deadline = schedule?.landBy;
-  const overdue = deadline !== null && deadline !== undefined && now.getTime() > Date.parse(deadline);
-  const autoMoved = overdue ? data.items.filter((item) => item.status === 'yellow' && item.priority !== 'P0' && item.disposition === undefined).map((item) => item.id) : [];
-  const gate = checklistGate(version);
-  const p0 = data.items.filter((item) => item.status === 'yellow' && item.priority === 'P0').map((item) => item.id);
-  gate.undecided = gate.undecided.filter((id) => !autoMoved.includes(id) && !p0.includes(id));
-  gate.moved = gate.moved.filter((id) => !p0.includes(id)).concat(autoMoved);
-  gate.knownIssues = gate.knownIssues.filter((item) => !p0.includes(item.id));
-  gate.blocked.push(...p0.filter((id) => !gate.blocked.includes(id)));
-  gate.ok = gate.red.length === 0 && gate.undecided.length === 0 && gate.blocked.length === 0;
+  const { autoMoved, ...gate } = cutChecklistGate(version, deadline, now);
   const [major, minor, patch] = version.split('.').map(Number);
   const next = `${major}.${minor}.${patch! + 1}`;
   const carried: string[] = [];
@@ -65,7 +66,8 @@ export function runChecklistGate(context: GraphContext = readGraphContext(), now
 
 if (import.meta.main) {
   try {
-    const result = runChecklistGate();
+    const context = readGraphContext();
+    const result = prereleaseChecklistSkip(context) ?? runChecklistGate(context);
     emitNodeResult(result);
     process.exitCode = result.outcome === 'ok' ? 0 : 1;
   } catch (error) {

package/scripts/release-loop/cut-branch.ts

@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { isReleaseVersion } from './release-version.js';
 
 export interface CutBranchOptions { version: string; base: string; pick: string[]; append?: boolean; dryRun?: boolean; repoRoot?: string; log?: (line: string) => void }
 
@@ -26,7 +27,7 @@ export function cutReleaseBranch(opts: CutBranchOptions): { branch: string; comm
   const report = (event: 'created' | 'refused' | 'conflict' | 'appended', reason?: string, commit?: string, extra?: Record<string, string | string[]>) =>
     debug.log('release-loop.cut-branch', event, { version: opts.version, branch, ...(commit ? { commit } : {}), ...(reason ? { reason } : {}), ...extra });
   try {
-    if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
+    if (!isReleaseVersion(opts.version)) throw new Error(`invalid release version: ${opts.version}`);
     if (!opts.pick.length) throw new Error('at least one --pick commit is required');
     for (const sha of [opts.base, ...opts.pick]) if (!/^[0-9a-f]{7,40}$/i.test(sha)) throw new Error(`invalid commit SHA: ${sha}`);
     git(repo, ['fetch', 'origin', 'main']);

package/scripts/release-loop/cutoff.ts

@@ -25,8 +25,10 @@ function requiredGit(args: string[]): string {
 }
 
 function versionParts(value: string): number[] | null {
-  if (!/^\d+\.\d+\.\d+$/.test(value)) return null;
-  return value.split('.').map(Number);
+  // A prerelease (0.2.18-rc.0) is placed by its base version — earlier stable tags are its baseline.
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-(?:rc|alpha|beta)\.\d+)?$/.exec(value);
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
 
 function compareVersions(a: number[], b: number[]): number {

package/scripts/release-loop/docs-land-node.ts

@@ -7,6 +7,7 @@ import { recordDocsFollow, type DocsFollowItem } from './release-docs.js';
 import { dirname, join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { errorResult, finishNode, nodeOutput, readGraphContext, runCommand, type CommandRunner } from './node-verdict.js';
+import { prereleaseKind } from './release-version.js';
 
 export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effectiveInstanceRoot(), ledgerRoot = releaseLedgerRoot()) {
   const context = readGraphContext();
@@ -119,6 +120,12 @@ export function runDocsLand(run: CommandRunner = runCommand, stateRoot = effecti
 
 if (import.meta.main) {
   let version = '';
-  try { version = readGraphContext().input.version; process.exitCode = finishNode('docs-land', version, runDocsLand()); }
+  try {
+    version = readGraphContext().input.version;
+    // RELEASE-REHEARSAL-RC: a prerelease never lands docs on main or upgrades the operating hosts.
+    process.exitCode = finishNode('docs-land', version, prereleaseKind(version) !== null
+      ? { outcome: 'ok', verdict: 'pass', summary: `docs-land skipped — ${version} is a prerelease`, skipped: 'prerelease' }
+      : runDocsLand());
+  }
   catch (error) { process.exitCode = finishNode('docs-land', version, errorResult(error)); }
 }

package/scripts/release-loop/docs-node.ts

@@ -72,7 +72,7 @@ export function runDocs(
       }
       throw new Error(`unknown argument: ${arg}`);
     }
-    if (!version || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/.test(version)) {
+    if (!version || !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:rc|alpha|beta)\.(?:0|[1-9]\d*))?$/.test(version)) {
       throw new Error('version required (--version or ELANOUS_GRAPH_CONTEXT.input.version): x.y.z');
     }
     root = resolve(root);