elanous 0.2.42 → 0.2.44

package/src/domains/retro-cycle.ts

@@ -7,6 +7,7 @@
 import { aggregatePeriod, type RetroDeps, type RetroPeriod, type PeriodSummary } from './retro-aggregate.js';
 import { renderReflectionMd, reflectionFilename } from './retro-report.js';
 import { proposeRebalance, checkProposal, hitlNotice, type PromotionCandidate, type RebalanceProposal } from './retro-rebalance.js';
+import { buildRetroFeatureProposals, renderRetroFeatureProposals, type RetroFeatureProposal, type RetroProposalSignal } from './retro-proposals.js';
 import type { CheckerVerdict } from './loop-contract.js';
 
 export interface RetroCycleDeps {
@@ -15,6 +16,7 @@ export interface RetroCycleDeps {
   writeReport: (filename: string, md: string) => string; // 저장 → 경로 반환
   narrate?: (summary: PeriodSummary) => Promise<string | undefined> | string | undefined; // LLM 서사 opt-in(비동기 허용)
   notify?: (text: string) => void;                    // HITL 승인 요청 발송
+  featureSignals?: (from: string, to: string) => readonly RetroProposalSignal[];
   now?: () => string;
 }
 
@@ -26,17 +28,26 @@ export interface RetroCycleReport {
   /** 독립 sanity check 판정(Phase C · builder≠checker 대칭). */
   sanity: CheckerVerdict;
   highlights: string[];
+  featureProposals: RetroFeatureProposal[];
 }
 
 /** 회고 1회 실행(오케스트레이터). 리포트 저장 + 제안 있으면 HITL 알림. narrate 비동기 허용. */
 export async function runRetroCycle(deps: RetroCycleDeps, period: RetroPeriod): Promise<RetroCycleReport> {
   const now = deps.now?.() ?? new Date().toISOString();
   const summary = aggregatePeriod(deps.retro, period, now);
+  const featureProposals = buildRetroFeatureProposals(
+    deps.featureSignals?.(summary.window.from, summary.window.to) ?? [],
+    { from: summary.window.from, to: summary.window.to, minimumRuns: 2 },
+  );
   const candidates = deps.candidates();
   const proposal: RebalanceProposal = proposeRebalance(summary, candidates);
   const sanity = checkProposal(proposal); // ★ builder(proposeRebalance)와 분리된 독립 검증
   const narrative = await deps.narrate?.(summary);
-  const md = renderReflectionMd(summary, { narrative, proposalMd: proposal.proposalMd });
+  const md = renderReflectionMd(summary, {
+    narrative,
+    proposalMd: proposal.proposalMd,
+    featureProposalMd: renderRetroFeatureProposals(featureProposals),
+  });
   const reportPath = deps.writeReport(reflectionFilename(summary), md);
 
   const hasProposal = proposal.deltas.length > 0;
@@ -46,5 +57,5 @@ export async function runRetroCycle(deps: RetroCycleDeps, period: RetroPeriod):
     deps.notify(notice);
   }
 
-  return { period, reportPath, hasProposal, proposalId: proposal.id, sanity, highlights: summary.highlights };
+  return { period, reportPath, hasProposal, proposalId: proposal.id, sanity, highlights: summary.highlights, featureProposals };
 }

package/src/domains/retro-proposals.ts

@@ -0,0 +1,92 @@
+import { createHash } from 'node:crypto';
+import { redactSecretText } from '../debug/log.js';
+
+export type RetroProposalSignalSource = 'incident' | 'doctor-visit';
+
+/** Minimal, redacted signals from durable ledgers; raw log text is deliberately excluded. */
+export interface RetroProposalSignal {
+  readonly runId: string;
+  readonly symptom: string;
+  readonly at: string;
+  readonly source: RetroProposalSignalSource;
+}
+
+export interface RetroFeatureProposal {
+  readonly id: string;
+  readonly title: string;
+  readonly symptom: string;
+  readonly evidence: {
+    readonly runIds: readonly string[];
+    readonly incidents: number;
+    readonly doctorVisits: number;
+  };
+  readonly expectedEffect: string;
+  readonly decisionSignal: string;
+  readonly costPeak: { readonly status: 'unknown'; readonly reason: string };
+  readonly localAndGlobalScope: { readonly status: 'unknown'; readonly reason: string };
+}
+
+export interface BuildRetroFeatureProposalsOptions {
+  readonly from?: string;
+  readonly to?: string;
+  readonly minimumRuns?: number;
+}
+
+/** Build deterministic proposal cards from repeated, recorded symptoms only. */
+export function buildRetroFeatureProposals(
+  signals: readonly RetroProposalSignal[],
+  options: BuildRetroFeatureProposalsOptions = {},
+): RetroFeatureProposal[] {
+  const minimumRuns = options.minimumRuns ?? 2;
+  if (!Number.isSafeInteger(minimumRuns) || minimumRuns < 2) throw new Error('minimumRuns must be an integer >= 2');
+  const from = options.from ? Date.parse(`${options.from}T00:00:00.000Z`) : -Infinity;
+  const to = options.to ? Date.parse(`${options.to}T23:59:59.999Z`) : Infinity;
+  if (Number.isNaN(from) || Number.isNaN(to)) throw new Error('from and to must be valid YYYY-MM-DD dates');
+  if (from > to) throw new Error('from must be on or before to');
+
+  const grouped = new Map<string, RetroProposalSignal[]>();
+  for (const signal of signals) {
+    if (signal.source !== 'incident' && signal.source !== 'doctor-visit') continue;
+    const symptom = redactSecretText(signal.symptom).replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 160);
+    const at = Date.parse(signal.at);
+    const runId = signal.runId.trim().replace(/[^\w.-]/g, '').slice(0, 100);
+    if (!runId || !symptom || !Number.isFinite(at) || at < from || at > to) continue;
+    const rows = grouped.get(symptom) ?? [];
+    rows.push({ ...signal, runId, symptom });
+    grouped.set(symptom, rows);
+  }
+
+  return [...grouped.entries()].flatMap(([symptom, rows]) => {
+    const runIds = [...new Set(rows.map((row) => row.runId))].sort();
+    if (runIds.length < minimumRuns) return [];
+    const incidents = rows.filter((row) => row.source === 'incident').length;
+    const doctorVisits = rows.filter((row) => row.source === 'doctor-visit').length;
+    const id = createHash('sha256').update(`${symptom}\n${runIds.join('\n')}`).digest('hex').slice(0, 12);
+    return [{
+      id,
+      title: `반복 증상 제안: ${symptom}`,
+      symptom,
+      evidence: { runIds, incidents, doctorVisits },
+      expectedEffect: `다음 회고 기간의 '${symptom}' 고유 런 수 감소`,
+      decisionSignal: `다음 기간에 같은 증상으로 기록된 고유 runId 수 < ${runIds.length}`,
+      costPeak: { status: 'unknown', reason: '비용 정본 필드가 확인되지 않아 측정 불가' },
+      localAndGlobalScope: { status: 'unknown', reason: '로컬/광역 사례 저장 정본이 확인되지 않아 범위 미정' },
+    } satisfies RetroFeatureProposal];
+  }).sort((a, b) => b.evidence.runIds.length - a.evidence.runIds.length
+    || (a.symptom < b.symptom ? -1 : a.symptom > b.symptom ? 1 : 0));
+}
+
+export function renderRetroFeatureProposals(cards: readonly RetroFeatureProposal[]): string | undefined {
+  if (cards.length === 0) return undefined;
+  const lines = ['## 반복 증상 피처 제안 (근거 기반 · 초안)'];
+  for (const card of cards) {
+    lines.push(`### ${card.title} · ${card.id}`);
+    lines.push(`- 증상: ${card.symptom}`);
+    lines.push(`- 근거: ${card.evidence.runIds.length}개 고유 런 (${card.evidence.runIds.join(', ')}) · incident ${card.evidence.incidents} · doctor visit ${card.evidence.doctorVisits}`);
+    lines.push(`- 예상 효과: ${card.expectedEffect}`);
+    lines.push(`- 판정 신호: ${card.decisionSignal}`);
+    lines.push(`- 비용 정점: 모름 (${card.costPeak.reason})`);
+    lines.push(`- 로컬/광역 두 층: 모름 (${card.localAndGlobalScope.reason})`);
+  }
+  return lines.join('\n');
+}

package/src/domains/retro-report.ts

@@ -16,7 +16,7 @@ export function reflectionFilename(summary: PeriodSummary): string {
 }
 
 /** 결정론 마크다운 리포트(순수). LLM 서사는 opts.narrative 로 주입(opt-in). */
-export function renderReflectionMd(summary: PeriodSummary, opts: { narrative?: string; proposalMd?: string } = {}): string {
+export function renderReflectionMd(summary: PeriodSummary, opts: { narrative?: string; proposalMd?: string; featureProposalMd?: string } = {}): string {
   const { window: w, backtest: b, regime: r, trades: t, highlights } = summary;
   const L: string[] = [];
   L.push(`# ${PERIOD_KO[w.period]} 회고 — ${w.from} ~ ${w.to}`);
@@ -84,6 +84,11 @@ export function renderReflectionMd(summary: PeriodSummary, opts: { narrative?: s
     L.push('');
   }
 
+  if (opts.featureProposalMd && opts.featureProposalMd.trim()) {
+    L.push(opts.featureProposalMd.trim());
+    L.push('');
+  }
+
   L.push('---');
   L.push(`_${PERIOD_KO[w.period]} 회고 · 페이퍼·disarmed · 실집행/리밸런싱은 대표 HITL 승인_`);
   return L.join('\n');

package/src/domains/telegram-kind-route.ts

@@ -36,16 +36,23 @@ function operationsBotToken(cfg: UserConfig): string | undefined {
   const tradingTokens = new Set(channels.filter(c => c.roles.includes('report')).map(c => c.botToken));
   // The report (trading) bot is never the operations bot — with or without a channels table (review must-fix · OUT1).
   if (cfg.telegram.reportChannel?.botToken) tradingTokens.add(cfg.telegram.reportChannel.botToken);
+  // An explicit operational channel is authoritative even when env/tokenRef/legacy botToken
+  // resolves first; those older sources can point at a different (or trading) bot.
+  const operationalChannels = channels.filter(c => (c.name === 'ops' && c.roles.includes('system'))
+    || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')));
+  if (operationalChannels.length > 0) {
+    const tokens = new Set(operationalChannels.filter(c => !tradingTokens.has(c.botToken)).map(c => c.botToken));
+    if (tokens.size !== 1) return undefined;
+    const explicitToken = tokens.values().next().value;
+    // The explicitly named operational channel outranks the generic tab's tokenRef;
+    // legacy/env conflicts without a trading identity remain ambiguous and fail closed.
+    if (main.source !== 'channels.main' && main.source !== 'tokenRef'
+      && main.token && main.token !== explicitToken && !tradingTokens.has(main.token)) return undefined;
+    return explicitToken;
+  }
+
   if (main.source !== 'channels.main') return main.token && !tradingTokens.has(main.token) ? main.token : undefined;
-  // channels.main may mean "first channel", which can be the trading bot.
-  // Only a named operations channel (or the named main channel) with an
-  // operational role establishes identity; array order and role alone do not.
-  const tokens = new Set(channels
-    .filter(c => (c.name === 'ops' && c.roles.includes('system'))
-      || (c.name === 'main' && c.roles.some(r => r === 'system' || r === 'qa' || r === 'default')))
-    .filter(c => !tradingTokens.has(c.botToken))
-    .map(c => c.botToken));
-  return tokens.size === 1 ? tokens.values().next().value : undefined;
+  return undefined;
 }
 
 function isAllowedBot(cfg: UserConfig, kind: string | undefined, token: string): boolean {

package/src/graph-runner/arg-allowance.ts

@@ -0,0 +1,13 @@
+export type AllowanceDecision =
+  | { readonly kind: 'run'; readonly requested: number; readonly granted: number; readonly clamped: boolean }
+  | { readonly kind: 'needs-human'; readonly requested: number; readonly remaining: 0 };
+
+/** Resolve a child allowance against the parent's remaining steps before spawning the child. */
+export function resolveChildAllowance(requested: number, parentRemaining: number): AllowanceDecision {
+  if (!Number.isSafeInteger(requested) || requested < 1) throw new Error('requested allowance must be a positive safe integer');
+  if (!(parentRemaining === Infinity || (Number.isSafeInteger(parentRemaining) && parentRemaining >= 0)))
+    throw new Error('parent remaining allowance must be a non-negative safe integer or Infinity');
+  if (parentRemaining === 0) return { kind: 'needs-human', requested, remaining: 0 };
+  const granted = Math.min(requested, parentRemaining);
+  return { kind: 'run', requested, granted, clamped: granted < requested };
+}

package/src/graph-runner/graph-cli.ts

@@ -55,6 +55,29 @@ export function registerGraphCommands(program: Command, runsDeps: {
         process.exitCode = 1;
       }
     });
+  graph.command('promote')
+    .description('Evaluate an injected ARG promotion fixture; this command never applies or writes an overlay')
+    .command('evaluate')
+    .requiredOption('--fixture <path>', 'JSON fixture containing trigger, candidate and injected evidence events')
+    .option('--json', 'Print the mock-only decision and proposal as JSON')
+    .action(async (opts: { fixture: string; json?: boolean }) => {
+      try {
+        const parsed: unknown = JSON.parse(readFileSync(resolve(opts.fixture), 'utf8'));
+        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('fixture root must be an object');
+        const fixture = parsed as Record<string, unknown>;
+        if (typeof fixture.trigger !== 'string' || fixture.candidate === null || typeof fixture.candidate !== 'object'
+          || Array.isArray(fixture.candidate) || !Array.isArray(fixture.events)) {
+          throw new Error('fixture requires trigger, candidate object and events array');
+        }
+        const { evaluateArgPromotionFixture } = await import('../self-implement/graph-overlay-yaml.js');
+        const result = evaluateArgPromotionFixture(fixture as Parameters<typeof evaluateArgPromotionFixture>[0]);
+        if (opts.json) await writeStdoutJson(JSON.stringify(result) + '\n');
+        else console.log(`graph promote: ${result.verdict} · mockOnly=${result.mockOnly} · wroteOverlay=false · ${JSON.stringify(result.metrics)}${result.blockers.length ? ` · blockers=${result.blockers.join(',')}` : ''}`);
+      } catch (error) {
+        console.error(`graph promote evaluate: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
   graph.command('wizard-run <request>')
     .description('Run one request through the smart wizard graph and stop at its approval gate')
     .option('--json', 'Print run identity and transitions as JSON')
@@ -95,7 +118,7 @@ export function registerGraphCommands(program: Command, runsDeps: {
         }
         const state = await runGraph(file, { ...(opts.resume ? { resumeRunId: opts.resume } : { dryRun: opts.dryRun }), ...(opts.from ? { fromNodeId: opts.from } : {}), useCurrentGraph: opts.useCurrentGraph, ...(input === undefined ? {} : { input }) });
         if (opts.json) await writeStdoutJson(JSON.stringify(state) + '\n');
-        else console.log(`${state.graphId} ${state.runId}: ${state.status} (${state.path.join(' → ')}, executed: ${state.executed})${state.pending ? ` — ${state.pending.message}` : ''}`);
+        else console.log(`${state.graphId} ${state.runId}: ${state.status} (${(state.plannedPath ?? state.path).join(' → ')}, executed: ${state.executed})${state.pending ? ` — ${state.pending.message}` : ''}`);
         if (state.status !== 'done' && state.status !== 'awaiting-approval') process.exitCode = 1;
       } catch (error) {
         console.error(`graph run: ${error instanceof Error ? error.message : String(error)}`);

package/src/graph-runner/graph-grow-llm.ts

@@ -26,7 +26,7 @@ export function createLLMGrowthProposer(callLLM: GrowthLLM = defaultGrowthLLM):
     const serializedOutput = typeof input.output === 'string' ? input.output : input.output === undefined ? '' : JSON.stringify(input.output);
     const prompt = [
       'Propose exactly one new contracted graph node to handle the unseen outcome and one return edge to an existing node.',
-      'Reply with only JSON: {"node":{"nodeId":"...","kind":"agent","recipe":"none","maxVisits":1,"contract":{"inputs":[],"tools":"read-only","outputs":[]}},"returnTo":"existing-node-id","reason":"..."}.',
+      'Reply with only JSON: {"node":{"nodeId":"...","kind":"agent","recipe":"none","maxVisits":1,"contract":{"inputs":[],"tools":"read-only","outputs":[]}},"returnTo":"existing-node-id","reason":"..."}. The only allowed kinds are agent, observe, and judge.',
       'Use only an existing recipe type (none, an existing cmd:/approval: recipe ID, or a catalog role); never invent commands. The missing-outcome edge and the return edge are built from node and returnTo after validation.',
       'Do not alter existing nodes or edges. The proposal will be validated independently; do not assume a recipe is safe.',
       `Graph snapshot: ${JSON.stringify(input.graph)}`,
@@ -42,6 +42,8 @@ export function createLLMGrowthProposer(callLLM: GrowthLLM = defaultGrowthLLM):
     const proposal = parsed as Record<string, unknown>;
     if (!proposal.node || typeof proposal.node !== 'object' || Array.isArray(proposal.node) ||
       typeof proposal.reason !== 'string' || !proposal.reason.trim() || typeof proposal.returnTo !== 'string') return undefined;
+    const node = proposal.node as Record<string, unknown>;
+    if (typeof node.kind !== 'string' || !['agent', 'observe', 'judge'].includes(node.kind)) return undefined;
     return { node: proposal.node, reason: proposal.reason, returnTo: proposal.returnTo } as GrowthProposal;
   };
 }

package/src/graph-runner/graph-run-api.ts

@@ -29,6 +29,8 @@ export interface GraphRunApiDeps {
   root?: string;
   run?: typeof runGraph;
   now?: () => number;
+  /** Allows a host-owned preview/demo request to stop an in-flight editor graph run. */
+  signal?: AbortSignal;
 }
 
 /** 시작 전에 죽은 런(레시피 없음 등)은 원장 파일이 안 생긴다 — 그 이유를 여기 잠깐 들고 있다가 상태 조회에 돌려준다. */
@@ -187,7 +189,7 @@ export function handleGraphRunStart(rawId: string, deps: GraphRunApiDeps = {}):
     return jsonResponse({ error: 'run-workspace-failed', reason: error instanceof Error ? error.message.slice(0, 200) : 'unknown' }, 500);
   }
   debug.log('graphs.run', 'started', { id, runId });
-  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, deps: { root } })
+  void (deps.run ?? runGraph)(join(work, 'graph.yaml'), { runId, input: { source: 'editor' }, ...(deps.signal ? { signal: deps.signal } : {}), deps: { root } })
     .then((state) => debug.log('graphs.run', 'finished', { id, runId, status: state.status, executed: state.executed }))
     .catch((error: unknown) => {
       const message = error instanceof Error ? error.message : String(error);