elanous 0.2.41 → 0.2.42

package/src/research/gap-followup.ts

@@ -18,6 +18,7 @@ export interface ResearchGapFollowupInput {
   request: string;
   questions: readonly BloomResearchQuestion[];
   evidence: readonly ResearchEvidenceEnvelope[];
+  signal?: AbortSignal;
   /** Optional remaining time supplied by the owning turn; omitted uses the fixed 2-minute cap. */
   remainingBudgetMs?: number;
   roundsUsed?: number;
@@ -128,6 +129,7 @@ export async function runGapFollowup(
   deps: ResearchGapFollowupDeps = {},
 ): Promise<ResearchGapFollowupResult> {
   const plan = planGapFollowup(input);
+  if (input.signal?.aborted) return { ...plan, followupEvidence: [], discoveryCards: [] };
   const startedAt = (deps.now ?? Date.now)();
   const deadline = startedAt + plan.timeBudgetMs;
   const discover = async (failedQuestions: ReadonlySet<string>): Promise<{ cards: string[]; evidence: ResearchEvidenceEnvelope[] }> => {
@@ -139,6 +141,9 @@ export async function runGapFollowup(
       const remainingMs = deadline - (deps.now ?? Date.now)();
       if (remainingMs <= 0) break;
       const controller = new AbortController();
+      const abortFromParent = () => controller.abort(input.signal?.reason);
+      input.signal?.addEventListener('abort', abortFromParent, { once: true });
+      if (input.signal?.aborted) abortFromParent();
       const timer = setTimeout(() => controller.abort(new Error('plugin discovery time budget exhausted')),
         Math.min(10_000, remainingMs));
       try {
@@ -158,7 +163,10 @@ export async function runGapFollowup(
           questionId: gap.questionId, reason: error instanceof Error ? error.message.slice(0, 160) : String(error).slice(0, 160),
         }, { level: 'warn' });
       }
-      finally { clearTimeout(timer); }
+      finally {
+        clearTimeout(timer);
+        input.signal?.removeEventListener('abort', abortFromParent);
+      }
     }
     return { cards, evidence };
   };
@@ -168,6 +176,9 @@ export async function runGapFollowup(
   }
 
   const controller = new AbortController();
+  const abortFromParent = () => controller.abort(input.signal?.reason);
+  input.signal?.addEventListener('abort', abortFromParent, { once: true });
+  if (input.signal?.aborted) abortFromParent();
   const timer = setTimeout(() => controller.abort(new Error('research gap follow-up time budget exhausted')),
     Math.max(1, deadline - (deps.now ?? Date.now)()));
   try {
@@ -200,6 +211,7 @@ export async function runGapFollowup(
     return { ...plan, followupEvidence: [...outcomes, ...discovered.evidence], discoveryCards: discovered.cards };
   } finally {
     clearTimeout(timer);
+    input.signal?.removeEventListener('abort', abortFromParent);
   }
 }
 

package/src/research/plugin-discovery.ts

@@ -136,15 +136,30 @@ function card(gap: string, candidates: readonly PluginDiscoveryCandidate[], inst
 
 /** One bounded, fail-soft discovery attempt for a research capability gap. */
 export async function discoverResearchPlugin(gapText: string, deps: PluginDiscoveryDeps = {}): Promise<PluginDiscoveryResult> {
+  const discoveryStartedAt = performance.now();
+  const log = deps.log ?? ((event: string, data: Record<string, unknown>) => debug.log('research.plugin-discovery', event, data));
+  const observe = (event: string, data: Record<string, unknown>): void => {
+    try { log(event, data); } catch { /* timing must not change discovery behavior */ }
+  };
+  observe('started', {});
+  const finish = (result: PluginDiscoveryResult): PluginDiscoveryResult => {
+    observe('completed', {
+      elapsedMs: Math.round((performance.now() - discoveryStartedAt) * 10) / 10,
+      outcome: result.outcome,
+      candidateCount: result.candidates.length,
+      installed: result.installed !== undefined,
+    });
+    return result;
+  };
   const gap = safeGap(gapText);
-  if (!gap) return { candidates: [], card: 'Plugin discovery skipped: unsafe or empty gap.', outcome: 'invalid-gap' };
+  if (!gap) return finish({ candidates: [], card: 'Plugin discovery skipped: unsafe or empty gap.', outcome: 'invalid-gap' });
   const aborted = (): PluginDiscoveryResult => ({ candidates: [], card: 'Plugin discovery skipped: time budget exhausted.', outcome: 'create-suggestion' });
-  if (deps.signal?.aborted) return aborted();
-  const log = deps.log ?? ((event: string, data: Record<string, unknown>) => debug.log('research.plugin-discovery', event, data));
+  if (deps.signal?.aborted) return finish(aborted());
   const threshold = Number.isSafeInteger(deps.githubStarThreshold) && (deps.githubStarThreshold as number) > 0
     ? deps.githubStarThreshold as number : configuredStarThreshold();
   const candidates: PluginDiscoveryCandidate[] = [];
 
+  const marketStartedAt = performance.now();
   try {
     const market = await (deps.market ?? (() => ensureMarketIndex('elanous')))();
     // A signed index is the only built-in source with a verifiable install spec.
@@ -159,15 +174,19 @@ export async function discoverResearchPlugin(gapText: string, deps: PluginDiscov
           installSpec: `${entry.name}@elanous` });
       }
     }
-  } catch { log('market-unavailable', { gap: gap.slice(0, 80) }); }
-  if (deps.signal?.aborted) return aborted();
+  } catch { observe('market-unavailable', { gap: gap.slice(0, 80) }); }
+  finally {
+    observe('stage-complete', { stage: 'signed-market', elapsedMs: Math.round((performance.now() - marketStartedAt) * 10) / 10 });
+  }
+  if (deps.signal?.aborted) return finish(aborted());
 
+  const searchStartedAt = performance.now();
   try {
     const found = await (deps.search ?? ((query: string, signal?: AbortSignal) => discoverCapability(query,
       { layer: 'skill', limit: MAX_CANDIDATES, community: false, signal })))(gap, deps.signal);
-    if (deps.signal?.aborted) return aborted();
+    if (deps.signal?.aborted) return finish(aborted());
     for (const hit of found.slice(0, MAX_CANDIDATES)) {
-      if (deps.signal?.aborted) return aborted();
+      if (deps.signal?.aborted) return finish(aborted());
       let url: URL;
       try { url = new URL(hit.url); } catch { continue; }
       if (url.protocol !== 'https:' || url.username || url.password) continue;
@@ -186,8 +205,11 @@ export async function discoverResearchPlugin(gapText: string, deps: PluginDiscov
           ? { installSpec: `https://github.com/${repo!.owner}/${repo!.repo}.git#${github.sha}` } : {}),
       });
     }
-  } catch { log('search-unavailable', { gap: gap.slice(0, 80) }); }
-  if (deps.signal?.aborted) return aborted();
+  } catch { observe('search-unavailable', { gap: gap.slice(0, 80) }); }
+  finally {
+    observe('stage-complete', { stage: 'capability-search', elapsedMs: Math.round((performance.now() - searchStartedAt) * 10) / 10 });
+  }
+  if (deps.signal?.aborted) return finish(aborted());
 
   const deduped = candidates.filter((item, index) => candidates.findIndex(other => other.url === item.url && other.name === item.name) === index)
     .slice(0, MAX_CANDIDATES);
@@ -197,20 +219,20 @@ export async function discoverResearchPlugin(gapText: string, deps: PluginDiscov
   if (installable.length === 1) {
     const candidate = installable[0]!;
     try {
-      if (deps.signal?.aborted) return aborted();
+      if (deps.signal?.aborted) return finish(aborted());
       const item = await (deps.install ?? defaultInstall)(candidate.installSpec!);
       const undo = `eln plugin remove ${item.name}`;
       installed = { name: item.name, path: item.path,
         notice: `Reason: missing research capability ${gap}; source: ${candidate.source}; permissions: ${candidate.permissions.join(', ') || 'none declared'}.`, undo };
-      log('installed', { name: item.name, source: candidate.source, undo });
+      observe('installed', { name: item.name, source: candidate.source, undo });
     } catch (error) {
-      log('install-refused', { name: candidate.name, reason: error instanceof Error ? error.message.slice(0, 120) : 'unknown' });
+      observe('install-refused', { name: candidate.name, reason: error instanceof Error ? error.message.slice(0, 120) : 'unknown' });
     }
   }
   const outcome: PluginDiscoveryResult['outcome'] = installed ? 'installed' : deduped.length ? 'proposed' : 'create-suggestion';
   const result = { candidates: deduped, installed, card: card(gap, deduped, installed), outcome };
-  log(outcome, { gap: gap.slice(0, 80), count: deduped.length, installed: installed?.name });
-  return result;
+  observe(outcome, { gap: gap.slice(0, 80), count: deduped.length, installed: installed?.name });
+  return finish(result);
 }
 
 /** Re-query through exactly one installed, declared read-only skill with no local-file or shell tools. */

package/src/research-bridge/invoke.ts

@@ -14,7 +14,7 @@
 // isolation without standing up the LLM stack.
 
 import type { ExternalResearchResult, InvokeResearchOpts } from './types.js';
-import type { SkillManifest } from '../skills/runner.js';
+import type { ExecuteSkillOpts, SkillManifest } from '../skills/runner.js';
 import type { BloomResearchQuestion } from '../auto-research/question-ladder-contract.js';
 import type { AxisFanoutDeps, AxisFanoutResult } from '../research/axis-fanout.js';
 import { recordResult } from './store.js';
@@ -76,8 +76,23 @@ export type ResearchInvoker = (
   args: string,
   onProgress?: (delta: string) => void,
   signal?: AbortSignal,
+  skillRootDir?: string,
 ) => Promise<ResearchInvocationOutcome>;
 
+export type ResearchSkillExecutorForTest = (
+  manifest: SkillManifest,
+  args: string,
+  onProgress?: (delta: string) => void,
+  opts?: ExecuteSkillOpts,
+) => Promise<{ finalResponse: string }>;
+
+let researchSkillExecutorForTest: ResearchSkillExecutorForTest | null = null;
+
+/** Replace only skill execution in tests; manifest parsing still uses the real selected skill root. */
+export function setResearchSkillExecutorForTest(executor: ResearchSkillExecutorForTest | null): void {
+  researchSkillExecutorForTest = executor;
+}
+
 let invoker: ResearchInvoker | null = null;
 
 /** Register the production / test invoker. Pass null to revert to
@@ -103,19 +118,21 @@ async function defaultInvoker(
   args: string,
   onProgress?: (delta: string) => void,
   signal?: AbortSignal,
+  skillRootDir?: string,
 ): Promise<ResearchInvocationOutcome> {
   const { parseSkillMd, executeSkill } = await import('../skills/runner.js');
-  const manifest = parseSkillMd(skillName);
+  const manifest = parseSkillMd(skillName, skillRootDir);
   if (!manifest) {
     return {
       output: '',
       ok: false,
-      error: `skill "${skillName}" not found under ~/.claude/skills/`,
+      error: `skill "${skillName}" not found under ${skillRootDir ?? '~/.claude/skills'}/`,
     };
   }
   try {
     // ★ research 격리 — 파일-쓰기 도구 deny 주입(main 트리 오염 차단). Bash·검색도구는 유지.
-    const result = await executeSkill(withResearchIsolation(manifest), args, (delta) => {
+    const run = researchSkillExecutorForTest ?? executeSkill;
+    const result = await run(withResearchIsolation(manifest), args, (delta) => {
       if (onProgress) onProgress(delta);
     }, { signal });
     return researchOutcomeFromSkillRun(result);
@@ -138,7 +155,7 @@ export async function invokeResearch(
 ): Promise<ExternalResearchResult> {
   const skillName = opts.skill || DEFAULT_SKILL;
   const startedAt = new Date();
-  const outcome = await (invoker ?? defaultInvoker)(skillName, topic, opts.onProgress, opts.signal);
+  const outcome = await (invoker ?? defaultInvoker)(skillName, topic, opts.onProgress, opts.signal, opts.skillRootDir);
   const finishedAt = new Date();
   const result: ExternalResearchResult = {
     topic,

package/src/research-bridge/types.ts

@@ -28,6 +28,8 @@ export interface ExternalResearchResult {
 export interface InvokeResearchOpts {
   /** Skill name override; default 'omni-crawl'. */
   skill?: string;
+  /** Root directory containing the selected catalog entry. */
+  skillRootDir?: string;
   /** Stream progress chunks back to the caller (e.g. dashboard chat
    *  pane) so the user sees activity for long-running invocations. */
   onProgress?: (delta: string) => void;

package/src/self-dev/decompose.ts

@@ -107,7 +107,7 @@ export interface SelfDevDecompositionMeta {
    *  `authored-empty`           Fabric 저작이 분해할 arc를 만들지 못했다
    *  `llm-failed`               LLM 호출 자체가 «실패»했다(타임아웃·제공자 장애) ⇒ 분해를 «못 한» 것이다
    *  ⛔ 「쪼갤 필요가 없었다」와 Fabric 사전분해 실패는 다른 값이다. */
-  outcome: 'decomposed' | 'single-no-subtasks' | 'missing-research-context' | 'grounding-empty' | 'authored-empty' | 'llm-failed';
+  outcome: 'decomposed' | 'single-no-subtasks' | 'slice-rejected' | 'missing-research-context' | 'grounding-empty' | 'authored-empty' | 'llm-failed';
   /** `llm-failed` 일 때만 실린다 — 문면의 «머리»를 자르지 않는다. */
   error?: string;
   /** Present for Fabric decomposition, including zero, to distinguish no omissions from no report. */
@@ -399,6 +399,10 @@ export function buildSelfDevDecomposePrompt(feature: string, maxTasks = DEFAULT_
     '- SEPARATE DEFINE FROM WIRE: adding a new function/type/export is a SEPARATE task from wiring it into an existing runtime call site. A task that both defines a new symbol AND integrates it across modules tends to leave dead-code (defined but never called) that fails integration gates. Pattern: (a) add the function + its unit test; then (b) a dependent task that wires it into the specific existing call site — name the exact `file.ts:function` to modify.',
     '- Exception to SEPARATE DEFINE FROM WIRE: Keep a definition and its registration/wiring in the same sub-feature — a handler with its route, a command with its CLI registration, a node with its graph/recipe entry.',
     '- Each sub-feature must be a self-contained, mergeable unit of work.',
+    '- LANDABLE SLICE CONTRACT: every sub-feature must state a completionBoundary that can be implemented and verified without a later sub-feature, future component, or unwired operational path. If it cannot stand alone, split it further or omit it.',
+    '- Every sub-feature must name one existing mock scenario as mockScenario.id (MS-01, MS-02, ...), plus a concrete mockScenario.injection and mockScenario.observation. Describe the event or input injected and the output/event that proves the slice works.',
+    '- List every required earlier slice explicitly in dependsOn. An empty list means this slice has no predecessor; never rely on implicit order or a future capability.',
+    '- Declare futureAssumptions as an array. If the slice needs any future component, later slice, or unwired operational path, list it there; that slice will be rejected with a decompose.slice-rejected event containing its id and reason, and must be split or omitted.',
     '- `dependsOn`: list the `id`s of sub-features that MUST land first (e.g. a shared',
     '  type/interface before its consumers). Independent sub-features share NO dependency',
     '  so they run in parallel. No cycles.',
@@ -410,8 +414,10 @@ export function buildSelfDevDecomposePrompt(feature: string, maxTasks = DEFAULT_
     '',
     '## Output (STRICT JSON — no prose, no code fence)',
     '{"subtasks":[{"id":"<short-slug>","feature":"<imperative sub-feature text>",',
-    '  "dependsOn":["<id>",...],"hotPaths":["<path>",...],',
-    '  "goalType":"<implement|research|document|operate>"}]}',
+    '  "completionBoundary":"<standalone change and observable outcome>",',
+    '  "mockScenario":{"id":"MS-01","injection":"<input/event injected>","observation":"<output/event observed>"},',
+    '  "futureAssumptions":[],"dependsOn":["<explicit predecessor id>",...],',
+    '  "hotPaths":["<path>",...],"goalType":"<implement|research|document|operate>"}]}',
   ].join('\n');
 }
 
@@ -421,6 +427,19 @@ interface RawSubtask {
   dependsOn?: unknown;
   hotPaths?: unknown;
   goalType?: unknown;
+  completionBoundary?: unknown;
+  mockScenario?: unknown;
+  futureAssumptions?: unknown;
+}
+
+interface RejectedDecompositionSlice {
+  id: string | null;
+  reasons: string[];
+}
+
+interface ValidatedDecomposition {
+  goals: SelfDevGoal[];
+  rejected: RejectedDecompositionSlice[];
 }
 
 const SELF_DEV_GOAL_TYPES = new Set(['implement', 'research', 'document', 'operate'] as const);
@@ -625,6 +644,90 @@ export function parseSelfDevDecomposition(
   return goals;
 }
 
+/** Parse the production decomposition contract and keep a reason for each rejected slice. */
+function parseValidatedSelfDevDecomposition(
+  subtasks: readonly unknown[],
+  defaults: { base?: string; autoMerge?: boolean },
+): ValidatedDecomposition {
+  const goals: SelfDevGoal[] = [];
+  const rejected: RejectedDecompositionSlice[] = [];
+  const allIds = new Set(subtasks.flatMap((value) => isRawSubtask(value)
+    && typeof value.id === 'string' && value.id.trim() ? [value.id.trim()] : []));
+  const seenIds = new Set<string>();
+
+  subtasks.forEach((value, index) => {
+    if (!isRawSubtask(value)) {
+      rejected.push({ id: null, reasons: ['slice must be an object'] });
+      return;
+    }
+    const feature = typeof value.feature === 'string' ? value.feature.trim() : '';
+    const id = typeof value.id === 'string' && value.id.trim() ? value.id.trim() : String(index);
+    const reasons: string[] = [];
+    const completionBoundary = typeof value.completionBoundary === 'string' ? value.completionBoundary.trim() : '';
+    if (!feature) reasons.push('feature is missing');
+    if (!completionBoundary) reasons.push('completionBoundary is missing');
+
+    const mock = value.mockScenario as { id?: unknown; injection?: unknown; observation?: unknown } | undefined;
+    const scenarioId = typeof mock?.id === 'string' ? mock.id.trim() : '';
+    const injection = typeof mock?.injection === 'string' ? mock.injection.trim() : '';
+    const observation = typeof mock?.observation === 'string' ? mock.observation.trim() : '';
+    if (!/^MS-[A-Z0-9][A-Z0-9-]*$/i.test(scenarioId)) reasons.push('mockScenario.id must be an MS id');
+    if (!injection) reasons.push('mockScenario.injection is missing');
+    if (!observation) reasons.push('mockScenario.observation is missing');
+
+    if (!Array.isArray(value.futureAssumptions)) reasons.push('futureAssumptions must be declared as an array');
+    else if (value.futureAssumptions.length > 0) reasons.push('future assumptions require split or omission');
+
+    if (value.dependsOn === undefined) reasons.push('dependsOn is missing; declare an explicit id array');
+    else if (!Array.isArray(value.dependsOn)) reasons.push('dependsOn must be an explicit id array');
+    const dependsOn = Array.isArray(value.dependsOn)
+      ? value.dependsOn.filter((dependency): dependency is string => typeof dependency === 'string' && dependency.trim().length > 0)
+      : [];
+    if (Array.isArray(value.dependsOn) && dependsOn.length !== value.dependsOn.length) reasons.push('dependsOn contains an invalid predecessor id');
+    for (const dependency of dependsOn) {
+      if (dependency === id || !allIds.has(dependency)) reasons.push(`dependsOn references a missing or self predecessor: ${dependency}`);
+    }
+
+    let uniqueId = id;
+    if (seenIds.has(uniqueId)) uniqueId = `${uniqueId}-${index}`;
+    seenIds.add(uniqueId);
+    if (reasons.length) {
+      rejected.push({ id, reasons: [...new Set(reasons)] });
+      return;
+    }
+
+    const llmHot = Array.isArray(value.hotPaths)
+      ? value.hotPaths.filter((path): path is string => typeof path === 'string')
+      : [];
+    const hotPaths = [...new Set([...llmHot, ...inferHotPaths(feature)])];
+    goals.push({
+      id: uniqueId,
+      feature,
+      completionBoundary,
+      mockScenario: { id: scenarioId, injection, observation },
+      ...(dependsOn.length ? { dependsOn } : {}),
+      ...(hotPaths.length ? { hotPaths } : {}),
+      ...(isSelfDevGoalType(value.goalType) ? { goalType: value.goalType } : {}),
+      ...defaults,
+    });
+  });
+
+  // A dependent slice cannot stay independently landable when its predecessor was rejected.
+  let removedDependent = true;
+  while (removedDependent) {
+    removedDependent = false;
+    const validIds = new Set(goals.map((goal) => goal.id));
+    for (const goal of [...goals]) {
+      const missing = (goal.dependsOn ?? []).filter((dependency) => !validIds.has(dependency));
+      if (missing.length === 0) continue;
+      goals.splice(goals.indexOf(goal), 1);
+      rejected.push({ id: goal.id ?? null, reasons: [`dependsOn references a rejected predecessor: ${missing.join(', ')}`] });
+      removedDependent = true;
+    }
+  }
+  return { goals, rejected };
+}
+
 /**
  * Decompose a feature into a self-dev DAG via the LLM seam. Falls back to
  * a single goal (the whole feature) when decomposition yields nothing —
@@ -710,10 +813,21 @@ export async function decomposeSelfDevGoal(
   const rawSubtasks = extractRawSubtasks(raw);
   const actualTaskCount = rawSubtasks.length;
   const decomposition: SelfDevDecompositionMeta = { recommendedMaxTasks: maxTasks, actualTaskCount, truncatedAtHardMax: actualTaskCount > hardMaxTasks, exceededRecommendedMax: actualTaskCount > maxTasks, outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed' };
-  const parsedGoals = parseSelfDevDecomposition(JSON.stringify({ subtasks: rawSubtasks.slice(0, hardMaxTasks) }), defaults);
+  const validated = parseValidatedSelfDevDecomposition(rawSubtasks.slice(0, hardMaxTasks), defaults);
+  for (const rejection of validated.rejected) {
+    debug.log(opts.observation?.category ?? 'self-dev.decompose', 'decompose.slice-rejected', {
+      ...observationIdentity(opts.observation ?? {}),
+      sliceId: rejection.id,
+      reasons: rejection.reasons,
+    }, { level: 'warn' });
+  }
+  const parsedGoals = validated.goals;
   const foldedGoals = foldRegistrationOnlyGoals(parsedGoals);
   const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(foldedGoals) : [single];
-  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
+  const finalDecomposition = parsedGoals.length === 0 && validated.rejected.length > 0
+    ? { ...decomposition, outcome: 'slice-rejected' as const }
+    : decomposition;
+  return finalizeDecomposition(feature, goals, finalDecomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
 /** Where the decompose model came from — `'explicit'` is the caller's `model` argument layer. */

package/src/self-dev/launch-preflight-text.ts

@@ -1,3 +1,5 @@
+import { parseTargetPathHintLine } from '../release-loop/checklist-target-path-hint.js';
+
 export type WorktreePathTouchAxis = 'touched' | 'untouched' | 'unreadable';
 
 /** 겹친 경로가 실제로 손대어졌는지의 읽기 전용 관측. */
@@ -534,15 +536,12 @@ export interface AskTargetPathHintsParseResult {
 }
 
 export function parseAskTargetPathHintsResult(askText: string): AskTargetPathHintsParseResult {
-  // ⛔ 첫 «비어 있지 않은» 줄만 본다 — 본문 전체를 훑으면 산문 속 경로까지 끌려와 오탐이 된다.
-  const firstLine = askText.split(/\r?\n/).find((line) => line.trim() !== '');
-  if (firstLine === undefined) return { paths: [], rejected: [], labelMissing: true };
-  const match = /^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]\s*(.*)$/i.exec(firstLine);
-  if (!match) return { paths: [], rejected: [], labelMissing: true };
+  const parsed = parseTargetPathHintLine(askText);
+  if (parsed.labelMissing) return { paths: [], rejected: [], labelMissing: true };
 
   const paths: string[] = [];
   const rejected: AskTargetPathHintRejection[] = [];
-  for (const fragment of match[1]!.split(/[·,]/)) {
+  for (const fragment of parsed.fragments) {
     const piece = fragment.trim().replace(/^`+|`+$/g, '');
     if (piece === '') rejected.push({ fragment, reason: 'empty' });
     // ⛔ 「경로처럼 생긴 것」만 남긴다 — 확장자나 디렉터리 구분자가 있어야 한다.

package/src/self-dev/orchestrate.ts

@@ -147,6 +147,16 @@ function shardIdentityFeature(feature: string, identity: SelfDevShardIdentity |
     : `${feature}\n\n## Shard identity\n${JSON.stringify(identity)}`;
 }
 
+function selfDevGoalFeature(goal: SelfDevGoal): string {
+  const { completionBoundary, mockScenario } = goal;
+  const acceptance: string[] = [];
+  if (completionBoundary?.trim()) acceptance.push(`Completion boundary: ${completionBoundary.trim()}`);
+  if (mockScenario?.id?.trim()) acceptance.push(`Mock scenario: ${mockScenario.id.trim()}`);
+  if (mockScenario?.injection?.trim()) acceptance.push(`Injection: ${mockScenario.injection.trim()}`);
+  if (mockScenario?.observation?.trim()) acceptance.push(`Observation: ${mockScenario.observation.trim()}`);
+  return acceptance.length ? `${goal.feature}\n\n## Slice acceptance\n${acceptance.join('\n')}` : goal.feature;
+}
+
 const SHARD_WORKING_MEMORY_EMIT_HINT =
   '\n\n## Working-memory handoff\nA downstream shard depends on this work. Before your final response, emit the following marker and one JSON object so it can reuse your findings. Put reusable boundaries in `reusables` and your key choices in `decisions`; use empty arrays when there are none.\n[WORKING-MEMORY]\n{"reusables":[],"decisions":[],"summary":"What this shard established for downstream work."}';
 
@@ -1236,7 +1246,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
     surfaceKind: 'self-implement',
     surface: (goal) => ({
       kind: 'self-implement',
-      feature: goal.feature,
+      feature: selfDevGoalFeature(goal),
       ...(goal.after !== undefined ? { after: goal.after } : {}),
       ...(goal.base !== undefined ? { base: goal.base } : {}),
       ...(goal.autoMerge !== undefined ? { autoMerge: goal.autoMerge } : {}),
@@ -1386,7 +1396,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
       const task = graph.getTask(taskId);
       if (task?.surface.kind === 'self-implement') {
         graph.updateTask(taskId, {
-          surface: { ...task.surface, feature: shardIdentityFeature(shard.goal.feature, identity) },
+          surface: { ...task.surface, feature: shardIdentityFeature(selfDevGoalFeature(shard.goal), identity) },
         }, { now: now() });
       }
     }

package/src/self-dev/review-provider-fallback.ts

@@ -230,6 +230,7 @@ export async function runSubscriptionReviewer(
 }
 
 export type ReviewFailureReason =
+  | 'credentials-unavailable'
   | 'overloaded'
   | 'rate-limited'
   | 'server-error'
@@ -238,11 +239,17 @@ export type ReviewFailureReason =
   | 'unknown-model-provider'
   | 'other';
 
-export type ReviewFallbackReason = Extract<ReviewFailureReason, 'overloaded' | 'rate-limited' | 'server-error' | 'timeout'>;
+export type ReviewFallbackReason = Extract<ReviewFailureReason, 'credentials-unavailable' | 'overloaded' | 'rate-limited' | 'server-error' | 'timeout'>;
 
 /** 실패 사유는 집계 가능한 유한 값으로 남긴다. */
 export function classifyReviewProviderFailure(message: string): ReviewFailureReason {
   const m = message.toLowerCase();
+  // Credential absence is provider-local: move to the next configured provider, then let the caller
+  // preserve its current artifact if every configured provider is keyless.
+  if ((m.includes('unavailable') && /(api\s*key|credentials?)/.test(m))
+    || /configure\s+(?:an?\s+)?api\s*key/.test(m)
+    || /(?:missing|no)\s+(?:provider\s+)?(?:api\s*)?key\b/.test(m)
+    || /credentials?\s+(?:are\s+)?unavailable/.test(m)) return 'credentials-unavailable';
   // ⭐ 실물 문면을 먼저 둔다 — `#10069` 가 낸 그 문장이다.
   if (m.includes('overloaded') || m.includes('server_overloaded')) return 'overloaded';
   if (m.includes('rate limit') || m.includes('rate_limit') || m.includes('429')) return 'rate-limited';
@@ -253,7 +260,7 @@ export function classifyReviewProviderFailure(message: string): ReviewFailureRea
 }
 
 function isReviewFallbackReason(reason: ReviewFailureReason): reason is ReviewFallbackReason {
-  return reason === 'overloaded' || reason === 'rate-limited' || reason === 'server-error' || reason === 'timeout';
+  return reason === 'credentials-unavailable' || reason === 'overloaded' || reason === 'rate-limited' || reason === 'server-error' || reason === 'timeout';
 }
 
 export interface ReviewProviderAttempt {

package/src/self-dev/run-supervisor.ts

@@ -7,6 +7,8 @@ import { authorRepairGoal } from '../harness/helper-repair.js';
 export type { SupervisorStopReason } from './run-types.js';
 export { SUPERVISOR_STOP_REASONS } from './run-types.js';
 import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
+import { readRunChart, recordRunChartDecision } from '../self-implement/run-chart.js';
+import { runLedgerDir } from '../self-implement/run-ledger.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { selectKnowhowPack } from '../self-implement/knowhow-pack.js';
@@ -215,8 +217,8 @@ export function needsHumanRepairGoal(result: SupervisorJobResult, reason: NeedsH
   const outside = expandedBeyondTargetPaths(result);
   const repairTargets = result.targetPaths?.length ? result.targetPaths : undefined;
   return [
-    `[supervisor-needs-human-repair:${reason}] ${NEEDS_HUMAN_REPAIR_INSTRUCTION[reason]}`,
     ...(repairTargets?.length ? [`대상 경로: ${repairTargets.join(', ')}`] : []),
+    `[supervisor-needs-human-repair:${reason}] ${NEEDS_HUMAN_REPAIR_INSTRUCTION[reason]}`,
     ...(outside.length ? [`대상 경로 밖 변경: ${outside.join(', ')}`] : []),
     ...(result.error?.message ? [`이전 실패: ${result.error.message.slice(0, 200)}`] : []),
     result.feature,
@@ -447,7 +449,7 @@ function mustFixScopeDecision(
   return { byTask, ...(split.length ? { split } : {}), ...(askOwner.length ? { askOwner } : {}) };
 }
 
-export function decideNextRun(input: {
+type DecideNextRunInput = {
   results: readonly SupervisorJobResult[];
   history?: readonly SupervisorRound[];
   limits?: SupervisorLimits;
@@ -463,7 +465,11 @@ export function decideNextRun(input: {
   needsHumanReasonRepairExecution?: boolean;
   /** 분해 제안을 실제 조각 실행으로 승격할 수 있는 supervisor 경로에만 true. */
   decompositionExecution?: boolean;
-}): SupervisorDecision {
+  /** Chart context available to the outer-supervisor judgment; pulled from this same run only. */
+  runChart?: readonly { device: string; stopKey: string; observed: string; verdict: string; action: string; handoff: string | null; why: string; readStopKeys: readonly string[] }[];
+};
+
+function decideNextRunCore(input: DecideNextRunInput): SupervisorDecision {
   const results = [...input.results];
   const history = [...(input.history ?? [])];
   const maxRounds = input.limits?.maxRounds ?? DEFAULT_MAX_ROUNDS;
@@ -923,6 +929,26 @@ export function decideNextRun(input: {
   };
 }
 
+/** Consume an unread doctor→reauthor chart handoff before returning a terminal exit. */
+export function decideNextRun(input: DecideNextRunInput): SupervisorDecision {
+  const decision = decideNextRunCore(input);
+  if (decision.action !== 'stop' || decision.stopReason === 'max-rounds') return decision;
+  const pendingReauthor = [...(input.runChart ?? [])].reverse().find((cell) => cell.handoff === 'reauthor'
+    && !input.runChart?.some((later) => later.device === 'outer-supervisor' && later.readStopKeys.includes(cell.stopKey)));
+  if (!pendingReauthor) return decision;
+  const eligible = input.results.filter((result) => decision.needsHuman.includes(result.taskId)
+    && result.status === 'failed' && result.feature.trim() && result.prNumber === undefined && !result.prUrl);
+  if (eligible.length === 0 || decision.round > (input.limits?.maxRounds ?? DEFAULT_MAX_ROUNDS)) return decision;
+  const taskIds = eligible.map((result) => result.taskId);
+  return { ...decision, action: 'relaunch', stopReason: undefined,
+    rerunnable: [...new Set([...decision.rerunnable, ...taskIds])],
+    needsHuman: decision.needsHuman.filter((taskId) => !taskIds.includes(taskId)),
+    classifications: decision.classifications.map((classification) => taskIds.includes(classification.taskId)
+      ? { ...classification, action: 'rerun' as const } : classification),
+    why: `run-chart handoff=reauthor consumed (${pendingReauthor.stopKey}) — needs-human 조각 ${taskIds.length}개를 재발사`,
+  };
+}
+
 export function appendRound(
   history: readonly SupervisorRound[],
   results: readonly SupervisorJobResult[],
@@ -1298,6 +1324,10 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
     const allUnreviewedAreNoDiff = unreviewed.length > 0
       && unreviewed.every((result) => result.reviewReason === 'no-diff');
 
+    const chartRunId = opts.runStore?.runId ?? results.find((result) => result.runId?.trim())?.runId ?? null;
+    const chartDir = opts.runStore?.dir ?? runLedgerDir();
+    const chartBeforeJudgment = chartRunId ? readRunChart(chartRunId, 'outer-supervisor', chartDir) : [];
+
     let decision = decideNextRun({
       results,
       history,
@@ -1309,11 +1339,19 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       ...(opts.limits ? { limits: opts.limits } : {}),
       ...(observed.deployFindings ? { deployFindings: observed.deployFindings } : {}),
       deliverableObservation: observed.state,
+      runChart: chartBeforeJudgment,
       ...(unreviewed.length > 0 ? {
         reviewed: false,
         ...(allUnreviewedAreNoDiff ? { reviewReason: 'no-diff' } : {}),
       } : {}),
     });
+    if (chartRunId) {
+      recordRunChartDecision({ runId: chartRunId, device: 'outer-supervisor',
+        stopKey: `${chartRunId}:outer-supervisor:${history.length + 1}`, observed: `results=${results.length}`,
+        verdict: decision.action, action: decision.action === 'stop' ? decision.stopReason ?? 'stop' : 'relaunch',
+        handoff: decision.action === 'stop' ? 'human' : 'macrophage', why: decision.why,
+        readStopKeys: chartBeforeJudgment.map((cell) => cell.stopKey), dir: chartDir });
+    }
 
     const reasonRepairSkipped = decision.action !== 'stop' || decision.stopReason !== 'needs-human' || history.length + 1 > maxRounds
       ? [] : results.flatMap((result) => {
@@ -1342,7 +1380,7 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
       }
     }
 
-    const runId = opts.runStore?.runId ?? results.find((result) => result.runId?.trim())?.runId ?? null;
+    const runId = chartRunId;
 
     let decomposePromotion: DecomposePromotionObservation = decision.decomposable.length === 0
       ? { attempted: false, reason: 'no-decomposable-decision' }

package/src/self-dev/run-types.ts

@@ -27,6 +27,10 @@ export interface SelfDevGoal {
   kind?: JobKind;
   /** Decomposition intent; deliberately distinct from executable `kind`. */
   goalType?: SelfDevGoalType;
+  /** Required for default-LLM decomposition slices; included in the child task prompt. */
+  completionBoundary?: string;
+  /** Existing simulation evidence required to make a decomposed slice independently reviewable. */
+  mockScenario?: { id: string; injection: string; observation: string };
   /** Feature/goal text → `elanous self implement <feature>` for dev jobs. */
   feature: string;
   /** Pod lease predecessor goal ID or PR number. */