elanous 0.2.41 → 0.2.43

package/src/repl/index.ts

@@ -41,6 +41,8 @@ import {
   type UserConfig,
 } from '../user-config.js';
 import { setAmbientSessionId, debug } from '../debug/log.js';
+import { buildInstalledSkillCatalogMessage, type InstalledSkillSummary } from '../dashboard/skill-catalog-preamble.js';
+import { resolveModelContextWindow } from '../models/context-window.js';
 import { decideSigintAction } from './sigint.js';
 import { decideSessionStart, observeSessionStart } from '../session/session-start.js';
 import { buildReplayTurnsFromSession } from './replay.js';
@@ -275,13 +277,39 @@ export function buildReplSystemPrompt(ctx: {
   sessionId?: string | undefined;
   /** 시험·임베디드 호출부용 시임 — 기본은 실제 홈·msg 원장·process.env. */
   seatBootDeps?: SeatBootDeps | undefined;
+  /** Installed skill summaries are injectable for deterministic prompt tests. */
+  skillCatalog?: readonly InstalledSkillSummary[] | undefined;
+  skillCatalogContextWindow?: number | null | undefined;
 }): string | undefined {
   const base = ctx.enabledToolNames === undefined
     ? undefined
     : buildAgentSystemPrompt(ctx.cfg, ctx.enabledToolNames);
+  const skillToolsEnabled = ctx.enabledToolNames?.includes('skill_exec') === true
+    && ctx.enabledToolNames.includes('elanous_skills_list');
+  let skillCatalogText = '';
+  if (skillToolsEnabled) {
+    try {
+      const catalog = ctx.skillCatalog ?? (() => {
+        const skills = require('../skills/index.js') as typeof import('../skills/index.js');
+        return skills.applySkillFilter(skills.getSkillIndex(), ctx.cfg.skills)
+          .map(({ name, description }) => ({ name, description }));
+      })();
+      const built = buildInstalledSkillCatalogMessage(
+        catalog,
+        ctx.skillCatalogContextWindow ?? resolveModelContextWindow(ctx.cfg.llm.model),
+      );
+      skillCatalogText = built.message?.content ?? '';
+      debug.log('repl.skill-catalog', 'built', {
+        skillCount: built.skillCount, estimatedTokens: built.estimatedTokens,
+        budgetTokens: built.budgetTokens, mode: built.mode,
+      });
+    } catch (error) {
+      debug.log('repl.skill-catalog', 'failed', { reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    }
+  }
   const card = buildSeatBootCardText(ctx);
-  if (card.length === 0) return base;
-  return base === undefined || base.length === 0 ? card : `${base}\n\n${card}`;
+  const parts = [skillCatalogText, base ?? '', card].filter(part => part.length > 0);
+  return parts.length > 0 ? parts.join('\n\n') : undefined;
 }
 
 /** 자리 부트 카드 문면(system 메시지 0~1개를 이어 붙인 것). 자리가 아니면 ''. */
@@ -344,6 +372,7 @@ async function runOneTurn(
   nextTuiDelivery?: { pending: PendingTaskNotification[] },
   onJsonDelta?: (delta: string) => void,
   onJsonStatus?: (line: string) => void,
+  onJsonReplace?: (fullText: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
@@ -374,6 +403,7 @@ async function runOneTurn(
     userConfig: cfg,
     sessionId,
     userText,
+    utteranceSurface: 'tui',
     systemPrompt,
     userImages: userImages.length > 0 ? userImages : undefined,
     ...(process.env.ELANOUS_TEST_FAKE_LLM === '1' && Number.isFinite(Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS))
@@ -387,6 +417,14 @@ async function runOneTurn(
       }
       else process.stdout.write(d);
     },
+    onReplaceText: (fullText) => {
+      if (jsonOutput) {
+        replyChunks.splice(0, replyChunks.length, fullText);
+        onJsonReplace?.(fullText);
+      } else {
+        process.stdout.write(`\n\n  [근거 반영된 답변]\n  ${fullText}\n`);
+      }
+    },
     onStatusLine: (line) => { onJsonStatus?.(line); },
     tools: replToolSpecs,
     dispatchTool: tools?.dispatch,
@@ -795,6 +833,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
           process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
             ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'status', turnId: turn.id, text })}\n`); }
             : undefined,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'replace', turnId: turn.id, text })}\n`); }
+            : undefined,
         );
       } catch (error) {
         if (!backgroundBridge) throw error;

package/src/research/axis-fanout.ts

@@ -1,7 +1,16 @@
 // Research-only native fanout. The caller supplies Bloom's question ladder;
 // each axis gets its own direct tool call and evidence stays attributed to it.
 import type { BloomResearchQuestion, ResearchEvidenceEnvelope } from '../auto-research/question-ladder-contract.js';
-import type { WebSearchHit } from '../web-search/provider.js';
+import { getAvailableResearchWebSearchProviders } from '../web-search/index.js';
+import type { WebSearchHit, WebSearchProvider } from '../web-search/provider.js';
+import { debug } from '../debug/log.js';
+
+const RESEARCH_SEARCH_ENGINES = ['exa', 'firecrawl'] as const;
+const RESEARCH_WEB_FALLBACK_IDS = ['exa', 'firecrawl'] as const;
+const RESEARCH_EXA_TIMEOUT_MS = 4_500;
+// Leave scheduler/logging headroom under the user-visible 15s aggregate cap.
+export const RESEARCH_SEARCH_BUDGET_MS = 14_500;
+const ENGINE_BREAKER_FAILURE_LIMIT = 2;
 
 export interface AxisToolCallPlan {
   questionId: string;
@@ -25,10 +34,124 @@ export interface AxisSearchResult {
   hits: AxisSearchHit[];
   errors: string[];
 }
-export type AxisSearch = (query: string) => Promise<AxisSearchHit[] | AxisSearchResult>;
+export interface AxisSearchContext {
+  questionPrompt?: string;
+  requestedWindow?: string;
+}
+export type AxisSearch = (query: string, signal?: AbortSignal, context?: AxisSearchContext) => Promise<AxisSearchHit[] | AxisSearchResult>;
 
 export interface AxisFanoutDeps {
   search?: AxisSearch;
+  signal?: AbortSignal;
+  admitToolCall?: (toolName: 'OmniSearch') => boolean;
+}
+
+interface ProviderHealth {
+  failures: number;
+  open: boolean;
+}
+
+/** Build one bounded searcher per research prepass. Research uses only the
+ * sequential Exa → Firecrawl fallback; Grok is reserved for explicit X intent.
+ * Per-engine serialization lets a timeout open that engine's
+ * breaker before queued Bloom axes start. */
+export function createResearchAxisSearcher(
+  availableProviders: readonly WebSearchProvider[] = getAvailableResearchWebSearchProviders(),
+  now: () => number = Date.now,
+): AxisSearch {
+  const webFallback = RESEARCH_WEB_FALLBACK_IDS.flatMap(id => availableProviders.filter(provider => provider.id === id));
+  const allowed = [...webFallback];
+  const health = new Map(allowed.map(provider => [provider.id, { failures: 0, open: false }]));
+  const deadline = now() + RESEARCH_SEARCH_BUDGET_MS;
+  const tails = new Map<string, Promise<void>>();
+
+  debug.log('research.search', 'provider-preflight', {
+    allowed: RESEARCH_SEARCH_ENGINES,
+    available: allowed.map(provider => provider.id),
+    excluded: availableProviders.filter(provider => !(RESEARCH_SEARCH_ENGINES as readonly string[]).includes(provider.id))
+      .map(provider => provider.id),
+    budgetMs: RESEARCH_SEARCH_BUDGET_MS,
+  });
+
+  const enqueue = <T>(providerId: string, run: () => Promise<T>): Promise<T> => {
+    const previous = tails.get(providerId) ?? Promise.resolve();
+    const current = previous.then(run, run);
+    tails.set(providerId, current.then(() => undefined, () => undefined));
+    return current;
+  };
+
+  return async (query, signal) => {
+    const hits: AxisSearchHit[] = [];
+    const errors: string[] = [];
+    const execute = async (provider: WebSearchProvider): Promise<boolean> => enqueue(provider.id, async () => {
+      const state = health.get(provider.id)!;
+      if (state.open) return false;
+      const remainingMs = deadline - now();
+      if (remainingMs <= 0) {
+        state.open = true;
+        errors.push(`${provider.id}: research search budget exhausted`);
+        return false;
+      }
+      const timeoutMs = provider.id === 'exa'
+        ? Math.min(RESEARCH_EXA_TIMEOUT_MS, remainingMs)
+        : remainingMs;
+      const startedAt = now();
+      try {
+        const controller = new AbortController();
+        const abortFromCaller = (): void => controller.abort(signal?.reason);
+        if (signal?.aborted) abortFromCaller();
+        else signal?.addEventListener('abort', abortFromCaller, { once: true });
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        let result;
+        try {
+          result = await Promise.race([
+            provider.search({ query, limit: 5 }, controller.signal),
+            new Promise<never>((_, reject) => {
+              timer = setTimeout(() => {
+                controller.abort();
+                reject(new DOMException(`${provider.id} research search timed out after ${timeoutMs}ms`, 'TimeoutError'));
+              }, timeoutMs);
+            }),
+          ]);
+        } finally {
+          if (timer !== undefined) clearTimeout(timer);
+          signal?.removeEventListener('abort', abortFromCaller);
+        }
+        if (result.hits.length === 0) {
+          state.failures += 1;
+          if (state.failures >= ENGINE_BREAKER_FAILURE_LIMIT) state.open = true;
+        } else {
+          state.failures = 0;
+          hits.push(...result.hits.map(hit => ({ ...hit, engine: provider.id })));
+        }
+        debug.log('research.search', 'provider-complete', {
+          provider: provider.id, queryLength: query.length, hits: result.hits.length,
+          durationMs: now() - startedAt, breakerOpen: state.open,
+        });
+        return result.hits.length > 0;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const timeout = error instanceof Error && /timeout|timed out|abort/i.test(`${error.name} ${error.message}`);
+        const quota = /quota|credit|rate.?limit|\b429\b|exhaust/i.test(message);
+        state.failures += 1;
+        if (timeout || quota || state.failures >= ENGINE_BREAKER_FAILURE_LIMIT) state.open = true;
+        errors.push(`${provider.id}: ${message}`);
+        debug.log('research.search', 'provider-failed', {
+          provider: provider.id, queryLength: query.length, durationMs: now() - startedAt,
+          timeout, quota, failures: state.failures, breakerOpen: state.open,
+        }, { level: 'warn' });
+        return false;
+      }
+    });
+    const runWebFallback = async (): Promise<void> => {
+      for (const provider of webFallback) {
+        if (!health.get(provider.id)?.open && await execute(provider)) return;
+      }
+    };
+    await runWebFallback();
+    if (hits.length === 0 && errors.length === 0) errors.push('no healthy Exa/Firecrawl research provider');
+    return { hits, errors };
+  };
 }
 
 /** Keep every query attached to the Bloom question that produced it. */
@@ -39,18 +162,6 @@ export function planAxisToolCalls(questions: readonly BloomResearchQuestion[]):
     .map(query => ({ questionId: question.id, tool: 'OmniSearch' as const, query })));
 }
 
-async function directOmniSearch(query: string): Promise<AxisSearchResult> {
-  const { dispatchOmniSearch } = await import('../skills/tools/omni-search.js');
-  const hits: AxisSearchHit[] = [];
-  const result = await dispatchOmniSearch({ query }, { onSource: hit => { hits.push(hit); } });
-  if (Object.keys(result.metadata.perEngine).length === 0) {
-    throw new Error('no available web-search providers');
-  }
-  const errors = Object.entries(result.metadata.perEngine)
-    .flatMap(([engine, info]) => info.error ? [`${engine}: ${info.error}`] : []);
-  return { hits, errors };
-}
-
 function evidenceFromHit(question: BloomResearchQuestion, hit: AxisSearchHit): ResearchEvidenceEnvelope {
   const published = hit.publishedAt;
   const date = published !== undefined && Number.isFinite(published) && published > 0
@@ -89,8 +200,17 @@ export async function fanOutAxisEvidence(
   if (new Set(questions.map(question => question.id)).size !== questions.length) {
     throw new Error('research axis question IDs must be unique');
   }
-  const search = deps.search ?? directOmniSearch;
-  const settled = await Promise.allSettled(plan.map(call => search(call.query)));
+  const search = deps.search ?? createResearchAxisSearcher();
+  const settled = await Promise.allSettled(plan.map(call => {
+    if (deps.admitToolCall && !deps.admitToolCall('OmniSearch')) {
+      return Promise.resolve({ hits: [], errors: ['research tool budget reached'] } satisfies AxisSearchResult);
+    }
+    const question = questions.find(candidate => candidate.id === call.questionId)!;
+    return search(call.query, deps.signal, {
+      questionPrompt: question.prompt,
+      requestedWindow: question.requestedWindow,
+    });
+  }));
   const axes: AxisEvidenceGroup[] = questions.map(question => ({ questionId: question.id, evidence: [] }));
   const groups = new Map(axes.map(axis => [axis.questionId, axis]));
   const byQuestion = new Map(questions.map(question => [question.id, question]));

package/src/research/bloom-exemplars.ts

@@ -34,10 +34,12 @@ const BLOOM_BY_LEVEL = Object.fromEntries(COGNITIVE_BY_LEVEL.map((cognitive, ind
   return [index + 1, cell];
 })) as Record<BloomExemplarLevel, Bloom2D>;
 
-// Public source tree intentionally contains only two original exemplars.
+// Public source tree intentionally contains a small set of original exemplars.
 const PUBLIC_EXEMPLARS: readonly BloomExemplar[] = [
   { domain: 'finance', level: 4, bloom: BLOOM_BY_LEVEL[4], question: '채권 금리 변화가 만기 구조와 발행자의 차환 위험에 어떤 경로로 연결되는가?' },
   { domain: 'finance', level: 5, bloom: BLOOM_BY_LEVEL[5], question: '현재 금리 전망을 반박할 수 있는 시장 지표와 그 신뢰도는 무엇인가?' },
+  { domain: 'technology', level: 4, bloom: BLOOM_BY_LEVEL[4], question: 'AI 데이터센터의 추론 처리량 증가가 GPU 전력밀도와 냉각 부하, 랙당 계통용량 요구에 어떤 경로로 이어지는가?' },
+  { domain: 'technology', level: 5, bloom: BLOOM_BY_LEVEL[5], question: 'AI 데이터센터 전력수요 전망을 반박할 수 있는 GPU 이용률·전력사용효율·계통접속 자료는 무엇이며 각 지표의 한계는 무엇인가?' },
 ];
 
 const DOMAIN_TERMS: Record<BloomExemplarDomain, readonly string[]> = {

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/ask-launch-flow.ts

@@ -29,8 +29,10 @@ import {
   renderConcurrentAuthoringNotice,
   renderLaunchPreflight,
   renderRepeatedBlockNotice,
+  renderSiblingContextLines,
   siblingTestPath,
   type AskPreflightDeps,
+  type SiblingContextCard,
   type LaunchPreflightResult,
   type PriorBlockSample,
   type RecentAuthoringSample,
@@ -245,6 +247,8 @@ export interface AskLaunchFlowInput {
   readonly goalType?: import('../self-implement/goal-author.js').GoalType;
   /** 런 식별자가 이미 있으면 앞단 관측을 그 키로 잇는다. 없으면 관측은 runId 없이 남는다. */
   readonly runId?: string;
+  /** CARD-TARGET-PATHS가 제공한 같은-경로 카드 관측. 발사 판정에는 쓰지 않는다. */
+  readonly cardsTouchingPaths?: readonly SiblingContextCard[];
   /** Explicit harness choice; false is distinct from omission. */
   readonly selfResolveClarifications?: boolean;
 }
@@ -258,6 +262,18 @@ export type AskLaunchFlowResult =
   /** ⑴ 저작에서 접지 예산(AUTHOR-TIMEBOX)을 넘겨 NOT-GROUNDED 로 끝났다 — 발사하지 «않는다». */
   | { readonly kind: 'stopped-by-timebox'; readonly goalFile: string };
 
+/**
+ * A harness entry can be named inside a request whose operative instruction is
+ * explicitly read-only. Require both a read-only marker and a no-write marker;
+ * either alone is too broad (for example, implementing a read-only feature).
+ */
+function isExplicitReadOnlyNoWriteRequest(text: string): boolean {
+  const normalized = text.normalize('NFKC').toLowerCase();
+  const readOnly = /(?:read[\s-]*only|readonly|읽기\s*전용|읽기만|파일\s*존재\s*여부만|상태만\s*확인)/u.test(normalized);
+  const noWrite = /(?:수정하지\s*마|변경하지\s*마|변경\s*금지|파일을?\s*만들지\s*마|쓰지\s*마|편집하지\s*마|no\s+(?:file\s+)?changes?|do\s+not\s+(?:edit|modify|write|create)|don't\s+(?:edit|modify|write|create)|without\s+(?:editing|modifying|writing)|\bcommit\b.{0,24}(?:하지\s*마|금지)|\bpush\b.{0,24}(?:하지\s*마|금지)|\bpr\b.{0,24}(?:하지\s*마|금지))/u.test(normalized);
+  return readOnly && noWrite;
+}
+
 /** ⑴ AUTHOR-TIMEBOX NOT-GROUNDED — 결과 줄을 쓰고 흐름을 끊는 값. */
 export type AskLaunchFlowTimeboxStop = Extract<AskLaunchFlowResult, { kind: 'stopped-by-timebox' }>;
 
@@ -858,9 +874,23 @@ export async function runAskLaunchFlow(
     // ⛔ 이 목록은 «광고»다 — 실제 단계와 어긋나면 조회하는 사람이 없는 단계를 찾거나 있는 단계를 안 찾는다.
     // ⛔ 분해 단계는 «두 이름 중 하나»로 난다 — 켜졌으면 `…-decomposition`, 꺼졌으면 `…-decomposition-skipped`.
     //   ⭐ 뒤엣것을 빼 두면 조회하는 사람이 「분해 관측이 0건이다」를 보고 «없어졌다»로 읽는다(실은 꺼진 것이다).
-    steps: ['ask-start', 'ask-pre-preflight', 'ask-authored', 'ask-launching-tree', 'ask-preflight', 'ask-launch-decomposition', 'ask-launch-decomposition-skipped', 'ask-launch'],
+    steps: ['ask-start', 'ask-readonly-no-launch', 'ask-pre-preflight', 'ask-authored', 'ask-launching-tree', 'ask-preflight', 'ask-launch-decomposition', 'ask-launch-decomposition-skipped', 'ask-launch'],
   }, 'info');
 
+  if (isExplicitReadOnlyNoWriteRequest(input.askText)) {
+    deps.log('ask-readonly-no-launch', {
+      entrance: entrance.id,
+      surface: entrance.surface,
+      inputSource: input.inputSource,
+      runId: input.runId ?? process.env.ELANOUS_RUN_ID ?? null,
+      authoringSkipped: true,
+      launchSkipped: true,
+      completionModeSelected: false,
+    }, 'info');
+    deps.print('[ask] 읽기 전용·변경 금지 요청으로 판정해 구현·자동 병합을 시작하지 않았습니다. TUI 읽기 도구로 결과만 확인하세요.');
+    return { kind: 'stopped-before-authoring' };
+  }
+
   const launchPreflight = await runPrePreflight(input, deps);
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
@@ -1036,6 +1066,47 @@ export async function runAskLaunchFlow(
     const preflight = decision.result;
     deps.print(renderLaunchPreflight(preflight, input.forceRequested && decision.shouldLaunch && preflight.blockers.length > 0, 'before-launch'));
     observeLaunchPreflight(deps, 'before-launch', decision);
+    let siblingCards = input.cardsTouchingPaths;
+    let siblingCardsUnmeasured = false;
+    if (siblingCards === undefined && preflight.paths.length > 0) {
+      try {
+        // CARD-TARGET-PATHS is a read-only signal: production entrances use the shared task-card store when
+        // no caller supplied a precomputed snapshot. The launch decision never depends on these matches.
+        const taskHand = await import('../task-agent/task-hand.js');
+        const state = taskHand.readTaskAgentState<{ tasks?: Record<string, import('../task-agent/task-hand.js').TaskCard> }>(taskHand.taskAgentStatePath());
+        siblingCards = taskHand.cardsTouchingPaths(Object.values(state.tasks ?? {}), preflight.paths)
+          .map(({ card, runId, paths }) => ({ cardId: card.id, ...(runId ? { runId } : {}), overlapPaths: paths }));
+      } catch (error) {
+        siblingCardsUnmeasured = true;
+        try { debug.log('self-dev.ask', 'sibling-context-cards-unmeasured', { reason: error instanceof Error ? error.message : String(error) }); }
+        catch { /* supplemental card context remains fail-soft */ }
+        siblingCards = [];
+      }
+    }
+    const siblingContextLines = renderSiblingContextLines(preflight, siblingCards);
+    const recentLanded = preflight.warnings.filter((warning) => warning.kind === 'recent-change' && preflight.paths.includes(warning.name)).length;
+    const siblingContextObservation = {
+      liveRuns: preflight.warnings.filter((warning) => warning.kind === 'live-run').length,
+      openPrs: preflight.warnings.filter((warning) => warning.kind === 'open-pr' || warning.kind === 'sibling-pr').length,
+      recentLanded,
+      unmeasured: siblingCardsUnmeasured || preflight.liveRuns.state === 'unknown' || preflight.openPrs.state === 'unknown' || preflight.recentChanges.state === 'unknown' || preflight.unreadableRuns > 0,
+    };
+    try { debug.log('self-dev.ask', 'sibling-context', siblingContextObservation); }
+    catch { /* sibling context observation must not change launch */ }
+    if (!sanitizeFailed && existsSync(goalFile)) {
+      try {
+        const document = deps.readFile(goalFile);
+        const firstSection = document.search(/^## /mu);
+        const header = siblingContextLines.join('\n');
+        const beforeFirstSection = firstSection < 0 ? document : document.slice(0, firstSection).trimEnd();
+        const contextualized = firstSection < 0
+          ? `${header}\n\n${document}`
+          : `${beforeFirstSection ? `${beforeFirstSection}\n` : ''}${header}\n형제가 같은 파일을 고친다 — 국소 변경만 · 무관 포맷 금지 · 자기 의도를 시험으로 고정\n\n${document.slice(firstSection)}`;
+        (deps.writeGoalDocument ?? deps.writeFile)(goalFile, contextualized);
+      } catch (error) {
+        deps.print(`[ask] 형제 맥락 기록 못 남김 (${error instanceof Error ? error.message : String(error)})`);
+      }
+    }
     // ⛔ 자식 격리 worktree를 만들기 전, 이 흐름을 호출한 작업 트리에서만 센다.
     //    이 관측은 발사 판정의 입력이 아니다 — 의도적으로 옛 판에서 쏘는 경우도 있다.
     const invokerBehindDefaultBranch = deps.measureInvokerBehindDefaultBranch?.()