elanous 0.2.40 → 0.2.41

package/src/agent-substrate/self-review-cli.ts

@@ -26,7 +26,7 @@ import { ZAI_OPENROUTER_FALLBACK_MODEL } from '../llm/zai-coding-plan.js';
 import { debug } from '../debug/log.js';
 import { ACP_BACKENDS, canonicalizeBackendId } from '../acp/backend-registry.js';
 import { buildManualReviewIntent, intentFromPr, prIntentSectionCoverage, reviewIntentTruncationFromPr, reviewIntentTruncationObservation } from './review-intent.js';
-import { budgetReviewerContext, isNoneSentinelFinding, reviewDiffBudgetObservation, splitDiffByFile, type ReviewImage, type ReviewInput, type ReviewerContextItem, type ReviewResult } from './pr-reviewer.js';
+import { NO_VERDICT_LINE_REASON, budgetReviewerContext, isNoneSentinelFinding, reviewDiffBudgetObservation, splitDiffByFile, type ReviewImage, type ReviewInput, type ReviewerContextItem, type ReviewResult } from './pr-reviewer.js';
 import type { ReferencedFileReader } from '../self-implement/goal-file-reader.js';
 import { getUserConfig, type LLMProviderName, type ReviewerMixSpec, type RoleLlmSpec, type SubscriptionReviewerSpec } from '../user-config.js';
 import { loadLlmPolicy } from '../policy/llm-policy.js';
@@ -96,6 +96,8 @@ export interface SelfReviewCliOpts {
   save?: string | undefined;
   /** Review only commits after a previously saved PR review head. */
   sinceReview?: string | undefined;
+  /** Internal delta self-heal metadata; never parsed from user CLI arguments. */
+  deltaHeal?: { cause: string; prescription: string } | undefined;
   /** One invocation past r5, only for a PR in OP's traffic.json allowlist; the reason is recorded before review starts. */
   overCapReason?: string | undefined;
 }
@@ -187,6 +189,7 @@ interface SavedReviewForDelta {
   mustFix: string[];
   reviewInputChars: number;
   reviewDurationMs: number;
+  result: Record<string, unknown>;
 }
 
 function selectSavedReviewForDelta(pr: string, selector: string, root = effectiveInstanceRoot()):
@@ -206,17 +209,20 @@ function selectSavedReviewForDelta(pr: string, selector: string, root = effectiv
     const row = raw as Record<string, unknown>;
     const recordPr = typeof row.pr === 'string' ? row.pr
       : Number.isSafeInteger(row.pr) ? String(row.pr) : undefined;
-    if (recordPr !== pr || row.reviewed !== true || typeof row.headCommit !== 'string' || !COMMIT_OID.test(row.headCommit)) continue;
+    if (recordPr !== pr || row.reviewed !== true || !['pass', 'warn', 'fail'].includes(String(row.verdict))
+      || typeof row.headCommit !== 'string' || !COMMIT_OID.test(row.headCommit)) continue;
     const named = name === token || name === `${token}.json` || name.startsWith(`${token}-${pr}-`);
     const byHead = /^[a-f0-9]{7,64}$/i.test(token) && row.headCommit.toLowerCase().startsWith(token.toLowerCase());
     if (!named && !byHead) continue;
-    if (!Array.isArray(row.mustFix) || !row.mustFix.every((item) => typeof item === 'string')) continue;
+    if (!Array.isArray(row.mustFix)) continue;
+    const mustFix = row.mustFix.filter((item): item is string => typeof item === 'string');
+    if (mustFix.length !== row.mustFix.length) continue;
     if (typeof row.reviewInputChars !== 'number' || !Number.isFinite(row.reviewInputChars) || row.reviewInputChars <= 0
       || typeof row.reviewDurationMs !== 'number' || !Number.isFinite(row.reviewDurationMs) || row.reviewDurationMs <= 0) continue;
     let mtimeMs = 0;
     try { mtimeMs = statSync(join(dir, name)).mtimeMs; } catch { continue; }
-    records.push({ file: name, headCommit: row.headCommit.toLowerCase(), mustFix: row.mustFix as string[],
-      reviewInputChars: row.reviewInputChars, reviewDurationMs: row.reviewDurationMs, mtimeMs });
+    records.push({ file: name, headCommit: row.headCommit.toLowerCase(), mustFix,
+      reviewInputChars: row.reviewInputChars, reviewDurationMs: row.reviewDurationMs, result: row, mtimeMs });
   }
   const distinctHeads = [...new Set(records.map((record) => record.headCommit))];
   if (distinctHeads.length > 1) return { error: 'saved-review-selector-ambiguous' };
@@ -1985,28 +1991,52 @@ async function runSelfReviewCliCommandPinned(
         ? `PR ${pr}: r5 상한 초과 리뷰는 OP traffic.json reviewOverCapAllow 허용 목록에 있어야 합니다.`
         : `PR ${pr}: 저장된 서로 다른 head 리뷰 ${previousRoundCount}개로 r5 상한에 도달했습니다. OP 허용 상태와 --over-cap-reason <사유>가 필요합니다.`;
       deps.observeDoctorReview?.('cap-refused', { pr, head: refusalHead, previousRoundCount, round: previousRoundCount + 1, reason: opAllowed ? 'missing-reason' : 'not-op-allowlisted' }, { level: 'warn' });
+      if (opts.sinceReview !== undefined) deps.log('review.delta-heal', {
+        pr, cause: 'cap-refused', prescription: 'retain-explicit-refusal', result: 'refused', headCommit: refusalHead,
+      }, { level: 'warn' });
       deps.error(message);
-      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'cap-refused', previousRoundCount, headCommit: refusalHead });
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'cap-refused',
+        ...(opts.sinceReview !== undefined ? { verdict: null, deltaOutcome: 'refused', deltaRefusal: 'cap-refused' } : {}),
+        previousRoundCount, headCommit: refusalHead });
       failed += 1;
       continue;
     }
     let deltaBase: SavedReviewForDelta | undefined;
+    let deltaHeal = opts.deltaHeal;
     if (opts.sinceReview !== undefined) {
       const selected = selectSavedReviewForDelta(pr, opts.sinceReview);
       if ('error' in selected) {
-        const message = `PR ${pr}: --since-review 기준을 읽지 못했습니다 (${selected.error}).`;
-        deps.error(message);
-        if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'delta-base-invalid', deltaRefusal: selected.error });
-        failed += 1;
-        continue;
+        if (selected.error === 'saved-review-directory-missing'
+          || selected.error === 'saved-review-not-found-or-missing-efficiency-receipt') {
+          deltaHeal = { cause: 'no-prior-reviewed-head', prescription: 'full-review-once' };
+        } else {
+          const message = `PR ${pr}: --since-review 기준을 읽지 못했습니다 (${selected.error}).`;
+          deps.error(message);
+          if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, verdict: null,
+            refusal: 'delta-base-invalid', deltaOutcome: 'refused', deltaRefusal: selected.error });
+          failed += 1;
+          continue;
+        }
+      } else {
+        deltaBase = selected.review;
       }
-      deltaBase = selected.review;
     }
     const diffResult = deltaBase ? readDeltaDiffAtHead(pr, deltaBase.headCommit, deps) : { read: readDiffAtHead(pr, deps) };
     if ('error' in diffResult) {
+      if (diffResult.error === 'no-new-head-since-review' && deltaBase) {
+        const reused = { ...deltaBase.result, deltaOutcome: 'reused', deltaHeal: {
+          cause: 'no-new-head', prescription: 'reuse-saved-verdict', result: 'verdict-reused',
+        } };
+        deps.log('review.delta-heal', { pr, cause: 'no-new-head', prescription: 'reuse-saved-verdict',
+          result: 'verdict-reused', headCommit: diffResult.headCommit ?? deltaBase.headCommit }, { level: 'info' });
+        if (opts.json || opts.save !== undefined) results.push(reused);
+        else deps.print(`\n━━ PR ${pr} (${String(deltaBase.result.model ?? 'saved review')}) ━━\n${deps.renderReview(reused as unknown as ReviewResult)}\n판정 재사용: ${deltaBase.headCommit}`);
+        continue;
+      }
       const message = `PR ${pr}: 델타 리뷰를 고정하지 못했습니다 (${diffResult.error}).`;
       deps.error(message);
-      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, refusal: 'delta-base-invalid', deltaRefusal: diffResult.error,
+      if (opts.json || opts.save !== undefined) results.push({ pr, error: message, reviewed: false, verdict: null,
+        refusal: 'delta-base-invalid', deltaOutcome: 'refused', deltaRefusal: diffResult.error,
         ...(diffResult.headCommit ? { headCommit: diffResult.headCommit } : {}) });
       failed += 1;
       continue;
@@ -2494,41 +2524,63 @@ async function runSelfReviewCliCommandPinned(
       claudeFallbackGlm = { reason, model: ZAI_OPENROUTER_FALLBACK_MODEL, glmReviewed: glmFailureReason === undefined,
         ...(glmFailureReason !== undefined ? { glmFailureReason } : {}) };
     }
+    if (deltaBase && review.reviewed !== true && review.failureReason === NO_VERDICT_LINE_REASON) {
+      let retryReview: ReviewResult;
+      try {
+        retryReview = await deps.reviewPullRequest(reviewInput, llmReview ?? prAcpReviewLLM ?? makeApi());
+      } catch (error) {
+        retryReview = { verdict: 'fail', mustFix: [], shouldFix: [], reviewed: false,
+          failureReason: safeLogText(error instanceof Error ? error.message : String(error), 400) };
+      }
+      if (retryReview.reviewed === true) {
+        review = retryReview;
+        deltaHeal = { cause: 'no-verdict-line', prescription: 'retry-delta-once' };
+      } else {
+        const retryResult = safeLogText(retryReview.failureReason === NO_VERDICT_LINE_REASON
+          ? 'no-verdict-line' : `retry-failed-${retryReview.failureReason || 'reviewed-false'}`, 400);
+        deps.log('review.delta-heal', { pr, cause: 'no-verdict-line', prescription: 'retry-delta-once',
+          result: retryResult, headCommit: diffRead.headCommit }, { level: 'warn' });
+        reviewPin?.remove();
+        const fallback = await runSelfReviewCliCommandPinned([pr], {
+          ...opts, sinceReview: undefined,
+          reviewerMixCapClaimed: opts.reviewerMixCapClaimed || Boolean(claimedCapPath),
+          deltaHeal: { cause: 'no-verdict-line', prescription: 'full-review-once-after-delta-retry' },
+        }, deps, pins);
+        results.push(...fallback.results);
+        failed += fallback.failed;
+        releaseCapClaim();
+        continue;
+      }
+    }
     const reviewDurationMs = Math.max(0, deps.now() - startedAt);
     let deltaReceipt: Record<string, unknown> = {};
     if (deltaBase) {
       const assessed = assessDeltaReview(review, deltaBase);
+      const inputRatio = reviewInputChars / deltaBase.reviewInputChars;
+      const timeRatio = reviewDurationMs / deltaBase.reviewDurationMs;
+      const maxRatio = 1 / 3;
       const deltaEfficiency = {
-        inputRatio: reviewInputChars / deltaBase.reviewInputChars,
-        timeRatio: reviewDurationMs / deltaBase.reviewDurationMs,
-        maxRatio: 1 / 3,
+        inputRatio, timeRatio, maxRatio,
+        withinTarget: inputRatio <= maxRatio && timeRatio <= maxRatio,
       };
-      const efficient = deltaEfficiency.inputRatio <= deltaEfficiency.maxRatio
-        && deltaEfficiency.timeRatio <= deltaEfficiency.maxRatio;
       if (review.reviewed !== true) {
         const reason = review.failureReason || 'delta-review-not-completed';
         review = { ...review, reviewed: false, verdict: 'fail', mustFix: [], shouldFix: [], failureReason: reason };
         deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
           deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency,
-          deltaRefusal: 'delta-review-not-completed' };
+          deltaOutcome: 'refused', deltaRefusal: 'delta-review-not-completed' };
       } else if (!assessed.valid) {
         review = { ...review, reviewed: false, verdict: 'fail', mustFix: [], shouldFix: [],
           failureReason: assessed.reason };
         deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
           deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency,
-          deltaRefusal: assessed.reason };
-      } else if (!efficient) {
-        review = { ...review, reviewed: false, verdict: 'fail', mustFix: [], shouldFix: [],
-          failureReason: 'delta-efficiency-limit-exceeded' };
-        deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
-          deltaFindings: assessed.deltaFindings, deltaInputChars: reviewInputChars,
-          deltaDurationMs: reviewDurationMs, deltaEfficiency, deltaRefusal: 'delta-efficiency-limit-exceeded' };
+          deltaOutcome: 'refused', deltaRefusal: assessed.reason };
       } else {
         review = { ...review, reviewed: true, verdict: assessed.mustFix.length ? 'fail' : 'pass',
           mustFix: assessed.mustFix, shouldFix: [] };
         deltaReceipt = { basedOn: deltaBase.headCommit, basedOnReview: deltaBase.file,
           deltaFindings: assessed.deltaFindings, excludedNewFindings: assessed.excludedNewFindings,
-          deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency };
+          deltaInputChars: reviewInputChars, deltaDurationMs: reviewDurationMs, deltaEfficiency, deltaOutcome: 'reviewed' };
       }
     }
     reviewPin?.remove();
@@ -2661,12 +2713,22 @@ async function runSelfReviewCliCommandPinned(
       continue;
     }
     const contextOutput = reviewerContextOutput(reviewerContext, decompositionContext);
-    const jsonReview = review.reviewed === true ? review : { ...review, verdict: null };
+    const jsonReview = review.reviewed === true ? review : { ...review, verdict: null,
+      ...(deltaHeal ? { failureReason: safeLogText(review.failureReason || 'reviewed-false', 400) } : {}) };
     // ⛔ 금지 백엔드가 낸 판정은 «근거 거부»다 — verdict·mustFix 를 그대로 실어 보내면 읽는 쪽이
     //    그것을 착지 판정으로 쓴다(관문도 reviewed===true 를 근거 조건으로 본다).
     const refusalOverride = landingGateAdmitted ? {} : { reviewed: false, verdict: null, refusal: 'review-forbidden-acp-backend' as const };
+    const deltaHealResult = safeLogText(review.reviewed === true && landingGateAdmitted
+      ? `verdict-${review.verdict}` : `refused-${review.failureReason || (landingGateAdmitted ? 'reviewed-false' : 'landing-gate')}`, 400);
+    if (deltaHeal) deps.log('review.delta-heal', { pr, cause: deltaHeal.cause,
+      prescription: deltaHeal.prescription, result: deltaHealResult, headCommit: diffRead.headCommit },
+    { level: review.reviewed === true && landingGateAdmitted ? 'info' : 'warn' });
+    const deltaHealOutput = deltaHeal ? {
+      ...(deltaBase ? {} : { deltaOutcome: review.reviewed === true && landingGateAdmitted ? 'healed-full-review' : 'refused' }),
+      deltaHeal: { ...deltaHeal, result: deltaHealResult },
+    } : {};
     const resultOutput = { pr, model: selectedModel, ...jsonReview, reviewInputChars, reviewDurationMs,
-      ...(deltaBase ? deltaReceipt : {}), ...reviewProvenance, ...respondedOutput, ...reviewerSelection,
+      ...(deltaBase ? deltaReceipt : {}), ...deltaHealOutput, ...reviewProvenance, ...respondedOutput, ...reviewerSelection,
       ...reviewCwdOutput, ...provenance, ...contextOutput, ...refusalOverride, ...landingGateFields,
       findingPathHeadChecks, pathWarnings, evidence: evidence.evidence, prDiffFiles: evidence.prDiffFiles,
       ...(evidence.authoredFiles !== undefined ? { authoredFiles: evidence.authoredFiles } : {}) };

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

@@ -23,6 +23,8 @@ export interface ResearchQuestionLadderRunOptions {
   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 {
@@ -238,8 +240,15 @@ export async function runResearchQuestionLadder(
   let raw: string;
   try {
     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${ladderContext}${retroGroundingContext(request)}`,
+      `${buildResearchQuestionLadderPrompt(request, sectionIds)}\n\n${exemplar.context ? `${exemplar.context}\n\n` : ''}${ladderContext}${retroGroundingContext(request)}`,
     );
     debug.log('research.turn', 'bloom-generated', { questionCount: 6 });
   } catch (error) {

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/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(' ');
+}

package/src/chat/pickers/state.ts

@@ -237,7 +237,13 @@ export function createPickerState(deps: PickerDeps): PickerState {
 
   const filteredSlash = (buf: PickerBufferView): SlashCommand[] => {
     const { role, showBeta } = readTuiSlashAudience();
-    return filterSlashCommands((buf.lines[0] ?? '').slice(1), deps.commands)
+    // /directive is intentionally outside the compact first-use menu, but an owner must be able
+    // to discover its ops-only command in the live palette. Keep that role-specific exception local
+    // to the palette so the shared first-use menu and help catalog remain at their 15-command policy.
+    const paletteCommands = role === 'owner'
+      ? deps.commands.map((command) => command.name === 'directive' ? { ...command, hidden: false } : command)
+      : deps.commands;
+    return filterSlashCommands((buf.lines[0] ?? '').slice(1), paletteCommands)
       .filter((cmd) => (role === 'owner' && slashMaturity(cmd.name) === undefined) || slashVisibleFor(cmd.name, role, { showBeta }));
   };
 

package/src/cli/log-event-names.ts

@@ -201,6 +201,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "chain-step-failed",
   "change",
   "chat-error",
+  "chat-history-compacted",
   "chat-input-consumed",
   "chat-main",
   "chat-main.await",
@@ -1075,6 +1076,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "read-error",
   "read.path-resolved",
   "readiness-threw",
+  "readonly-tool-repeat-suppressed",
   "ready",
   "ready.timeout",
   "rebuild",
@@ -1140,6 +1142,9 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "reply.tts.ok",
   "request",
   "request-received",
+  "request-size",
+  "request-size-compact",
+  "request-size-compact-error",
   "request-watch-fail",
   "request.error",
   "request.out",

package/src/cli/mcp-login.ts

@@ -11,6 +11,8 @@ import {
   prepareMcpOAuthAuthorization,
   authorizeMcpDevice,
   type McpOAuthFetch,
+  type AuthorizationServerMetadata,
+  type ProtectedResourceMetadata,
 } from '../mcp/mcp-oauth.js';
 import { parseWwwAuthenticate } from '../mcp/client.js';
 import { debug } from '../debug/log.js';
@@ -129,6 +131,7 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
       early: callbackListener,
       serverId: opts.serverId,
       resourceMetadataUrl: challenge.resourceMetadata,
+      discovered,
       ...(challenge.scope ? { scope: challenge.scope } : {}),
       resourceUrl: spec.url,
       ...oauthOpts,
@@ -245,6 +248,7 @@ function loginFailureStage(error: unknown): 'authorization' | 'token' | 'login'
 async function openLoginListener(opts: {
   serverId: string;
   resourceMetadataUrl: string;
+  discovered: { resource: ProtectedResourceMetadata; metadata: AuthorizationServerMetadata };
   scope?: string;
   resourceUrl: string;
   fetch?: McpOAuthFetch;
@@ -253,13 +257,14 @@ async function openLoginListener(opts: {
   onListener?: (server: Server) => void;
   early: Awaited<ReturnType<typeof listenForCallback>>;
 }): Promise<{ listener: Awaited<ReturnType<typeof listenForCallback>>; authorization: Awaited<ReturnType<typeof prepareMcpOAuthAuthorization>> }> {
-  const prior = await priorRegistration(opts);
+  const prior = loadStoredRegistration(opts.discovered.metadata.issuer, opts);
   const preferred = loopbackRedirectPort(prior?.redirectUri);
   if (preferred === null && (prior === null || prior.redirectUri)) {
     const listener = opts.early;
     debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'fresh' });
     const authorization = await prepareMcpOAuthAuthorization({
       resourceMetadataUrl: opts.resourceMetadataUrl,
+      discovered: opts.discovered,
       scope: opts.scope,
       redirectUri: listener.redirectUri,
       resourceUrl: opts.resourceUrl,
@@ -276,6 +281,7 @@ async function openLoginListener(opts: {
       debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'registered' });
       const authorization = await prepareMcpOAuthAuthorization({
         resourceMetadataUrl: opts.resourceMetadataUrl,
+        discovered: opts.discovered,
         scope: opts.scope,
         redirectUri: listener.redirectUri,
         resourceUrl: opts.resourceUrl,
@@ -296,6 +302,7 @@ async function openLoginListener(opts: {
   });
   const authorization = await prepareMcpOAuthAuthorization({
     resourceMetadataUrl: opts.resourceMetadataUrl,
+    discovered: opts.discovered,
     scope: opts.scope,
     redirectUri: listener.redirectUri,
     resourceUrl: opts.resourceUrl,
@@ -306,23 +313,6 @@ async function openLoginListener(opts: {
   return { listener, authorization };
 }
 
-async function priorRegistration(opts: {
-  resourceMetadataUrl: string;
-  resourceUrl: string;
-  fetch?: McpOAuthFetch;
-  storePath?: string;
-}): Promise<ReturnType<typeof loadStoredRegistration>> {
-  try {
-    const discovered = await discoverMcpOAuth(opts.resourceMetadataUrl, {
-      resourceUrl: opts.resourceUrl,
-      ...(opts.fetch ? { fetch: opts.fetch } : {}),
-    });
-    return loadStoredRegistration(discovered.metadata.issuer, opts);
-  } catch {
-    return null;
-  }
-}
-
 function isAddressInUse(error: unknown): boolean {
   return Boolean(error && typeof error === 'object' && 'code' in error && (error as { code: unknown }).code === 'EADDRINUSE');
 }