elanous 0.2.38 → 0.2.41

package/src/research/plugin-discovery.ts

@@ -0,0 +1,242 @@
+import { debug } from '../debug/log.js';
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { discoverCapability, type CapabilityCandidate } from '../agent-mission/discover-capability.js';
+import { ensureMarketIndex, type MarketIndex } from '../plugins/install/market-fetch.js';
+import { installPlugin, type InstalledPlugin } from '../plugins/install/plugin-install.js';
+import { getUserConfig } from '../user-config.js';
+
+const MAX_CANDIDATES = 5;
+const MAX_GAP_LENGTH = 240;
+const DEFAULT_GITHUB_STARS = 1_000;
+
+export type PluginDiscoverySource = 'signed-market' | 'official-external' | 'github' | 'other';
+export interface PluginDiscoveryCandidate {
+  name: string;
+  url: string;
+  source: PluginDiscoverySource;
+  description: string;
+  license?: string;
+  permissions: string[];
+  stars?: number;
+  trusted: boolean;
+  /** Only a verified signed-index entry is accepted by the built-in installer. */
+  installSpec?: string;
+}
+
+export interface PluginDiscoveryResult {
+  candidates: PluginDiscoveryCandidate[];
+  installed?: { name: string; path: string; notice: string; undo: string };
+  card: string;
+  outcome: 'installed' | 'proposed' | 'create-suggestion' | 'invalid-gap';
+}
+
+export interface PluginDiscoveryDeps {
+  signal?: AbortSignal;
+  market?: () => Promise<MarketIndex>;
+  search?: (gap: string, signal?: AbortSignal) => Promise<CapabilityCandidate[]>;
+  githubPackage?: (url: string, signal?: AbortSignal) => Promise<{ stars: number; sha?: string; license?: string; permissions?: string[] } | undefined>;
+  install?: (spec: string) => Promise<InstalledPlugin>;
+  /** Config seam; an invalid value fails closed to the default threshold. */
+  githubStarThreshold?: number;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}
+
+function safeGap(text: string): string | null {
+  const gap = text.normalize('NFKC').trim();
+  if (!gap || gap.length > MAX_GAP_LENGTH || /(?:api[_-]?key|password|secret|token|authorization|bearer|sk-[\w-]+|gh[pousr]_[\w-]+)/i.test(gap)) return null;
+  return gap.replace(/https?:\/\/\S+/g, '[url]');
+}
+
+function configuredStarThreshold(): number {
+  const raw = getUserConfig().raw as Record<string, unknown>;
+  const discovery = raw.pluginDiscovery;
+  const value = discovery && typeof discovery === 'object' && !Array.isArray(discovery)
+    ? (discovery as Record<string, unknown>).githubStarThreshold : undefined;
+  return Number.isSafeInteger(value) && (value as number) > 0 ? value as number : DEFAULT_GITHUB_STARS;
+}
+
+function words(text: string): string[] {
+  return (text.toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) ?? [])
+    .filter(word => !['missing', 'evidence', 'data', 'plugin', 'skill', 'tool', 'research', 'unavailable'].includes(word));
+}
+
+function relevance(gap: string, text: string): number {
+  const terms = new Set(words(gap));
+  if (terms.size === 0) return 0;
+  const haystack = new Set(words(text));
+  return [...terms].filter(term => haystack.has(term)).length / terms.size;
+}
+
+function officialExternal(url: URL): boolean {
+  return url.hostname === 'docs.anthropic.com' || url.hostname === 'code.claude.com'
+    || url.hostname === 'developers.openai.com' || url.hostname === 'openai.com'
+    || url.hostname === 'docs.x.ai' || url.hostname === 'x.ai';
+}
+
+function githubRepo(url: URL): { owner: string; repo: string } | null {
+  if (url.hostname !== 'github.com') return null;
+  const [owner, repo, ...rest] = url.pathname.split('/').filter(Boolean);
+  return owner && repo && rest.length === 0 && /^[\w.-]+$/.test(owner) && /^[\w.-]+$/.test(repo)
+    ? { owner, repo } : null;
+}
+
+async function defaultGithubPackage(raw: string, signal?: AbortSignal): Promise<{ stars: number; sha?: string; license?: string; permissions?: string[] } | undefined> {
+  const repo = githubRepo(new URL(raw));
+  if (!repo) return undefined;
+  const api = `https://api.github.com/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.repo)}`;
+  const options = {
+    headers: { accept: 'application/vnd.github+json' }, signal: AbortSignal.any([AbortSignal.timeout(5_000), ...(signal ? [signal] : [])]),
+  };
+  const response = await fetch(api, options);
+  if (!response.ok) return undefined;
+  const body = await response.json() as { stargazers_count?: unknown; default_branch?: unknown; size?: unknown;
+    archived?: unknown; license?: { spdx_id?: unknown } };
+  if (!Number.isSafeInteger(body.stargazers_count)) return undefined;
+  const metadata = { stars: body.stargazers_count as number,
+    ...(typeof body.license?.spdx_id === 'string' ? { license: body.license.spdx_id } : {}) };
+  if (body.archived === true || !Number.isSafeInteger(body.size) || (body.size as number) > 10_000
+    || typeof body.default_branch !== 'string') return metadata;
+  const commit = await fetch(`${api}/commits/${encodeURIComponent(body.default_branch)}`, options);
+  if (!commit.ok) return metadata;
+  const sha = (await commit.json() as { sha?: unknown }).sha;
+  if (typeof sha !== 'string' || !/^[a-fA-F0-9]{40}$/.test(sha)) return metadata;
+  const manifest = await fetch(`${api}/contents/plugin.json?ref=${sha}`, options);
+  if (!manifest.ok) return metadata;
+  const file = await manifest.json() as { type?: unknown; size?: unknown; content?: unknown; encoding?: unknown };
+  if (file.type !== 'file' || file.encoding !== 'base64' || !Number.isSafeInteger(file.size)
+    || (file.size as number) > 64_000 || typeof file.content !== 'string') return metadata;
+  try {
+    const parsed = JSON.parse(Buffer.from(file.content, 'base64').toString('utf8')) as { capabilities?: unknown };
+    const permissions = Array.isArray(parsed.capabilities)
+      ? parsed.capabilities.flatMap(value => value && typeof value === 'object'
+        && typeof value.kind === 'string' ? [value.kind as string] : []) : [];
+    return { ...metadata, sha, permissions };
+  } catch { return metadata; }
+}
+
+function defaultInstall(spec: string): Promise<InstalledPlugin> {
+  // The installer stages, verifies signature/hash and scans before moving into the plugin root.
+  // Capabilities and credentials require a separate user decision; no blanket --yes.
+  return installPlugin(spec, { consent: () => false, allowUnsigned: false });
+}
+
+function card(gap: string, candidates: readonly PluginDiscoveryCandidate[], installed?: PluginDiscoveryResult['installed']): string {
+  const lines = [`Plugin discovery · ${gap}`];
+  if (installed) lines.push(`Installed ${installed.name}. ${installed.notice} Undo: ${installed.undo}`);
+  for (const candidate of candidates) {
+    lines.push(`- ${candidate.name} · ${candidate.source} · ${candidate.trusted ? 'trusted source' : 'proposal only'} · ${candidate.url}`);
+    lines.push(`  ${candidate.description || 'No description'} · license: ${candidate.license ?? 'unknown'} · permissions: ${candidate.permissions.join(', ') || 'none declared'}${candidate.stars === undefined ? '' : ` · stars: ${candidate.stars}`}`);
+  }
+  if (candidates.filter(candidate => candidate.trusted && candidate.installSpec).length > 1)
+    lines.push('Several verified packages match. Choose one before installation.');
+  if (!candidates.length) lines.push('No matching plugin found. Suggest creating a skill or plugin draft for approval.');
+  return lines.join('\n');
+}
+
+/** One bounded, fail-soft discovery attempt for a research capability gap. */
+export async function discoverResearchPlugin(gapText: string, deps: PluginDiscoveryDeps = {}): Promise<PluginDiscoveryResult> {
+  const gap = safeGap(gapText);
+  if (!gap) return { 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));
+  const threshold = Number.isSafeInteger(deps.githubStarThreshold) && (deps.githubStarThreshold as number) > 0
+    ? deps.githubStarThreshold as number : configuredStarThreshold();
+  const candidates: PluginDiscoveryCandidate[] = [];
+
+  try {
+    const market = await (deps.market ?? (() => ensureMarketIndex('elanous')))();
+    // A signed index is the only built-in source with a verifiable install spec.
+    if (market.signature === 'ok' && market.index.name === 'elanous') {
+      for (const entry of market.index.plugins) {
+        const labels = [entry.name, entry.description ?? '', ...entry['ai.elanous'].capabilities,
+          ...(entry['ai.elanous'].vocab ?? [])].join(' ');
+        if (relevance(gap, labels) < 0.5) continue;
+        candidates.push({ name: entry.name, url: market.market.url, source: 'signed-market',
+          description: (entry.description ?? '').slice(0, 180), license: undefined,
+          permissions: [...entry['ai.elanous'].capabilities], trusted: true,
+          installSpec: `${entry.name}@elanous` });
+      }
+    }
+  } catch { log('market-unavailable', { gap: gap.slice(0, 80) }); }
+  if (deps.signal?.aborted) return aborted();
+
+  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();
+    for (const hit of found.slice(0, MAX_CANDIDATES)) {
+      if (deps.signal?.aborted) return aborted();
+      let url: URL;
+      try { url = new URL(hit.url); } catch { continue; }
+      if (url.protocol !== 'https:' || url.username || url.password) continue;
+      const repo = githubRepo(url);
+      const source: PluginDiscoverySource = repo ? 'github' : officialExternal(url) ? 'official-external' : 'other';
+      let github: Awaited<ReturnType<NonNullable<PluginDiscoveryDeps['githubPackage']>>>;
+      if (repo) {
+        try { github = await (deps.githubPackage ?? defaultGithubPackage)(url.href, deps.signal); } catch { /* metadata unavailable */ }
+      }
+      if (relevance(gap, `${hit.title} ${hit.snippet}`) === 0) continue;
+      candidates.push({ name: hit.title.slice(0, 100), url: url.href, source,
+        description: hit.snippet.slice(0, 180), permissions: github?.permissions ?? [],
+        stars: github?.stars, license: github?.license,
+        trusted: source === 'official-external' || (source === 'github' && github !== undefined && github.stars >= threshold),
+        ...(source === 'github' && github?.sha && github.stars >= threshold
+          ? { 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();
+
+  const deduped = candidates.filter((item, index) => candidates.findIndex(other => other.url === item.url && other.name === item.name) === index)
+    .slice(0, MAX_CANDIDATES);
+  const installable = deduped.filter(item => item.trusted && item.installSpec);
+  let installed: PluginDiscoveryResult['installed'];
+  // Ambiguous matches require a choice. Search-result URLs and stars alone never become install specs.
+  if (installable.length === 1) {
+    const candidate = installable[0]!;
+    try {
+      if (deps.signal?.aborted) return 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 });
+    } catch (error) {
+      log('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;
+}
+
+/** Re-query through exactly one installed, declared read-only skill with no local-file or shell tools. */
+export async function rerunInstalledPluginResearch(
+  gap: string, installation: NonNullable<PluginDiscoveryResult['installed']>, signal: AbortSignal,
+): Promise<{ ok: boolean; output: string; error?: string }> {
+  if (!safeGap(gap) || signal.aborted) return { ok: false, output: '', error: 'unsafe gap or expired budget' };
+  const root = join(installation.path, 'skills');
+  let names: string[];
+  try { names = readdirSync(root, { withFileTypes: true }).filter(item => item.isDirectory()).map(item => item.name); }
+  catch { return { ok: false, output: '', error: 'installed package has no skill directory' }; }
+  const { parseSkillMd, executeSkill } = await import('../skills/runner.js');
+  const safe = names.flatMap(name => {
+    const manifest = parseSkillMd(name, root);
+    return manifest?.sideEffects === 'none' ? [manifest] : [];
+  });
+  if (safe.length !== 1) return { ok: false, output: '', error: 'installed package has no unique declared read-only skill' };
+  const manifest = safe[0]!;
+  try {
+    const run = await executeSkill({ ...manifest,
+      allowedTools: ['WebSearch', 'WebFetch'],
+      deniedTools: [...new Set([...(manifest.deniedTools ?? []), 'Bash', 'Read', 'Write', 'Edit', 'NotebookEdit'])],
+    }, gap, () => {}, { signal });
+    const output = run.finalResponse.trim();
+    return { ok: output.length > 0, output, ...(output ? {} : { error: 'installed skill returned no research output' }) };
+  } catch (error) {
+    return { ok: false, output: '', error: error instanceof Error ? error.message : String(error) };
+  }
+}

package/src/research-bridge/invoke.ts

@@ -75,6 +75,7 @@ export type ResearchInvoker = (
   skillName: string,
   args: string,
   onProgress?: (delta: string) => void,
+  signal?: AbortSignal,
 ) => Promise<ResearchInvocationOutcome>;
 
 let invoker: ResearchInvoker | null = null;
@@ -101,6 +102,7 @@ async function defaultInvoker(
   skillName: string,
   args: string,
   onProgress?: (delta: string) => void,
+  signal?: AbortSignal,
 ): Promise<ResearchInvocationOutcome> {
   const { parseSkillMd, executeSkill } = await import('../skills/runner.js');
   const manifest = parseSkillMd(skillName);
@@ -115,7 +117,7 @@ async function defaultInvoker(
     // ★ research 격리 — 파일-쓰기 도구 deny 주입(main 트리 오염 차단). Bash·검색도구는 유지.
     const result = await executeSkill(withResearchIsolation(manifest), args, (delta) => {
       if (onProgress) onProgress(delta);
-    });
+    }, { signal });
     return researchOutcomeFromSkillRun(result);
   } catch (err) {
     return {
@@ -136,7 +138,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);
+  const outcome = await (invoker ?? defaultInvoker)(skillName, topic, opts.onProgress, opts.signal);
   const finishedAt = new Date();
   const result: ExternalResearchResult = {
     topic,

package/src/research-bridge/types.ts

@@ -31,4 +31,6 @@ export interface InvokeResearchOpts {
   /** 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;
+  /** Cancel a bounded automatic follow-up when its caller's time budget expires. */
+  signal?: AbortSignal;
 }

package/src/self-dev/ask-launch-flow.ts

@@ -38,17 +38,15 @@ import {
 import { execFileSync } from 'node:child_process';
 import { dirname, isAbsolute as isAbsolutePath, relative as relativePath, resolve as resolvePath, sep } from 'node:path';
 import {
-  applyClarificationReply,
   planClarificationIntake,
   selfAnswerGoalDocumentClarifications,
   type GoalClarificationSelfResolver,
 } from '../self-implement/goal-author-clarification.js';
-import { classifyReauthoredAsk, countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
-import { observeFrontNodeEntry, observeFrontNodeExit, observeFrontNodeUnit, type AuthorExitOutcome } from './graph-front-nodes.js';
+import { countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
+import { observeFrontNodeEntry, observeFrontNodeExit, runFrontNodeUnit, type AuthorExitOutcome } from './graph-front-nodes.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { decomposeSelfDevGoal, type SelfDevDecomposeOptions, type SelfDevDecomposition } from './decompose.js';
 import { observeDecomposerSelection, readFabricDecomposeConfig, selectFabricDecomposer } from './self-orchestrate-runtime.js';
-import type { GoalDocumentClarification } from '../self-implement/goal-author-clarification.js';
 
 export type SelfResolveClarificationsSource = 'flag' | 'default';
 
@@ -187,7 +185,6 @@ export interface AskLaunchFlowDeps {
   readLine(prompt: string): Promise<string>;
   /** Optional structured clarification adapter. Omitted callers retain the
    * existing CLI line-input contract exactly. */
-  readClarification?(clarification: GoalDocumentClarification): Promise<string>;
   selfResolveClarification?: GoalClarificationSelfResolver;
   /** Replaces the goal document after a self-answer; production entrances pass an atomic writer. */
   writeGoalDocument?(path: string, document: string): void;
@@ -409,21 +406,28 @@ export async function recommendLaunchDecomposition(
       fabricDecomposeConfig.autoPathThreshold,
     );
     const decomposeGoalType = input.goalType ?? declaredGoalType(input.askText);
+    const frontRunId = input.runId ?? process.env.ELANOUS_RUN_ID;
     observeFrontNodeEntry('decompose', {
       provenance: 'authoring-decomposition-start',
-      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
+      ...(decomposeGoalType === null ? {} : { goalType: decomposeGoalType }),
+    });
+    const result = await runFrontNodeUnit({
+      node: 'decompose',
+      execute: (goalDocument) => Promise.race([
+        deps.decomposeGoal
+          ? deps.decomposeGoal(goalDocument)
+          : decomposeSelfDevGoal(goalDocument, {
+            ...deps.decomposeOptions,
+            decomposer: selection.decomposer,
+            observation: prelaunchDecompositionObservation(goalDocument),
+          }),
+        timeout,
+      ]),
+    }, document!, {
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
       ...(decomposeGoalType === null ? {} : { goalType: decomposeGoalType }),
     });
-    const result = await observeFrontNodeUnit('decompose', input.runId ?? process.env.ELANOUS_RUN_ID, decomposeGoalType ?? undefined, () => Promise.race([
-      deps.decomposeGoal
-        ? deps.decomposeGoal(document!)
-        : decomposeSelfDevGoal(document!, {
-          ...deps.decomposeOptions,
-          decomposer: selection.decomposer,
-          observation: prelaunchDecompositionObservation(document!),
-        }),
-      timeout,
-    ]));
     if (result === timedOut) {
       // ⛔ 「시간 초과」를 「못 쟀다」로 뭉개지 않는다 — 분해기는 «아직 답하는 중»이고
       //   그 답은 `prelaunch-decomposition` 이름으로 «따로» 내려앉는다(위 주석).
@@ -753,8 +757,7 @@ async function runPrePreflight(
     : false;
 }
 
-/** ⑴b 되묻기 «수신» — 답이 들어가면 «재저작»하고 그 새 골을 돌려준다.
- *  ⛔ 무인 계약은 그대로다 — 대화형이 «아니면» 종전처럼 지나가고, 그 사실을 관측에 남긴다. */
+/** ⑴b 되묻기 intake — shared self-resolution policy, then continue with answered/deferred goal. */
 async function intakeClarifications(
   authored: AskAuthoredGoal,
   input: AskLaunchFlowInput,
@@ -775,113 +778,45 @@ async function intakeClarifications(
     interactive: deps.isInteractive(),
     goalFile: effectiveGoalFile,
   }, 'info');
-  if (mode === 'none') {
+  if (pending.length === 0) {
     deps.print('[ask] ⑴b 되묻기 없음 — 저작기가 물을 것이 없었다');
     return effectiveGoalFile;
   }
-  if (mode === 'deferred-noninteractive') {
-    // The resolver comes in through deps (I/O seam): production entrances pass the author
-    // self-resolver; a caller that injects none keeps the previous deferred behaviour.
-    if (selfResolveClarifications.value && deps.selfResolveClarification) try {
-      const resolution = await selfAnswerGoalDocumentClarifications(document, {
-        path: 'ask', ask: input.askText, resolver: deps.selfResolveClarification,
-      });
-      if (resolution.newlyAnswered > 0) {
-        (deps.writeGoalDocument ?? deps.writeFile)(effectiveGoalFile, resolution.document);
-        document = resolution.document;
-      }
-    } catch (error) {
-      deps.log('ask-clarify', { goalFile: effectiveGoalFile, reason: 'self-answer-failed', error: error instanceof Error ? error.message : String(error) }, 'warn');
-    }
-    const remaining = planClarificationIntake(document, false).pending;
-    // 미답으로 남은 문항만 기존 답변 창구를 안내한다.
-    deps.print(`[ask] ⑴b ⚠️ 미답 되묻기 ${remaining.length}건 — 저작은 그대로 간다 · 구현 전에 LLM 릴레이가 먼저 답하고, 못 하면 미답으로 진행한다 (사람을 기다리지 않는다)`);
-    for (const item of remaining) {
-      deps.print(`[ask]    ❓ [${item.questionId}] ${item.question}`);
-      item.options.forEach((option, index) => deps.print(`[ask]       ${index}) ${option.label}`));
+  // Deferred and interactive entrances share the same per-question resolution policy used by
+  // direct goal authoring. In particular, never read from the TUI here: unresolved stays DEFERRED.
+  if (selfResolveClarifications.value && deps.selfResolveClarification) try {
+    const resolution = await selfAnswerGoalDocumentClarifications(document, {
+      path: 'ask', ask: input.askText, resolver: deps.selfResolveClarification,
+    });
+    if (resolution.newlyAnswered > 0) {
+      (deps.writeGoalDocument ?? deps.writeFile)(effectiveGoalFile, resolution.document);
+      document = resolution.document;
     }
-    if (remaining.length > 0) {
-      const goalArg = deps.relativeToCwd(effectiveGoalFile);
-      deps.print(`[ask]    ▶ 답하려면: elanous self clarify answer ${goalArg} <questionId> <옵션번호>   (자유 답은 --other "<문장>")`);
-      deps.print(`[ask]    ▶ 답한 뒤 재저작: elanous self author --supersedes ${goalArg}`);
+  } catch (error) {
+    deps.log('ask-clarify', { goalFile: effectiveGoalFile, reason: 'self-answer-failed', error: error instanceof Error ? error.message : String(error) }, 'warn');
     }
-    return effectiveGoalFile;
-  }
-  deps.print(`[ask] ⑴b 저작기가 ${pending.length}건 묻는다 — 빈 줄은 건너뛴다(그 건은 DEFERRED 로 남는다)`);
-  let answeredCount = 0;
-  let seedQuestionId = '';
-  for (const item of pending) {
-    deps.print(`\n[ask] ❓ ${item.question}`);
-    item.options.forEach((option, index) => deps.print(`        ${index}) ${option.label} — ${option.description}`));
-    if (item.includeOther) deps.print('        (숫자 = 위 옵션 · 그 밖의 입력 = 자유 답 · 빈 줄 = 건너뜀)');
-    const reply = deps.readClarification
-      ? await deps.readClarification(item)
-      : await deps.readLine('        > ');
-    // ⛔ 「옵션인가 자유 답인가 · 빈 줄인가」 판정도 순수 seam 이 한다.
-    const applied = applyClarificationReply(document, item, reply);
-    if (!applied.answered) continue;
-    document = applied.document;
-    if (answeredCount === 0) seedQuestionId = item.questionId;
-    answeredCount += 1;
-  }
+  const remaining = planClarificationIntake(document, false).pending;
   deps.log('ask-clarify', {
-    inputSource: input.inputSource, goalFile: effectiveGoalFile,
-    pendingCount: pending.length, answeredCount, interactive: deps.isInteractive(),
-  }, 'info');
-  if (answeredCount === 0) {
-    deps.print('[ask] ⑴b 답이 없다 — 그대로 간다(미답은 골에 DEFERRED 로 남는다)');
-    return effectiveGoalFile;
-  }
-  deps.writeFile(effectiveGoalFile, document);
-  deps.print(`[ask] ⑴b ${answeredCount}건 답함 — 그 답을 시드로 «재저작»한다`);
-  // ⭐ `--from-clarification` 은 답한 것 «전부»를 시드로 가져간다(하나만 지목해도 된다).
-  const reauthored = await deps.authorGoal([], {
-    cwd: deps.cwd(),
-    ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
-    ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
-    fromClarification: `${deps.relativeToCwd(effectiveGoalFile)}#${seedQuestionId}`,
-    reauthorFromAnsweredClarification: true,
-    selfResolveClarifications: selfResolveClarifications.value,
-  });
-  const parentDocument = document;
-  effectiveGoalFile = isAbsolutePath(reauthored.path) ? reauthored.path : resolvePath(deps.cwd(), reauthored.path);
-  deps.print(`[ask] ⑴b 재저작됨: ${reauthored.path}`);
-  // 재저작도 «같은 저작 진입점»이다 — 접지가 예산 초과로 끊기면 같은 결과 줄을 쓴다(조용히 넘기지 않는다).
-  const reauthoredTimebox = reauthored.authored?.document === undefined
-    ? null
-    : readGoalAuthorGroundingTimebox(reauthored.authored.document);
-  if (reauthoredTimebox !== null) {
-    deps.print(formatGoalAuthorTimeboxResultLine(reauthored.path, reauthoredTimebox));
-    deps.log('ask-author-timebox', {
-      goalFile: reauthored.path,
-      provenance: 'reauthor',
-      outcome: 'NOT-GROUNDED',
-      budgetMs: reauthoredTimebox.budgetMs,
-      elapsedMs: reauthoredTimebox.elapsedMs,
-      grounded: reauthored.authored?.grounded ?? null,
-    }, 'warn');
-    // ⛔⭐⭐ 재저작 NOT-GROUNDED 도 «끝»이다 — 결과 줄을 쓰고 되묻기 이후 단계로 지나가지 않는다.
-    observeFrontNodeExit({ node: 'author', outcome: 'not-grounded' }, {
-      ...(input.runId === undefined ? {} : { runId: input.runId }),
-      attempt: 1, goalFile: effectiveGoalFile,
-      reason: `grounding-timebox-exhausted (budget ${reauthoredTimebox.budgetMs}ms, elapsed ${reauthoredTimebox.elapsedMs}ms)`,
-    });
-    return { kind: 'stopped-by-timebox', goalFile: effectiveGoalFile };
-  }
-  // ⛔ 「재저작이 «났다»」와 「재저작이 «옳았다»」는 다른 물음이다(JDG-T35 3단 ⑶).
-  const childDocument = reauthored.authored?.document ?? deps.readFile(effectiveGoalFile);
-  const askFidelity = classifyReauthoredAsk(parentDocument, childDocument);
-  if (askFidelity !== 'preserved') {
-    deps.print(`[ask] ⑴b ⚠️ 재저작 ask 판정: ${askFidelity} — ⛔ 「preserved」가 아니면 사람의 ask 가 살아남았는지 «확인하라»`);
+    goalFile: effectiveGoalFile, pendingCount: pending.length,
+    selfAnsweredCount: pending.length - remaining.length, unansweredCount: remaining.length,
+    interactive: deps.isInteractive(), continuedWithoutPrompt: true,
+  }, remaining.length ? 'warn' : 'info');
+  if (remaining.length > 0) {
+    deps.print(`[ask] ⑴b ⚠️ 미답 되묻기 ${remaining.length}건 — 골에 DEFERRED 로 기록하고 사람 입력을 기다리지 않고 진행한다`);
+    const goalFile = deps.relativeToCwd(effectiveGoalFile);
+    for (const item of remaining) {
+      deps.print(`[ask]    ❓ [${item.questionId}] ${item.question} — DEFERRED`);
+      if (item.options.length > 0) {
+        deps.print(`[ask]       선택지 답변: elanous self clarify answer ${goalFile} ${item.questionId} <0-based-optionIndex>`);
+      }
+      if (item.includeOther) {
+        deps.print(`[ask]       자유 답변: elanous self clarify answer ${goalFile} ${item.questionId} --other "<답>"`);
+      }
+      deps.print(`[ask]       골을 다시 저작하려면: elanous self author --from-clarification ${goalFile}#${item.questionId}`);
+    }
+  } else {
+    deps.print(`[ask] ⑴b ${pending.length}건 자동 후보 선택 — 근거와 가정을 골에 기록했다`);
   }
-  deps.log('ask-reauthored', {
-    inputSource: input.inputSource, fromGoalFile: authored.path,
-    goalFile: reauthored.path, answeredCount,
-    grounded: reauthored.authored?.grounded ?? null,
-    askFidelity,
-    selfResolveClarifications: selfResolveClarifications.value,
-    selfResolveClarificationsSource: selfResolveClarifications.source,
-  }, 'info');
   return effectiveGoalFile;
 }
 
@@ -943,25 +878,32 @@ export async function runAskLaunchFlow(
     //   ⛔ 선언이 «없을 때» 넘기면 안 된다 — 저작기의 정식 기본값을 덮어쓰게 된다.
     const declaredAskGoalType = declaredGoalType(input.askText);
     const goalType = input.goalType ?? declaredAskGoalType;
+    const frontRunId = input.runId ?? process.env.ELANOUS_RUN_ID;
     const frontObservation = {
-      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
       ...(goalType === null ? {} : { goalType }),
     };
     // ⭐ RFC §5 5단계 — 확인된 implement 저작만 활성 구현 그래프에 이름을 잇는다.
     observeFrontNodeEntry('author', { ...frontObservation, provenance: 'authoring-start' });
-    const authored = await deps.authorGoal([authorAskText], {
-      cwd: deps.cwd(),
-      ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
-      ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
+    const authored = await runFrontNodeUnit({
+      node: 'author',
+      execute: (text, context) => deps.authorGoal([text], {
+        cwd: deps.cwd(),
+        ...(input.groundingCwd === undefined ? {} : { groundingCwd: input.groundingCwd }),
+        ...(input.authorGrade === undefined ? {} : { authorGrade: input.authorGrade }),
+        ...(context.goalType === undefined ? {} : { goalType: context.goalType }),
+        // ⛔ 인라인 ask(`harness say`)는 askFile 이 없다 — 그 칸을 넘기면 저작기가 빈 줄을 쓴다.
+        ...(() => {
+          if (input.inputSource !== 'ask' || input.askFile === undefined) return {};
+          const askFile = lineageAskFile(input.askFile);
+          return askFile === undefined ? {} : { askFile };
+        })(),
+        ...(launchPreflight === undefined ? {} : { launchPreflight }),
+        selfResolveClarifications: selfResolveClarifications.value,
+      }),
+    }, authorAskText, {
+      ...(frontRunId === undefined ? {} : { runId: frontRunId }),
       ...(goalType === null ? {} : { goalType }),
-      // ⛔ 인라인 ask(`harness say`)는 askFile 이 없다 — 그 칸을 넘기면 저작기가 빈 줄을 쓴다.
-      ...(() => {
-        if (input.inputSource !== 'ask' || input.askFile === undefined) return {};
-        const askFile = lineageAskFile(input.askFile);
-        return askFile === undefined ? {} : { askFile };
-      })(),
-      ...(launchPreflight === undefined ? {} : { launchPreflight }),
-      selfResolveClarifications: selfResolveClarifications.value,
     }).catch((error: unknown) => {
       // GRAPH-AUTHOR-FAIL-EDGE: 저작기가 던진 자리 = author `fail` 출구. ⛔ 관측만 하고 같은 오류를 그대로 다시 던진다.
       observeFrontNodeExit({ node: 'author', outcome: 'fail' }, {

package/src/self-dev/dev-cli.ts

@@ -25,8 +25,7 @@ import { inspectDecisionObservations, inspectDecisionSignalKinds, inspectDecisio
 import type { EvidenceMode } from '../agent-mission/driver.js';
 import type { PreparedDevWorktree } from '../harness/harness-worktree-auto.js';
 import type { ChildLlmEffort, ChildLlmSelection } from '../agent/run-context.js';
-import { reasoningEffortCeiling } from '../intelligence-map/model-catalog.js';
-import type { ReasoningEffortCeiling } from '../intelligence-map/model-catalog.js';
+import { reasoningEffortCeiling, childLlmEffortProblem, type ReasoningEffortCeiling } from '../intelligence-map/model-catalog.js';
 import { tierModel } from '../llm/model-defaults.js';
 import { LLM_TIER_MAP_BY_PROVIDER } from '../model-tier/llm-tier-map.js';
 import { MODEL_TIERS } from '../model-tier/types.js';
@@ -225,6 +224,10 @@ export interface DevSelfRunSuperviseOptions {
   queryTerminalRunStatuses?: (runIds: readonly string[], timeoutMs: number) => Readonly<Record<string, string>> | undefined;
   nowMs?: () => number;
   printDecision?: (line: string) => void;
+  /** Test-only supervisor side-effect seams. */
+  taskAgentShadow?: false;
+  taskAgentRejudge?: false;
+  sweepPendingMerges?: typeof import('../self-implement/frozen-merges.js').sweepFrozenMerges;
 }
 
 export interface DevSelfRunExecution {
@@ -1047,8 +1050,11 @@ export async function executeDevSelfRun(
     executedRounds = 1;
     if (!supervise) return { result };
 
-    const asSupervisorJobResult = (currentFeature: string, current: SelfImplementResult) => singleRunAsJobResult(currentFeature, current);
-    const initialJob = singleRunAsJobResult(feature, result);
+    const reasonRepairEnabled = getUserConfig().tools.selfImplement.supervisor?.reasonRepair === true
+      && supervise.executePiece !== undefined;
+    const asSupervisorJobResult = (currentFeature: string, current: SelfImplementResult) =>
+      singleRunAsJobResult(currentFeature, current, reasonRepairEnabled);
+    const initialJob = singleRunAsJobResult(feature, result, reasonRepairEnabled);
     const wiring = supervise.deliverableDocument === undefined
       ? undefined
       : buildDeliverableTargets(supervise.deliverableDocument, ['single'], 'all', '127.0.0.1');
@@ -1113,9 +1119,15 @@ export async function executeDevSelfRun(
     }
     await superviseRun({
       initial: [initialJob],
+      ...(supervise.taskAgentShadow === false ? { taskAgentShadow: false } : {}),
+      ...(supervise.taskAgentRejudge === false ? { taskAgentRejudge: false } : {}),
+      ...(supervise.sweepPendingMerges ? { sweepPendingMerges: supervise.sweepPendingMerges } : {}),
+      // Pod worktree paths are not necessarily mounted in this parent process.
+      knowhowRepo: process.cwd(),
       // A review-oscillation repair goal runs through the existing piece executor (fragment re-execution with the
       // authored goal as its feature). Without that executor the rerun could only replay the same goal — declare false.
       repairGoalExecution: supervise.executePiece !== undefined,
+      needsHumanReasonRepairExecution: reasonRepairEnabled,
       enrich: (results) => hydrateDevGoalCauseObserved(
         hydrateDevDecomposeProposals(results, supervise.readProposals ?? readDecomposeProposals),
       ),
@@ -1576,7 +1588,7 @@ export function __resetStaleOpenRouterSnapshotWarningForTests(): void {
   staleOpenRouterSnapshotWarned = false;
 }
 
-export const CHILD_LLM_EFFORT_LADDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+export { CHILD_LLM_EFFORT_LADDER } from '../intelligence-map/model-catalog.js';
 
 export function childLlmEffortCeiling(_provider: string, model: string): ReasoningEffortCeiling {
   return reasoningEffortCeiling(resolveModelAlias(model.trim()) ?? model.trim());
@@ -1586,20 +1598,10 @@ export function resolveChildLlmEffort(
   provider: string, model: string, entered: string,
 ): { effort: ChildLlmEffort; ceiling: ReasoningEffortCeiling } {
   const value = entered.trim().toLowerCase();
-  const ladder: readonly string[] = CHILD_LLM_EFFORT_LADDER;
-  if (!ladder.includes(value)) {
-    throw new DevPipelineError(`--child-llm-effort 알 수 없음: ${entered} · 후보: ${CHILD_LLM_EFFORT_LADDER.join(', ')}`);
-  }
+  const problem = childLlmEffortProblem(model, entered);
+  if (problem) throw new DevPipelineError(problem);
   const effort = value as ChildLlmEffort;
   const ceiling = childLlmEffortCeiling(provider, model);
-  if (ceiling === 'none') {
-    throw new DevPipelineError(`--child-llm-effort 거부: ${model} 은 추론 노력을 «안 받는다»(ceiling=none)`);
-  }
-  if (ladder.indexOf(effort) > ladder.indexOf(ceiling)) {
-    throw new DevPipelineError(
-      `--child-llm-effort 거부: ${effort} 가 ${model} 의 상한(${ceiling})을 넘는다`,
-    );
-  }
   return { effort, ceiling };
 }