elanous 0.2.37 → 0.2.40

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/format.ts

@@ -7,6 +7,7 @@
 //     into the chat pane so the user sees what was archived.
 
 import type { ExternalResearchResult } from './types.js';
+import type { ResearchOutputRouteDecision } from '../research/output-router.js';
 
 const PREFILL_OUTPUT_CAP = 6000;
 
@@ -19,13 +20,27 @@ export function formatResearchSummary(r: ExternalResearchResult): string {
   return head;
 }
 
-export function formatResearchPrefill(r: ExternalResearchResult): string {
+// TODO(AXIS-FANOUT): pass the route from the production caller when that upstream interface lands.
+// Keeping it optional preserves the existing prefill byte-for-byte until then.
+export function formatResearchPrefill(r: ExternalResearchResult, route?: ResearchOutputRouteDecision): string {
   const truncated = r.output.length > PREFILL_OUTPUT_CAP;
   const body = truncated ? r.output.slice(0, PREFILL_OUTPUT_CAP) + '\n\n…(truncated — see archive)' : r.output;
   const lines: string[] = [];
   lines.push('<external-research>');
   lines.push(`  <topic>${r.topic}</topic>`);
   lines.push(`  <skill>${r.skill}</skill>`);
+  if (route) {
+    lines.push(`  <output_format>${route.format}</output_format>`);
+    lines.push(`  <question_weight source="${route.weightSource}">${route.weight}</question_weight>`);
+    lines.push(`  <output_route_observation>${JSON.stringify(route.observation)}</output_route_observation>`);
+    if (route.skillCallPlan) {
+      lines.push(`  <output_skill>${route.skillCallPlan.skill}</output_skill>`);
+      lines.push('  <output_skill_args>');
+      lines.push(route.skillCallPlan.args);
+      lines.push('  </output_skill_args>');
+    }
+    if (route.fallbackReason) lines.push(`  <output_route_fallback>${route.fallbackReason}</output_route_fallback>`);
+  }
   lines.push(`  <duration_ms>${r.durationMs}</duration_ms>`);
   lines.push(`  <ok>${r.ok}</ok>`);
   lines.push(`  <output>`);

package/src/research-bridge/index.ts

@@ -7,6 +7,7 @@ export type {
 
 export {
   invokeResearch,
+  invokeResearchAxes,
   setResearchInvoker,
   type ResearchInvoker,
   type ResearchInvocationOutcome,

package/src/research-bridge/invoke.ts

@@ -15,6 +15,8 @@
 
 import type { ExternalResearchResult, InvokeResearchOpts } from './types.js';
 import type { 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';
 
 const DEFAULT_SKILL = 'omni-crawl';
@@ -31,6 +33,15 @@ const DEFAULT_SKILL = 'omni-crawl';
 // 조사 부작용만 원천 봉쇄. deny wins over allow(tool-policy). 순수·spread(원본 불변).
 export const RESEARCH_DENIED_TOOLS = ['Write', 'Edit', 'NotebookEdit'] as const;
 
+const ANSI_CONTROL_SEQUENCES = /\u001B(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001B\\))/g;
+
+/** Select the model's final answer, never the TUI-rendered tool transcript. */
+export function researchOutputFromSkillRun(
+  run: { finalResponse: string },
+): string {
+  return run.finalResponse.replace(ANSI_CONTROL_SEQUENCES, '');
+}
+
 export function withResearchIsolation(manifest: SkillManifest): SkillManifest {
   const deniedTools = [...new Set([...(manifest.deniedTools ?? []), ...RESEARCH_DENIED_TOOLS])];
   return { ...manifest, deniedTools };
@@ -45,10 +56,26 @@ export interface ResearchInvocationOutcome {
   error?: string;
 }
 
+/** A successful skill call with no final answer is an incomplete invocation. */
+export function researchOutcomeFromSkillRun(
+  run: { finalResponse: string },
+): ResearchInvocationOutcome {
+  const output = researchOutputFromSkillRun(run);
+  if (output.length === 0) {
+    return {
+      output,
+      ok: false,
+      error: 'skill run finished without a final assistant response',
+    };
+  }
+  return { output, ok: true };
+}
+
 export type ResearchInvoker = (
   skillName: string,
   args: string,
   onProgress?: (delta: string) => void,
+  signal?: AbortSignal,
 ) => Promise<ResearchInvocationOutcome>;
 
 let invoker: ResearchInvoker | null = null;
@@ -59,10 +86,23 @@ export function setResearchInvoker(fn: ResearchInvoker | null): void {
   invoker = fn;
 }
 
+/** Research-turn entry once Bloom has supplied its question axes. This uses
+ *  native search per axis; it never sends the entire request to a skill. */
+export async function invokeResearchAxes(
+  questions: readonly BloomResearchQuestion[],
+  deps: AxisFanoutDeps = {},
+): Promise<AxisFanoutResult> {
+  // Keep the generic chat entry's static module closure unchanged; axis search
+  // is loaded only for a Bloom research turn.
+  const { fanOutAxisEvidence } = await import('../research/axis-fanout.js');
+  return fanOutAxisEvidence(questions, deps);
+}
+
 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);
@@ -73,17 +113,15 @@ async function defaultInvoker(
       error: `skill "${skillName}" not found under ~/.claude/skills/`,
     };
   }
-  let buffered = '';
   try {
     // ★ research 격리 — 파일-쓰기 도구 deny 주입(main 트리 오염 차단). Bash·검색도구는 유지.
-    const result = await executeSkill(withResearchIsolation(manifest), args, (delta, full) => {
-      buffered = full;
+    const result = await executeSkill(withResearchIsolation(manifest), args, (delta) => {
       if (onProgress) onProgress(delta);
-    });
-    return { output: result.fullResponse || buffered, ok: true };
+    }, { signal });
+    return researchOutcomeFromSkillRun(result);
   } catch (err) {
     return {
-      output: buffered,
+      output: '',
       ok: false,
       error: err instanceof Error ? err.message : String(err),
     };
@@ -100,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 { countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
 import { observeFrontNodeEntry, observeFrontNodeExit, observeFrontNodeUnit, 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;
@@ -753,8 +750,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 +771,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;
 }