elanous 0.2.38 → 0.2.41

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

@@ -1,55 +1,288 @@
 import { streamLLM } from '../llm.js';
 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 { debug, redactSecretText } from '../debug/log.js';
+import {
+  buildWorkingBackwardsContractPrompt,
+  formatWorkingBackwardsLadderContext,
+  parseWorkingBackwardsContract,
+  type WorkingBackwardsOutputContract,
+} from '../research/lenses/working-backwards.js';
 import { attachResearchEvidence, buildResearchQuestionLadderPrompt,
-  parseSixLevelResearchQuestionLadder, type ResearchEvidenceEnvelope,
+  parseSixLevelResearchQuestionLadder, type BloomLevel, type ResearchEvidenceEnvelope,
   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>;
+  routeOutput?: typeof routeResearchOutput;
+  invokeOutputSkill?: (skill: string, args: string) => Promise<{ ok: boolean; output: string; error?: string }>;
+  /** Test seam for the bounded Bloom 4/5 evidence-gap follow-up. */
+  gapFollowup?: typeof runGapFollowup;
+  /** Test/config seam for an explicitly installed private Bloom exemplar pack. */
+  bloomExemplarPackPath?: string;
 }
 
 export interface ResearchGroundingResult {
   ok: boolean;
   output: string;
+  error?: string;
 }
 
 export interface ResearchQuestionLadderRunResult {
   ok: boolean;
   ladder: SixLevelResearchQuestionLadder;
+  outputContract?: WorkingBackwardsOutputContract;
   output: string;
   error?: string;
 }
 
+export interface WorkingBackwardsBlankSlot {
+  id: string;
+  title: string;
+  purpose: string;
+}
+
+export interface WorkingBackwardsPlannedNode {
+  /** `ladder` = 사다리 질문 생성 노드(questions가 아직 없을 때), `axis` = 해당 질문의 증거 검색 노드. */
+  kind: 'ladder' | 'axis';
+  /** 이 노드가 채우려는 출력 계약 섹션 슬롯. */
+  sectionId: string;
+  /** 노드 식별자 — ladder 계획은 `ladder:<sectionId>`, axis 계획은 사다리 질문 id. */
+  nodeId: string;
+  /** axis 노드가 물고 있는 사다리 질문의 Bloom 단계. */
+  level?: BloomLevel;
+  /** axis 노드가 실행할 검색어. */
+  searchTerms?: string[];
+}
+
+export interface WorkingBackwardsCompletionBoundary {
+  /** 아직 채워지지 않은 출력 계약 섹션 슬롯(빈 칸 목록). */
+  blankSlots: WorkingBackwardsBlankSlot[];
+  /** 빈 칸마다 그 칸을 채울 ladder/axis 노드 계획(노드 계획). */
+  nodePlan: WorkingBackwardsPlannedNode[];
+  /** 모든 출력 계약 슬롯이 채워졌다 — 호출자는 이때 추가 research를 멈춘다. */
+  complete: boolean;
+}
+
+/**
+ * Working Backwards 완료 경계 — 출력 계약(buildWorkingBackwardsContractPrompt → parse…Contract)의
+ * 슬롯 중 채워지지 않은 칸을 찾고 각 칸을 채울 노드 계획을 낸다. questions 없이 부르면 모든 슬롯이
+ * 빈 칸이고 계획은 사다리 생성(`ladder:<sectionId>`)이 된다. questions·evidence 와 함께 부르면
+ * complete 증거를 1건 이상 가진 질문이 슬롯을 채운 것으로 보고, 빈 칸에는 해당 질문의 axis 검색
+ * 노드가 계획된다. 질문은 출력 계약의 sectionId로 배정하며, 할당되지 않은 슬롯은 ladder 노드로 남긴다.
+ */
+export function planWorkingBackwardsCompletion(
+  contract: WorkingBackwardsOutputContract,
+  questions: SixLevelResearchQuestionLadder['questions'] = [],
+  evidence: ResearchEvidenceEnvelope[] = [],
+): WorkingBackwardsCompletionBoundary {
+  const fulfilledQuestionIds = new Set(questions
+    .filter((question) => evidence.some((item) => item.questionId === question.id && item.outcome === 'complete'))
+    .map((question) => question.id));
+  const blankSlots: WorkingBackwardsBlankSlot[] = [];
+  const nodePlan: WorkingBackwardsPlannedNode[] = [];
+  contract.sections.forEach((section) => {
+    const assigned = questions.filter((question) => question.sectionId === section.id);
+    const unfilled = assigned.filter((question) => !fulfilledQuestionIds.has(question.id));
+    if (assigned.length > 0 && unfilled.length === 0) return;
+    blankSlots.push({ id: section.id, title: section.title, purpose: section.purpose });
+    for (const question of unfilled) {
+      nodePlan.push({
+        kind: 'axis',
+        sectionId: section.id,
+        nodeId: question.id,
+        level: question.level,
+        searchTerms: [...question.searchTerms],
+      });
+    }
+    if (assigned.length === 0) {
+      nodePlan.push({ kind: 'ladder', sectionId: section.id, nodeId: `ladder:${section.id}` });
+    }
+  });
+  return { blankSlots, nodePlan, complete: blankSlots.length === 0 };
+}
+
+/** 조사 런 귀속용 orchestration 식별자 — 회고 레코드에 싣는다. */
+function orchestrationId(): string {
+  return globalThis.crypto?.randomUUID
+    ? globalThis.crypto.randomUUID()
+    : `orch-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** 회고 레코드 — 조사 런 종료 시 주제별로 정확히 1건 저장되고 다음 같은 주제 턴에 1단 근거로 주입된다. */
+interface ResearchRetroRecord {
+  topic: string;
+  observedGap: string;
+  orchestrationId: string;
+  observedAt: string;
+}
+
+/** 주제별 최신 회고 레코드 저장소 — Map.set 이므로 주제당 정확히 1건만 남는다. */
+const retroRecordsByTopic = new Map<string, ResearchRetroRecord>();
+
+/** 조사 런에서 채워지지 않은 증거 공백을 회고 문장으로 뽑는다(비밀은 redactSecretText 로 가린다). */
+function deriveObservedGap(
+  ladder: SixLevelResearchQuestionLadder,
+  evidence: ResearchEvidenceEnvelope[],
+): string {
+  const incomplete = ladder.questions
+    .filter((question) => !evidence.some((item) => item.questionId === question.id && item.outcome === 'complete'))
+    .map((question) => `${question.id}: ${question.prompt}`);
+  return incomplete.length > 0
+    ? `unfilled evidence — fill first: ${incomplete.join('; ')}`
+    : 'none — every output-contract section slot was filled';
+}
+
+/** 회고 레코드를 저장하고 관측 이벤트로 남긴다 — 비밀·자격 문자열은 저장 전에 가린다. */
+function saveRetroRecord(topic: string, ladder: SixLevelResearchQuestionLadder, evidence: ResearchEvidenceEnvelope[]): void {
+  const record: ResearchRetroRecord = {
+    topic: redactSecretText(topic),
+    observedGap: redactSecretText(deriveObservedGap(ladder, evidence)),
+    orchestrationId: orchestrationId(),
+    observedAt: new Date().toISOString(),
+  };
+  retroRecordsByTopic.set(record.topic, record);
+  debug.log('research.turn', 'retro-record-saved', { ...record });
+}
+
+/** 같은 주제의 최신 회고 레코드를 1단 근거로 주입한다 — 주입 사실은 debug.log 에 행으로 남는다. */
+function retroGroundingContext(topic: string): string {
+  const prior = retroRecordsByTopic.get(redactSecretText(topic));
+  if (!prior) return '';
+  debug.log('research.turn', 'retro-grounding-injected', { ...prior });
+  return `\n\n## Prior turn retro (tier-1 grounding)\nTopic: ${prior.topic}\n`
+    + `- Fill this gap first: ${prior.observedGap}\n`
+    + `- State what changed since last time (지난번 대비 달라진 것).`;
+}
+
+/** 완료 경계를 관측 이벤트로 남긴다 — 출력 계약 → 빈 칸 목록 → 노드 계획, 다 차면 stop 로그는 호출자가 남긴다. */
+function logCompletionBoundary(stage: string, boundary: WorkingBackwardsCompletionBoundary): void {
+  debug.log('research.turn', 'completion-boundary', {
+    stage,
+    blankSlotIds: boundary.blankSlots.map((slot) => slot.id),
+    plannedNodes: boundary.nodePlan.map((node) => `${node.kind}:${node.nodeId}`),
+    complete: boundary.complete,
+  });
+}
+
+/** 완료 경계의 최종 상태를 골격 칸(계약 슬롯별 채움 상태 + 빈 칸 노드 계획)으로 렌더링한다. */
+function formatWorkingBackwardsSkeleton(
+  contract: WorkingBackwardsOutputContract,
+  boundary: WorkingBackwardsCompletionBoundary,
+  evidenceRejected = false,
+): string {
+  const lines = ['## Answer skeleton (Working Backwards output contract)'];
+  for (const section of contract.sections) {
+    if (!boundary.blankSlots.some((slot) => slot.id === section.id)) {
+      lines.push(`- [${section.id}] ${section.title} — ${section.purpose} — filled`);
+      continue;
+    }
+    const plan = boundary.nodePlan
+      .filter((node) => node.sectionId === section.id)
+      .map((node) => node.kind === 'ladder'
+        ? `ladder ${node.nodeId}`
+        : `axis ${node.nodeId} (${(node.searchTerms ?? []).join(', ')})`)
+      .join(' · ');
+    lines.push(`- [${section.id}] ${section.title} — ${section.purpose} — blank · plan: ${plan}`);
+  }
+  if (boundary.complete) {
+    lines.push('Completion boundary: stopped — every output-contract section slot is filled.');
+    if (evidenceRejected) lines.push('Completion note: rejected evidence was discarded; the valid evidence above remains available.');
+  }
+  return lines.join('\n');
+}
+
 /** Generate Bloom axes, search each axis natively, and attach its source evidence. */
 export async function runResearchQuestionLadder(
   request: string,
   options: ResearchQuestionLadderRunOptions = {},
 ): Promise<ResearchQuestionLadderRunResult> {
   const initial: SixLevelResearchQuestionLadder = { request, questions: [], evidence: [] };
+  let contractRaw: string;
+  try {
+    contractRaw = await (options.generateContract ?? ((prompt) => defaultGenerate(prompt, 'research-working-backwards-contract')))(
+      buildWorkingBackwardsContractPrompt(request),
+    );
+  } catch (error) {
+    const reason = errorText(error);
+    debug.log('research.lens', 'working-backwards-contract-failed', { reason }, { level: 'warn' });
+    return { ok: false, ladder: initial, output: '', error: `output contract generation failed: ${reason}` };
+  }
+
+  let generatedContract: unknown;
+  try {
+    generatedContract = JSON.parse(extractJson(contractRaw));
+  } catch (error) {
+    const reason = errorText(error);
+    debug.log('research.lens', 'working-backwards-contract-invalid', { reason }, { level: 'warn' });
+    return { ok: false, ladder: initial, output: '', error: `output contract returned invalid JSON: ${reason}` };
+  }
+  const parsedContract = parseWorkingBackwardsContract(generatedContract);
+  if (!parsedContract.ok) {
+    debug.log('research.lens', 'working-backwards-contract-invalid', { reason: parsedContract.reason }, { level: 'warn' });
+    return { ok: false, ladder: initial, output: '', error: parsedContract.reason };
+  }
+  const outputContract = parsedContract.value;
+  debug.log('research.lens', 'selected', { lens: 'working-backwards', bloomLevel: 0 });
+  const ladderContext = formatWorkingBackwardsLadderContext(outputContract);
+  debug.log('research.lens', 'applied', {
+    lens: 'working-backwards', sectionCount: outputContract.sections.length,
+    completionCriteriaCount: outputContract.completionCriteria.length,
+  });
+  const contractBoundary = planWorkingBackwardsCompletion(outputContract);
+  logCompletionBoundary('output-contract', contractBoundary);
+
   let raw: string;
   try {
-    raw = await (options.generate ?? defaultGenerate)(buildResearchQuestionLadderPrompt(request));
+    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 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)}`,
+    );
+    debug.log('research.turn', 'bloom-generated', { questionCount: 6 });
   } catch (error) {
-    return { ok: false, ladder: initial, output: '', error: `question generation failed: ${errorText(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)}` };
   }
 
   let generated: unknown;
   try {
     generated = JSON.parse(extractJson(raw));
   } catch (error) {
-    return { ok: false, ladder: initial, output: '', error: `question generation returned invalid JSON: ${errorText(error)}` };
+    debug.log('research.turn', 'bloom-validation-failed', { reason: errorText(error) }, { level: 'warn' });
+    return { ok: false, ladder: initial, outputContract, output: '', error: `question generation returned invalid JSON: ${errorText(error)}` };
+  }
+  const parsed = parseSixLevelResearchQuestionLadder(
+    withRequest(generated, request), outputContract.sections.map((section) => section.id),
+  );
+  if (!parsed.ok) {
+    debug.log('research.turn', 'bloom-validation-failed', { reason: parsed.reason }, { level: 'warn' });
+    return { ok: false, ladder: initial, outputContract, output: '', error: parsed.reason };
   }
-  const parsed = parseSixLevelResearchQuestionLadder(withRequest(generated, request));
-  if (!parsed.ok) return { ok: false, ladder: initial, output: '', error: parsed.reason };
 
   const ladder = parsed.value;
+  debug.log('research.turn', 'bloom-ladder-validated', { questionCount: ladder.questions.length });
   const observedAt = new Date().toISOString();
   let fanout: AxisFanoutResult;
   try {
     fanout = await (options.invokeAxes ?? invokeResearchAxes)(ladder.questions);
+    debug.log('research.turn', 'axis-evidence-collected', {
+      axisCount: fanout.axes.length,
+      evidenceCount: fanout.axes.reduce((count, axis) => count + axis.evidence.length, 0),
+    });
   } catch (error) {
+    debug.log('research.turn', 'axis-evidence-failed', { reason: errorText(error) }, { level: 'warn' });
     fanout = {
       plan: [],
       axes: ladder.questions.map((question) => ({ questionId: question.id, error: errorText(error), evidence: [{
@@ -60,8 +293,8 @@ export async function runResearchQuestionLadder(
     };
   }
 
-  let allOk = true;
-  const sections: string[] = [`# Research: ${request}`, ''];
+  let evidenceRejected = false;
+  const sections: string[] = [`# Research: ${request}`, '', `## Output contract\n${ladderContext}`, ''];
   const byQuestion = new Map(fanout.axes.map((axis) => [axis.questionId, axis]));
   for (const question of ladder.questions) {
     const axis = byQuestion.get(question.id);
@@ -75,12 +308,11 @@ export async function runResearchQuestionLadder(
     for (const envelope of envelopes) {
       const attached = attachResearchEvidence(ladder, envelope);
       if (!attached.ok) {
-        allOk = false;
+        evidenceRejected = true;
         snippets.push(`Evidence rejected: ${attached.reason}`);
         continue;
       }
       ladder.evidence = attached.value.evidence;
-      if (envelope.outcome !== 'complete') allOk = false;
       snippets.push(`- [${envelope.outcome}] ${envelope.sourceKind} · ${envelope.source}: ${envelope.content}`);
     }
     sections.push(`## ${question.id} · Bloom ${question.level}: ${question.prompt}`,
@@ -88,30 +320,140 @@ export async function runResearchQuestionLadder(
       ...snippets);
   }
 
-  const incompleteQuestions = ladder.questions.filter((question) => {
-    const evidence = ladder.evidence.filter((item) => item.questionId === question.id);
-    return evidence.length === 0 || evidence.some((item) => item.outcome !== 'complete');
-  }).length;
+  let finalBoundary = planWorkingBackwardsCompletion(outputContract, ladder.questions, ladder.evidence);
+  logCompletionBoundary('axis-fanout', finalBoundary);
+  if (finalBoundary.complete) {
+    debug.log('research.turn', 'completion-boundary-stop', {
+      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}`);
+      }
+      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,
+      });
+      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) }, { level: 'warn' });
+    }
+  }
+
+  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));
+
+  const incompleteQuestions = ladder.questions.filter((question) =>
+    !ladder.evidence.some((item) => item.questionId === question.id && item.outcome === 'complete')).length;
+  const allOk = !evidenceRejected && incompleteQuestions === 0;
+  debug.log('research.lens', 'verdict', {
+    lens: 'working-backwards',
+    features: {
+      requiredSectionCount: outputContract.sections.length,
+      completionCriteriaCount: outputContract.completionCriteria.length,
+      questionCount: ladder.questions.length,
+      incompleteQuestionCount: incompleteQuestions,
+    },
+    action: allOk ? 'evidence-ready-for-synthesis' : 'evidence-incomplete',
+  });
+  const output = sections.join('\n\n');
+  let route: ReturnType<typeof routeResearchOutput> | undefined;
+  try {
+    route = (options.routeOutput ?? routeResearchOutput)({
+      question: request,
+      synthesizedResult: output,
+      axes: ladder.questions.map((question) => `${question.id}: ${question.prompt}`),
+    });
+  } catch (error) {
+    debug.log('research.turn', 'output-router-fallback', { reason: errorText(error) }, { level: 'warn' });
+  }
+  debug.log('research.turn', 'output-routed', {
+    format: route?.format ?? 'text',
+    axisCount: route?.observation.axisCount ?? ladder.questions.length,
+    selectedSkill: route?.skillCallPlan?.skill,
+    fallbackReason: route?.fallbackReason ?? (route ? undefined : 'router-failed'),
+  });
+  let routedOutput = '';
+  if (route?.skillCallPlan) {
+    try {
+      const formatted = await (options.invokeOutputSkill ?? defaultInvokeOutputSkill)(
+        route.skillCallPlan.skill, route.skillCallPlan.args,
+      );
+      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 });
+      } else {
+        debug.log('research.turn', 'output-skill-fallback', {
+          skill: route.skillCallPlan.skill,
+          reason: formatted.error ?? 'empty output',
+        }, { level: 'warn' });
+      }
+    } catch (error) {
+      debug.log('research.turn', 'output-skill-fallback', {
+        skill: route.skillCallPlan.skill,
+        reason: errorText(error),
+      }, { level: 'warn' });
+    }
+  }
+  saveRetroRecord(request, ladder, ladder.evidence);
   return {
     ok: allOk,
     ladder,
-    output: sections.join('\n\n'),
+    outputContract,
+    output: output + routedOutput,
     ...(allOk ? {} : { error: `${incompleteQuestions} of ${ladder.questions.length} question searches were incomplete` }),
   };
 }
 
+async function defaultInvokeOutputSkill(skill: string, args: string) {
+  const result = await invokeResearch(args, { skill });
+  return { ok: result.ok, output: result.output, ...(result.error ? { error: result.error } : {}) };
+}
+
 /** Preserve usable partial findings when the grounding seam has only an ok/output contract. */
 export function researchTurnForGrounding(result: ResearchQuestionLadderRunResult): ResearchGroundingResult {
   const output = result.output.trim() || result.error || 'Research question ladder failed.';
   return {
     ok: result.ladder.evidence.some((item) => item.outcome === 'complete') && result.output.trim().length > 0,
     output,
+    ...(result.error ? { error: result.error } : {}),
   };
 }
 
-async function defaultGenerate(prompt: string): Promise<string> {
+async function defaultGenerate(prompt: string, usageSite: string): Promise<string> {
   return streamLLM([{ role: 'user', content: prompt }], () => {}, {
-    usageSite: 'research-question-ladder',
+    usageSite,
     usagePhase: 'research',
   });
 }

package/src/autopilot/agent-loop.ts

@@ -50,7 +50,7 @@ export type AutopilotTermination =
   | { kind: 'budget'; budget: 'iterations' | 'wallClock' | 'outputChars'; observed: number; limit: number }
   | { kind: 'cancelled' }
   | { kind: 'risky'; pattern: RiskyPattern; iteration: number }
-  | { kind: 'error'; message: string };
+  | { kind: 'error'; message: string; code?: string };
 
 /** Decision returned by the optional risky-tool-call policy hook. */
 export type RiskyPolicyDecision = 'allow' | 'deny';

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/pty-control-loop.ts

@@ -97,9 +97,11 @@ export interface RunSupervisor {
 }
 
 /** brain의 완료 선언을 현재 관측으로 검증하는 ground-truth 게이트 결과. */
+export const VERIFY_DONE_STOP = 'VERIFY_DONE_STOP' as const;
+
 export type VerifyDoneResult =
   | { readonly ok: true }
-  | { readonly ok: false; readonly retry: string };
+  | { readonly ok: false; readonly retry: string; readonly stop?: typeof VERIFY_DONE_STOP };
 
 export interface PtyControlDeps {
   /** 현재 화면 텍스트(예: handle.renderScreen). */
@@ -613,6 +615,11 @@ export async function runPtyControlLoop(
         if (verification.ok) {
           return finish({ kind: 'success', reason: decision.reason }, step);
         }
+        if (verification.stop === VERIFY_DONE_STOP) {
+          const message = `verification failed and retry is disabled: ${verification.retry}`;
+          debug.log('autopilot.control', 'verify-stop', { step, reason: message });
+          return finish({ kind: 'error', code: VERIFY_DONE_STOP, message }, step);
+        }
         if (!deps.inject(verification.retry)) {
           debug.log('autopilot.control', 'yield', { step, reason: 'arbiter denied verify retry inject — 사람 takeover' });
           return finish({ kind: 'cancelled' }, step);

package/src/boot/daemon-tools/index.ts

@@ -70,7 +70,7 @@ import { buildDelegateAgentTool, dispatchDelegateAgent } from './delegate-agent.
 import {
   SELF_IMPLEMENT_TOOL_NAMES,
   buildSelfImplementDaemonSpec,
-  dispatchSelfImplement,
+  dispatchSelfImplementManaged,
 } from './self-implement.js';
 // ⭐ 소환기(F2 · RFC-observability-driven-tool-selection · 2026-07-26) —
 //   tier-flip 이 deferred 를 만들면 ToolSearch 를 active 에 **주입**하므로, 이 서피스는
@@ -395,6 +395,7 @@ export function toolSurface(kind: DaemonToolSurfaceKind, cfg?: import('../../use
       // L2 core + L3 finance(gated) — buildSharedAppTools 단일 dispatch · B5: 진행 한 줄(emitFeedback)·세션·호출 id 를 넘긴다.
       return shared.dispatch(name, args, {
         surface: 'tui',
+        signal: ctx.signal,
         ...(ctx.requestOrigin ? { requestOrigin: ctx.requestOrigin } : {}),
         ...(ctx.verifiedOwner ? { verifiedOwner: ctx.verifiedOwner } : {}),
         ...(ctx.sessionId ? { sessionId: ctx.sessionId } : {}),
@@ -458,7 +459,7 @@ export function toolSurface(kind: DaemonToolSurfaceKind, cfg?: import('../../use
             debug.log('substrate.nest', 'spawn-refused', { tool: name, ...nestInfo() }, { level: 'warn' });
             return { error: `nest-cap: 재귀 상한(${nestInfo().max}중) 도달 — SelfImplement 비활성(액자 폭주 방지)` };
           }
-          return dispatchSelfImplement(args, ctx);
+          return dispatchSelfImplementManaged(args, ctx);
         }
         throw new ToolSafetyError(
           'unavailable',
@@ -532,7 +533,7 @@ export function toolSurface(kind: DaemonToolSurfaceKind, cfg?: import('../../use
           debug.log('substrate.nest', 'spawn-refused', { tool: name, ...nestInfo() }, { level: 'warn' });
           return { error: `nest-cap: 재귀 상한(${nestInfo().max}중) 도달 — SelfImplement 비활성(액자 폭주 방지)` };
         }
-        return dispatchSelfImplement(args, ctx);
+        return dispatchSelfImplementManaged(args, ctx);
       }
       if (name === 'RunDevHarness') {
         if (nestCapReached()) {