elanous 0.2.42 → 0.2.44

package/src/research/axis-fanout.ts

@@ -1,12 +1,14 @@
 // 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 { getAvailableWebSearchProviders } from '../web-search/index.js';
+import { getAvailableResearchWebSearchProviders } from '../web-search/index.js';
 import type { WebSearchHit, WebSearchProvider } from '../web-search/provider.js';
 import { debug } from '../debug/log.js';
+import { dispatchWebFetch } from '../skills/tools/webfetch.js';
 
-const RESEARCH_SEARCH_ENGINES = ['grok', 'grok-api', 'firecrawl'] as const;
-const RESEARCH_GROK_TIMEOUT_MS = 8_000;
+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;
@@ -33,11 +35,17 @@ export interface AxisSearchResult {
   hits: AxisSearchHit[];
   errors: string[];
 }
-export type AxisSearch = (query: string, signal?: AbortSignal) => 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;
+  fetchPage?: (url: string, question: BloomResearchQuestion, signal?: AbortSignal) => Promise<{ url: string; output: string }>;
   signal?: AbortSignal;
+  admitToolCall?: (toolName: 'OmniSearch' | 'WebFetch') => boolean;
 }
 
 interface ProviderHealth {
@@ -45,20 +53,16 @@ interface ProviderHealth {
   open: boolean;
 }
 
-/** Build one bounded searcher per research prepass. Free/DDG is deliberately
- * excluded: it is not a safe fallback for stock research and can consume a
- * full 15s timeout for every query. Per-engine serialization lets the first
- * timeout open that engine's breaker before queued Bloom axes start. */
+/** 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[] = getAvailableWebSearchProviders(),
+  availableProviders: readonly WebSearchProvider[] = getAvailableResearchWebSearchProviders(),
   now: () => number = Date.now,
 ): AxisSearch {
-  const grok = availableProviders.find(provider => provider.id === 'grok')
-    ?? availableProviders.find(provider => provider.id === 'grok-api');
-  const allowed = [
-    ...(grok ? [grok] : []),
-    ...availableProviders.filter(provider => provider.id === 'firecrawl'),
-  ];
+  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>>();
@@ -81,23 +85,18 @@ export function createResearchAxisSearcher(
   return async (query, signal) => {
     const hits: AxisSearchHit[] = [];
     const errors: string[] = [];
-    const selected = allowed.filter(provider => !health.get(provider.id)?.open);
-    if (selected.length === 0) return { hits, errors: ['no healthy Grok/Firecrawl research provider'] };
-
-    await Promise.all(selected.map(provider => enqueue(provider.id, async () => {
+    const execute = async (provider: WebSearchProvider): Promise<boolean> => enqueue(provider.id, async () => {
       const state = health.get(provider.id)!;
-      if (state.open) return;
+      if (state.open) return false;
       const remainingMs = deadline - now();
       if (remainingMs <= 0) {
         state.open = true;
         errors.push(`${provider.id}: research search budget exhausted`);
-        return;
+        return false;
       }
-      const activeCount = Math.max(1, allowed.filter(candidate => !health.get(candidate.id)?.open).length);
-      const isGrok = provider.id === 'grok' || provider.id === 'grok-api';
-      const timeoutMs = isGrok
-        ? Math.min(RESEARCH_GROK_TIMEOUT_MS, remainingMs)
-        : Math.max(1, Math.floor(remainingMs / activeCount));
+      const timeoutMs = provider.id === 'exa'
+        ? Math.min(RESEARCH_EXA_TIMEOUT_MS, remainingMs)
+        : remainingMs;
       const startedAt = now();
       try {
         const controller = new AbortController();
@@ -131,6 +130,7 @@ export function createResearchAxisSearcher(
           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}`);
@@ -142,8 +142,16 @@ export function createResearchAxisSearcher(
           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 };
   };
 }
@@ -195,7 +203,35 @@ export async function fanOutAxisEvidence(
     throw new Error('research axis question IDs must be unique');
   }
   const search = deps.search ?? createResearchAxisSearcher();
-  const settled = await Promise.allSettled(plan.map(call => search(call.query, deps.signal)));
+  const fetchPage = deps.fetchPage ?? (!deps.search
+    ? async (url: string, question: BloomResearchQuestion, signal?: AbortSignal) =>
+      dispatchWebFetch({ url, prompt: question.prompt }, { signal })
+    : undefined);
+  const fetchedQuestions = new Set<string>();
+  const settled = await Promise.allSettled(plan.map(async call => {
+    if (deps.admitToolCall && !deps.admitToolCall('OmniSearch')) {
+      return { hits: [], errors: ['research tool budget reached'] } satisfies AxisSearchResult;
+    }
+    const question = questions.find(candidate => candidate.id === call.questionId)!;
+    const raw = await search(call.query, deps.signal, {
+      questionPrompt: question.prompt,
+      requestedWindow: question.requestedWindow,
+    });
+    const response = Array.isArray(raw) ? { hits: raw, errors: [] } : raw;
+    if (!fetchPage || response.hits.length === 0 || fetchedQuestions.has(question.id)) return response;
+    fetchedQuestions.add(question.id);
+    if (deps.admitToolCall && !deps.admitToolCall('WebFetch')) return response;
+    try {
+      const page = await fetchPage(response.hits[0]!.url, question, deps.signal);
+      return { ...response, fetchedPage: page };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      debug.log('research.search', 'native-fetch-failed', {
+        questionId: question.id, reason: message.slice(0, 200),
+      }, { level: 'warn' });
+      return response;
+    }
+  }));
   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]));
@@ -211,10 +247,24 @@ export async function fanOutAxisEvidence(
     const group = groups.get(call.questionId)!;
     const question = byQuestion.get(call.questionId)!;
     if (outcome.status === 'fulfilled') {
-      const response = Array.isArray(outcome.value) ? { hits: outcome.value, errors: [] } : outcome.value;
+      const response = outcome.value;
       if (response.hits.length === 0 && response.errors.length === 0) {
         group.evidence.push({ ...failedEvidence(question, call.query, 'no hits returned'), outcome: 'partial' });
       }
+      const fetchedPage = 'fetchedPage' in response ? response.fetchedPage : undefined;
+      if (fetchedPage) {
+        const content = fetchedPage.output;
+        const excerpt = Array.from(content).slice(0, 8_000).join('');
+        group.evidence.push({
+          questionId: question.id,
+          sourceKind: 'web-fetch',
+          source: fetchedPage.url,
+          ...(question.requestedWindow ? { requestedWindow: question.requestedWindow } : {}),
+          content: excerpt,
+          outcome: excerpt ? 'complete' : 'partial',
+          truncated: Array.from(content).length > 8_000,
+        });
+      }
       for (const hit of response.hits) {
         try {
           group.evidence.push(evidenceFromHit(question, hit));

package/src/research/lenses/second-order.ts

@@ -0,0 +1,312 @@
+/** Chain order a synthesis step lands in: what happens first, what that causes, what that settles. */
+export type SecondOrderOrder = 'primary' | 'secondary' | 'tertiary';
+
+export interface SecondOrderLensStage {
+  order: SecondOrderOrder;
+  label: string;
+  horizonDays: number;
+  purpose: string;
+}
+
+/** Public lens definition: what the T2 second-order lens is and which orders it fans a synthesis into. */
+export interface SecondOrderLensDefinition {
+  id: string;
+  cell: string;
+  tier: string;
+  rfc: string;
+  description: string;
+  stages: readonly SecondOrderLensStage[];
+}
+
+/** Public verification format attached to every secondary effect. */
+export interface SecondOrderVerificationNode {
+  claim: string;
+  scenarioCondition: string | null;
+  metric: string | null;
+  expectedValue: number | null;
+  threshold: number | null;
+  unit: string | null;
+  windowDays: number;
+  falsifiable: boolean | null;
+  measurementStatus: 'unmeasured' | 'needs-operationalization';
+  evidenceSource: string | null;
+}
+
+export interface SecondOrderEvidenceFact {
+  questionId: string;
+  question: string;
+  content: string;
+  source: string;
+  outcome: 'complete' | 'partial' | 'failed';
+  observedWindow?: string;
+  units?: string;
+}
+
+export interface SecondOrderChainNode {
+  id: string;
+  order: SecondOrderOrder;
+  orderIndex: 1 | 2 | 3;
+  statement: string;
+  horizonDays: number;
+  derivedFrom: readonly string[];
+  verification: SecondOrderVerificationNode | null;
+}
+
+/** Public result-chain format: primary → secondary → tertiary, with secondary effects verified. */
+export interface SecondOrderResultChain {
+  lensId: string;
+  question: string;
+  orderStages: readonly SecondOrderLensStage[];
+  nodes: readonly SecondOrderChainNode[];
+}
+
+export type SecondOrderTriggerKind = 'decision' | 'forecast' | 'none';
+
+export interface SecondOrderTriggerDecision {
+  triggered: boolean;
+  kind: SecondOrderTriggerKind;
+  score: number;
+  matchedSignals: readonly string[];
+  reason: string;
+}
+
+export interface SecondOrderLensInput {
+  question: string;
+  synthesis: readonly string[];
+  /** IDs must align with synthesis; evidence is joined by questionId, never by flat-array position. */
+  synthesisQuestionIds?: readonly string[];
+  evidenceFacts?: readonly SecondOrderEvidenceFact[];
+}
+
+export interface SecondOrderLensResult {
+  lens: SecondOrderLensDefinition;
+  trigger: SecondOrderTriggerDecision;
+  chain: SecondOrderResultChain | null;
+}
+
+/** Injection seam lets a host supply private trigger calibration without shipping it here. */
+export type SecondOrderTriggerClassifier = (question: string) => SecondOrderTriggerDecision;
+
+export const SECOND_ORDER_LENS: SecondOrderLensDefinition = {
+  id: 'second-order',
+  cell: 'THINK-LENS-T2-SECOND-ORDER',
+  tier: 'T2',
+  rfc: 'RFC-PRO §2',
+  description: '결정·예측 질문에서 6단 종합을 1차 → 2차 → 3차 결과 사슬로 펼치고, 2차 효과마다 검증 노드를 붙인다.',
+  stages: [
+    {
+      order: 'primary',
+      label: '1차 결과',
+      horizonDays: 30,
+      purpose: '결정이나 예측이 직접 만드는 즉시 효과',
+    },
+    {
+      order: 'secondary',
+      label: '2차 결과',
+      horizonDays: 180,
+      purpose: '1차 효과가 다른 주체로 전이되며 생기는 효과 — 검증 노드가 붙는 자리',
+    },
+    {
+      order: 'tertiary',
+      label: '3차 결과',
+      horizonDays: 540,
+      purpose: '2차 효과가 구조·규범·시장에 정착하며 생기는 효과',
+    },
+  ],
+};
+
+const DECISION_QUESTION_FORM = /(?:해야\s*(?:할까|하나|할지)|(?:고르|선택|결정|전환|도입|투자|진입|매수|매도)(?:해야\s*(?:할까|하나|할지)|할까|할지\s*(?:말지|여부)))|\b(?:should\s+(?:i|we)|whether\s+to|choose\s+between|decide\s+whether)\b/i;
+const FORECAST_QUESTION_FORM = /(?:얼마나\s+[^?\n]{0,80}(?:될|오를|내릴|늘어날|줄어들|바뀔|변할)|(?:언제|몇)\s+[^?\n]{0,80}(?:될|오를|내릴|늘어날|줄어들|바뀔)|어떻게\s+(?:될까|변할까))|\b(?:how\s+much|how\s+many)\s+(?:will|might|could|is\s+expected\s+to|is\s+projected\s+to)\b.{0,120}\b(?:rise|fall|grow|shrink|change|cost|be)\b|\b(?:when\s+will|what\s+will)\b.{0,120}\b(?:rise|fall|grow|shrink|change|cost|be)\b|\bwill\s+[^?\n]{1,120}\b(?:increase|decrease|rise|fall|grow|shrink|change|cost|remain|reach|exceed|decline)\b/i;
+
+/** Decide whether a question is a decision or a forecast, i.e. whether the second-order lens applies. */
+export function detectSecondOrderTrigger(question: string): SecondOrderTriggerDecision {
+  const text = requireText(question, 'question').toLowerCase();
+  if (!/[?？]\s*$/u.test(text)) return noTrigger();
+  const decision = DECISION_QUESTION_FORM.exec(text);
+  const forecast = FORECAST_QUESTION_FORM.exec(text);
+  const kind: SecondOrderTriggerKind = decision ? 'decision' : forecast ? 'forecast' : 'none';
+  const score = kind === 'none' ? 0 : 1;
+  const matchedSignals = Object.freeze(kind === 'decision' ? ['decision-form'] : kind === 'forecast' ? ['forecast-form'] : []);
+  if (kind === 'none') {
+    return {
+      triggered: false,
+      kind: 'none',
+      score,
+      matchedSignals,
+      reason: '질문이 결정이나 예측이 아니라 결과 사슬을 펼치지 않는다',
+    };
+  }
+  return {
+    triggered: true,
+    kind,
+    score,
+    matchedSignals,
+    reason: kind === 'decision'
+      ? '결정 질문이므로 1차 → 2차 → 3차 결과 사슬을 펼친다'
+      : '예측 질문이므로 1차 → 2차 → 3차 결과 사슬을 펼친다',
+  };
+}
+
+function noTrigger(): SecondOrderTriggerDecision {
+  return {
+    triggered: false,
+    kind: 'none',
+    score: 0,
+    matchedSignals: Object.freeze([]),
+    reason: '결정·예측 질문형이 아니므로 결과 사슬을 펼치지 않는다',
+  };
+}
+
+/** Expand synthesis steps into a primary → secondary → tertiary chain with a verification node on each secondary effect. */
+export function buildSecondOrderResultChain(input: SecondOrderLensInput): SecondOrderResultChain {
+  const question = requireText(input.question, 'question');
+  const steps = input.synthesis.map((step, index) => requireText(step, `synthesis[${index}]`));
+  if (input.evidenceFacts?.length && input.synthesisQuestionIds?.length !== steps.length) {
+    throw new Error('synthesisQuestionIds must align with synthesis when evidenceFacts are supplied');
+  }
+  if (steps.length < SECOND_ORDER_LENS.stages.length) {
+    throw new Error('synthesis requires at least three steps to expand into a result chain');
+  }
+
+  const buckets = splitIntoOrders(steps, SECOND_ORDER_LENS.stages.length);
+  const nodes: SecondOrderChainNode[] = [];
+  let previousIds: string[] = [];
+  for (const [stageIndex, stage] of SECOND_ORDER_LENS.stages.entries()) {
+    const stageIds: string[] = [];
+    for (const [stepIndex, statement] of buckets[stageIndex]!.entries()) {
+      const inputIndex = buckets.slice(0, stageIndex).reduce((count, bucket) => count + bucket.length, 0) + stepIndex;
+      const questionId = input.synthesisQuestionIds?.[inputIndex];
+      const fact = questionId ? combineQuestionEvidence(questionId, input.evidenceFacts ?? []) : undefined;
+      const id = `${stage.order}-${stepIndex + 1}`;
+      stageIds.push(id);
+      const parentIndex = stageIndex === 0 ? -1 : Math.min(stepIndex, previousIds.length - 1);
+      const parentId = parentIndex >= 0 ? previousIds[parentIndex] : undefined;
+      const parent = parentId ? nodes.find((node) => node.id === parentId) : undefined;
+      const outputStatement = fact
+        ? makeOutcomeHypothesis(stage.order, question, fact, parent?.statement)
+        : stage.order === 'primary'
+          ? `1차 가설: ${statement}`
+          : `${stage.order === 'secondary' ? '2차' : '3차'} 가설: ${parent?.statement ?? '앞 단계 결과'}가 이어지면 ${statement}라는 후속 결과가 생길 수 있다.`;
+      nodes.push({
+        id,
+        order: stage.order,
+        orderIndex: (stageIndex + 1) as 1 | 2 | 3,
+        statement: outputStatement,
+        horizonDays: stage.horizonDays,
+        derivedFrom: Object.freeze(parentId ? [parentId] : []),
+        verification: stage.order === 'secondary'
+          ? buildVerificationNode(outputStatement, fact, stepIndex)
+          : null,
+      });
+    }
+    previousIds = stageIds;
+  }
+
+  return {
+    lensId: SECOND_ORDER_LENS.id,
+    question,
+    orderStages: SECOND_ORDER_LENS.stages,
+    nodes: Object.freeze(nodes),
+  };
+}
+
+/** Run the lens: the trigger decides whether a chain is produced at all. */
+export function applySecondOrderLens(
+  input: SecondOrderLensInput,
+  classifyTrigger: SecondOrderTriggerClassifier = detectSecondOrderTrigger,
+): SecondOrderLensResult {
+  const trigger = classifyTrigger(input.question);
+  if (!trigger.triggered) return { lens: SECOND_ORDER_LENS, trigger, chain: null };
+  return { lens: SECOND_ORDER_LENS, trigger, chain: buildSecondOrderResultChain(input) };
+}
+
+function buildVerificationNode(statement: string, fact: SecondOrderEvidenceFact | undefined, index: number): SecondOrderVerificationNode {
+  const metric = fact?.outcome === 'complete' ? extractObservableMetric(fact.content) : null;
+  const windowDays = 90 * (index + 1);
+  const scenarioCondition = metric && fact
+    ? `${fact.observedWindow ? `${fact.observedWindow} 기준선` : '확인 가능한 기준선'}과 ${windowDays}일 뒤 ${metric}을 비교한다. 판정 임계값은 아직 정하지 않았다.`
+    : null;
+  return {
+    claim: statement,
+    scenarioCondition,
+    metric,
+    expectedValue: null,
+    threshold: null,
+    unit: fact?.units ?? null,
+    windowDays,
+    falsifiable: null,
+    measurementStatus: metric ? 'needs-operationalization' : 'unmeasured',
+    evidenceSource: fact?.source ?? null,
+  };
+}
+
+function splitIntoOrders(steps: readonly string[], orderCount: number): string[][] {
+  const base = Math.floor(steps.length / orderCount);
+  const remainder = steps.length % orderCount;
+  const buckets: string[][] = [];
+  let cursor = 0;
+  for (let index = 0; index < orderCount; index += 1) {
+    const size = base + (index < remainder ? 1 : 0);
+    buckets.push(steps.slice(cursor, cursor + size));
+    cursor += size;
+  }
+  return buckets;
+}
+
+function makeOutcomeHypothesis(
+  order: SecondOrderOrder,
+  question: string,
+  fact: SecondOrderEvidenceFact,
+  parentStatement?: string,
+): string {
+  const detail = compactEvidence(fact.content);
+  const citation = `[${fact.questionId}; ${fact.source}; ${fact.outcome}]`;
+  if (fact.outcome !== 'complete') {
+    return `${order === 'primary' ? '1차' : order === 'secondary' ? '2차' : '3차'} 가설 미작성: ${fact.question}에 대한 완전한 근거를 확보하지 못했다 (${fact.outcome}; ${citation}).`;
+  }
+  if (order === 'primary') return `1차 가설: 「${question}」의 직접 효과 후보는 「${detail}」이다. 근거 ${citation}`;
+  if (order === 'secondary') return `2차 가설: 「${parentStatement ?? '직접 결과'}」가 이어질 경우 「${detail}」라는 후속 효과가 생길 수 있다. 근거 ${citation}`;
+  return `3차 가설: 「${parentStatement ?? '2차 효과'}」가 지속될 경우 「${detail}」라는 장기 결과로 이어질 수 있다. 근거 ${citation}`;
+}
+
+function compactEvidence(value: string): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length > 180 ? `${normalized.slice(0, 177)}…` : normalized;
+}
+
+function combineQuestionEvidence(questionId: string, evidenceFacts: readonly SecondOrderEvidenceFact[]): SecondOrderEvidenceFact | undefined {
+  const matching = evidenceFacts.filter((fact) => fact.questionId === questionId);
+  if (!matching.length) return undefined;
+  const complete = matching.filter((fact) => fact.outcome === 'complete');
+  const selected = complete.length ? complete : matching;
+  const units = [...new Set(selected.map((fact) => fact.units).filter((unit): unit is string => Boolean(unit)))].join(', ');
+  const observedWindow = [...new Set(selected.map((fact) => fact.observedWindow).filter((window): window is string => Boolean(window)))].join(', ');
+  return {
+    questionId,
+    question: selected[0]!.question,
+    content: selected.map((fact) => fact.content).join(' · '),
+    source: [...new Set(selected.map((fact) => fact.source))].join(', '),
+    outcome: complete.length ? 'complete' : selected.some((fact) => fact.outcome === 'partial') ? 'partial' : 'failed',
+    ...(observedWindow ? { observedWindow } : {}),
+    ...(units ? { units } : {}),
+  };
+}
+
+function extractObservableMetric(value: string): string | null {
+  const patterns = [
+    /(?:응답\s*시간|처리\s*시간|처리량|대기\s*시간|전환율|이탈률|잔존율|오류율|정확도|매출|수익|비용|수출액|수출량|문의\s*건수|사용자\s*수|판매량|생산성|파이프라인)/iu,
+    /\b(?:response time|processing time|wait time|conversion rate|churn rate|retention rate|error rate|accuracy|revenue|cost|export volume|inquiry count|user count|sales volume|productivity|pipeline|adoption rate|demand)\b/iu,
+  ];
+  for (const pattern of patterns) {
+    const match = value.match(pattern);
+    if (match?.[0]) return match[0].replace(/\s+/g, ' ').trim();
+  }
+  return null;
+}
+
+function requireText(value: unknown, field: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    throw new Error(`${field} must not be empty`);
+  }
+  return value.trim();
+}

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?.()

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

@@ -67,6 +67,7 @@ import { BEDROCK_DEFAULT_MODEL, BEDROCK_MODELS, findBedrockModel, resolveBedrock
 import { ZAI_CODING_DEFAULT_MODEL, ZAI_CODING_MODELS } from '../llm/zai-coding-plan.js';
 import { isVerifiedOpenGatewayModel, OPENGATEWAY_DEFAULT_MODEL, OPENGATEWAY_VERIFIED_MODELS } from '../llm/opengateway-models.js';
 import { DEV_PLAN_REPLACEMENT } from './cli-help-text.js';
+import { DEFAULT_TUI_TEST_READY_TIMEOUT_MS } from '../self-implement/elanous-tui-spawn.js';
 export { DEV_PLAN_REPLACEMENT, formatDevPlanOptionHelp } from './cli-help-text.js';
 
 /** dev CLI 옵션(commander) — `--no-*` 는 false 로 도착. input/executor 는 액션이 빌드해 별도 전달. */
@@ -929,7 +930,9 @@ export function startDraftTriage(
         const inventory = inventories.find((entry) => entry.repository === repository)?.snapshot;
         const enriched = { ...draft, branch: draft.branch ?? '', ...inventoryByUrl.get(draft.url!) };
         if ((!inventory || !inventoryByUrl.has(draft.url!)) && !IN_TEST_PROCESS()) { unobservedDrafts.push(draft.number); continue; }
-        const decision = decideDraft({ draft: enriched, runStatus: resolvedStatus, mergedTwins: inventory?.merged ?? [], ageHours: (nowMs() - draft.openedAtMs) / 3_600_000, liveBranches });
+        const triageNow = nowMs();
+        const decision = decideDraft({ draft: enriched, now: new Date(triageNow), runStatus: resolvedStatus,
+          mergedTwins: inventory?.merged ?? [], ageHours: (triageNow - draft.openedAtMs) / 3_600_000, liveBranches });
         if (decision.reason.startsWith('superseded-by')) decisions.superseded += 1;
         else if (decision.reason === 'stale-ended-run') decisions.staleEndedRun += 1;
         else if (decision.reason.startsWith('label:')) decisions.humanApproval += 1;   // approval-waiting or human «keep»
@@ -2187,7 +2190,9 @@ export function buildDevCliSpec(
       ...spec,
       elanous: {
         ...(opts.hold ? { hold: true } : {}),
-        ...(opts.readyTimeoutMs !== undefined ? { readyTimeoutMs: parsePositiveInt(opts.readyTimeoutMs, '--ready-timeout-ms') } : {}),
+        ...(opts.readyTimeoutMs !== undefined
+          ? { readyTimeoutMs: parsePositiveInt(opts.readyTimeoutMs, '--ready-timeout-ms') }
+          : opts.hold ? { readyTimeoutMs: DEFAULT_TUI_TEST_READY_TIMEOUT_MS } : {}),
         ...(opts.json ? { json: true } : {}),
         ...(opts.goal !== undefined ? { goal: opts.goal } : {}),
         ...(opts.maxSteps !== undefined ? { maxSteps: parsePositiveInt(opts.maxSteps, '--max-steps') } : {}),

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

@@ -68,6 +68,8 @@ export interface DevMissionOpts {
   resources?: 'on' | 'off';
   backendExplicit?: string;
   headless?: boolean;
+  /** Optional second user turn resumed in the same Claude/Codex CLI session. */
+  followUp?: string;
   evidence?: EvidenceMode;
   maxRounds?: number;
   commit?: boolean;
@@ -643,6 +645,7 @@ export function toAgentMissionSpec(
     evidence: m.evidence ?? { kind: 'tsc' }, // 기본 tsc(mission 옵션 미지정 시)
     agent: resolveBackend(plan.executor.backend),
     ...(m.headless === true ? { headless: true } : {}),
+    ...(m.followUp !== undefined ? { followUp: m.followUp } : {}),
     ...(m.chain ? { chain: m.chain } : {}),
     ...(m.plugin ? { plugin: m.plugin } : {}),
     ...(m.resources !== undefined ? { resources: m.resources } : {}),
@@ -670,6 +673,7 @@ export function buildAgentMissionDevSpec(o: {
   branch: string;
   base?: string;
   headless?: boolean;
+  followUp?: string;
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   plugin?: { plugin: string; marketplace: string };
   resources?: 'on' | 'off';
@@ -691,6 +695,7 @@ export function buildAgentMissionDevSpec(o: {
     mission: {
       evidence: o.evidence,
       ...(o.headless === true ? { headless: true } : {}),
+      ...(o.followUp !== undefined ? { followUp: o.followUp } : {}),
       ...(o.chain ? { chain: o.chain } : {}),
       ...(o.plugin ? { plugin: o.plugin } : {}),
       ...(o.resources !== undefined ? { resources: o.resources } : {}),