elanous 0.2.42 → 0.2.44

package/src/self-implement/run-chart.ts

@@ -55,8 +55,11 @@ export function readRunChart(runId: string, device: RunChartDevice, dir: string)
 export function runChartMetrics(entries: readonly RunLedgerEntry[]): { emptyHandoffs: number; unreadHandoffs: number; conflictingVerdicts: number } {
   const cells = entries.filter((e) => e.event === 'run-chart-cell');
   const emptyHandoffs = cells.filter((e) => !String(e.data.handoff ?? '').trim()).length;
-  const unreadHandoffs = cells.filter((e) => Boolean(e.data.handoff)
-    && !cells.some((next) => next.data.readStopKeys instanceof Array && next.data.readStopKeys.includes(String(e.data.stopKey)))).length;
+  const unreadHandoffs = cells.filter((e) => {
+    const handoff = String(e.data.handoff ?? '').trim().toLowerCase();
+    return handoff !== '' && handoff !== 'none'
+      && !cells.some((next) => next.data.readStopKeys instanceof Array && next.data.readStopKeys.includes(String(e.data.stopKey)));
+  }).length;
   const verdicts = new Map<string, Set<string>>();
   for (const cell of cells) {
     const key = `${String(cell.data.device)}\0${String(cell.data.stopKey)}`;
@@ -90,7 +93,7 @@ export function recordRunChartDecision(input: RunChartDecision): RunChartWriteRe
     }
     append.push({ timestamp: new Date().toISOString(), runId: input.runId, event: 'run-chart-cell', data: {
       device: input.device, stopKey: input.stopKey, observed: input.observed.slice(0, 240), verdict: input.verdict,
-      action: input.action, handoff: input.handoff, why: input.why.slice(0, 240), readStopKeys: input.readStopKeys.slice(-RUN_CHART_READ_CELLS),
+      action: input.action, handoff: input.handoff ?? 'none', why: input.why.slice(0, 240), readStopKeys: input.readStopKeys.slice(-RUN_CHART_READ_CELLS),
       ...(input.waitCount === undefined ? {} : { waitCount: input.waitCount }),
       ...(input.failureClass === undefined ? {} : { failureClass: input.failureClass }),
     } });

package/src/self-implement/run-ledger.ts

@@ -1,4 +1,5 @@
-import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, statSync, truncateSync, unlinkSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { refuseProductionLedgerWriteInTest } from '../harness/ledger-write-guard.js';
@@ -32,9 +33,15 @@ export interface RunLedgerEntry {
   shardIdentityReadFailure?: RunShardIdentityReadFailure;
 }
 
+/** Stable signature for an ordered observed route; callers record the evidence basis separately. */
+export function pathSignatureOf(steps: readonly { readonly from: string; readonly to: string; readonly skipped?: readonly string[] }[]): string {
+  return createHash('sha256').update(JSON.stringify(steps.map(step => [step.from, step.to, step.skipped ?? []]))).digest('hex').slice(0, 12);
+}
+
 const RUN_GRAPH_STEP_EVENTS = new Set([
   'node-enter', 'node-exit', 'edge-taken', 'node-skipped', 'node-added', 'edge-rerouted',
   'unit-expanded', 'unit-collapsed', 'pipeline-node-entry', 'pipeline-node-exit', 'graph-edge-taken',
+  'graph.path',
 ]);
 
 function isRunGraphStepEvent(entry: RunLedgerEntry): boolean {
@@ -192,6 +199,7 @@ export interface RunOriginData extends Record<string, unknown> {
 }
 
 export type RunLedgerWriter = (entry: RunLedgerEntry) => void;
+export type RunLedgerBatchWriter = (entries: readonly RunLedgerEntry[]) => void;
 export type RunLedgerReader = (path: string, encoding?: 'utf8') => string | Buffer;
 
 /** A live PTY lacks its producer correlation id, or that id lacks an observable JSONL ledger. */
@@ -820,6 +828,48 @@ export function appendRunLedgerEntry(entry: RunLedgerEntry, dir = runLedgerDir()
   }
 }
 
+/** Append one run's structural graph events as a rollback-protected ledger batch. */
+export function appendRunLedgerEntries(entries: readonly RunLedgerEntry[], dir = runLedgerDir()): void {
+  if (entries.length === 0) return;
+  const runId = entries[0]!.runId;
+  if (!runId || entries.some((entry) => entry.runId !== runId)) throw new Error('run ledger batch must have one runId');
+  if (entries.some((entry) => !isRunGraphStepEvent(entry))) throw new Error('run ledger batch accepts graph-step events only');
+  if (refuseProductionLedgerWriteInTest(dir, 'run-ledger')) return;
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const live = runLedgerPath(runId, dir);
+  const devProject = process.env.ELANOUS_DEV_PROJECT;
+  withRunLedgerLock(dir, runId, () => {
+    restoreArchivedRunLedger(dir, runId);
+    let lastSequence = lastRunGraphEventSequence(runId, dir);
+    const rows = entries.map((entry) => {
+      const sequenced = sequenceRunGraphEvent(entry, lastSequence);
+      lastSequence = sequenced.seq ?? (typeof sequenced.data.seq === 'number' ? sequenced.data.seq : lastSequence);
+      return sequenced.devProject === undefined && typeof devProject === 'string' && devProject.startsWith('prj-')
+        ? { ...sequenced, devProject }
+        : sequenced;
+    });
+    const lines = rows.map((row) => `${JSON.stringify(row)}\n`).join('');
+    const appendLine = separateAppendedLedgerLine(live, lines);
+    const existed = existsSync(live);
+    const sizeBefore = existed ? statSync(live).size : 0;
+    try {
+      appendFileSync(live, appendLine, 'utf8');
+    } catch (error) {
+      try {
+        if (existed) truncateSync(live, sizeBefore);
+        else if (existsSync(live)) unlinkSync(live);
+      } catch (rollbackError) {
+        throw new AggregateError([error, rollbackError], `run ledger batch append and rollback failed: ${runId}`);
+      }
+      throw error;
+    }
+  });
+  for (const entry of entries) {
+    try { recordRunRequestVsEffectiveFromLedger(runId, dir, entry); }
+    catch { /* This comparison is observation and cannot fail a committed batch. */ }
+  }
+}
+
 /** Caller decision inside `appendRunLedgerEntryChecked`: either `append` exactly one entry, or skip with `result`. */
 export type RunLedgerCheckedAppendDecision<T> =
   | { append: false; result: T }

package/src/self-implement/runtime-overlay-run-steps.ts

@@ -0,0 +1,95 @@
+import type { GraphTemplate } from './graph-templates.js';
+import type { GraphTemplateSpec } from './graph-yaml.js';
+import type { RunLedgerEntry } from './run-ledger.js';
+
+type RuntimeOverlayGraph = Pick<GraphTemplate, 'nodes' | 'edges'> | Pick<GraphTemplateSpec, 'nodes' | 'edges'>;
+
+const DEFAULT_OUTCOME = '$default';
+const ABSENT_ROUTE = '$absent';
+
+export interface RuntimeOverlayRunStepsInput {
+  readonly runId: string;
+  readonly timestamp: string;
+  readonly before: RuntimeOverlayGraph;
+  readonly after: RuntimeOverlayGraph;
+  readonly overlayIds: readonly string[];
+  readonly round: number;
+}
+
+interface GraphRoute {
+  readonly from: string;
+  readonly outcome: string;
+  readonly to: string;
+}
+
+function routesOf(graph: RuntimeOverlayGraph): Map<string, GraphRoute> {
+  const routes = new Map<string, GraphRoute>();
+  if (!Array.isArray(graph.edges)) {
+    const compiledEdges = graph.edges as Readonly<Record<string, readonly string[]>>;
+    for (const [from, destinations] of Object.entries(compiledEdges)) {
+      for (const [index, to] of destinations.entries()) {
+        routes.set(`${from}\u0000${index}`, { from, outcome: String(index), to: String(to) });
+      }
+    }
+    return routes;
+  }
+  for (const edge of graph.edges) {
+    if (edge.to !== undefined) {
+      routes.set(`${edge.from}\u0000${DEFAULT_OUTCOME}`, { from: edge.from, outcome: DEFAULT_OUTCOME, to: edge.to });
+      continue;
+    }
+    for (const [outcome, to] of Object.entries(edge.map ?? {})) {
+      routes.set(`${edge.from}\u0000${outcome}`, { from: edge.from, outcome, to: String(to) });
+    }
+  }
+  return routes;
+}
+
+function reason(input: RuntimeOverlayRunStepsInput): string {
+  return `runtime overlay ${input.overlayIds.join(', ')} applied at round ${input.round}`;
+}
+
+/** Convert an already accepted runtime overlay into the existing structural ledger vocabulary. */
+export function runtimeOverlayRunSteps(input: RuntimeOverlayRunStepsInput): RunLedgerEntry[] {
+  if (input.overlayIds.length === 0) return [];
+  const detail = reason(input);
+  const beforeNodes = new Set(input.before.nodes.map((node) => node.nodeId));
+  const entries: RunLedgerEntry[] = input.after.nodes
+    .filter((node) => !beforeNodes.has(node.nodeId))
+    .map((node) => ({
+      timestamp: input.timestamp,
+      runId: input.runId,
+      event: 'node-added',
+      data: {
+        node: node.nodeId,
+        kind: node.kind,
+        decider: 'runtime-overlay',
+        reason: detail,
+        trigger: { overlayIds: input.overlayIds, round: input.round },
+      },
+    }));
+
+  const beforeRoutes = routesOf(input.before);
+  const afterRoutes = routesOf(input.after);
+  const changedRoutes = [...afterRoutes.entries()]
+    .filter(([key, route]) => beforeRoutes.get(key)?.to !== route.to)
+    .sort(([left], [right]) => left.localeCompare(right));
+  for (const [key, route] of changedRoutes) {
+    entries.push({
+      timestamp: input.timestamp,
+      runId: input.runId,
+      event: 'edge-rerouted',
+      data: {
+        from: route.from,
+        outcome: route.outcome,
+        to: route.to,
+        was: beforeRoutes.get(key)?.to ?? ABSENT_ROUTE,
+        decider: 'runtime-overlay',
+        reason: detail,
+      },
+    });
+  }
+  return entries;
+}
+
+export { ABSENT_ROUTE, DEFAULT_OUTCOME };

package/src/self-implement/tdd-evidence-tags.ts

@@ -0,0 +1,9 @@
+/** Stable TDD terminal-evidence tags shared by the producer and Pod result mapper. */
+export const TDD_RED_TAG = 'tdd-red' as const;
+export const TDD_GREEN_TAG = 'tdd-green' as const;
+export const TDD_RECORD_TAGS = [TDD_RED_TAG, TDD_GREEN_TAG] as const;
+export type TddRecordTag = typeof TDD_RECORD_TAGS[number];
+
+export function isTddRecordTag(value: unknown): value is TddRecordTag {
+  return value === TDD_RED_TAG || value === TDD_GREEN_TAG;
+}

package/src/self-implement/test-scenario-request.ts

@@ -28,6 +28,8 @@ export interface TestScenarioRequestInput {
   readonly registeredMethodologies: readonly string[];
   /** 라이브 명령의 «출처» — 보통 저작 중인 골 문서의 경로. 없으면 measured 로 못 간다. */
   readonly commandSource?: string;
+  /** Multiple authoritative source candidates are retained for review, never chosen by priority. */
+  readonly commandSourceCandidates?: readonly string[];
 }
 
 export type TestScenarioLiveStatus = 'measured' | 'unmeasured';
@@ -61,7 +63,25 @@ export function requestTestScenario(input: TestScenarioRequestInput): TestScenar
   const canLaunch = input.launch !== null
     && (input.launch.port !== undefined || (input.launch.entrypoint ?? '').trim() !== '');
   const methodologyAvailable = input.registeredMethodologies.includes(LAUNCH_METHODOLOGY);
-  const commandSource = input.commandSource?.trim();
+  const commandSourceCandidates = [...new Set((input.commandSourceCandidates ?? [])
+    .map((candidate) => candidate.trim())
+    .filter((candidate) => /^[^:\s]+:[^:\s]+$/u.test(candidate)))];
+  const explicitCommandSource = input.commandSource?.trim() || undefined;
+  const candidateConflict = commandSourceCandidates.length > 1
+    || (commandSourceCandidates.length === 1 && explicitCommandSource !== undefined && commandSourceCandidates[0] !== explicitCommandSource);
+  const commandSource = candidateConflict
+    ? undefined
+    : explicitCommandSource || commandSourceCandidates[0];
+  // Ambiguous declarations must use file:key tokens. Preserve a legacy explicit
+  // document path as a labeled source token rather than emitting a malformed item.
+  const explicitAmbiguityCandidate = explicitCommandSource
+    ? (/^[^:\s]+:[^:\s]+$/u.test(explicitCommandSource) ? explicitCommandSource : `${explicitCommandSource}:explicit-command-source`)
+    : undefined;
+  const ambiguityCandidates = [...new Set([
+    ...commandSourceCandidates,
+    ...(candidateConflict && explicitAmbiguityCandidate ? [explicitAmbiguityCandidate] : []),
+  ])];
+  const commandSourceAmbiguous = candidateConflict || (!commandSource && commandSourceCandidates.length > 1);
 
   if (canLaunch && methodologyAvailable && commandSource) {
     return {
@@ -76,15 +96,17 @@ export function requestTestScenario(input: TestScenarioRequestInput): TestScenar
   }
 
   // ⛔ 사유를 «가장 바깥 원인»으로 고른다 — 선언이 없으면 방법론·명령출처를 따질 자리가 아니다.
-  const reason = !canLaunch
-    ? 'no-launch-declaration'
+  const reason = commandSourceAmbiguous
+    ? 'ambiguous-command-source'
+    : !canLaunch
+      ? 'no-launch-declaration'
     : !methodologyAvailable
       ? 'no-methodology'
       : 'no-command-source';
   return {
     sections: [
       scenarioSection(UNKNOWN_DELIVERABLE, input.acceptanceCriteria),
-      unmeasuredLiveSection(reason),
+      unmeasuredLiveSection(reason, reason === 'ambiguous-command-source' ? ambiguityCandidates : [], reason === 'ambiguous-command-source' && candidateConflict ? explicitCommandSource : undefined),
       resultReportSection(),
     ],
     deliverableType: UNKNOWN_DELIVERABLE,
@@ -138,13 +160,22 @@ function measuredLiveSection(methodology: string, commandSource: string, launch:
 }
 
 /** L 층(측정 불가) — ⛔ 방법론·명령출처·기동·눈·기대를 «싣지 않는다»(파서가 금지한다). */
-function unmeasuredLiveSection(reason: string): string {
+function unmeasuredLiveSection(reason: string, candidates: readonly string[] = [], explicitSource?: string): string {
+  const prerequisite = reason === 'no-launch-declaration'
+    ? '골이 `## 산출물을 어떻게 켜나` 절에 `Port:` 또는 `Entrypoint:` 를 선언했으면 됐다'
+    : reason === 'ambiguous-command-source'
+      ? '골이 후보 중 하나를 권위 있는 명령 출처로 확정했으면 됐다'
+      : reason === 'no-methodology'
+        ? '호출자가 등록 방법론 레지스트리에 `deliverable-verify` 를 등록했으면 됐다'
+        : '골이 권위 있는 명령 출처를 선언했으면 됐다';
   return [
     '## L. 라이브',
     '',
     '### 상태 `unmeasured`',
     `- 사유: \`${reason}\``,
-    '- 무엇이 있었으면 됐나: 골이 `## 산출물을 어떻게 켜나` 절에 `Port:` 또는 `Entrypoint:` 를 선언했으면 됐다',
+    ...(reason.startsWith('ambiguous-') ? [`- 후보 목록: ${candidates.join(', ')}`] : []),
+    ...(explicitSource ? [`- 원래 명시 출처(후보와 별도): \`${explicitSource}\``] : []),
+    `- 무엇이 있었으면 됐나: ${prerequisite}`,
     '',
     '> ⚠️ ⛔ 「측정 불가」는 「결함 없음」이 «아니다». 이 골은 라이브 층을 «안 본 채» 끝난다.',
   ].join('\n');

package/src/self-implement/train-gate-receipt.ts

@@ -0,0 +1,166 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
+import {
+  computeReceiptKey,
+  gateEnvFingerprint,
+  gateLockfileHash,
+  GATE_RECEIPT_SCHEMA,
+  loadGateReceipts,
+  saveGateReceipt,
+  type GateReceipt,
+  type GateReceiptIdentity,
+} from './gate-receipt-registry.js';
+
+export interface TrainGateReceiptInput {
+  repo: string;
+  commit: string;
+  baseSha: string;
+  changedFiles: readonly string[];
+  deletedFiles?: readonly string[];
+  scenarioTests?: readonly string[];
+}
+
+export interface PassedSelfGateReceiptInput extends TrainGateReceiptInput {
+  /** Exact artifact emitted by `self gate --artifact-dir`; its pass and typecheck binding are revalidated here. */
+  summaryPath: string;
+}
+
+type Execute = (script: string, cwd: string) => { status: number | null; stdout: string; stderr: string };
+
+const SHA40 = /^[0-9a-f]{40}$/i;
+const TEST_FILE = /\.test\.[cm]?[jt]sx?$/;
+const quote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
+
+function registryPath(repo: string): string | undefined {
+  const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: repo, encoding: 'utf8', timeout: 10_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  const commonDir = (result.stdout ?? '').trim();
+  return result.status === 0 && commonDir ? join(commonDir, 'elanous-host-regate', 'gate-receipts.json') : undefined;
+}
+
+function identityFor(input: TrainGateReceiptInput, checks?: readonly string[]): GateReceiptIdentity | undefined {
+  if (!SHA40.test(input.commit) || !SHA40.test(input.baseSha)) return undefined;
+  const bun = spawnSync('bun', ['--version'], { cwd: input.repo, encoding: 'utf8', timeout: 10_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  const bunVersion = (bun.stdout ?? '').trim();
+  if (bun.status !== 0 || !bunVersion) return undefined;
+  return {
+    headCommit: input.commit,
+    baseCommit: input.baseSha,
+    bunVersion,
+    lockfileHash: gateLockfileHash(input.repo),
+    radiusFiles: [...new Set(input.changedFiles)].sort(),
+    checks: checks ? [...checks] : [
+      'train:changed-file-typecheck',
+      ...(input.scenarioTests?.length || input.changedFiles.some((file) => TEST_FILE.test(file) && !input.deletedFiles?.includes(file)) ? ['train:deterministic-tests'] : []),
+      ...(input.scenarioTests ?? []).map((file) => `train:scenario-test:${file}`),
+      'train:pwa-build',
+    ],
+    envFingerprint: gateEnvFingerprint(process.env),
+  };
+}
+
+/** Record only after revalidating the exact self-gate summary, then independently measure changed-only interference. */
+export async function recordPassedSelfGateReceipt(
+  input: PassedSelfGateReceiptInput,
+  detect: (files: readonly string[]) => Promise<{ status: 'no-interference' | 'interference' | 'unmeasurable' }> = async (files) => {
+    const { detectTestInterference } = await import('../../scripts/detect-test-interference.js');
+    return detectTestInterference(files);
+  },
+): Promise<GateReceipt | undefined> {
+  let summary: Record<string, unknown>;
+  try { summary = JSON.parse(readFileSync(input.summaryPath, 'utf8')) as Record<string, unknown>; }
+  catch { return undefined; }
+  const typecheck = summary.typecheck as Record<string, unknown> | undefined;
+  const cohort = Array.isArray(summary.cohort) ? summary.cohort.filter((file): file is string => typeof file === 'string') : [];
+  const changedTestFiles = [...new Set(input.changedFiles.filter((file) => TEST_FILE.test(file)
+    && !input.deletedFiles?.includes(file)))].sort();
+  if (summary.head40 !== input.commit || summary.base40 !== input.baseSha || summary.exitCode !== 0
+    || !['passed', 'pass'].includes(String(summary.verdict)) || summary.introduced !== 0
+    || summary.unknown !== 0 || summary.unrunImporters !== 0
+    || typecheck?.status !== 'passed' || typecheck.base40 !== input.baseSha
+    || typecheck.head40 !== input.commit || typecheck.exitCode !== 0 || typecheck.newErrors !== 0
+    || changedTestFiles.some((file) => !cohort.includes(file))) return undefined;
+  const testFiles = [...new Set(input.changedFiles.filter((file) => TEST_FILE.test(file)
+    && !input.deletedFiles?.includes(file)))].sort();
+  if (!testFiles.length) return undefined;
+  const interference = await detect(testFiles);
+  if (interference.status !== 'no-interference') return undefined;
+  const identity = identityFor(input, ['test-interference:changed-only']);
+  const path = process.env.ELANOUS_GATE_RECEIPT_REGISTRY_PATH || registryPath(input.repo);
+  if (!identity || !path) return undefined;
+  const receipt = passedEvidenceReceipt(identity, input.changedFiles);
+  try { saveGateReceipt(path, receipt); }
+  catch { return undefined; }
+  return receipt;
+}
+
+function scriptFor(input: TrainGateReceiptInput, files: readonly string[]): string {
+  const tests = [...new Set([
+    ...files.filter((file) => TEST_FILE.test(file) && !input.deletedFiles?.includes(file)),
+    ...(input.scenarioTests ?? []),
+  ])];
+  return [
+    `TSC_BASE_REF=${quote(input.baseSha)} bun scripts/ci-typecheck-changed.ts --local`,
+    ...(tests.length ? [`bun run test:deterministic ${tests.map(quote).join(' ')}`] : []),
+    `bun scripts/ci-pwa-build-gate.ts --changed-files ${files.map(quote).join(' ')}`,
+  ].join(' && ');
+}
+
+function passedEvidenceReceipt(identity: GateReceiptIdentity, files: readonly string[]): GateReceipt {
+  const receiptIdentity: GateReceiptIdentity = { ...identity, radiusFiles: [...new Set(files)].sort() };
+  return {
+    ...receiptIdentity,
+    schema: GATE_RECEIPT_SCHEMA,
+    key: computeReceiptKey(receiptIdentity, 'passed'),
+    verdict: 'passed',
+    savedAt: new Date().toISOString(),
+  };
+}
+
+export function runTrainGateWithReceipts(input: TrainGateReceiptInput, execute: Execute = (script, cwd) => {
+  const result = spawnSync('sh', ['-c', script], { cwd, encoding: 'utf8', timeout: 120 * 60_000, maxBuffer: 32 * 1024 * 1024 });
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}): { status: number | null; stdout: string; stderr: string } {
+  const context = identityFor(input);
+  const path = process.env.ELANOUS_GATE_RECEIPT_REGISTRY_PATH || registryPath(input.repo);
+  if (!context || !path) return execute(scriptFor(input, input.changedFiles), input.repo);
+
+  const changedFiles = [...new Set(input.changedFiles)].sort();
+  const result = execute(scriptFor(input, changedFiles), input.repo);
+  if (result.status === 0 && changedFiles.length) {
+    try { saveGateReceipt(path, passedEvidenceReceipt(context, changedFiles)); }
+    catch { /* A receipt is an optimization; a passed gate remains passed if persistence fails. */ }
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  const raw = process.argv[2];
+  try {
+    if (!raw) throw new Error('train gate receipt input is required');
+    const input = JSON.parse(raw) as TrainGateReceiptInput & Partial<PassedSelfGateReceiptInput>;
+    if (input.summaryPath) {
+      const receipt = await recordPassedSelfGateReceipt(input as PassedSelfGateReceiptInput);
+      const registryFile = process.env.ELANOUS_GATE_RECEIPT_REGISTRY_PATH;
+      if (registryFile) {
+        const registry = loadGateReceipts(registryFile);
+        process.stdout.write(`${String.fromCharCode(10)}__GATE_RECEIPTS__${Buffer.from(JSON.stringify(registry)).toString('base64')}${String.fromCharCode(10)}`);
+      }
+      if (!receipt) process.exitCode = 1;
+    } else {
+      const result = runTrainGateWithReceipts({ ...input, repo: process.cwd() });
+      process.stdout.write(result.stdout);
+      process.stderr.write(result.stderr);
+      const registryFile = process.env.ELANOUS_GATE_RECEIPT_REGISTRY_PATH;
+      if (registryFile) {
+        const registry = loadGateReceipts(registryFile);
+        process.stdout.write(`${String.fromCharCode(10)}__GATE_RECEIPTS__${Buffer.from(JSON.stringify(registry)).toString('base64')}${String.fromCharCode(10)}`);
+      }
+      process.exitCode = result.status ?? 1;
+    }
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+}

package/src/self-implement/train-gate-remote.ts

@@ -3,8 +3,12 @@
  *  Unlike `dispatchHeavyCheck` it never falls back to a local run: a busy host or an infra failure is «unmeasured».
  *  The only local commands are git (cat-file · rev-parse · push · diff). */
 import { debug } from '../debug/log.js';
+import { spawnSync } from 'node:child_process';
 import { parseGateScenario, readGateScenarioFile } from './gate-scenario.js';
 import { getDefaultLogStore } from '../mss/logging/log-store.js';
+import { join } from 'node:path';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
+import { saveGateReceipt, type GateReceipt } from './gate-receipt-registry.js';
 import {
   gateRemoteHostCap, realGateRemoteRunner, resolveGateRemoteSettings, runOnRemote,
   type GateRemoteRunner, type GateRemoteSettings, type RemoteRunOutcome,
@@ -30,6 +34,51 @@ export interface TrainGateInput {
 
 export interface TrainGateResult { outcome: TrainGateOutcome; host: string; ms?: number; rc?: number; reason?: string }
 
+const GATE_RECEIPTS_MARKER = String.fromCharCode(10) + '__GATE_RECEIPTS__';
+
+function sharedGateReceiptPath(repo: string, runner: GateRemoteRunner): string | undefined {
+  try {
+    const result = runner.local('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], repo);
+    const commonDir = result.stdout.trim();
+    return result.rc === 0 && commonDir ? join(commonDir, 'elanous-host-regate', 'gate-receipts.json') : undefined;
+  } catch { return undefined; }
+}
+
+/** The exact persistent registry used by local train receipt merging. */
+export function gateReceiptRegistryPathForRepo(repo: string): string | undefined {
+  const result = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], {
+    cwd: repo, encoding: 'utf8', timeout: 10_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER,
+  });
+  const commonDir = (result.stdout ?? '').trim();
+  return result.status === 0 && commonDir ? join(commonDir, 'elanous-host-regate', 'gate-receipts.json') : undefined;
+}
+
+/** Merge the existing remote-writer marker into the local common-dir registry. Invalid rows fail closed. */
+export function mergeGateReceiptRegistryPayload(payload: string, path: string): number {
+  let saved = 0;
+  try {
+    const rows = JSON.parse(Buffer.from(payload, 'base64').toString('utf8')) as Record<string, unknown>;
+    for (const [key, value] of Object.entries(rows)) {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+      const receipt = value as GateReceipt;
+      if (receipt.key !== key) continue;
+      try { saveGateReceipt(path, receipt); saved++; }
+      catch { /* Invalid remote records are discarded; local gates remain fail-open. */ }
+    }
+  } catch { /* A malformed response never changes the measured gate verdict. */ }
+  return saved;
+}
+
+function mergeReturnedReceipts(outcome: RemoteRunOutcome, path: string | undefined): RemoteRunOutcome {
+  if (outcome.kind !== 'ran' || outcome.rc !== 0 || !path) return outcome;
+  const stdout = outcome.stdout.toString('utf8');
+  const marker = stdout.lastIndexOf(GATE_RECEIPTS_MARKER);
+  if (marker < 0) return outcome;
+  const payload = stdout.slice(marker + GATE_RECEIPTS_MARKER.length).trim();
+  mergeGateReceiptRegistryPayload(payload, path);
+  return { ...outcome, stdout: Buffer.from(stdout.slice(0, marker)) };
+}
+
 export interface TrainGateObservation {
   host: string; commit: string; baseSha: string; outcome: TrainGateOutcome;
   rc?: number; ms?: number; reason?: string; changedFiles: number;
@@ -42,22 +91,6 @@ export interface TrainGateDeps {
   observe?: (entry: TrainGateObservation) => void;
 }
 
-const quote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
-const TEST_FILE = /\.test\.[cm]?[jt]sx?$/;
-
-/** The host-side shell body: each step runs only if the one before it passed. Exported for tests. */
-export function trainGateScript(baseSha: string, changedFiles: readonly string[], deleted: ReadonlySet<string> = new Set(), scenarioTests: readonly string[] = []): string {
-  // A deleted test file is a changed path (tsc/PWA reach) but not something to run.
-  const changedTests = changedFiles.filter((file) => TEST_FILE.test(file) && !deleted.has(file));
-  const tests = scenarioTests.length ? [...new Set([...changedTests, ...scenarioTests])] : changedTests;
-  const steps = [
-    `TSC_BASE_REF=${quote(baseSha)} bun scripts/ci-typecheck-changed.ts --local`,
-    ...(tests.length ? [`bun run test:deterministic ${tests.map(quote).join(' ')}`] : []),
-    `bun scripts/ci-pwa-build-gate.ts --changed-files ${changedFiles.map(quote).join(' ')}`,
-  ];
-  return steps.join(' && ');
-}
-
 async function loadSettings(): Promise<GateRemoteSettings> {
   try {
     const { getUserConfig } = await import('../user-config.js');
@@ -76,6 +109,10 @@ export const TRAIN_GATE_HOST = 'node-b';
 
 export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): Promise<TrainGateResult> {
   const settings = input.settings ?? await loadSettings();
+  const receiptPath = sharedGateReceiptPath(input.repo, runner);
+  // Each remote full gate writes into a fresh scratch registry; returned rows merge into the local shared registry.
+  // No existing registry contents are needed for receipt registration.
+  const payloadFiles = receiptPath ? [{ env: 'ELANOUS_GATE_RECEIPT_REGISTRY_PATH', content: '{}' }] : undefined;
   const host = settings.host;
   const hostCap = gateRemoteHostCap(settings, host);
   let scenarioTests: string[] = [];
@@ -110,14 +147,21 @@ export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemo
   const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
   const now = deps.now ?? Date.now;
   const deadline = now() + settings.slotWaitSeconds * 1000;
-  const script = trainGateScript(input.baseSha, input.changedFiles, new Set(input.deletedFiles ?? []), scenarioTests);
   let outcome: RemoteRunOutcome;
   for (;;) {
     try {
       outcome = runOnRemote({
         repo: input.repo, host, mirror: settings.mirror, commit: input.commit, refs: [input.baseSha],
-        argv: ['sh', '-c', script], installPwa: true, hostCap,
+        argv: ['bun', 'src/self-implement/train-gate-receipt.ts', JSON.stringify({
+          repo: input.repo,
+          commit: input.commit,
+          baseSha: input.baseSha,
+          changedFiles: input.changedFiles,
+          deletedFiles: input.deletedFiles ?? [],
+          scenarioTests,
+        })], installPwa: true, hostCap, ...(payloadFiles ? { payloadFiles } : {}),
       }, runner);
+      outcome = mergeReturnedReceipts(outcome, receiptPath);
     } catch (error) {
       outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
     }

package/src/session/chat.ts

@@ -20,7 +20,7 @@ import { debug } from '../debug/log.js';
 import { createRequestSizeGuard, formatRequestSizeStatus, type RequestSizeGuard } from './request-size-guard.js';
 import type { InputSourceKind } from '../input/input-source-kind.js';
 import {
-  getProviderForConfig, streamLLMWithTools, type LLMMessage, type LLMOpts, type LLMProvider,
+  getProviderForConfigAsync, streamLLMWithTools, type LLMMessage, type LLMOpts, type LLMProvider,
   type LLMToolSpec, type ContentBlock,
 } from '../llm.js';
 import type { UserConfig } from '../user-config.js';
@@ -407,7 +407,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
       reasoningEffort: llmOpts?.reasoningEffort ?? null,
     });
   }
-  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
+  const provider = opts.provider ?? await getProviderForConfigAsync(opts.userConfig, llmOpts?.model);
 
   // 2) Assemble, trim, call. When images are attached for THIS turn,
   //    swap the string content of the latest user message for
@@ -511,8 +511,9 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     // streamLLMWithTools)으로 라우팅. 미아밍이면 아래 기존 single-turn 경로 그대로(회귀 0).
     const goalLoopCfg = opts.userConfig.llm.goalLoop;
     const armGoalLoop = opts.goalLoop === true || goalLoopCfg?.enabled === true;
-    const armTuiResearchTurn = opts.utteranceSurface === 'tui' && turnTools.length > 0 && isResearchAgentIntent(opts.userText);
-    if (armGoalLoop || armTuiResearchTurn) {
+    const armResearchTurn = (opts.utteranceSurface === 'tui' || opts.utteranceSurface === 'ask')
+      && turnTools.length > 0 && isResearchAgentIntent(opts.userText);
+    if (armGoalLoop || armResearchTurn) {
       // ⭐ CHILD-CONTEXT-BUDGET(0.2.35 칸) — 구현 자식(self-implement 공간)의 첫 goal-loop
       //    턴에서 실제 effectiveSystemPrompt·turnTools 스키마·userText(골)의 구성 바이트를
       //    composeChildContext 로 계측해 child.context-composition 사건 1회로 남긴다.
@@ -563,6 +564,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
           },
         },
         ...(turnLlmOpts?.model ? { modelOverride: turnLlmOpts.model } : {}),
+        ...(turnLlmOpts?.reasoningEffort ? { reasoningEffort: turnLlmOpts.reasoningEffort } : {}),
         ...(turnLlmOpts?.budgetGrant ? { budgetGrant: turnLlmOpts.budgetGrant } : {}),
         ...(guardedTurnLlmOpts?.requestSizeGuard
           ? { requestSizeGuard: guardedTurnLlmOpts.requestSizeGuard } : {}),

package/src/session/session-fanout.ts

@@ -224,6 +224,8 @@ export interface SessionChunkEvent {
   seq: number;
   /** 텍스트 델타(누적은 sink 의 라이브핸들이). */
   delta?: string;
+  /** Replace the current assistant text accumulated for this stream. */
+  textOperation?: 'replace';
   /** 툴 활동(⚙️…✓ inline 렌더용). */
   tool?: { id: string; name: string; phase: 'call' | 'result'; ok?: boolean };
   /** 🧠 추론(모드 gated·선택). */

package/src/session/streaming/acp-stream-sink.ts

@@ -36,7 +36,8 @@ export function createAcpStreamSink(broadcast: AcpBroadcast): StreamingSurfaceSi
       if (!sessionId) return;
       if (ev.delta) {
         // push(chunk) 등가 — agent_message_chunk(byte-identical).
-        void broadcast(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: ev.delta } });
+        void broadcast(sessionId, { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: ev.delta },
+          ...(ev.textOperation === 'replace' ? { _meta: { elanous: { textOperation: 'replace' } } } : {}) });
       }
       if (ev.reasoning) {
         // 🧠 추론 — agent_thought_chunk(ACP 의 thought 채널).

package/src/session/streaming/chunk-producer.ts

@@ -20,6 +20,7 @@ import { debug } from '../../debug/log.js';
  *  shadow 시엔 'acp' 구독자 부재 → tg/dc/pwa 미러만. reasoning 채널 추가 지원. */
 export interface AcpChunkProducer {
   delta: (text: string) => void;
+  replaceText: (text: string) => void;
   /** ⭐ `result` 는 «결과 단계»에서만 뜻이 있고, 주면 ACP `rawOutput` 으로 실려 나간다.
    *
    *  ⛔⭐⭐ **「안 줬다」의 «사유»를 여기서 만들지 않는다.**
@@ -53,6 +54,11 @@ export function makeAcpChunkProducer(sessionId: string, opts: { streamId?: strin
       fo({ streamId, seq: seq++, delta: text });
       deltas++;
     },
+    replaceText(text: string): void {
+      accum = text;
+      fo({ streamId, seq: seq++, delta: text, textOperation: 'replace' });
+      deltas++;
+    },
     tool(id, name, phase, ok, result): void {
       fo({ streamId, seq: seq++, tool: {
         id, name, phase,