elanous 0.2.37 → 0.2.40

package/src/release-loop/gate-shards.ts

@@ -12,6 +12,12 @@ export type ShardState = typeof SHARD_STATES[number];
 export interface GateShard {
   id: string;
   state: ShardState;
+  /** Kubernetes Job for the current attempt; lets the gate watchdog reconcile a lost completion callback. */
+  job?: string;
+  /** Attempt identity associated with the currently recorded Job/result marker. */
+  attemptId?: string;
+  /** Result JSON for the current attempt; retries replace this so an older marker cannot close a new Job. */
+  resultFile?: string;
   startedAt?: string;
   endedAt?: string;
   /** 설치(install) 단계에 쓴 초. */
@@ -61,8 +67,14 @@ function shardOf(value: unknown): GateShard | null {
   const waitReason = str(raw.waitReason);
   const plannedMin = num(raw.plannedMin);
   const host = str(raw.host, 120);
+  const job = str(raw.job, 120);
+  const attemptId = str(raw.attemptId, 120);
+  const resultFile = str(raw.resultFile, 200);
   return {
     id, state,
+    ...(job ? { job } : {}),
+    ...(attemptId ? { attemptId } : {}),
+    ...(resultFile ? { resultFile } : {}),
     ...(startedAt ? { startedAt } : {}), ...(endedAt ? { endedAt } : {}),
     ...(installSec !== undefined ? { installSec } : {}), ...(rc !== undefined ? { rc } : {}),
     ...(waitReason ? { waitReason } : {}), ...(plannedMin !== undefined ? { plannedMin } : {}),
@@ -70,6 +82,55 @@ function shardOf(value: unknown): GateShard | null {
   };
 }
 
+export type GateJobTerminal = 'complete' | 'failed';
+
+/** Forget the prior child Job before a shard descends into a retry/split attempt. */
+export function beginGateShardAttempt(shard: GateShard, now = new Date()): GateShard {
+  const next: GateShard = { ...shard, state: 'retry', startedAt: now.toISOString() };
+  delete next.endedAt;
+  delete next.waitReason;
+  delete next.host;
+  delete next.job;
+  delete next.resultFile;
+  delete next.attemptId;
+  return next;
+}
+
+/**
+ * Close each stale running row when its result marker or Kubernetes Job has terminal evidence.
+ * A result marker can close a row even when the Kubernetes status read is unavailable.
+ */
+export function finalizeTerminalGateShards(
+  file: GateShardsFile,
+  terminalJobs: ReadonlyMap<string, GateJobTerminal>,
+  results: ReadonlyMap<string, { completed?: boolean; jobName?: string; attemptId?: string; jobFailed?: boolean; rc?: number | null; reason?: 'timeout' | 'stall' }>,
+  now: Date = new Date(),
+  staleAfterMs = 120_000,
+): GateShardsFile {
+  const active = file.shards.filter((shard) => shard.state === 'running' || shard.state === 'retry');
+  if (!active.length) return file;
+  const at = now.getTime();
+  const ready = active.map((shard) => {
+    const result = results.get(shard.id);
+    const resultTerminal = result?.completed === true && result.jobName === shard.job && result.attemptId === shard.attemptId;
+    const k8sTerminal = shard.job ? terminalJobs.get(shard.job) : undefined;
+    const startedAt = shard.startedAt ? Date.parse(shard.startedAt) : Number.NaN;
+    if (!resultTerminal && !k8sTerminal) return undefined;
+    if (!Number.isFinite(startedAt) || at - startedAt < staleAfterMs) return undefined;
+    return { shard, result, state: resultTerminal
+      ? (result!.reason === 'timeout' ? 'timeout' as const : result!.reason === 'stall' || result!.jobFailed === true ? 'failed' as const : 'done' as const)
+      : k8sTerminal === 'failed' ? 'failed' as const : 'done' as const };
+  });
+  const finalized = ready.filter((entry): entry is NonNullable<typeof entry> => entry !== undefined);
+  if (!finalized.length) return file;
+  const byId = new Map(finalized.map(({ shard, result, state }) => {
+    const current = { ...shard };
+    delete current.waitReason;
+    return [shard.id, { ...current, state, endedAt: now.toISOString(), ...(result && typeof result.rc === 'number' ? { rc: result.rc } : {}) } satisfies GateShard];
+  }));
+  return { ...file, updatedAt: now.toISOString(), shards: file.shards.map((shard) => byId.get(shard.id) ?? shard) };
+}
+
 function verdictOf(value: unknown): GateShardsVerdict | undefined {
   if (!value || typeof value !== 'object') return undefined;
   const raw = value as Record<string, unknown>;

package/src/release-loop/light-rc.ts

@@ -7,7 +7,7 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
-import { runSelfGateCli, type SelfGateCliOptions, type SelfGateCliResult } from '../self-implement/gate-cli.js';
+import { runSelfGateCliAsync, type SelfGateCliOptions, type SelfGateCliResult } from '../self-implement/gate-cli.js';
 import { dispatchHeavyCheck, isValidGateHost, type DispatchDeps, type DispatchOptions } from '../self-implement/gate-remote.js';
 import { latestPublishedPreviousVersion } from '../../scripts/release-loop/unattended-release.js';
 import { baseVersion, isReleaseVersion } from '../../scripts/release-loop/release-version.js';
@@ -29,6 +29,8 @@ export interface LightRcOptions {
   /** Run on this machine (the remote child is re-invoked with it). */
   local?: boolean;
   shards?: number;
+  /** Maximum simultaneously active gate bundles, including per-file RSS samples (default three). */
+  shardConcurrency?: number;
   /** OP FU — pass `--fixed-shard-distribution` to self gate (sorted round-robin into `shards`, no RSS pre-measurement).
    *  Opt-in; absent = the measured planner, unchanged. Also carried to the remote child. */
   fixedShardDistribution?: boolean;
@@ -71,7 +73,7 @@ export interface LightRcDeps {
   git?: (args: string[], cwd: string) => { rc: number | null; stdout: string };
   previousVersion?: (version: string, ledgerRoot?: string) => string;
   readFile?: (path: string) => string | undefined;
-  runGate?: (cwd: string, options: SelfGateCliOptions) => SelfGateCliResult;
+  runGate?: (cwd: string, options: SelfGateCliOptions) => SelfGateCliResult | Promise<SelfGateCliResult>;
   dispatch?: (opts: DispatchOptions, deps?: DispatchDeps) => Promise<number>;
   /** Extra dispatch deps (runner · settings) — tests drive the real dispatch with a fake host. */
   dispatchDeps?: Omit<DispatchDeps, 'write'>;
@@ -175,6 +177,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   if (!isReleaseVersion(version)) throw new Error(`release version must be x.y.z: ${version}`);
   const shards = opts.shards ?? LIGHT_RC_DEFAULT_SHARDS;
   if (!Number.isSafeInteger(shards) || shards < 1) throw new Error(`invalid --shards count: ${opts.shards}`);
+  if (opts.shardConcurrency !== undefined && (!Number.isSafeInteger(opts.shardConcurrency) || opts.shardConcurrency < 1 || opts.shardConcurrency > 4)) throw new Error(`invalid --shard-concurrency: ${opts.shardConcurrency}`);
   if (opts.remote !== undefined && !isValidGateHost(opts.remote)) throw new Error(`invalid --remote host: ${opts.remote}`);
   const log = opts.log ?? ((line: string) => process.stderr.write(`${line}\n`));
   const cwd = repoRoot(deps);
@@ -195,7 +198,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
     try {
       const dir = checkout?.dir ?? cwd;
       if (checkout) alwaysInclude = readList(dir);
-      local = (deps.runGate ?? runSelfGateCli)(dir, { base, shards, ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), alwaysInclude, includeImporterTests: true });
+      local = await (deps.runGate ?? runSelfGateCliAsync)(dir, { base, shards, ...(opts.shardConcurrency !== undefined ? { shardConcurrency: opts.shardConcurrency } : {}), ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), alwaysInclude, includeImporterTests: true });
       if (opts.rehearsalTui) {
         const command = async (cmd: string, args: string[], tree: string, limitMs?: number) => {
           const run = spawnSync(cmd, args, { cwd: tree, encoding: 'utf8', timeout: limitMs });
@@ -212,7 +215,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
     // Keep the self-gate contract: an unavailable remote leaves this release check unmeasured; do not start a heavy gate locally.
     tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
-    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
+    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.shardConcurrency !== undefined ? ['--shard-concurrency', String(opts.shardConcurrency)] : []), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
     flags: { remote: opts.local ? undefined : opts.remote ?? true, local: !!opts.local },
     runLocal,
   }, {

package/src/release-loop/merged-pr-checklist.ts

@@ -7,7 +7,7 @@ import { listChecklist, setItem } from './checklist.js';
 import { judgeLandedCell } from './landed-to-green.js';
 import { evidencePlan, landedButYellow, type MergedChecklistPr } from './landed-but-yellow.js';
 import { assignedVersions, evidenceAdd } from './feature-store.js';
-import { boundMergedTaskCells, candidateMergedTaskCells, closeMergedTaskCard } from '../task-agent/postland-card.js';
+import { boundMergedTaskCells, candidateMergedTaskCells, closeMergedTaskCard, recordMergedTaskImplFindings } from '../task-agent/postland-card.js';
 
 export interface MergedPrChecklistDeps {
   readPr?: (number: number, cwd: string) => { state: string; baseRefName: string; title: string; body: string | null; mergedAt: string; url?: string; headRefOid?: string; files?: Array<{ path: string }> };
@@ -19,13 +19,19 @@ export interface MergedPrChecklistDeps {
   closeTaskCard?: typeof closeMergedTaskCard;
   boundTaskCells?: typeof boundMergedTaskCells;
   candidateTaskCells?: typeof candidateMergedTaskCells;
+  feedbackStatePath?: string;
+  feedbackFollowUp?: NonNullable<Parameters<typeof recordMergedTaskImplFindings>[2]>['followUp'];
   log?: typeof debug.log;
 }
 
+function readMergedPr(number: number, cwd: string): NonNullable<MergedPrChecklistDeps['readPr']> extends (number: number, cwd: string) => infer T ? T : never {
+  return JSON.parse(execFileSync('gh', ['pr', 'view', String(number), '--json', 'state,baseRefName,title,body,mergedAt,url,headRefOid,files'], { cwd, encoding: 'utf8', timeout: 30_000 }));
+}
+
 /** A confirmed main merge is the only entry. The existing checklist matcher owns PR-to-cell decisions. */
 export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: string, deps: MergedPrChecklistDeps = {}): void {
   const log = deps.log ?? debug.log.bind(debug);
-  const pr = (deps.readPr ?? ((n, dir) => JSON.parse(execFileSync('gh', ['pr', 'view', String(n), '--json', 'state,baseRefName,title,body,mergedAt,url,headRefOid,files'], { cwd: dir, encoding: 'utf8', timeout: 30_000 })) as ReturnType<NonNullable<MergedPrChecklistDeps['readPr']>>))(number, cwd);
+  const pr = (deps.readPr ?? readMergedPr)(number, cwd);
   if (pr.state !== 'MERGED' || pr.baseRefName !== 'main') return;
   const merged: MergedChecklistPr = { number, title: pr.title, body: pr.body, mergedAt: pr.mergedAt };
   const versions = deps.versions?.() ?? (() => {
@@ -116,6 +122,23 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   for (const id of missing) log('release.checklist', 'merged-pr-cell-not-found', { pr: number, id });
 }
 
+/** Production merge entry: reconcile synchronously, then await idempotent PR-body feedback before returning. */
+export async function syncMergedPrChecklistWithFeedback(
+  number: number,
+  cwd: string,
+  goalFile?: string,
+  deps: MergedPrChecklistDeps = {},
+): Promise<Awaited<ReturnType<typeof recordMergedTaskImplFindings>>> {
+  const pr = (deps.readPr ?? readMergedPr)(number, cwd);
+  syncMergedPrChecklist(number, cwd, goalFile, { ...deps, readPr: () => pr });
+  if (pr.url && pr.headRefOid) {
+    return await recordMergedTaskImplFindings({ ...pr, number, url: pr.url, headRefOid: pr.headRefOid }, cwd,
+      { ...(deps.feedbackStatePath ? { statePath: deps.feedbackStatePath } : {}),
+        ...(deps.feedbackFollowUp ? { followUp: deps.feedbackFollowUp } : {}) });
+  }
+  return null;
+}
+
 const LABEL_IDS = '([A-Za-z0-9_-]+(?:[ \\t]*(?:,|·)[ \\t]*[A-Za-z0-9_-]+)*)';
 const LABEL_END = '(?=[ \\t]*$|[ \\t]+[—–·(-])';
 const DESIGNATION = new RegExp(`^ {0,3}(?:#{1,6}[ \\t]+|[-*][ \\t]+)?칸[ \\t]*:[ \\t]*${LABEL_IDS}${LABEL_END}`);

package/src/release-loop/rehearsal-shard-plan.ts

@@ -87,7 +87,12 @@ export function planRehearsalShards(version: string, root: string, checkout: str
   let gatePlanShards: number | null = null;
   try {
     const board = (deps.board ?? readGateShards)(gateShardsPath(version, root));
-    gatePlanShards = board?.version === version && board.shards.length && new Set(board.shards.map(shard => shard.id)).size === board.shards.length ? board.shards.length : null;
+    if (board?.version === version && board.shards.length
+      && new Set(board.shards.map(shard => shard.id)).size === board.shards.length) {
+      // Split/retry/tail rows are observations, not extra planned shards. Older boards used arbitrary IDs.
+      const roots = board.shards.filter(shard => /^pod-\d+$/.test(shard.id));
+      gatePlanShards = roots.length || (board.shards.some(shard => /^pod-\d+/.test(shard.id)) ? null : board.shards.length);
+    }
   } catch (error) { reasons.push(`persisted gate shard plan unreadable: ${error instanceof Error ? error.message : String(error)}`); }
   let testFiles: number | null = null;
   let measuredFiles = 0;

package/src/release-loop/rehearsal.ts

@@ -67,6 +67,15 @@ export function planRehearsal(schedules: readonly ReleaseSchedule[], now: Date,
   return { status: 'not-yet', version, cutAt, nextStepAt: new Date(cut - open[0]!.minutes * minute).toISOString() };
 }
 
+export interface RehearsalRecovery {
+  failedShard: string;
+  remeasuredFiles: number | null;
+  durationMs: number | null;
+  poolOverwriteApplied: boolean | null;
+  outcome: 'ok' | 'failed';
+  error?: string;
+}
+
 export interface RehearsalStamp {
   version: string;
   step: StepId;
@@ -79,6 +88,7 @@ export interface RehearsalStamp {
   regressionFiles?: string[];
   result?: LightRcResult;
   hardGate?: HardGateResult;
+  recovery?: RehearsalRecovery;
   hardGateRunId?: string;
   hardGateLog?: string;
   /** B6: an unmeasured hard gate always retains a cause, run id and durable local evidence path. */
@@ -94,6 +104,7 @@ export interface RehearsalOptions {
   apply?: boolean;
   checkout?: string;
   ledgerRoot?: string;
+  recoveryRun?: string;
   shards?: number;
   remote?: string;
 }
@@ -109,6 +120,7 @@ export interface RehearsalDeps {
   notify?: (text: string) => void | boolean | Promise<void | boolean>;
   git?: (args: string[], cwd: string) => { rc: number | null; stdout: string; stderr?: string };
   leakCheck?: (checkout: string) => { status: number | null; detail?: string };
+  resumeGate?: (runId: string, checkout: string) => Promise<{ files: number; durationMs: number; poolOverwriteApplied: boolean; ok: boolean }>;
 }
 
 export type RehearsalTickResult = RehearsalPlan & { applied?: boolean; stamps?: RehearsalStamp[]; notificationFailures?: number };
@@ -495,7 +507,7 @@ export async function runRehearsalTick(opts: RehearsalOptions = {}, deps: Rehear
               const introducedCount: number | null = stamp.outcome === 'unmeasured' || stamp.outcome === 'error' ? null : hard.introduced.length;
               const preexistingCount: number | null = introducedCount === null ? null : hard.preexisting;
               const totalFailures: number | null = introducedCount === null || preexistingCount === null ? null : introducedCount + preexistingCount;
-              stamp.summary = oneLine(`hard gate ${hard.outcome} · introduced ${introducedCount ?? 'UNKNOWN'} · preexisting ${preexistingCount ?? 'UNKNOWN'} · total failures ${totalFailures ?? 'UNKNOWN'} · node-b Pod · 12 shards · runId ${hardGateRunId} · evidence ${hardGateLog}${cause ? ` · ${cause}` : ''}`);
+              stamp.summary = oneLine(`hard gate ${hard.outcome} · introduced ${introducedCount ?? 'UNKNOWN'} · preexisting ${preexistingCount ?? 'UNKNOWN'} · total failures ${totalFailures ?? 'UNKNOWN'} · 원격 Pod · 12 shards · runId ${hardGateRunId} · evidence ${hardGateLog}${cause ? ` · ${cause}` : ''}`);
             } else {
             const shardPlan = opts.shards === undefined ? (deps.shardPlan ?? planRehearsalShards)(plan.version, root, checkout, { ...deps.shardPlanDeps, remoteGate: true }) : undefined;
             if (shardPlan) stamp.shardPlan = shardPlan;
@@ -520,6 +532,21 @@ export async function runRehearsalTick(opts: RehearsalOptions = {}, deps: Rehear
                 console.error(line);
               } }, { cwd })))(plan.version, checkout, selection);
             stamp.result = result;
+            if (opts.recoveryRun && result.unmeasured !== null) {
+              const failedShard = result.unmeasured;
+              const started = Date.now();
+              try {
+                const recovered = await deps.resumeGate?.(opts.recoveryRun, checkout);
+                if (!recovered) throw new Error('release resume --from gate is unavailable for this rehearsal');
+                stamp.recovery = { failedShard, remeasuredFiles: recovered.files, durationMs: recovered.durationMs,
+                  poolOverwriteApplied: recovered.poolOverwriteApplied, outcome: recovered.ok ? 'ok' : 'failed',
+                  ...(!recovered.ok ? { error: 'resumed gate did not pass' } : {}) };
+              } catch (error) {
+                stamp.recovery = { failedShard, remeasuredFiles: null, durationMs: Math.max(0, Date.now() - started),
+                  poolOverwriteApplied: null, outcome: 'failed',
+                  error: oneLine(error instanceof Error ? error.message : String(error)) };
+              }
+            }
             if (regressionFiles.length) stamp.regressionFiles = regressionFiles;
             const shardMismatch = selection.shards !== undefined && result.shards !== selection.shards
               ? `selected shards ${selection.shards} but RC reported ${result.shards}` : null;

package/src/repl/index.ts

@@ -198,6 +198,7 @@ function buildReplTools(): {
     specs.push(wakeup.spec);
     dispatchByName.set(wakeup.spec.name, wakeup.dispatch);
   }
+  (require('../tui/sidetab/nl-tool.js') as typeof import('../tui/sidetab/nl-tool.js')).registerNextSidetabReplTool(specs, dispatchByName, process as unknown as import('../tui/sidetab/nl-tool.js').NextSidetabIpcProcess);
   const planner = sr.createSearchPlannerState({ maxAutoNarrowCandidates: 2 });
   const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
     try {
@@ -342,6 +343,7 @@ async function runOneTurn(
   jsonOutput: boolean,
   nextTuiDelivery?: { pending: PendingTaskNotification[] },
   onJsonDelta?: (delta: string) => void,
+  onJsonStatus?: (line: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
@@ -374,6 +376,10 @@ async function runOneTurn(
     userText,
     systemPrompt,
     userImages: userImages.length > 0 ? userImages : undefined,
+    ...(process.env.ELANOUS_TEST_FAKE_LLM === '1' && Number.isFinite(Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS))
+      && Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS) > 0
+      ? { llmOpts: { streamIdleTimeoutMs: Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS) } }
+      : {}),
     onDelta: (d) => {
       if (jsonOutput) {
         replyChunks.push(d);
@@ -381,6 +387,7 @@ async function runOneTurn(
       }
       else process.stdout.write(d);
     },
+    onStatusLine: (line) => { onJsonStatus?.(line); },
     tools: replToolSpecs,
     dispatchTool: tools?.dispatch,
     onToolCall: (call) => {
@@ -785,6 +792,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
           process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
             ? (delta) => { process.stdout.write(`${JSON.stringify({ event: 'delta', turnId: turn.id, text: delta })}\n`); }
             : undefined,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'status', turnId: turn.id, text })}\n`); }
+            : undefined,
         );
       } catch (error) {
         if (!backgroundBridge) throw error;

package/src/research/axis-fanout.ts

@@ -0,0 +1,133 @@
+// Research-only native fanout. The caller supplies Bloom's question ladder;
+// each axis gets its own direct tool call and evidence stays attributed to it.
+import type { BloomResearchQuestion, ResearchEvidenceEnvelope } from '../auto-research/question-ladder-contract.js';
+import type { WebSearchHit } from '../web-search/provider.js';
+
+export interface AxisToolCallPlan {
+  questionId: string;
+  tool: 'OmniSearch';
+  query: string;
+}
+
+export interface AxisEvidenceGroup {
+  questionId: string;
+  evidence: ResearchEvidenceEnvelope[];
+  error?: string;
+}
+
+export interface AxisFanoutResult {
+  plan: AxisToolCallPlan[];
+  axes: AxisEvidenceGroup[];
+}
+
+export type AxisSearchHit = WebSearchHit & { engine?: string };
+export interface AxisSearchResult {
+  hits: AxisSearchHit[];
+  errors: string[];
+}
+export type AxisSearch = (query: string) => Promise<AxisSearchHit[] | AxisSearchResult>;
+
+export interface AxisFanoutDeps {
+  search?: AxisSearch;
+}
+
+/** Keep every query attached to the Bloom question that produced it. */
+export function planAxisToolCalls(questions: readonly BloomResearchQuestion[]): AxisToolCallPlan[] {
+  return questions.flatMap(question => question.searchTerms
+    .map(query => query.trim())
+    .filter(Boolean)
+    .map(query => ({ questionId: question.id, tool: 'OmniSearch' as const, query })));
+}
+
+async function directOmniSearch(query: string): Promise<AxisSearchResult> {
+  const { dispatchOmniSearch } = await import('../skills/tools/omni-search.js');
+  const hits: AxisSearchHit[] = [];
+  const result = await dispatchOmniSearch({ query }, { onSource: hit => { hits.push(hit); } });
+  if (Object.keys(result.metadata.perEngine).length === 0) {
+    throw new Error('no available web-search providers');
+  }
+  const errors = Object.entries(result.metadata.perEngine)
+    .flatMap(([engine, info]) => info.error ? [`${engine}: ${info.error}`] : []);
+  return { hits, errors };
+}
+
+function evidenceFromHit(question: BloomResearchQuestion, hit: AxisSearchHit): ResearchEvidenceEnvelope {
+  const published = hit.publishedAt;
+  const date = published !== undefined && Number.isFinite(published) && published > 0
+    ? new Date(published) : undefined;
+  const observedAt = date && Number.isFinite(date.getTime()) ? date.toISOString() : undefined;
+  return {
+    questionId: question.id,
+    sourceKind: hit.engine ? `web-search:${hit.engine}` : 'web-search',
+    source: hit.url,
+    ...(question.requestedWindow ? { requestedWindow: question.requestedWindow } : {}),
+    ...(observedAt ? { observedAt } : {}),
+    content: [hit.title, hit.snippet].filter(Boolean).join(' — '),
+    outcome: hit.snippet ? 'complete' : 'partial',
+    truncated: true, // Search snippets are excerpts, not the complete source page.
+  };
+}
+
+function failedEvidence(question: BloomResearchQuestion, query: string, message: string): ResearchEvidenceEnvelope {
+  return {
+    questionId: question.id,
+    sourceKind: 'search-query',
+    source: query,
+    ...(question.requestedWindow ? { requestedWindow: question.requestedWindow } : {}),
+    content: message,
+    outcome: 'failed',
+    truncated: false,
+  };
+}
+
+/** Invoke all axis queries concurrently, preserving ladder order and partial failures. */
+export async function fanOutAxisEvidence(
+  questions: readonly BloomResearchQuestion[],
+  deps: AxisFanoutDeps = {},
+): Promise<AxisFanoutResult> {
+  const plan = planAxisToolCalls(questions);
+  if (new Set(questions.map(question => question.id)).size !== questions.length) {
+    throw new Error('research axis question IDs must be unique');
+  }
+  const search = deps.search ?? directOmniSearch;
+  const settled = await Promise.allSettled(plan.map(call => search(call.query)));
+  const axes: AxisEvidenceGroup[] = questions.map(question => ({ questionId: question.id, evidence: [] }));
+  const groups = new Map(axes.map(axis => [axis.questionId, axis]));
+  const byQuestion = new Map(questions.map(question => [question.id, question]));
+  for (const question of questions) {
+    if (!plan.some(call => call.questionId === question.id)) {
+      const group = groups.get(question.id)!;
+      group.error = 'no search terms';
+      group.evidence.push(failedEvidence(question, question.prompt, group.error));
+    }
+  }
+  settled.forEach((outcome, index) => {
+    const call = plan[index]!;
+    const group = groups.get(call.questionId)!;
+    const question = byQuestion.get(call.questionId)!;
+    if (outcome.status === 'fulfilled') {
+      const response = Array.isArray(outcome.value) ? { hits: outcome.value, errors: [] } : outcome.value;
+      if (response.hits.length === 0 && response.errors.length === 0) {
+        group.evidence.push({ ...failedEvidence(question, call.query, 'no hits returned'), outcome: 'partial' });
+      }
+      for (const hit of response.hits) {
+        try {
+          group.evidence.push(evidenceFromHit(question, hit));
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          group.error = group.error ? `${group.error}; ${message}` : message;
+          group.evidence.push(failedEvidence(question, call.query, message));
+        }
+      }
+      for (const message of response.errors) {
+        group.error = group.error ? `${group.error}; ${message}` : message;
+        group.evidence.push(failedEvidence(question, call.query, message));
+      }
+    } else {
+      const message = outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason);
+      group.error = group.error ? `${group.error}; ${message}` : message;
+      group.evidence.push(failedEvidence(question, call.query, message));
+    }
+  });
+  return { plan, axes };
+}

package/src/research/edge-decision.ts

@@ -0,0 +1,197 @@
+import type { GraphNodeSpec } from '../self-implement/graph-yaml.js';
+
+/** Opaque Bloom 4/5 output. The hook owns the decision boundary, not analysis policy. */
+export interface BloomEdgeAssessment {
+  gaps: readonly unknown[];
+  contradictions: readonly unknown[];
+  verdicts: readonly unknown[];
+}
+
+export type ResearchEdgeAction = 'add' | 'prune' | 'deepen' | 'stop';
+
+export interface ResearchEdgeProposal {
+  node: GraphNodeSpec;
+  returnTo?: string;
+  reason: string;
+}
+
+export interface ResearchEdgeDecision {
+  action: ResearchEdgeAction;
+  reason: string;
+  evidence: readonly string[];
+  /** Ordinal-free, explicitly supplied strength on [0, 1]; never inferred from votes. */
+  evidenceStrength?: number;
+  /** Optional T3 record-only confidence; never changes the live edge decision. */
+  confidence?: number;
+  counterEvidenceRefs?: readonly string[];
+  outsideViewRefs?: readonly string[];
+  proposal?: ResearchEdgeProposal;
+}
+
+export interface ResolvedResearchEdgeDecision extends ResearchEdgeDecision {
+  provider: string;
+}
+
+/** T3 evidence is retained beside the current live decision, never applied to it. */
+export interface ResearchEdgeDecisionEnvelope extends ResolvedResearchEdgeDecision {
+  recommendation?: ResolvedResearchEdgeDecision;
+  votes: readonly ResolvedResearchEdgeDecision[];
+  dissent: readonly ResolvedResearchEdgeDecision[];
+  counterEvidenceRefs: readonly string[];
+  outsideViewRefs: readonly string[];
+  agreesWithLive?: boolean;
+  mode: 'record-only';
+}
+
+export type ResearchEdgeDecisionProvider = (
+  assessment: BloomEdgeAssessment,
+) => ResearchEdgeDecision | Promise<ResearchEdgeDecision>;
+
+export interface ResearchEdgeDecisionRegistry {
+  register(provider: ResearchEdgeDecisionProvider, name?: string, options?: { priority?: number }): () => void;
+  decide(assessment: BloomEdgeAssessment): Promise<ResearchEdgeDecisionEnvelope>;
+}
+
+const noOpDecision: ResearchEdgeDecision = {
+  action: 'stop',
+  reason: 'no edge decision provider registered',
+  evidence: [],
+};
+
+/** One registry belongs to one run. With no provider, the graph takes one round and stops. */
+export function createResearchEdgeDecisionRegistry(): ResearchEdgeDecisionRegistry {
+  const providers = new Map<symbol, { name: string; decide: ResearchEdgeDecisionProvider; priority?: number }>();
+  return {
+    register(provider, name = 'registered', options = {}) {
+      if (options.priority !== undefined && !Number.isFinite(options.priority)) {
+        throw new TypeError('research edge provider priority must be finite when supplied');
+      }
+      const key = Symbol('research-edge-decision-provider');
+      providers.set(key, { name, decide: provider, ...(options.priority === undefined ? {} : { priority: options.priority }) });
+      return () => { providers.delete(key); };
+    },
+    async decide(assessment) {
+      const entries = [...providers.values()];
+      if (!entries.length) return envelope({ ...noOpDecision, provider: 'default-noop' }, []);
+      const results = await Promise.all(entries.map(async (entry) => {
+        try {
+          const decision = await entry.decide(assessment);
+          return isResearchEdgeDecision(decision)
+            ? { entry, decision }
+            : { entry, error: 'returned an invalid decision' };
+        } catch (error) {
+          return { entry, error: `failed: ${String(error)}` };
+        }
+      }));
+      const valid = results.filter((result): result is { entry: typeof entries[number]; decision: ResearchEdgeDecision } => 'decision' in result);
+      const failures = results.filter((result): result is { entry: typeof entries[number]; error: string } => 'error' in result);
+      if (!valid.length) return envelope({ action: 'stop', reason: `all edge decision providers failed: ${failures.map(({ entry, error }) => `${entry.name} ${error}`).join('; ')}`, evidence: [], provider: 'composition' }, []);
+      if (valid.length === 1 && !failures.length) {
+        const [{ entry, decision }] = valid;
+        const live = { ...decision, evidence: [...decision.evidence], provider: entry.name };
+        return envelope(live, votes(valid));
+      }
+
+      // Agreement composes evidence. Disagreement is resolved by declared evidence strength,
+      // then explicit provider priority; an unresolved tie fails closed instead of voting.
+      const actions = new Set(valid.map(({ decision }) => decision.action));
+      const proposalKeys = new Set(valid.filter(({ decision }) => decision.action === 'add')
+        .map(({ decision }) => JSON.stringify(decision.proposal)));
+      const conflict = actions.size > 1 || proposalKeys.size > 1;
+      let candidates = valid;
+      if (conflict) {
+        const ranked = valid.map((result) => ({ ...result,
+          strength: result.decision.evidenceStrength ?? -1,
+        })).sort((a, b) => b.strength - a.strength);
+        const top = ranked[0]!;
+        const tiedStrength = ranked.filter((item) => item.strength === top.strength);
+        if (tiedStrength.length > 1 && tiedStrength.some((item) => item.entry.priority === undefined)) return envelope({
+          action: 'stop', reason: `unresolved edge decision conflict: ${tiedStrength.map(({ entry }) => entry.name).join(', ')} (priority unspecified)`,
+          evidence: [...new Set(valid.flatMap(({ decision }) => decision.evidence))], provider: 'composition',
+        }, votes(valid));
+        tiedStrength.sort((a, b) => (b.entry.priority ?? 0) - (a.entry.priority ?? 0));
+        const winner = tiedStrength[0]!;
+        const tied = tiedStrength.filter((item) => item.entry.priority === winner.entry.priority);
+        if (tied.length > 1) return envelope({
+          action: 'stop', reason: `unresolved edge decision conflict: ${tied.map(({ entry }) => entry.name).join(', ')}`,
+          evidence: [...new Set(valid.flatMap(({ decision }) => decision.evidence))], provider: 'composition',
+        }, votes(valid));
+        candidates = [winner];
+      }
+      const winner = candidates[0]!;
+      const evidence = [...new Set(valid.flatMap(({ decision }) => decision.evidence))];
+      const contributors = valid.map(({ entry }) => entry.name).join(', ');
+      const notes = failures.map(({ entry, error }) => `${entry.name} ${error}`);
+      const reason = conflict
+        ? `conflict resolved by ${winner.entry.name} (strength=${winner.decision.evidenceStrength ?? 'unspecified'}, priority=${winner.entry.priority ?? 'unspecified'}); ${winner.decision.reason}`
+        : `composed ${contributors}: ${winner.decision.reason}`;
+      const evidenceNote = evidence.length ? `; evidence=${evidence.join(' | ')}` : '';
+      const live = { ...winner.decision, reason: [...notes, `${reason}${evidenceNote}`].join('; '), evidence, provider: conflict ? winner.entry.name : `composition[${contributors}]` };
+      return envelope(live, votes(valid));
+    },
+  };
+}
+
+function isResearchEdgeDecision(value: unknown): value is ResearchEdgeDecision {
+  if (!isRecord(value) || !['add', 'prune', 'deepen', 'stop'].includes(String(value.action))
+    || typeof value.reason !== 'string' || !value.reason.trim()
+    || !Array.isArray(value.evidence) || !value.evidence.every((item) => typeof item === 'string')
+    || (value.evidenceStrength !== undefined && (typeof value.evidenceStrength !== 'number'
+      || !Number.isFinite(value.evidenceStrength) || value.evidenceStrength < 0 || value.evidenceStrength > 1))) {
+    return false;
+  }
+  if (value.action === 'add') return isResearchEdgeProposal(value.proposal);
+  return value.proposal === undefined;
+}
+
+function votes(valid: readonly { entry: { name: string }; decision: ResearchEdgeDecision }[]): ResolvedResearchEdgeDecision[] {
+  return valid.map(({ entry, decision }) => {
+    const confidence = typeof decision.confidence === 'number' && Number.isFinite(decision.confidence)
+      && decision.confidence >= 0 && decision.confidence <= 1 ? decision.confidence : undefined;
+    const counterEvidenceRefs = Array.isArray(decision.counterEvidenceRefs)
+      ? decision.counterEvidenceRefs.filter((item): item is string => typeof item === 'string') : [];
+    const outsideViewRefs = Array.isArray(decision.outsideViewRefs)
+      ? decision.outsideViewRefs.filter((item): item is string => typeof item === 'string') : [];
+    return {
+      ...decision,
+      ...(confidence === undefined ? { confidence: undefined } : { confidence }),
+      counterEvidenceRefs,
+      outsideViewRefs,
+      evidence: [...decision.evidence],
+      provider: entry.name,
+    };
+  });
+}
+
+function envelope(live: ResolvedResearchEdgeDecision, recordedVotes: readonly ResolvedResearchEdgeDecision[]): ResearchEdgeDecisionEnvelope {
+  const scored = recordedVotes.filter((vote) => vote.confidence !== undefined);
+  const strongest = scored.length ? Math.max(...scored.map((vote) => vote.confidence!)) : undefined;
+  const leaders = strongest === undefined ? [] : scored.filter((vote) => vote.confidence === strongest);
+  const leaderActions = new Set(leaders.map(({ action }) => action));
+  const leaderPayloads = new Set(leaders.map(({ action, proposal }) => JSON.stringify({ action, proposal })));
+  const recommendation = !leaders.length ? undefined
+    : leaderActions.size > 1 || leaderPayloads.size > 1
+      ? { action: 'stop' as const, reason: 'conflicting strongest evidence', evidence: [...new Set(leaders.flatMap(({ evidence }) => evidence))], confidence: strongest, provider: 'evidence-composer' }
+      : leaders[0];
+  const sameLive = (vote: ResolvedResearchEdgeDecision) => vote.action === live.action && JSON.stringify(vote.proposal) === JSON.stringify(live.proposal);
+  return {
+    ...live,
+    votes: [...recordedVotes],
+    dissent: recommendation ? recordedVotes.filter((vote) => vote.action !== recommendation.action || JSON.stringify(vote.proposal) !== JSON.stringify(recommendation.proposal)) : [],
+    counterEvidenceRefs: [...new Set(recordedVotes.flatMap((vote) => vote.counterEvidenceRefs ?? []))],
+    outsideViewRefs: [...new Set(recordedVotes.flatMap((vote) => vote.outsideViewRefs ?? []))],
+    ...(recommendation ? { recommendation, agreesWithLive: sameLive(recommendation) } : {}),
+    mode: 'record-only',
+  };
+}
+
+function isResearchEdgeProposal(value: unknown): value is ResearchEdgeProposal {
+  return isRecord(value) && isRecord(value.node) && typeof value.node.nodeId === 'string'
+    && typeof value.node.kind === 'string' && typeof value.node.recipe === 'string'
+    && typeof value.reason === 'string' && value.reason.trim().length > 0
+    && (value.returnTo === undefined || typeof value.returnTo === 'string');
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}