elanous 0.2.38 → 0.2.40

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 };
@@ -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/research/edge-decision.ts

@@ -19,6 +19,12 @@ 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;
 }
 
@@ -26,13 +32,24 @@ 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): () => void;
-  decide(assessment: BloomEdgeAssessment): Promise<ResolvedResearchEdgeDecision>;
+  register(provider: ResearchEdgeDecisionProvider, name?: string, options?: { priority?: number }): () => void;
+  decide(assessment: BloomEdgeAssessment): Promise<ResearchEdgeDecisionEnvelope>;
 }
 
 const noOpDecision: ResearchEdgeDecision = {
@@ -43,25 +60,74 @@ const noOpDecision: ResearchEdgeDecision = {
 
 /** 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 }>();
+  const providers = new Map<symbol, { name: string; decide: ResearchEdgeDecisionProvider; priority?: number }>();
   return {
-    register(provider, name = 'registered') {
+    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 });
+      providers.set(key, { name, decide: provider, ...(options.priority === undefined ? {} : { priority: options.priority }) });
       return () => { providers.delete(key); };
     },
     async decide(assessment) {
-      const provider = [...providers.values()].at(-1);
-      if (!provider) return { ...noOpDecision, provider: 'default-noop' };
-      try {
-        const decision = await provider.decide(assessment);
-        if (!isResearchEdgeDecision(decision)) {
-          return { action: 'stop', reason: 'edge decision provider returned an invalid decision', evidence: [], provider: provider.name };
+      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)}` };
         }
-        return { ...decision, evidence: [...decision.evidence], provider: provider.name };
-      } catch (error) {
-        return { action: 'stop', reason: `edge decision provider failed: ${String(error)}`, evidence: [], provider: provider.name };
+      }));
+      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));
     },
   };
 }
@@ -69,13 +135,56 @@ export function createResearchEdgeDecisionRegistry(): ResearchEdgeDecisionRegist
 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')) {
+    || !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'

package/src/research/gap-followup.ts

@@ -0,0 +1,249 @@
+import type { BloomResearchQuestion, ResearchEvidenceEnvelope } from '../auto-research/question-ladder-contract.js';
+import { invokeResearch } from '../research-bridge/invoke.js';
+import type { SkillIndexEntry } from '../skills/index.js';
+import { getSkillIndex } from '../skills/index.js';
+import { detectSkillTrigger } from '../skills/router.js';
+import { discoverResearchPlugin, rerunInstalledPluginResearch } from './plugin-discovery.js';
+import { debug } from '../debug/log.js';
+
+export const MAX_GAP_FOLLOWUP_ROUNDS = 1;
+export const MAX_GAP_FOLLOWUP_MS = 120_000;
+/** Default research-only skills permitted to auto-fill one evidence gap. */
+export const READ_ONLY_AUTO_FOLLOWUP_SKILLS: ReadonlySet<string> = new Set([
+  'omni-market', 'kr-flow', 'omni-crawl', 'social-pulse', 'omni-digest',
+]);
+const MAX_GAP_TEXT = 8_000;
+
+export interface ResearchGapFollowupInput {
+  request: string;
+  questions: readonly BloomResearchQuestion[];
+  evidence: readonly ResearchEvidenceEnvelope[];
+  /** Optional remaining time supplied by the owning turn; omitted uses the fixed 2-minute cap. */
+  remainingBudgetMs?: number;
+  roundsUsed?: number;
+  /** Test seam; production resolves the installed registry. */
+  skills?: readonly SkillIndexEntry[];
+  /** Production can widen/narrow the built-in read-only skill set. */
+  readOnlySkillAllowlist?: ReadonlySet<string>;
+}
+
+export type ResearchGapAction = 'auto-fill' | 'followup';
+export type ResearchGapReason =
+  | 'auto-fill-eligible'
+  | 'round-limit'
+  | 'time-budget'
+  | 'no-skill-match'
+  | 'ambiguous-skill-match'
+  | 'skill-not-read-only'
+  | 'skill-not-allowlisted';
+
+export interface ResearchGapClassification {
+  questionId: string;
+  gap: string;
+  action: ResearchGapAction;
+  reason: ResearchGapReason;
+  skill?: string;
+}
+
+export interface ResearchGapFollowupCall {
+  questionId: string;
+  skill: string;
+  query: string;
+}
+
+export interface ResearchGapFollowupPlan {
+  /** Zero or one. The bound is part of the public contract. */
+  rounds: 0 | 1;
+  timeBudgetMs: number;
+  classifications: ResearchGapClassification[];
+  followups: ResearchGapFollowupCall[];
+}
+
+export interface ResearchGapFollowupResult extends ResearchGapFollowupPlan {
+  followupEvidence: ResearchEvidenceEnvelope[];
+  discoveryCards?: string[];
+}
+
+export interface ResearchGapFollowupDeps {
+  runSkill?: (skill: string, query: string, signal: AbortSignal) => Promise<{ ok: boolean; output: string; error?: string }>;
+  discoverPlugin?: typeof discoverResearchPlugin;
+  rerunInstalled?: typeof rerunInstalledPluginResearch;
+  now?: () => number;
+}
+
+/**
+ * Use Bloom analyze/evaluate axes (4/5) to find explicit evidence gaps,
+ * match those gaps against the installed skill registry, and auto-fill only from
+ * the OP-approved research allowlist. Only explicit read-only declarations
+ * are auto-run; missing, write, or spawn declarations remain ask-first
+ * follow-ups. Cost metadata is not a gate.
+ */
+export function planGapFollowup(input: ResearchGapFollowupInput): ResearchGapFollowupPlan {
+  const timeBudgetMs = Math.max(0, Math.min(MAX_GAP_FOLLOWUP_MS,
+    input.remainingBudgetMs === undefined ? MAX_GAP_FOLLOWUP_MS
+      : Number.isFinite(input.remainingBudgetMs) ? input.remainingBudgetMs : 0));
+  const allowlist = input.readOnlySkillAllowlist ?? READ_ONLY_AUTO_FOLLOWUP_SKILLS;
+  const skillIndex = [...(input.skills ?? getSkillIndex())];
+  const questions = new Map(input.questions.map((question) => [question.id, question]));
+  const gaps = findResearchGaps(input.questions, input.evidence);
+  const classifications: ResearchGapClassification[] = [];
+  const followups: ResearchGapFollowupCall[] = [];
+  const roundAvailable = (input.roundsUsed ?? 0) < MAX_GAP_FOLLOWUP_ROUNDS;
+
+  for (const gap of gaps) {
+    const question = questions.get(gap.questionId);
+    const routeText = [question?.prompt, gap.text].filter(Boolean).join('\n');
+    const query = [input.request, question?.prompt, gap.text].filter(Boolean).join('\n');
+    const match = detectSkillTrigger(routeText, skillIndex, { minScore: 1 });
+    const top = match.top;
+    const matchedSkill = top ? skillIndex.find((skill) => skill.name === top.name) : undefined;
+    let reason: ResearchGapReason;
+    if (!roundAvailable) reason = 'round-limit';
+    else if (timeBudgetMs <= 0) reason = 'time-budget';
+    else if (!top || top.matchedTriggers.length === 0) reason = 'no-skill-match';
+    else if (!match.unambiguous) reason = 'ambiguous-skill-match';
+    else if (matchedSkill?.sideEffects !== 'none') reason = 'skill-not-read-only';
+    else if (!allowlist.has(top.name)) reason = 'skill-not-allowlisted';
+    else reason = 'auto-fill-eligible';
+
+    if (reason === 'auto-fill-eligible' && top) {
+      followups.push({ questionId: gap.questionId, skill: top.name, query });
+      classifications.push({ questionId: gap.questionId, gap: gap.text, action: 'auto-fill', reason, skill: top.name });
+    } else {
+      classifications.push({ questionId: gap.questionId, gap: gap.text, action: 'followup', reason, ...(top ? { skill: top.name } : {}) });
+    }
+  }
+
+  return {
+    rounds: followups.length > 0 ? 1 : 0,
+    timeBudgetMs,
+    classifications,
+    followups,
+  };
+}
+
+/** Execute all eligible axes as one bounded round; timeout aborts each skill invocation. */
+export async function runGapFollowup(
+  input: ResearchGapFollowupInput,
+  deps: ResearchGapFollowupDeps = {},
+): Promise<ResearchGapFollowupResult> {
+  const plan = planGapFollowup(input);
+  const startedAt = (deps.now ?? Date.now)();
+  const deadline = startedAt + plan.timeBudgetMs;
+  const discover = async (failedQuestions: ReadonlySet<string>): Promise<{ cards: string[]; evidence: ResearchEvidenceEnvelope[] }> => {
+    const gaps = plan.classifications.filter(item => item.reason === 'no-skill-match'
+      || (item.reason === 'auto-fill-eligible' && failedQuestions.has(item.questionId)));
+    const cards: string[] = [];
+    const evidence: ResearchEvidenceEnvelope[] = [];
+    for (const gap of gaps.slice(0, 2)) {
+      const remainingMs = deadline - (deps.now ?? Date.now)();
+      if (remainingMs <= 0) break;
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(new Error('plugin discovery time budget exhausted')),
+        Math.min(10_000, remainingMs));
+      try {
+        const result = await (deps.discoverPlugin ?? discoverResearchPlugin)(gap.gap, { signal: controller.signal });
+        cards.push(result.card);
+        if (result.installed && !controller.signal.aborted && deadline > (deps.now ?? Date.now)()) {
+          const rerun = await (deps.rerunInstalled ?? rerunInstalledPluginResearch)(gap.gap, result.installed, controller.signal);
+          const output = Array.from(rerun.output).slice(0, MAX_GAP_TEXT).join('');
+          evidence.push({ questionId: gap.questionId, sourceKind: `plugin:${result.installed.name}`,
+            source: result.installed.name, observedAt: new Date((deps.now ?? Date.now)()).toISOString(),
+            content: output || rerun.error || 'installed plugin returned no research output',
+            outcome: rerun.ok && output ? 'complete' : 'failed',
+            truncated: Array.from(rerun.output).length > MAX_GAP_TEXT });
+        }
+      } catch (error) {
+        debug.log('research.plugin-discovery', 'followup-unavailable', {
+          questionId: gap.questionId, reason: error instanceof Error ? error.message.slice(0, 160) : String(error).slice(0, 160),
+        }, { level: 'warn' });
+      }
+      finally { clearTimeout(timer); }
+    }
+    return { cards, evidence };
+  };
+  if (plan.followups.length === 0) {
+    const discovered = await discover(new Set());
+    return { ...plan, followupEvidence: discovered.evidence, discoveryCards: discovered.cards };
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(new Error('research gap follow-up time budget exhausted')),
+    Math.max(1, deadline - (deps.now ?? Date.now)()));
+  try {
+    const outcomes = await Promise.all(plan.followups.map(async (call): Promise<ResearchEvidenceEnvelope> => {
+      try {
+        const result = await (deps.runSkill ?? defaultRunSkill)(call.skill, call.query, controller.signal);
+        const output = Array.from(result.output).slice(0, MAX_GAP_TEXT).join('');
+        return {
+          questionId: call.questionId,
+          sourceKind: `skill:${call.skill}`,
+          source: call.skill,
+          observedAt: new Date((deps.now ?? Date.now)()).toISOString(),
+          content: output || result.error || 'skill returned no research output',
+          outcome: result.ok && output ? 'complete' : 'failed',
+          truncated: Array.from(result.output).length > MAX_GAP_TEXT,
+        };
+      } catch (error) {
+        return {
+          questionId: call.questionId,
+          sourceKind: `skill:${call.skill}`,
+          source: call.skill,
+          observedAt: new Date((deps.now ?? Date.now)()).toISOString(),
+          content: controller.signal.aborted ? 'follow-up exceeded its time budget' : errorText(error),
+          outcome: 'failed',
+          truncated: false,
+        };
+      }
+    }));
+    const discovered = await discover(new Set(outcomes.filter(item => item.outcome !== 'complete').map(item => item.questionId)));
+    return { ...plan, followupEvidence: [...outcomes, ...discovered.evidence], discoveryCards: discovered.cards };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function findResearchGaps(
+  questions: readonly BloomResearchQuestion[],
+  evidence: readonly ResearchEvidenceEnvelope[],
+): Array<{ questionId: string; text: string }> {
+  const byQuestion = new Map<string, ResearchEvidenceEnvelope[]>();
+  for (const item of evidence) byQuestion.set(item.questionId, [...(byQuestion.get(item.questionId) ?? []), item]);
+  const gaps: Array<{ questionId: string; text: string }> = [];
+  const seen = new Set<string>();
+  for (const question of questions) {
+    if (question.level !== 4 && question.level !== 5) continue;
+    const items = byQuestion.get(question.id) ?? [];
+    const questionGaps = new Set<string>();
+    if (items.length === 0) questionGaps.add(question.prompt);
+    for (const item of items) {
+      const sentences = item.content.split(/(?<=[.!?。！？])\s+|\n+/).map((sentence) => sentence.trim()).filter(Boolean);
+      const matches = sentences.filter(isExplicitGap);
+      const candidates = matches.length ? matches : item.outcome === 'complete' ? [] : [item.content.trim() || question.prompt];
+      for (const text of candidates) {
+        const normalized = text.toLowerCase();
+        if (text && !seen.has(`${question.id}\0${normalized}`)) {
+          seen.add(`${question.id}\0${normalized}`);
+          questionGaps.add(text);
+        }
+      }
+    }
+    if (questionGaps.size > 0) {
+      gaps.push({ questionId: question.id, text: Array.from([...questionGaps].join(' ')).slice(0, MAX_GAP_TEXT).join('') });
+    }
+  }
+  return gaps;
+}
+
+function isExplicitGap(text: string): boolean {
+  return /\b(?:unavailable|not available|missing|not found|no data|no evidence|unknown|unverified|could not find|failed to find|not provided|blank|empty|not covered)\b|\bno\b.{0,80}\b(?:data|evidence|records|series)\b.{0,80}\b(?:found|available|verified)\b|(?:미확인|확인되지 않|자료가 없|데이터가 없|자료 부족|데이터 부족|빈값|값이 비|시계열.{0,20}없|공백|찾지 못|미제공|미수집|검증되지 않|수급 미확인)/i.test(text);
+}
+
+async function defaultRunSkill(skill: string, query: string, signal: AbortSignal): Promise<{ ok: boolean; output: string; error?: string }> {
+  const result = await invokeResearch(query, { skill, signal });
+  return { ok: result.ok, output: result.output, ...(result.error ? { error: result.error } : {}) };
+}
+
+function errorText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}