elanous 0.2.40 → 0.2.42

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

@@ -3,7 +3,8 @@ import { invokeResearchAxes } from '../research-bridge/index.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 +17,18 @@ 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;
+  generateContract?: (prompt: string, signal?: AbortSignal) => Promise<string>;
+  generate?: (prompt: string, signal?: AbortSignal) => Promise<string>;
+  invokeAxes?: (questions: SixLevelResearchQuestionLadder['questions'], signal?: AbortSignal) => 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;
 }
 
 export interface ResearchGroundingResult {
@@ -203,9 +209,10 @@ 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 { ok: false, ladder: initial, output: '', error: 'research aborted' };
   } catch (error) {
     const reason = errorText(error);
     debug.log('research.lens', 'working-backwards-contract-failed', { reason }, { level: 'warn' });
@@ -238,9 +245,18 @@ export async function runResearchQuestionLadder(
   let raw: string;
   try {
     const sectionIds = outputContract.sections.map((section) => section.id);
-    raw = await (options.generate ?? ((prompt) => defaultGenerate(prompt, 'research-question-ladder')))(
-      `${buildResearchQuestionLadderPrompt(request, sectionIds)}\n\n${ladderContext}${retroGroundingContext(request)}`,
+    // Keep the premium exemplar bank outside the TUI's static import closure.
+    const { getBloomExemplarContext } = await import('../research/bloom-exemplars.js');
+    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, signal) => defaultGenerate(prompt, 'research-question-ladder', signal)))(
+      `${buildResearchQuestionLadderPrompt(request, sectionIds)}\n\n${exemplar.context ? `${exemplar.context}\n\n` : ''}${ladderContext}${retroGroundingContext(request)}`,
+      options.signal,
     );
+    if (options.signal?.aborted) return { ok: false, ladder: initial, outputContract, output: '', error: 'research aborted' };
     debug.log('research.turn', 'bloom-generated', { questionCount: 6 });
   } catch (error) {
     debug.log('research.turn', 'bloom-failed', { reason: errorText(error) }, { level: 'warn' });
@@ -267,7 +283,8 @@ export async function runResearchQuestionLadder(
   const observedAt = new Date().toISOString();
   let fanout: AxisFanoutResult;
   try {
-    fanout = await (options.invokeAxes ?? invokeResearchAxes)(ladder.questions);
+    fanout = await (options.invokeAxes ?? ((questions, signal) => invokeResearchAxes(questions, { signal })))(ladder.questions, options.signal);
+    if (options.signal?.aborted) 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),
@@ -318,47 +335,92 @@ export async function runResearchQuestionLadder(
       stage: 'axis-fanout', reason: 'every output-contract section slot is filled',
     });
   }
-  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' });
+      }
+    }
+    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}`),
+        );
       }
-      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,
+      debug.log('research.turn', 'gap-followup-skipped', {
+        reason: 'no-runnable-followup-calls',
+        classifications: followupPlan.classifications.length,
+        timeBudgetMs: followupPlan.timeBudgetMs,
       });
-      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',
+          });
+        }
+      } 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) 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');
@@ -396,24 +458,43 @@ 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 && !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' });
     }
   }
@@ -427,8 +508,8 @@ export async function runResearchQuestionLadder(
   };
 }
 
-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 } : {}) };
 }
 
@@ -442,10 +523,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/discovery/wiki-claim-proposer.ts

@@ -2,7 +2,8 @@
 //
 // 구 핸드오프의 생존 지식을 **문서 전체 요약이 아닌 claim 단위**로 추출해, 기존 하이브리드 검색으로
 // 대상 WIKI-* living 페이지를 골라 doc-curate 큐에 제안한다. 핵심 규율(미션 불변식):
-//   · 각 claim proposal 에 원문 구절·출처 경로·마지막 검증 시점(provenance) 필수.
+//   · 각 claim proposal 에 원문 구절·출처 경로·마지막 검증 시점(provenance) 필수 — 하나라도 없으면
+//     제안이 성립하지 않는다(rejected 관측): 어떤 페이지에도 자동 쓰기·고치기·링크 제안을 남기지 않는다.
 //   · 기존 claim 과 충돌하면 **덮어쓰지 않고** 병렬 근거 + contradiction 플래그(비파괴).
 //   · 출력은 doc-curate CurationProposal(큐) 로만 — 자동 이동·병합·archive 없음(HITL 승인 게이트).
 //   · 깨진 판정을 LLM 에 안 맡김(결정론 추출·검색/충돌만 주입). 새 큐/파서 안 만들고 재사용.
@@ -49,6 +50,7 @@ export function extractClaims(text: string, sourcePath: string, nowDate: string)
 }
 
 const WIKI_CLAIM_DISCARD_REASON = 'no-matching-wiki-page' as const;
+const WIKI_CLAIM_REJECT_REASON = 'missing-provenance' as const;
 
 export interface WikiClaimStatistics {
   receivedClaims: number;
@@ -58,6 +60,12 @@ export interface WikiClaimStatistics {
     reason: typeof WIKI_CLAIM_DISCARD_REASON;
     sourcePaths: string[];
   };
+  /** 가산 관측(근거 필수 불변식 시행) — provenance 없어 명시적 거부된 claim. 0건이면 기존 계약 보존을 위해 필드를 싣지 않는다. */
+  rejected?: {
+    reason: typeof WIKI_CLAIM_REJECT_REASON;
+    claims: number;
+    sourcePaths: string[];
+  };
 }
 
 export type WikiClaimItems = CurationItem[] & { statistics: WikiClaimStatistics };
@@ -85,12 +93,22 @@ export function defaultDetectConflict(claim: Claim, existing: string): boolean {
   return hit >= 2 && neg;
 }
 
+/** 근거(provenance 3요소 — 원문 구절·출처 경로·마지막 검증 시점)가 온전한가. 하나라도 비면 제안이 성립하지 않는다. */
+function hasCompleteProvenance(claim: Claim): boolean {
+  return claim.sourceQuote.trim() !== '' && claim.sourcePath.trim() !== '' && claim.lastVerified.trim() !== '';
+}
+
 /** claim → CurationItem (add/update · provenance · 충돌 시 contradiction 플래그·비파괴 diff). 순수+주입. */
 export function proposeWikiClaimItems(claims: readonly Claim[], deps: WikiClaimDeps): WikiClaimItems {
   const detect = deps.detectConflict ?? defaultDetectConflict;
   const items = [] as unknown as WikiClaimItems;
   const discardedSourcePaths: string[] = [];
+  const rejectedSourcePaths: string[] = [];
   for (const c of claims) {
+    if (!hasCompleteProvenance(c)) {
+      rejectedSourcePaths.push(c.sourcePath);
+      continue; // 근거 필수 불변식 — provenance 없는 claim 은 쓰기·고치기·링크 제안으로 성립하지 않는다.
+    }
     const page = deps.findWikiPage(c);
     if (!page) {
       discardedSourcePaths.push(c.sourcePath);
@@ -121,6 +139,9 @@ export function proposeWikiClaimItems(claims: readonly Claim[], deps: WikiClaimD
     proposedItems: items.length,
     discardedClaims: discardedSourcePaths.length,
     discarded: { reason: WIKI_CLAIM_DISCARD_REASON, sourcePaths: discardedSourcePaths },
+    ...(rejectedSourcePaths.length > 0
+      ? { rejected: { reason: WIKI_CLAIM_REJECT_REASON, claims: rejectedSourcePaths.length, sourcePaths: rejectedSourcePaths } }
+      : {}),
   };
   Object.defineProperty(items, 'statistics', { value: statistics, enumerable: false });
   try {

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
@@ -617,11 +620,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 +888,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

@@ -13,9 +13,9 @@
 //   - onProgress ← ux.progress (각 스테이지 진행을 서피스로).
 //   - 큰 gate log → ux.spillFile (파일 첨부).
 
-import { basename, join } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
-import { existsSync, linkSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, linkSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import type { LLMToolSpec } from '../../llm.js';
 import { childLifetimeSignal } from '../../turn-abort-scope.js';
 import { buildSelfImplementSpec } from '../../self-implement/self-implement-runtime.js';
@@ -48,7 +48,13 @@ export function resolveDispatchEntry(ctx: DaemonToolDispatchCtx): import('../../
 
 /** 데몬 서피스용 스펙 — 내부 툴과 단일 출처(buildSelfImplementSpec) 공유. */
 export function buildSelfImplementDaemonSpec(): LLMToolSpec {
-  return buildSelfImplementSpec();
+  const spec = buildSelfImplementSpec();
+  const properties = spec.parameters.properties as Record<string, Record<string, unknown>>;
+  properties.goalFile = {
+    type: 'string',
+    description: '기존 SelfImplement 골 문서를 재개할 때만 지정한다. 문서에 결정을 반영한 뒤 같은 골을 다시 실행하며, 저장소 내부 GOAL-* 문서 경로만 허용된다.',
+  };
+  return spec;
 }
 
 // ⭐ 판정은 `../../self-implement/observe-only.js` **한 자리**가 한다 — 이 스위치를 타는 경로가
@@ -90,7 +96,7 @@ const END_STAGES: readonly SelfImplementProgressStage[] = ['pr-opened', 'aborted
 export type SelfImplementLaunchedToolResult = SelfImplementResult & { runId: string; kind: 'launched'; message: string; next: string; missing: string[] };
 export type SelfImplementPendingToolResult = Partial<SelfImplementResult> & { kind: 'pending'; message: string; next: string; missing: string[] };
 export type SelfImplementObservedOnlyToolResult = { kind: 'observed-only'; observed: true; message: string; next: string; missing: ['runId', 'node'] };
-export type SelfImplementFailedToolResult = Partial<SelfImplementResult> & { kind: 'failed'; reason: string; message: string; next: string; missing: string[] };
+export type SelfImplementFailedToolResult = Partial<SelfImplementResult> & { kind: 'failed'; reason: string; message: string; next: string; missing: string[]; goalFile?: string };
 export type SelfImplementToolResult = SelfImplementLaunchedToolResult | SelfImplementPendingToolResult | SelfImplementObservedOnlyToolResult | SelfImplementFailedToolResult;
 
 /** 하니스가 런을 맡았다 — 파일 편집은 하니스 몫이므로 모델의 직접 Write/Edit 을 문면으로 막는다. */
@@ -220,6 +226,7 @@ const GOAL_ORIGINAL_TEXT_LIMIT = null;
 
 type GoalAuthorSummary = {
   authored: boolean;
+  reused: boolean;
   goalFile: string | null;
   userTextState: 'absent' | 'empty' | 'present';
   originalChars: number | null;
@@ -231,10 +238,23 @@ type GoalAuthorSummary = {
 function emitGoalAuthorSummary(ux: SurfaceUx, summary: GoalAuthorSummary): void {
   const message = summary.authored
     ? `goal-author authored ${basename(summary.goalFile!)} (${summary.userTextState}; ${summary.storedChars} chars; truncated=${summary.truncated})`
-    : `goal-author not authored (${summary.userTextState}; no goal source)`;
+    : summary.reused
+      ? `goal-author resumed ${basename(summary.goalFile!)} (${summary.userTextState})`
+      : `goal-author not authored (${summary.userTextState}; no goal source)`;
   ux.progress(message, { phase: 'delta' });
 }
 
+function resolveResumableGoalFile(requestedPath: string, cwd: string): string {
+  const root = realpathSync(cwd);
+  const candidate = realpathSync(isAbsolute(requestedPath) ? requestedPath : resolve(root, requestedPath));
+  const relativePath = relative(root, candidate);
+  if (!relativePath || relativePath === '..' || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)
+    || !/^GOAL-[^/\\]+\.(?:md|txt)$/i.test(basename(candidate))) {
+    throw new Error('goalFile must point to an existing GOAL-*.md or GOAL-*.txt document inside the repository');
+  }
+  return candidate;
+}
+
 /** Observability only; tool selection remains model-led. */
 function harnessMentionState(userText: string | undefined): 'absent' | 'matched' | 'not-matched' {
   if (userText === undefined) return 'absent';
@@ -293,7 +313,18 @@ export async function dispatchSelfImplement(
   }
 
   let goalFile: string | undefined;
-  if (goalSourceText !== undefined) {
+  let resumedGoal = false;
+  if (args.goalFile !== undefined) {
+    if (typeof args.goalFile !== 'string' || !args.goalFile.trim()) {
+      return buildFailedToolResult('goalFile must be a non-empty path to an existing authored goal document');
+    }
+    try {
+      goalFile = resolveResumableGoalFile(args.goalFile, ctx.cwd);
+      resumedGoal = true;
+    } catch (error) {
+      return buildFailedToolResult(error instanceof Error ? error.message : String(error));
+    }
+  } else if (goalSourceText !== undefined) {
     const recentStepCounts = readRecentStepCountsFailOpen(recentStepCountReader);
     goalFile = (await authorGoal(goalSourceText, ctx.cwd, {
       goalTitle: feature,
@@ -334,7 +365,7 @@ export async function dispatchSelfImplement(
     if (clarification.decisionRequired.length > 0) {
       const ledger = decisionLedgerFactory?.() ?? new DecisionLedger();
       const decisions = clarification.decisionRequired.map((item) => {
-        const ref = `self-implement-clarification:${args.runId ?? goalFile}:${item.questionId}`;
+        const ref = `self-implement-clarification:${goalFile}:${item.questionId}`;
         return ledger.raiseOnce({
           title: `SelfImplement 확인 필요: ${item.header}`.slice(0, 120),
           category: item.category,
@@ -360,7 +391,12 @@ export async function dispatchSelfImplement(
         unanswered: clarification.decisionRequired.length,
         reason: 'safety-critical-clarification-requires-recorded-decision',
       });
-      return buildFailedToolResult(`goal author clarification requires a recorded decision before launch; record the answer in the goal document and rerun SelfImplement (${decisions.map((decision) => decision.id).join(', ')})`);
+      const reason = `goal author clarification requires a recorded decision before launch (${decisions.map((decision) => decision.id).join(', ')})`;
+      const next = `Edit ${goalFile} with the explicit answer, then rerun SelfImplement using the same feature and goalFile=${goalFile}; the decision card alone does not launch or resume work`;
+      return {
+        kind: 'failed', reason, goalFile, next, missing: ['runId', 'node'],
+        message: `SelfImplement did not launch: ${reason}. Record the answer in ${goalFile}, then rerun the same feature with goalFile=${goalFile}. A decision-card choice alone does not resume the run.`,
+      };
     }
     if (clarification.unanswered > 0) {
       debug.log('daemon-tools.self-implement', 'goal-clarification-assumption-incomplete', {
@@ -372,7 +408,8 @@ export async function dispatchSelfImplement(
     }
   }
   const goalAuthorSummary: GoalAuthorSummary = {
-    authored: goalFile !== undefined,
+    authored: goalFile !== undefined && !resumedGoal,
+    reused: resumedGoal,
     goalFile: goalFile ?? null,
     userTextState: originalUserText === undefined ? 'absent' : originalUserText === '' ? 'empty' : 'present',
     originalChars,

package/src/budget/shadow-arms.ts

@@ -75,3 +75,55 @@ export function planShadowArms(input: PlanShadowArmsInput): ShadowArmsPlan {
 
   return { fire, skipped, remainingUsd };
 }
+
+// ── SHADOW-MODEL-ARMS · 그림자 «1팔» probe(명시 실행 · 관측만) ─────────────────────
+/**
+ * ⭐ 그림자 1팔 probe — `planShadowArms` 를 일일 상한 안에서 «실제 호출»해
+ *   난이도·모델·예상/실제 비용·결과를 기록한다.
+ *   ⛔ 관측만 한다 — 라이브 LLM 호출 0 · 파일 원장 쓰기 0. 팔은 «계획»이고 실행은 후속 조각이다.
+ *   ⛔ 후보가 여러 개여도 첫 후보 «1팔»만 계획한다(저작 단계 팔은 단일 팔이다).
+ */
+export interface ShadowArmProbeRecord {
+  stage: ShadowStage;
+  difficulty: ShadowDifficulty;
+  model: string;
+  result: 'fire' | 'skipped';
+  skipReason: 'over-daily-cap' | 'unknown-price' | null;
+  expectedUsd: number | null;
+  actualUsd: number;
+  remainingUsd: number;
+}
+
+/** 그림자 1팔을 실제 호출해 기록을 낸다 — 실제 지출은 없다(계획만, actualUsd=0). */
+export function probeShadowArm(input: PlanShadowArmsInput): ShadowArmProbeRecord {
+  const model = input.candidates[0] ?? '';
+  const plan = planShadowArms({ ...input, candidates: [model] });
+  const fired = plan.fire[0];
+  const skipped = plan.skipped[0];
+  return {
+    stage: input.stage,
+    difficulty: input.difficulty,
+    model,
+    result: fired ? 'fire' : 'skipped',
+    skipReason: skipped?.reason ?? null,
+    expectedUsd: fired?.estUsd ?? null,
+    actualUsd: 0,
+    remainingUsd: plan.remainingUsd,
+  };
+}
+
+/** 한 줄 원장 형식 — 예상 비용이 없으면 `expectedUsd=unknown`, fire 사유는 `under-daily-cap` 이다. */
+export function formatShadowArmProbeRecord(record: ShadowArmProbeRecord): string {
+  const reason = record.skipReason ?? 'under-daily-cap';
+  const expectedUsd = record.expectedUsd === null ? 'unknown' : `${record.expectedUsd}`;
+  return [
+    `shadow-arm stage=${record.stage}`,
+    `difficulty=${record.difficulty}`,
+    `model=${record.model}`,
+    `result=${record.result}`,
+    `reason=${reason}`,
+    `expectedUsd=${expectedUsd}`,
+    `actualUsd=${record.actualUsd}`,
+    `remainingUsd=${record.remainingUsd}`,
+  ].join(' ');
+}