elanous 0.2.43 → 0.2.44

package/src/dashboard/classic-sidetab-mission-trio.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { debug } from '../debug/log.js';
 import type { ClassicSidetabMissionDispatchContext, ClassicSidetabMissionPairSessionRegistry, ClassicSidetabMissionResult } from './classic-sidetab-mission.js';
 import { redactMissionResultPath } from './mission-cli-consumer.js';
 import type { ClassicMissionNotificationEnqueue } from './classic-sidetab-mission-job.js';
@@ -70,10 +71,10 @@ function renderTrioSynthesis(mission: string, results: Record<ClassicMissionAgen
     ...candidates,
     '',
     '## 채택 결과',
-    '_부모 응답에서 확정_',
+    '_최종 채택문은 알림을 받은 부모 응답에서 작성한다. 성공 후보가 있으면 이 후보들만 근거로 채택하고, 성공 후보가 하나면 그 결과를 그대로 채택한다._',
     '',
     '## 채택 근거',
-    '_부모 응답에서 확정_',
+    '_후보별 상태와 원문은 위 표에 기록했다. 실패한 손은 채택 근거에서 제외한다._',
     '',
   ].join('\n');
 }
@@ -124,12 +125,14 @@ export async function startClassicSidetabMissionTrio<Session extends TrioSession
   const missionIds = [...ids.values()];
   deps.registry.register(missionIds, sessionIds);
   const outcomes = new Map<ClassicMissionAgent, Promise<MissionOutcome>>();
+  const completedOutcomes = new Map<ClassicMissionAgent, MissionOutcome>();
   for (const agent of agents) {
     const session = sessions.get(agent) ?? null;
     if (agent === 'grok' && !session) continue;
-    outcomes.set(agent, Promise.resolve().then(() => deps.runVisible(agent, deps.mission, session, ids.get(agent))).catch((error) => ({
+    const outcome = Promise.resolve().then(() => deps.runVisible(agent, deps.mission, session, ids.get(agent))).catch((error): MissionOutcome => ({
       ok: false, status: 'failed', error: error instanceof Error ? error.message : String(error),
-    })));
+    }));
+    outcomes.set(agent, outcome.then((result) => { completedOutcomes.set(agent, result); return result; }));
   }
   const members: Record<ClassicMissionAgent, ClassicSidetabMissionResult> = {
     codex: sessions.get('codex') ? { ok: true, status: 'running', interactionId: ids.get('codex') } : { ok: false, status: 'failed', error: 'Codex sidetab PTY could not start' },
@@ -146,7 +149,7 @@ export async function startClassicSidetabMissionTrio<Session extends TrioSession
     }, timeoutMs);
   });
   const settled = Promise.all([...outcomes].map(async ([agent, promise]) => [agent, await promise] as const));
-  const completion = Promise.race([settled.then((results) => ({ didTimeout: false, results })), timedOut.then(() => ({ didTimeout: true, results: [] as const }))]).then(({ didTimeout, results }) => {
+  const completion = Promise.race([settled.then((results) => ({ didTimeout: false, results })), timedOut.then(() => ({ didTimeout: true, results: [...completedOutcomes.entries()] as const }))]).then(({ didTimeout, results }) => {
     const finishedAt = now();
     const all: Record<ClassicMissionAgent, MissionOutcome> = {
       codex: { ...members.codex, ...(members.codex.status === 'running' ? { error: undefined } : {}) },
@@ -173,27 +176,47 @@ export async function startClassicSidetabMissionTrio<Session extends TrioSession
     } else {
       synthesisError = 'no sidetab workspace was available for the synthesis record';
     }
-    const timeoutReason = didTimeout ? 'mission exceeded the one-hour safety timeout' : undefined;
+    const timeoutReason = didTimeout ? 'mission exceeded the configured safety timeout' : undefined;
     const answer = (agent: ClassicMissionAgent): string => {
       const result = all[agent];
       const screen = result.finalScreen?.trim();
       const screenRecord = screen ? `\n\n${agent} final raw PTY screen:\n${screen.length > MAX_FINAL_SCREEN_CHARS ? `${screen.slice(-MAX_FINAL_SCREEN_CHARS)}\n[screen tail truncated]` : screen}` : '';
       const initial = result.initialScreen?.trim();
       const initialRecord = initial ? `\n\n${agent} first PTY snapshot:\n${initial.length > 1_200 ? `${initial.slice(-1_200)}\n[first screen tail truncated]` : initial}` : '';
-      if (timeoutReason && (result.status === 'running' || result.error === undefined)) return `${agent}: ${timeoutReason}${initialRecord}${screenRecord}`;
+      if (timeoutReason && result.status === 'running') return `${agent}: ${timeoutReason}${initialRecord}${screenRecord}`;
       if (!result.ok) return `${agent}: ${result.error ?? 'failed; no answer returned'}${initialRecord}${screenRecord}`;
       const content = result.content?.trim();
       if (!content) return `${agent}: completed without an answer${screenRecord}`;
       const safe = redactMissionResultPath(content, result.path);
       return `${agent} candidate:\n${safe.length > MAX_ANSWER_CHARS ? `${safe.slice(0, MAX_ANSWER_CHARS)}\n[answer truncated]` : safe}${initialRecord}${screenRecord}`;
     };
-    const grokFailed = !all.grok.ok;
+    const grokFailed = Boolean(grokFallback) || !all.grok.ok;
+    // When Grok cannot start, the run is explicitly a two-hand fallback;
+    // do not count the unstarted Grok hand as missing coverage or a failure.
+    const expectedAgents = grokFallback ? (['codex', 'claude'] as const) : (['codex', 'claude', 'grok'] as const);
+    const candidateAgents = expectedAgents.filter((agent) => all[agent].ok && Boolean(all[agent].content?.trim()));
+    const failedMembers = expectedAgents
+      .filter((agent) => !candidateAgents.includes(agent))
+      .map((agent) => ({
+        agent,
+        reason: timeoutReason && all[agent].status === 'running'
+          ? timeoutReason
+          : all[agent].error ?? (all[agent].ok ? 'completed without an answer' : all[agent].status ?? 'failed'),
+      }));
+    // A completed notification with at least one candidate lets the parent
+    // synthesize/adopt the available work. `coverage` describes partial runs;
+    // state and JSON status intentionally share the same done/error value.
+    const notificationStatus = candidateAgents.length > 0 ? 'done' : 'error';
+    const coverage = candidateAgents.length === 0 ? 'none' : candidateAgents.length === expectedAgents.length ? 'complete' : 'partial';
     const body = [
       `Three-hand comparison · same goal · ${grokFailed ? `Grok unavailable; continued with Codex + Claude (${all.grok.error ?? 'failed'})` : 'Codex + Claude + Grok results'}`,
+      `Coverage: ${coverage}; successful candidates: ${candidateAgents.length ? candidateAgents.join(', ') : 'none'}; failed members: ${failedMembers.length ? failedMembers.map(({ agent, reason }) => `${agent} (${reason})`).join('; ') : 'none'}.`,
       synthesisPath ? `Synthesis record: ${synthesisPath}` : `Synthesis record unavailable: ${synthesisError ?? 'unknown write failure'}`,
-      'The record contains the candidate results and attribution table; fill its adoption and rationale sections with the selected synthesis.',
+      candidateAgents.length > 0
+        ? 'Adopt or synthesize the final answer from the successful candidates only. If exactly one candidate succeeded, adopt it directly. Name failed members and never imply they succeeded.'
+        : 'No candidate succeeded; explicitly report that no result can be adopted.',
       '', answer('codex'), '', answer('claude'), '', answer('grok'), '',
-      'Compare the available candidates, select or combine the strongest answer, and present the adopted result with a short reason. Do not claim an unavailable or failed candidate succeeded.',
+      candidateAgents.length > 0 ? 'Present a non-empty adopted result and a short reason.' : 'Leave the adopted result explicitly unavailable; do not fabricate one.',
     ].join('\n');
     try {
       deps.enqueue({
@@ -201,8 +224,8 @@ export async function startClassicSidetabMissionTrio<Session extends TrioSession
         ...(deps.context?.parentSessionId ? { parentSessionId: deps.context.parentSessionId } : {}),
         agentName: grokFailed ? 'Codex + Claude (Grok fallback)' : 'Codex + Claude + Grok',
         label: 'sidetab mission comparison',
-        state: all.codex.ok && all.claude.ok ? 'done' : 'error',
-        output: JSON.stringify({ status: grokFailed ? 'partial' : 'done', body, artifacts: synthesisPath ? [synthesisPath] : [], id: ids.get('codex') ?? ids.get('claude') ?? taskId, grokFallback: grokFailed ? all.grok.error : undefined }),
+        state: notificationStatus,
+        output: JSON.stringify({ status: notificationStatus, coverage, successfulMembers: candidateAgents, failedMembers, body, artifacts: synthesisPath ? [synthesisPath] : [], id: ids.get('codex') ?? ids.get('claude') ?? taskId, grokFallback: grokFailed ? all.grok.error : undefined }),
         ...(synthesisPath ? { resultPath: synthesisPath } : {}),
         truncated: body.includes('[answer truncated]'),
         durationMs: Math.max(0, finishedAt - startedAt),

package/src/dashboard/classic-sidetab-mission.ts

@@ -30,6 +30,8 @@ export interface ClassicSidetabMissionResult {
   finalScreen?: string;
   /** First child PTY frame, retained to explain startup menus and input interception. */
   initialScreen?: string;
+  failureStage?: string;
+  failureScreen?: string;
 }
 export interface ClassicSidetabMissionToolResult {
   status: 'running' | 'done' | 'error' | 'aborted';

package/src/dashboard/index.ts

@@ -973,6 +973,7 @@ import {
 } from './context-menu-action-runtime.js';
 import { createDashboardTerminalPopupRuntime } from './terminal-popup-runtime.js';
 import { createDashboardSidetabRuntime, mergeLocalAgentSessions, runDashboardAgentMission } from './sidetab-runtime.js';
+import { visibleMissionFailureLogData } from './visible-mission-diagnostics.js';
 import { CLASSIC_SIDETAB_MISSION_TOOL_NAME, createClassicSidetabMissionIntegration, createClassicSidetabMissionPairSessionRegistry, type ClassicSidetabHandReplyInput, type ClassicSidetabMissionAgent, type ClassicSidetabMissionDispatchContext, type ClassicSidetabMissionIntegration, type ClassicSidetabMissionPairResult, type ClassicSidetabMissionResult, type ClassicSidetabMissionTrioResult } from './classic-sidetab-mission.js';
 import { cancelClassicMissionCli, startClassicMissionCli } from './mission-cli-consumer.js';
 import { enqueueClassicSidetabMissionCompletion } from './classic-sidetab-mission-job.js';
@@ -13861,7 +13862,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             error: `${agent}: 설치·로그인 상태를 확인하지 못했습니다`,
           };
         }
-        return runDashboardAgentMission({
+        const result = await runDashboardAgentMission({
           agent,
           requestedOutputPath,
           open: () => TerminalPopup.agent(agent === 'claude' ? 'claude-code' : 'codex').cwd(workingDir.cwd).open() ?? undefined,
@@ -13886,6 +13887,9 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             if (terminalModalRouter.current()?.id === session.id) terminalModalRouter.close();
           },
         });
+        const failure = visibleMissionFailureLogData(agent, result);
+        if (failure) debug.log('classic-sidetab.mission', 'failed', failure, { level: 'warn' });
+        return result;
       },
       detach: (row) => {
         if (row?.currentProcess) {
@@ -14073,6 +14077,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
           const result = await resultPromise.finally(() => { missionFinished = true; });
           await askMonitor;
           handReplyTargets.delete(missionId!);
+          const failure = visibleMissionFailureLogData(member, result, missionId);
+          if (failure) debug.log('classic-sidetab.mission-pair', 'member-failed', failure, { level: 'warn' });
           if (result.ok) await missionStore.complete(missionId!);
           else await missionStore.finish(missionId!, { status: 'failed', error: result.error ?? 'visible mission failed' });
           return { ...result, status: result.ok ? 'completed' as const : 'failed' as const, interactionId: missionId };
@@ -14144,6 +14150,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             outputPath,
             handleTrust: (screen, write) => backend.handleTrust?.(screen, write) ?? false,
           });
+          const failure = visibleMissionFailureLogData(member, result, missionId);
+          if (failure) debug.log('classic-sidetab.mission-trio', 'member-failed', failure, { level: 'warn' });
           return { ...result, status: result.ok ? 'completed' : 'failed', interactionId: missionId, finalScreen: session.preview.renderForLLM() };
         } catch (error) {
           return {

package/src/dashboard/sidetab-runtime.ts

@@ -20,6 +20,8 @@ export interface DashboardMissionResult {
   missionVisible: boolean;
   promptReturned: boolean;
   completionMarker: boolean;
+  failureStage?: string;
+  failureScreen?: string;
   error?: string;
 }
 

package/src/dashboard/visible-mission-diagnostics.ts

@@ -0,0 +1,16 @@
+import type { VisibleMissionResult } from '../sidetab-core/visible-agent-mission.js';
+
+/** Keep failure logs to the bounded, redacted diagnostic fields produced by the visible-mission runner. */
+export function visibleMissionFailureLogData(
+  agent: string,
+  result: Pick<VisibleMissionResult, 'ok' | 'failureStage' | 'failureScreen'>,
+  interactionId?: string,
+): { agent: string; failureStage: string | null; failureScreen: string | null; interactionId?: string } | null {
+  if (result.ok) return null;
+  return {
+    agent,
+    failureStage: result.failureStage ?? null,
+    failureScreen: result.failureScreen ?? null,
+    ...(interactionId ? { interactionId } : {}),
+  };
+}

package/src/domains/retro-cycle-observation.ts

@@ -0,0 +1,43 @@
+import { randomUUID } from 'node:crypto';
+import type { RetroPeriod } from './retro-aggregate.js';
+
+export interface RetroCycleLifecycleReport {
+  period: RetroPeriod;
+  reportPath: string;
+  hasProposal: boolean;
+  proposalId?: string;
+}
+
+export interface RetroCycleActionRefs {
+  runId: string;
+  reportPath: string;
+}
+
+export type RetroCycleLog = (category: string, event: string, data: Record<string, unknown>) => void;
+
+export interface RetroCycleLifecycleDeps {
+  recordAction: (refs: RetroCycleActionRefs) => void;
+  log: RetroCycleLog;
+  createId?: () => string;
+}
+
+/** Assign one run identity and propagate it through the action record and queryable events. */
+export function finishRetroCycleRun(report: RetroCycleLifecycleReport, deps: RetroCycleLifecycleDeps): string {
+  const runId = `retro-${(deps.createId ?? randomUUID)()}`;
+  deps.recordAction({ runId, reportPath: report.reportPath });
+  deps.log('retro.cycle', 'collected', {
+    runId,
+    period: report.period,
+    reportPath: report.reportPath,
+    hasProposal: report.hasProposal,
+  });
+  if (report.hasProposal) {
+    deps.log('retro.cycle', 'proposed', {
+      runId,
+      period: report.period,
+      reportPath: report.reportPath,
+      proposalId: report.proposalId ?? null,
+    });
+  }
+  return runId;
+}

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/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;
   };
 }