elanous 0.2.41 → 0.2.43

package/src/auto-research/research-turn.ts

@@ -1,9 +1,11 @@
 import { streamLLM } from '../llm.js';
 import { invokeResearchAxes } from '../research-bridge/index.js';
+import { RESEARCH_TURN_DEADLINE_STOP_ERROR } from '../core-turn/research-policy.js';
 import { invokeResearch } from '../research-bridge/invoke.js';
 import type { AxisFanoutResult } from '../research/axis-fanout.js';
 import { routeResearchOutput } from '../research/output-router.js';
-import { runGapFollowup } from '../research/gap-followup.js';
+import { planGapFollowup, runGapFollowup } from '../research/gap-followup.js';
+import type { ResearchGapFollowupInput, ResearchGapFollowupPlan } from '../research/gap-followup.js';
 import { debug, redactSecretText } from '../debug/log.js';
 import {
   buildWorkingBackwardsContractPrompt,
@@ -16,13 +18,19 @@ import { attachResearchEvidence, buildResearchQuestionLadderPrompt,
   type SixLevelResearchQuestionLadder } from './question-ladder-contract.js';
 
 export interface ResearchQuestionLadderRunOptions {
-  generateContract?: (prompt: string) => Promise<string>;
-  generate?: (prompt: string) => Promise<string>;
-  invokeAxes?: (questions: SixLevelResearchQuestionLadder['questions']) => Promise<AxisFanoutResult>;
+  signal?: AbortSignal;
+  admitToolCall?: (toolName: string) => boolean;
+  allowPartialOnAbort?: boolean;
+  allowOutputSkill?: boolean;
+  generateContract?: (prompt: string, signal?: AbortSignal) => Promise<string>;
+  generate?: (prompt: string, signal?: AbortSignal) => Promise<string>;
+  invokeAxes?: (questions: SixLevelResearchQuestionLadder['questions'], signal?: AbortSignal, admitToolCall?: (toolName: string) => boolean) => Promise<AxisFanoutResult>;
   routeOutput?: typeof routeResearchOutput;
-  invokeOutputSkill?: (skill: string, args: string) => Promise<{ ok: boolean; output: string; error?: string }>;
+  invokeOutputSkill?: (skill: string, args: string, signal?: AbortSignal) => Promise<{ ok: boolean; output: string; error?: string }>;
   /** Test seam for the bounded Bloom 4/5 evidence-gap follow-up. */
   gapFollowup?: typeof runGapFollowup;
+  /** Test seam for deciding whether production gap-follow-up has any runnable calls. */
+  planGapFollowup?: (input: ResearchGapFollowupInput) => ResearchGapFollowupPlan;
   /** Test/config seam for an explicitly installed private Bloom exemplar pack. */
   bloomExemplarPackPath?: string;
 }
@@ -33,6 +41,14 @@ export interface ResearchGroundingResult {
   error?: string;
 }
 
+function invokeProductionResearchAxes(
+  questions: SixLevelResearchQuestionLadder['questions'],
+  signal?: AbortSignal,
+  admitToolCall?: (toolName: string) => boolean,
+): Promise<AxisFanoutResult> {
+  return invokeResearchAxes(questions, { signal, admitToolCall });
+}
+
 export interface ResearchQuestionLadderRunResult {
   ok: boolean;
   ladder: SixLevelResearchQuestionLadder;
@@ -69,6 +85,15 @@ export interface WorkingBackwardsCompletionBoundary {
   complete: boolean;
 }
 
+function partialResearchOutput(request: string, ladder: SixLevelResearchQuestionLadder, note: string): string {
+  const evidence = ladder.evidence.map(item => `- [${item.outcome}] ${item.sourceKind} · ${item.source}: ${item.content}`);
+  return [
+    `# Partial research: ${request}`,
+    `Research stopped at its wall-clock limit (${note}). Synthesize only the evidence listed here and state remaining uncertainty.`,
+    ...(evidence.length ? ['', '## Evidence collected before stopping', ...evidence] : ['', 'No source evidence was collected before the deadline.']),
+  ].join('\n');
+}
+
 /**
  * Working Backwards 완료 경계 — 출력 계약(buildWorkingBackwardsContractPrompt → parse…Contract)의
  * 슬롯 중 채워지지 않은 칸을 찾고 각 칸을 채울 노드 계획을 낸다. questions 없이 부르면 모든 슬롯이
@@ -205,11 +230,23 @@ export async function runResearchQuestionLadder(
   const initial: SixLevelResearchQuestionLadder = { request, questions: [], evidence: [] };
   let contractRaw: string;
   try {
-    contractRaw = await (options.generateContract ?? ((prompt) => defaultGenerate(prompt, 'research-working-backwards-contract')))(
-      buildWorkingBackwardsContractPrompt(request),
+    contractRaw = await (options.generateContract ?? ((prompt, signal) => defaultGenerate(prompt, 'research-working-backwards-contract', signal)))(
+      buildWorkingBackwardsContractPrompt(request), options.signal,
     );
+    if (options.signal?.aborted) {
+      return options.allowPartialOnAbort
+        ? { ok: false, ladder: initial, output: partialResearchOutput(request, initial, 'before question generation'), error: RESEARCH_TURN_DEADLINE_STOP_ERROR }
+        : { ok: false, ladder: initial, output: '', error: 'research aborted' };
+    }
   } catch (error) {
     const reason = errorText(error);
+    if (options.signal?.aborted) {
+      return {
+        ok: false, ladder: initial,
+        output: options.allowPartialOnAbort ? partialResearchOutput(request, initial, 'output-contract generation') : '',
+        error: RESEARCH_TURN_DEADLINE_STOP_ERROR,
+      };
+    }
     debug.log('research.lens', 'working-backwards-contract-failed', { reason }, { level: 'warn' });
     return { ok: false, ladder: initial, output: '', error: `output contract generation failed: ${reason}` };
   }
@@ -242,16 +279,31 @@ export async function runResearchQuestionLadder(
     const sectionIds = outputContract.sections.map((section) => section.id);
     // Keep the premium exemplar bank outside the TUI's static import closure.
     const { getBloomExemplarContext } = await import('../research/bloom-exemplars.js');
+    const { buildResearchBloom45Directive } = await import('../core-turn/deep-turn-bloom.js');
+    const bloom45Directive = await buildResearchBloom45Directive();
     const exemplar = getBloomExemplarContext(request, options.bloomExemplarPackPath);
     debug.log('research.turn', 'bloom-exemplars-selected', {
       domain: exemplar.domain, domainSignal: exemplar.domainSignal,
       source: exemplar.source, count: exemplar.count, levels: exemplar.levels,
     });
-    raw = await (options.generate ?? ((prompt) => defaultGenerate(prompt, 'research-question-ladder')))(
-      `${buildResearchQuestionLadderPrompt(request, sectionIds)}\n\n${exemplar.context ? `${exemplar.context}\n\n` : ''}${ladderContext}${retroGroundingContext(request)}`,
+    raw = await (options.generate ?? ((prompt, signal) => defaultGenerate(prompt, 'research-question-ladder', signal)))(
+      `${buildResearchQuestionLadderPrompt(request, sectionIds)}\n\n${bloom45Directive}\n\n${exemplar.context ? `${exemplar.context}\n\n` : ''}${ladderContext}${retroGroundingContext(request)}`,
+      options.signal,
     );
+    if (options.signal?.aborted) {
+      return options.allowPartialOnAbort
+        ? { ok: false, ladder: initial, outputContract, output: partialResearchOutput(request, initial, 'before axis searches'), error: RESEARCH_TURN_DEADLINE_STOP_ERROR }
+        : { ok: false, ladder: initial, outputContract, output: '', error: 'research aborted' };
+    }
     debug.log('research.turn', 'bloom-generated', { questionCount: 6 });
   } catch (error) {
+    if (options.signal?.aborted) {
+      return {
+        ok: false, ladder: initial, outputContract,
+        output: options.allowPartialOnAbort ? partialResearchOutput(request, initial, 'question generation') : '',
+        error: RESEARCH_TURN_DEADLINE_STOP_ERROR,
+      };
+    }
     debug.log('research.turn', 'bloom-failed', { reason: errorText(error) }, { level: 'warn' });
     return { ok: false, ladder: initial, outputContract, output: '', error: `question generation failed: ${errorText(error)}` };
   }
@@ -273,10 +325,16 @@ export async function runResearchQuestionLadder(
 
   const ladder = parsed.value;
   debug.log('research.turn', 'bloom-ladder-validated', { questionCount: ladder.questions.length });
+  debug.log('research.turn', 'deep-bloom-applied', {
+    levels: [4, 5], trigger: 'research-intent',
+    stage: 'research-ladder',
+    questionCount: ladder.questions.filter((question) => question.level === 4 || question.level === 5).length,
+  });
   const observedAt = new Date().toISOString();
   let fanout: AxisFanoutResult;
   try {
-    fanout = await (options.invokeAxes ?? invokeResearchAxes)(ladder.questions);
+    fanout = await (options.invokeAxes ?? invokeProductionResearchAxes)(ladder.questions, options.signal, options.admitToolCall);
+    if (options.signal?.aborted && !options.allowPartialOnAbort) return { ok: false, ladder, outputContract, output: '', error: 'research aborted' };
     debug.log('research.turn', 'axis-evidence-collected', {
       axisCount: fanout.axes.length,
       evidenceCount: fanout.axes.reduce((count, axis) => count + axis.evidence.length, 0),
@@ -326,54 +384,128 @@ export async function runResearchQuestionLadder(
     debug.log('research.turn', 'completion-boundary-stop', {
       stage: 'axis-fanout', reason: 'every output-contract section slot is filled',
     });
+    debug.log('research.stop', 'stage', {
+      stage: 'axis-fanout', reason: 'completion-boundary-satisfied',
+      evidenceCount: ladder.evidence.length,
+    });
   }
-  if (!finalBoundary.complete) {
-    try {
-      const followup = await (options.gapFollowup ?? runGapFollowup)({
-        request,
-        questions: ladder.questions,
-        evidence: ladder.evidence,
-      });
-      const followupLines = [
-        '## Bounded research gap follow-up',
-        `Rounds: ${followup.rounds} · budget: ${followup.timeBudgetMs}ms`,
-        ...followup.classifications.map((item) => `- ${item.questionId} [${item.action}/${item.reason}]${item.skill ? ` · ${item.skill}` : ''}: ${item.gap}`),
-      ];
-      for (const envelope of followup.followupEvidence) {
-        const attached = attachResearchEvidence(ladder, envelope);
-        if (!attached.ok) {
-          evidenceRejected = true;
-          followupLines.push(`- Evidence rejected: ${attached.reason}`);
-          continue;
-        }
-        ladder.evidence = attached.value.evidence;
-        followupLines.push(`- [${envelope.outcome}] ${envelope.sourceKind} · ${envelope.source}: ${envelope.content}`);
+  if (!finalBoundary.complete && !options.signal?.aborted) {
+    const followupStartedAt = performance.now();
+    const followupInput: ResearchGapFollowupInput = {
+      request,
+      questions: ladder.questions,
+      evidence: ladder.evidence,
+      ...(options.signal ? { signal: options.signal } : {}),
+    };
+    let followupPlan: ResearchGapFollowupPlan | undefined;
+    if (options.planGapFollowup || !options.gapFollowup) {
+      try {
+        followupPlan = (options.planGapFollowup ?? planGapFollowup)(followupInput);
+        debug.log('research.turn', 'gap-followup-planned', {
+          rounds: followupPlan.rounds,
+          classifications: followupPlan.classifications.length,
+          calls: followupPlan.followups.length,
+          elapsedMs: Math.round((performance.now() - followupStartedAt) * 10) / 10,
+        });
+      } catch (error) {
+        debug.log('research.turn', 'gap-followup-plan-failed', {
+          reason: errorText(error),
+          elapsedMs: Math.round((performance.now() - followupStartedAt) * 10) / 10,
+        }, { level: 'warn' });
       }
-      for (const card of followup.discoveryCards ?? []) followupLines.push(card);
-      if (followup.classifications.length || followup.followupEvidence.length) sections.push(...followupLines);
-      debug.log('research.turn', 'gap-followup-completed', {
-        rounds: followup.rounds,
-        classifications: followup.classifications.length,
-        evidenceCount: followup.followupEvidence.length,
-        evidenceAttached: ladder.evidence.length,
+    }
+    if (followupPlan && followupPlan.followups.length === 0) {
+      if (followupPlan.classifications.length > 0) {
+        sections.push(
+          '## Bounded research gap follow-up',
+          `Rounds: ${followupPlan.rounds} · budget: ${followupPlan.timeBudgetMs}ms`,
+          ...followupPlan.classifications.map((item) => `- ${item.questionId} [${item.action}/${item.reason}]${item.skill ? ` · ${item.skill}` : ''}: ${item.gap}`),
+        );
+      }
+      debug.log('research.turn', 'gap-followup-skipped', {
+        reason: 'no-runnable-followup-calls',
+        classifications: followupPlan.classifications.length,
+        timeBudgetMs: followupPlan.timeBudgetMs,
+      });
+      debug.log('research.stop', 'stage', {
+        stage: 'gap-followup', reason: 'no-runnable-followup-calls',
+        classifications: followupPlan.classifications.length,
       });
-      finalBoundary = planWorkingBackwardsCompletion(outputContract, ladder.questions, ladder.evidence);
-      logCompletionBoundary('gap-followup', finalBoundary);
-      if (finalBoundary.complete) {
-        debug.log('research.turn', 'completion-boundary-stop', {
-          stage: 'gap-followup', reason: 'every output-contract section slot is filled',
+    } else {
+      const executionStartedAt = performance.now();
+      debug.log('research.turn', 'gap-followup-started', {
+        evidenceCount: ladder.evidence.length,
+        completeEvidenceCount: ladder.evidence.filter((item) => item.outcome === 'complete').length,
+      });
+      try {
+        const followup = await (options.gapFollowup ?? runGapFollowup)(followupInput);
+        const followupLines = [
+          '## Bounded research gap follow-up',
+          `Rounds: ${followup.rounds} · budget: ${followup.timeBudgetMs}ms`,
+          ...followup.classifications.map((item) => `- ${item.questionId} [${item.action}/${item.reason}]${item.skill ? ` · ${item.skill}` : ''}: ${item.gap}`),
+        ];
+        for (const envelope of followup.followupEvidence) {
+          const attached = attachResearchEvidence(ladder, envelope);
+          if (!attached.ok) {
+            evidenceRejected = true;
+            followupLines.push(`- Evidence rejected: ${attached.reason}`);
+            continue;
+          }
+          ladder.evidence = attached.value.evidence;
+          followupLines.push(`- [${envelope.outcome}] ${envelope.sourceKind} · ${envelope.source}: ${envelope.content}`);
+        }
+        for (const card of followup.discoveryCards ?? []) followupLines.push(card);
+        if (followup.classifications.length || followup.followupEvidence.length) sections.push(...followupLines);
+        debug.log('research.turn', 'gap-followup-completed', {
+          rounds: followup.rounds,
+          classifications: followup.classifications.length,
+          evidenceCount: followup.followupEvidence.length,
+          evidenceAttached: ladder.evidence.length,
+          elapsedMs: Math.round((performance.now() - executionStartedAt) * 10) / 10,
         });
+        finalBoundary = planWorkingBackwardsCompletion(outputContract, ladder.questions, ladder.evidence);
+        logCompletionBoundary('gap-followup', finalBoundary);
+        if (finalBoundary.complete) {
+          debug.log('research.turn', 'completion-boundary-stop', {
+            stage: 'gap-followup', reason: 'every output-contract section slot is filled',
+          });
+          debug.log('research.stop', 'stage', {
+            stage: 'gap-followup', reason: 'completion-boundary-satisfied',
+            evidenceCount: ladder.evidence.length,
+          });
+        }
+      } catch (error) {
+        debug.log('research.turn', 'gap-followup-failed', {
+          reason: errorText(error),
+          elapsedMs: Math.round((performance.now() - executionStartedAt) * 10) / 10,
+        }, { level: 'warn' });
       }
-    } catch (error) {
-      debug.log('research.turn', 'gap-followup-failed', { reason: errorText(error) }, { level: 'warn' });
     }
   }
+  if (options.signal?.aborted && !options.allowPartialOnAbort) return { ok: false, ladder, outputContract, output: '', error: 'research aborted' };
 
   const outputContractSectionIndex = sections.findIndex((section) => section.startsWith('## Output contract\n'));
   if (outputContractSectionIndex < 0) throw new Error('output contract section is missing from research output');
   sections.splice(outputContractSectionIndex + 1, 0,
     formatWorkingBackwardsSkeleton(outputContract, finalBoundary, evidenceRejected));
 
+  // The axis fanout is the last stage allowed to spend the research budget.
+  // Once it returns after an abort, keep whatever evidence it collected and
+  // return it directly; no post-deadline router/skill stage may discard it or
+  // attempt more model work with the already-aborted signal.
+  if (options.signal?.aborted && options.allowPartialOnAbort) {
+    const partialOutput = sections.join('\n\n');
+    saveRetroRecord(request, ladder, ladder.evidence);
+    debug.log('research.stop', 'stopped', {
+      reason: 'wall-clock-budget', stage: 'after-axis-evidence',
+      evidenceCount: ladder.evidence.length,
+    });
+    return {
+      ok: false, ladder, outputContract, output: partialOutput,
+      error: RESEARCH_TURN_DEADLINE_STOP_ERROR,
+    };
+  }
+
   const incompleteQuestions = ladder.questions.filter((question) =>
     !ladder.evidence.some((item) => item.questionId === question.id && item.outcome === 'complete')).length;
   const allOk = !evidenceRejected && incompleteQuestions === 0;
@@ -405,39 +537,64 @@ export async function runResearchQuestionLadder(
     fallbackReason: route?.fallbackReason ?? (route ? undefined : 'router-failed'),
   });
   let routedOutput = '';
-  if (route?.skillCallPlan) {
+  const hasCompleteEvidence = ladder.evidence.some((item) => item.outcome === 'complete');
+  if (route?.skillCallPlan && options.allowOutputSkill === false) {
+    debug.log('research.turn', 'output-skill-skipped', {
+      skill: route.skillCallPlan.skill,
+      reason: 'research turn tool allowlist excludes skill execution',
+      evidenceCount: ladder.evidence.length,
+    });
+  } else if (route?.skillCallPlan && !hasCompleteEvidence) {
+    debug.log('research.turn', 'output-skill-skipped', {
+      skill: route.skillCallPlan.skill,
+      reason: 'no-complete-evidence',
+      evidenceCount: ladder.evidence.length,
+    });
+  } else if (route?.skillCallPlan) {
+    const outputSkillStartedAt = performance.now();
+    debug.log('research.turn', 'output-skill-started', {
+      skill: route.skillCallPlan.skill,
+      evidenceCount: ladder.evidence.length,
+      completeEvidenceCount: ladder.evidence.filter((item) => item.outcome === 'complete').length,
+    });
     try {
       const formatted = await (options.invokeOutputSkill ?? defaultInvokeOutputSkill)(
-        route.skillCallPlan.skill, route.skillCallPlan.args,
+        route.skillCallPlan.skill, route.skillCallPlan.args, options.signal,
       );
       if (formatted.ok && formatted.output.trim()) {
         routedOutput = `\n\n## Routed ${route.format} output (${route.skillCallPlan.skill})\n\n${formatted.output.trim()}`;
-        debug.log('research.turn', 'output-skill-completed', { skill: route.skillCallPlan.skill, outputChars: formatted.output.length });
+        debug.log('research.turn', 'output-skill-completed', {
+          skill: route.skillCallPlan.skill,
+          outputChars: formatted.output.length,
+          elapsedMs: Math.round((performance.now() - outputSkillStartedAt) * 10) / 10,
+        });
       } else {
         debug.log('research.turn', 'output-skill-fallback', {
           skill: route.skillCallPlan.skill,
           reason: formatted.error ?? 'empty output',
+          elapsedMs: Math.round((performance.now() - outputSkillStartedAt) * 10) / 10,
         }, { level: 'warn' });
       }
     } catch (error) {
       debug.log('research.turn', 'output-skill-fallback', {
         skill: route.skillCallPlan.skill,
         reason: errorText(error),
+        elapsedMs: Math.round((performance.now() - outputSkillStartedAt) * 10) / 10,
       }, { level: 'warn' });
     }
   }
   saveRetroRecord(request, ladder, ladder.evidence);
   return {
-    ok: allOk,
+    ok: allOk && !options.signal?.aborted,
     ladder,
     outputContract,
     output: output + routedOutput,
-    ...(allOk ? {} : { error: `${incompleteQuestions} of ${ladder.questions.length} question searches were incomplete` }),
+    ...(!allOk || options.signal?.aborted ? { error: options.signal?.aborted ? RESEARCH_TURN_DEADLINE_STOP_ERROR : `${incompleteQuestions} of ${ladder.questions.length} question searches were incomplete` } : {}),
   };
 }
 
-async function defaultInvokeOutputSkill(skill: string, args: string) {
-  const result = await invokeResearch(args, { skill });
+async function defaultInvokeOutputSkill(skill: string, args: string, signal?: AbortSignal) {
+  const result = await invokeResearch(args, { skill, signal });
   return { ok: result.ok, output: result.output, ...(result.error ? { error: result.error } : {}) };
 }
 
@@ -451,10 +608,11 @@ export function researchTurnForGrounding(result: ResearchQuestionLadderRunResult
   };
 }
 
-async function defaultGenerate(prompt: string, usageSite: string): Promise<string> {
+async function defaultGenerate(prompt: string, usageSite: string, signal?: AbortSignal): Promise<string> {
   return streamLLM([{ role: 'user', content: prompt }], () => {}, {
     usageSite,
     usagePhase: 'research',
+    ...(signal ? { signal } : {}),
   });
 }
 

package/src/autopilot/pr-manager.ts

@@ -488,12 +488,15 @@ function editExistingPr(run: CmdRunner, input: UpsertPrInput, url: string): Upse
 /** Same-card rework may have a new run branch. Merge the bound PR head into that work,
  * then update the bound branch with a plain fast-forward push. Every identity read is
  * checked again after the inventory snapshot; an ambiguous or moved PR stays refused. */
-function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullable<GuardVerdict['sameCellReuse']>, recheck: () => GuardVerdict): UpsertPrOutcome {
+function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullable<GuardVerdict['sameCellReuse']>,
+  initialInventory: GuardVerdict, recheck: () => GuardVerdict): UpsertPrOutcome {
   const cwd = input.worktreePath;
   const pushEvidence = { ref: `refs/heads/${target.branch}`, remoteHead: target.headSha, cardId: target.cardId };
-  const fail = (detail: string): UpsertPrOutcome => {
+  const fail = (detail: string, inventoryEvidence?: { inventoryBefore: unknown; inventoryAfter: unknown; inventoryDiff: unknown }): UpsertPrOutcome => {
     const safeDetail = sanitizeCredentialText(detail).slice(0, 300);
-    debug.log('autopilot.pr-manager', 'same-cell-push-decision', { ...pushEvidence, outcome: 'refused', reason: safeDetail }, { level: 'warn' });
+    debug.log('autopilot.pr-manager', 'same-cell-push-decision', {
+      ...pushEvidence, outcome: 'refused', reason: safeDetail, ...inventoryEvidence,
+    }, { level: 'warn' });
     return { ok: false, reason: 'guard', detail: `same-cell reuse: ${safeDetail}` };
   };
   if (!/^[0-9a-f]{40}$/i.test(target.headSha) || !Number.isSafeInteger(target.number) || target.number < 1
@@ -545,10 +548,37 @@ function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullab
       return fail('PR changed before superseding draft');
     const newRef = `refs/heads/${input.branch}`;
     if (!run('git', ['-C', cwd, 'check-ref-format', '--branch', input.branch]).ok) return fail('new run branch name invalid');
-    const newRemote = run('git', ['-C', cwd, 'ls-remote', '--heads', 'origin', newRef]);
-    if (!newRemote.ok || newRemote.out.trim()) return fail('new run branch already exists or remote unreadable');
     const localHead = run('git', ['-C', cwd, 'rev-parse', 'HEAD']);
-    if (!localHead.ok || !/^[0-9a-f]{40}$/i.test(localHead.out.trim())) return fail('new run head unreadable');
+    const localHeadSha = localHead.out.trim();
+    if (!localHead.ok || !/^[0-9a-f]{40}$/i.test(localHeadSha)) return fail('new run head unreadable');
+    const newRemote = run('git', ['-C', cwd, 'ls-remote', '--heads', 'origin', newRef]);
+    if (!newRemote.ok) return fail('new run branch already exists or remote unreadable');
+    let retryBranchAlreadyExists = false;
+    if (newRemote.out.trim()) {
+      if (newRemote.out.trim() !== `${localHeadSha}\t${newRef}`) return fail('new run branch already exists or remote unreadable');
+      const existingDrafts = run('gh', ['pr', 'list', '--head', input.branch, '--state', 'open', '--json', 'url'], { cwd });
+      let existingRows: Array<{ url?: unknown }>;
+      try { existingRows = JSON.parse(existingDrafts.out) as Array<{ url?: unknown }>; }
+      catch { return fail('existing retry draft listing malformed'); }
+      if (!existingDrafts.ok) return fail('existing retry draft lookup failed');
+      if (!existingRows.length) retryBranchAlreadyExists = true;
+      else {
+        if (existingRows.length !== 1 || typeof existingRows[0]?.url !== 'string') return fail('existing retry draft lookup ambiguous');
+        const existingUrl = existingRows[0].url;
+        const existingView = run('gh', ['pr', 'view', existingUrl, '--json', 'state,isDraft,headRefOid,headRefName,body,url'], { cwd });
+        let existingFields: Record<string, unknown>;
+        try { existingFields = JSON.parse(existingView.out) as Record<string, unknown>; }
+        catch { return fail('existing retry draft identity malformed'); }
+        if (!existingView.ok || existingFields.state !== 'OPEN' || existingFields.isDraft !== true
+          || existingFields.headRefOid !== localHeadSha || existingFields.headRefName !== input.branch
+          || existingFields.url !== existingUrl || typeof existingFields.body !== 'string'
+          || cellIdFromBody(existingFields.body) !== cellIdFromBody(input.body)
+          || cardIdFromBody(existingFields.body) !== cardIdFromBody(input.body))
+          return fail('existing retry draft identity mismatch');
+        return { ok: true, url: existingUrl, reused: true };
+      }
+    }
+    if (!retryBranchAlreadyExists) {
     // Upload the commit through a unique scratch ref. GitHub's create-ref API then
     // atomically refuses a concurrent writer of the intended branch name.
     const runKey = input.runId ? runSuffixKey(input.runId) : null;
@@ -587,6 +617,7 @@ function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullab
       : { ok: false, out: '', err: 'repository identity unavailable' };
     reapScratchRef(createdRef.ok ? 'branch-created' : 'create-refused');
     if (!createdRef.ok) return fail(`new run branch create refused: ${(createdRef.err || createdRef.out).slice(0, 220)}`);
+    }
     const stateLabels = new Set(labelsForAxis('state').map(label => label.name));
     const labels = [...new Set([...(input.labels ?? []).filter(label => !stateLabels.has(label as typeof PR_LABEL_NAMES.running)),
       PR_LABEL_NAMES.running, ...(input.seat ? [`seat:${input.seat}`] : [])])];
@@ -617,11 +648,39 @@ function reuseSameCellPr(run: CmdRunner, input: UpsertPrInput, target: NonNullab
     || finalPr.url !== pr.url) return fail('PR changed before push');
   const finalRemote = run('git', ['-C', cwd, 'ls-remote', '--exit-code', 'origin', remoteRef]);
   if (!finalRemote.ok || finalRemote.out.trim() !== `${target.headSha}\t${remoteRef}`) return fail('remote head changed before push');
-  const latest = recheck().sameCellReuse;
+  const latestInventory = recheck();
+  const latest = latestInventory.sameCellReuse;
   if (!latest || latest.number !== target.number || latest.branch !== target.branch
     || latest.headSha !== target.headSha || latest.cellId !== target.cellId
-    || latest.cardId !== target.cardId || Boolean(latest.legacyBound) !== Boolean(target.legacyBound))
-    return fail('OPEN PR inventory changed before push');
+    || latest.cardId !== target.cardId || Boolean(latest.legacyBound) !== Boolean(target.legacyBound)) {
+    const snapshot = (verdict: GuardVerdict) => ({
+      conflicts: [...(verdict.sameCellConflicts ?? [])].map((row) => ({ pr: row.pr,
+        branch: row.branch === null ? null : sanitizeCredentialText(row.branch).slice(0, 180),
+        headSha: /^[0-9a-f]{40}$/i.test(row.headSha) ? row.headSha.toLowerCase() : 'invalid',
+        cardId: row.cardId === null ? null : sanitizeCredentialText(row.cardId).slice(0, 128), slice: row.slice ?? null,
+      })).sort((a, b) => a.pr - b.pr),
+      reusable: verdict.sameCellReuse ? { number: verdict.sameCellReuse.number,
+        branch: sanitizeCredentialText(verdict.sameCellReuse.branch).slice(0, 180),
+        headSha: /^[0-9a-f]{40}$/i.test(verdict.sameCellReuse.headSha) ? verdict.sameCellReuse.headSha.toLowerCase() : 'invalid',
+        cellId: sanitizeCredentialText(verdict.sameCellReuse.cellId).slice(0, 128),
+        cardId: sanitizeCredentialText(verdict.sameCellReuse.cardId).slice(0, 128),
+        legacyBound: Boolean(verdict.sameCellReuse.legacyBound) } : null,
+    });
+    const before = snapshot(initialInventory);
+    const after = snapshot(latestInventory);
+    const beforeByPr = new Map(before.conflicts.map((row) => [row.pr, row]));
+    const afterByPr = new Map(after.conflicts.map((row) => [row.pr, row]));
+    const inventoryDiff = {
+      added: after.conflicts.filter((row) => !beforeByPr.has(row.pr)),
+      removed: before.conflicts.filter((row) => !afterByPr.has(row.pr)),
+      changed: after.conflicts.flatMap((row) => {
+        const old = beforeByPr.get(row.pr);
+        return old && JSON.stringify(old) !== JSON.stringify(row) ? [{ pr: row.pr, before: old, after: row }] : [];
+      }),
+      reusableChanged: JSON.stringify(before.reusable) !== JSON.stringify(after.reusable),
+    };
+    return fail('OPEN PR inventory changed before push', { inventoryBefore: before, inventoryAfter: after, inventoryDiff });
+  }
   // The result descends from the exact fetched head. The explicit lease binds the
   // remote update to that head, so a delete or move between reads cannot be revived.
   // The Pod hook receives these values for this one push only. It checks the Pod card,
@@ -857,7 +916,7 @@ export function makePrManager(
       };
       const earlyVerdict = earlyGuard ? siblingSliceAllowed(earlyGuard) : undefined;
       const freshGuard = () => checkCreate!({ cwd, base: comparisonBase, seat: input.seat ?? seatFromEnvironment(), body: input.body }, run);
-      if (earlyVerdict?.sameCellReuse) return reuseSameCellPr(run, input, earlyVerdict.sameCellReuse, freshGuard);
+      if (earlyVerdict?.sameCellReuse) return reuseSameCellPr(run, input, earlyVerdict.sameCellReuse, earlyVerdict, freshGuard);
       if (earlyVerdict?.status === 'refuse') return { ok: false, reason: 'guard', detail: sameCellGuardDetail(earlyVerdict, candidateCardId) };
       const earlyInventoryUnknown = !!candidateCardId && (!checkCreate || (earlyVerdict?.status === 'unknown'
         && earlyVerdict.reasons.length === 1 && earlyVerdict.reasons[0]?.code === 'inventory-unknown'));

package/src/autopilot/pty-control-loop.ts

@@ -73,6 +73,8 @@ export interface ControlObservation {
   readonly subjectPtyId?: string;
   /** 이 판단이 속한 harness run. harness 밖 감독자는 생략한다. */
   readonly runId?: string;
+  /** Recent same-run chart cells pulled immediately before this supervision judgment. */
+  readonly runChart?: readonly { device: string; stopKey: string; observed: string; verdict: string; action: string; handoff: string | null; why: string }[];
   /** Last structured action that could not be performed; brain sees the reason next round. */
   readonly unavailableAction?: string;
 }

package/src/boot/daemon-tools/self-implement.ts

@@ -30,7 +30,7 @@ import { debug } from '../../debug/log.js';
 import { globalAgentRegistry, type AgentRegistry } from '../../agent/registry.js';
 import type { TaskNotificationQueue } from '../../agent/task-notification.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
-import { writeAuthoredGoal } from '../../self-implement/goal-author.js';
+import { resolveGoalAuthorReviewerPrecheckEnabled, writeAuthoredGoal } from '../../self-implement/goal-author.js';
 import { selfAnswerOrAssumeGoalDocumentClarifications, type GoalClarificationSelfResolver } from '../../self-implement/goal-author-clarification.js';
 import { writeGoalDocumentAtomic } from '../../self-implement/goal-document-write.js';
 import { DecisionLedger } from '../../decisions/decision-ledger.js';
@@ -220,6 +220,7 @@ type SelfImplementGoalAuthor = (ask: string, cwd: string, deps?: {
   goalTitle?: string;
   decomposeSteps?: (objective: string, opts?: { context?: string }) => Promise<readonly string[]>;
   onProgress?: (phase: import('../../self-implement/goal-author.js').GoalAuthorPhase, event: 'start' | 'end') => void;
+  reviewerPrecheckEnabled?: boolean;
 }) => Promise<{ path: string }>;
 
 const GOAL_ORIGINAL_TEXT_LIMIT = null;
@@ -328,6 +329,7 @@ export async function dispatchSelfImplement(
     const recentStepCounts = readRecentStepCountsFailOpen(recentStepCountReader);
     goalFile = (await authorGoal(goalSourceText, ctx.cwd, {
       goalTitle: feature,
+      reviewerPrecheckEnabled: resolveGoalAuthorReviewerPrecheckEnabled(),
       decomposeSteps: createDecomposeSteps(ctx.signal, {
         repositoryRoot: ctx.cwd,
         ...(adversarialReview !== undefined ? { adversarialReview } : {}),

package/src/boot/daemon-tools/web-search.ts

@@ -40,8 +40,7 @@ export function buildWebSearchTool(): LLMToolSpec {
   return {
     name: 'WebSearch',
     description:
-      'Search the public web via the daemon\'s configured provider (Grok / ' +
-      'Firecrawl / etc.). When no key is available, falls back to keyless DuckDuckGo. ' +
+      'Search the public web via Exa then Firecrawl; X/Twitter intent may use Grok. ' +
       'Returns a ranked list of URLs + titles + snippets. ' +
       'For fact questions, answer directly from the snippets and URLs; read the full body only when insufficient. ' +
       'Pair with a follow-up Read or external WebFetch when the model needs ' +