elanous 0.2.37 → 0.2.38

package/src/research/edge-decision.ts

@@ -0,0 +1,88 @@
+import type { GraphNodeSpec } from '../self-implement/graph-yaml.js';
+
+/** Opaque Bloom 4/5 output. The hook owns the decision boundary, not analysis policy. */
+export interface BloomEdgeAssessment {
+  gaps: readonly unknown[];
+  contradictions: readonly unknown[];
+  verdicts: readonly unknown[];
+}
+
+export type ResearchEdgeAction = 'add' | 'prune' | 'deepen' | 'stop';
+
+export interface ResearchEdgeProposal {
+  node: GraphNodeSpec;
+  returnTo?: string;
+  reason: string;
+}
+
+export interface ResearchEdgeDecision {
+  action: ResearchEdgeAction;
+  reason: string;
+  evidence: readonly string[];
+  proposal?: ResearchEdgeProposal;
+}
+
+export interface ResolvedResearchEdgeDecision extends ResearchEdgeDecision {
+  provider: string;
+}
+
+export type ResearchEdgeDecisionProvider = (
+  assessment: BloomEdgeAssessment,
+) => ResearchEdgeDecision | Promise<ResearchEdgeDecision>;
+
+export interface ResearchEdgeDecisionRegistry {
+  register(provider: ResearchEdgeDecisionProvider, name?: string): () => void;
+  decide(assessment: BloomEdgeAssessment): Promise<ResolvedResearchEdgeDecision>;
+}
+
+const noOpDecision: ResearchEdgeDecision = {
+  action: 'stop',
+  reason: 'no edge decision provider registered',
+  evidence: [],
+};
+
+/** One registry belongs to one run. With no provider, the graph takes one round and stops. */
+export function createResearchEdgeDecisionRegistry(): ResearchEdgeDecisionRegistry {
+  const providers = new Map<symbol, { name: string; decide: ResearchEdgeDecisionProvider }>();
+  return {
+    register(provider, name = 'registered') {
+      const key = Symbol('research-edge-decision-provider');
+      providers.set(key, { name, decide: provider });
+      return () => { providers.delete(key); };
+    },
+    async decide(assessment) {
+      const provider = [...providers.values()].at(-1);
+      if (!provider) return { ...noOpDecision, provider: 'default-noop' };
+      try {
+        const decision = await provider.decide(assessment);
+        if (!isResearchEdgeDecision(decision)) {
+          return { action: 'stop', reason: 'edge decision provider returned an invalid decision', evidence: [], provider: provider.name };
+        }
+        return { ...decision, evidence: [...decision.evidence], provider: provider.name };
+      } catch (error) {
+        return { action: 'stop', reason: `edge decision provider failed: ${String(error)}`, evidence: [], provider: provider.name };
+      }
+    },
+  };
+}
+
+function isResearchEdgeDecision(value: unknown): value is ResearchEdgeDecision {
+  if (!isRecord(value) || !['add', 'prune', 'deepen', 'stop'].includes(String(value.action))
+    || typeof value.reason !== 'string' || !value.reason.trim()
+    || !Array.isArray(value.evidence) || !value.evidence.every((item) => typeof item === 'string')) {
+    return false;
+  }
+  if (value.action === 'add') return isResearchEdgeProposal(value.proposal);
+  return value.proposal === undefined;
+}
+
+function isResearchEdgeProposal(value: unknown): value is ResearchEdgeProposal {
+  return isRecord(value) && isRecord(value.node) && typeof value.node.nodeId === 'string'
+    && typeof value.node.kind === 'string' && typeof value.node.recipe === 'string'
+    && typeof value.reason === 'string' && value.reason.trim().length > 0
+    && (value.returnTo === undefined || typeof value.returnTo === 'string');
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/src/research/output-router.ts

@@ -0,0 +1,127 @@
+import type { SkillIndexEntry } from '../skills/index.js';
+import { getSkillIndex } from '../skills/index.js';
+
+export type ResearchQuestionWeight = 'light' | 'medium' | 'heavy';
+export type ResearchOutputFormat = 'text' | 'table' | 'card' | 'web-article' | 'diagram';
+export type ResearchOutputFallbackReason = 'no-matching-skill-in-registry';
+
+export interface ResearchOutputRouteInput {
+  question: string;
+  synthesizedResult: string;
+  weight?: ResearchQuestionWeight;
+  axes?: readonly string[];
+  skills?: readonly SkillIndexEntry[];
+}
+
+export interface ResearchOutputRouteDecision {
+  weight: ResearchQuestionWeight;
+  weightSource: 'caller' | 'estimated';
+  format: ResearchOutputFormat;
+  skillCallPlan?: { skill: string; args: string };
+  fallbackReason?: ResearchOutputFallbackReason;
+  observation: {
+    resultChars: number;
+    axisCount: number;
+    estimatedWeight: ResearchQuestionWeight;
+    selectedSkill?: string;
+    fallback?: ResearchOutputFallbackReason;
+  };
+}
+
+const OUTPUT_FORMAT_SIGNALS: Record<Exclude<ResearchOutputFormat, 'text'>, readonly string[]> = {
+  table: ['comparison table', 'research table', 'data table', 'tabular report', '비교 표', '조사 표'],
+  card: ['knowledge card', 'research card', 'summary card', 'flashcard', '지식 카드', '요약 카드'],
+  'web-article': ['web article', 'web publishing', 'html article', 'article publishing', '웹 아티클'],
+  diagram: ['diagram', '다이어그램', 'visualization', '시각화', 'chart'],
+};
+
+const normalizeMetadata = (value: string): string => value.toLowerCase().replace(/[_-]+/g, ' ').replace(/\s+/g, ' ').trim();
+
+function countAxes(axes: readonly string[] | undefined): number {
+  return new Set((axes ?? []).map((axis) => normalizeMetadata(axis)).filter(Boolean)).size;
+}
+
+export function estimateResearchQuestionWeight(resultChars: number, axisCount: number): ResearchQuestionWeight {
+  if (resultChars >= 4_000 || axisCount >= 4) return 'heavy';
+  if (resultChars >= 1_200 || axisCount >= 2) return 'medium';
+  return 'light';
+}
+
+function chooseFormat(weight: ResearchQuestionWeight, axisCount: number): ResearchOutputFormat {
+  if (weight === 'light') return 'text';
+  if (weight === 'medium') return axisCount >= 2 ? 'table' : 'card';
+  return axisCount >= 4 ? 'diagram' : 'web-article';
+}
+
+function skillScore(format: Exclude<ResearchOutputFormat, 'text'>, skill: SkillIndexEntry): number {
+  const metadata = normalizeMetadata([
+    skill.name,
+    skill.category ?? '',
+    skill.description,
+    ...skill.triggers,
+    ...skill.extractedTriggers,
+  ].join(' '));
+  return OUTPUT_FORMAT_SIGNALS[format].reduce((score, signal) => {
+    const normalizedSignal = normalizeMetadata(signal);
+    return metadata.includes(normalizedSignal) ? score + normalizedSignal.length : score;
+  }, 0);
+}
+
+function findOutputSkill(
+  format: Exclude<ResearchOutputFormat, 'text'>,
+  skills: readonly SkillIndexEntry[],
+): SkillIndexEntry | undefined {
+  return skills
+    .map((skill) => ({ skill, score: skillScore(format, skill) }))
+    .filter((entry) => entry.score > 0)
+    .sort((a, b) => b.score - a.score || a.skill.name.localeCompare(b.skill.name))[0]?.skill;
+}
+
+function buildSkillArgs(question: string, synthesizedResult: string, format: ResearchOutputFormat): string {
+  return [
+    `Format the synthesized research output as ${format}.`,
+    `Question: ${escapeSkillArgument(question)}`,
+    'Research synthesis:',
+    escapeSkillArgument(synthesizedResult),
+  ].join('\n\n');
+}
+
+/** Keep untrusted research text from closing the XML-like prefill argument block. */
+function escapeSkillArgument(value: string): string {
+  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+/** Deterministic output routing. Weight may be supplied by an upstream axis; otherwise it is inferred from synthesis size and distinct axes. */
+export function routeResearchOutput(input: ResearchOutputRouteInput): ResearchOutputRouteDecision {
+  const resultChars = input.synthesizedResult.length;
+  const axisCount = countAxes(input.axes);
+  const estimatedWeight = estimateResearchQuestionWeight(resultChars, axisCount);
+  const weight = input.weight ?? estimatedWeight;
+  const desiredFormat = chooseFormat(weight, axisCount);
+  const observation = { resultChars, axisCount, estimatedWeight };
+
+  if (desiredFormat === 'text') {
+    return { weight, weightSource: input.weight ? 'caller' : 'estimated', format: 'text', observation };
+  }
+
+  const registry = input.skills ?? getSkillIndex();
+  const selected = findOutputSkill(desiredFormat, registry);
+  if (!selected) {
+    const fallbackReason: ResearchOutputFallbackReason = 'no-matching-skill-in-registry';
+    return {
+      weight,
+      weightSource: input.weight ? 'caller' : 'estimated',
+      format: 'text',
+      fallbackReason,
+      observation: { ...observation, fallback: fallbackReason },
+    };
+  }
+
+  return {
+    weight,
+    weightSource: input.weight ? 'caller' : 'estimated',
+    format: desiredFormat,
+    skillCallPlan: { skill: selected.name, args: buildSkillArgs(input.question, input.synthesizedResult, desiredFormat) },
+    observation: { ...observation, selectedSkill: selected.name },
+  };
+}

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,6 +56,21 @@ 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,
@@ -59,6 +85,18 @@ 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,
@@ -73,17 +111,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 };
+    return researchOutcomeFromSkillRun(result);
   } catch (err) {
     return {
-      output: buffered,
+      output: '',
       ok: false,
       error: err instanceof Error ? err.message : String(err),
     };

package/src/self-dev/decompose.ts

@@ -442,6 +442,24 @@ function isRawSubtask(value: unknown): value is RawSubtask {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function ensureSingleCompletionCriterion(feature: string, targetPaths: string[]): string {
+  const lines = feature.split(/\r?\n/);
+  const criteria = lines.filter((line) => /^\s*완료 기준\s*:/.test(line));
+  if (criteria.length === 0) {
+    return `${feature}\n완료 기준: ${targetPaths.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.`;
+  }
+  if (criteria.length === 1 && criteria[0]!.trim().length > '완료 기준:'.length) return feature;
+  const criterionText = criteria
+    .map((line) => line.replace(/^\s*완료 기준\s*:\s*/, '').trim())
+    .filter(Boolean)
+    .join(' · ');
+  const normalizedCriterion = criterionText || `${targetPaths.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.`;
+  const firstCriterionIndex = lines.findIndex((line) => /^\s*완료 기준\s*:/.test(line));
+  const withoutCriteria = lines.filter((line) => !/^\s*완료 기준\s*:/.test(line));
+  withoutCriteria.splice(Math.min(firstCriterionIndex, withoutCriteria.length), 0, `완료 기준: ${normalizedCriterion}`);
+  return withoutCriteria.join('\n');
+}
+
 /**
  * G6 (1c) — 결정론적 hotPaths 추론. 분해된 sub-goal 의 feature 텍스트에서 repo 파일
  * 경로(src/…·docs/…·scripts/… + 확장자)를 뽑는다. LLM 이 hotPaths 를 안 채워도 hot-file
@@ -476,7 +494,8 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
         ? own[index]!
         : (goal.hotPaths ?? []).filter((path) => parentTargets.includes(path)));
       const claimedOwners = parentTargets.map((path) => goals.flatMap((_, index) => claims[index]!.includes(path) ? [index] : []));
-      const conflictingClaims = claimedOwners.some((indices) => indices.length > 1);
+      const sharedExplicitTarget = own.length === 2 && own[0]!.some((path) => own[1]!.includes(path));
+      const conflictingClaims = sharedExplicitTarget || claimedOwners.some((indices) => indices.length > 1);
       const nameOwners = parentTargets.map((path) => {
         const stemWords = path.split('/').at(-1)!.replace(/\.[^.]+$/, '').toLowerCase().match(/[a-z0-9]+/g) ?? [];
         if (!stemWords.length || stemWords.join('').length < 4) return [];
@@ -507,24 +526,41 @@ export function inheritDecomposedTargetPaths(parentFeature: string, goals: SelfD
       // A named path wins over model order; if every path points at one child,
       // keep the old scope rather than inventing work for the other child.
       const partitions = goals.map((_, index) => parentTargets.filter((_, pathIndex) => owners[pathIndex] === index));
-      const sharedOtherPaths = (goals[0]?.hotPaths ?? []).some((path) =>
-        !parentTargets.includes(path) && (goals[1]?.hotPaths ?? []).includes(path));
       const conflictingParentReference = goals.some((goal, index) =>
         own[index]!.length > 0 && (goal.hotPaths ?? []).some((path) =>
           parentTargets.includes(path) && !own[index]!.includes(path)));
       if (partitions.every((paths) => paths.length > 0)
         && !conflictingClaims && !ambiguousName && !conflictingNameClaim && !conflictingUnclaimedHint
-        && !sharedOtherPaths && !conflictingParentReference) return goals.map((goal, index) => {
+        && !conflictingParentReference) return goals.map((goal, index) => {
         const targets = partitions[index]!;
-        return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...targets])],
-          feature: `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}\n완료 기준: ${targets.join(' · ')}의 변경을 확인하고 관련 시험을 통과한다.` };
+        // A declared child target may add a helper outside the parent fence. Bare
+        // hotPaths outside that fence are references, so do not widen the write fence.
+        const explicitHelpers = own[index]!.filter((path) => !parentTargets.includes(path));
+        const feature = `${goal.feature}${own[index]!.length ? '' : `\n대상 경로: ${targets.join(' · ')}`}`;
+        return { ...goal, hotPaths: [...new Set([...targets, ...explicitHelpers])],
+          feature: ensureSingleCompletionCriterion(feature, targets) };
       });
     }
   }
-  return goals.map((goal) => {
+  const explicitChildTargets = goals.map((goal) => declaredTargets(goal.feature ?? ''));
+  const explicitParentTargets = explicitChildTargets.map((paths) => paths.filter((path) => parentTargets.includes(path)));
+  const explicitTargetsArePartition = goals.length === 2
+    && explicitParentTargets.every((paths) => paths.length > 0)
+    && new Set(explicitChildTargets.flat()).size === explicitChildTargets.flat().length
+    && explicitParentTargets[0]!.every((path) => !explicitParentTargets[1]!.includes(path))
+    && new Set(explicitParentTargets.flat()).size === parentTargets.length
+    && parentTargets.every((path) => explicitParentTargets.flat().includes(path))
+    && goals.every((goal, index) => (goal.hotPaths ?? []).every((path) =>
+      !parentTargets.includes(path) || explicitChildTargets[index]!.includes(path)));
+  return goals.map((goal, index) => {
     // hotPaths also contains inferred references; only an explicit target line establishes child scope.
-    const own = declaredTargets(goal.feature ?? '');
-    if (own.length) return goal;
+    const own = explicitChildTargets[index]!;
+    if (own.length) {
+      if (explicitTargetsArePartition) {
+        return { ...goal, hotPaths: own, feature: ensureSingleCompletionCriterion(goal.feature ?? '', own) };
+      }
+      return goal;
+    }
     return { ...goal, hotPaths: [...new Set([...(goal.hotPaths ?? []), ...parentTargets])],
       feature: `${goal.feature}\n대상 경로: ${parentTargets.join(' · ')}` };
   });