elanous 0.2.25 → 0.2.28

package/src/cli/brief-cli.ts

@@ -1,9 +1,97 @@
 import type { Command } from 'commander';
 import { BRIEF_DOMAINS, BRIEF_PRIORITIES, BRIEF_REACTIONS, BRIEF_SLOTS, BriefItemsInputError, BriefItemsLedger, type BriefDomain, type BriefPriority, type BriefReaction, type BriefSendSlot } from '../briefing/brief-items.js';
 import { kindRouteTarget } from '../domains/telegram-kind-route.js';
-import { sendTelegramReturningId } from '../autopilot/mission-notify.js';
+import { sendTelegramButtonsTo, type TgButton } from '../autopilot/mission-notify.js';
 import { getUserConfig } from '../user-config.js';
 
+export function briefFeedbackButtons(ids: readonly number[]): TgButton[][] {
+  return ids.map(id => [
+    { text: `👀 ${id} 읽음`, data: `brief-item:${id}:read` },
+    { text: `✅ ${id} 움직임`, data: `brief-item:${id}:button` },
+    { text: `➖ ${id} 넘김`, data: `brief-item:${id}:ignore` },
+  ]);
+}
+
+export interface BriefTelegramUpdate {
+  botId: string;
+  chatId: number;
+  messageId: number;
+  updateId: string;
+  text?: string;
+  callbackData?: string;
+}
+
+export function recordBriefTelegramUpdate(ledger: BriefItemsLedger, update: BriefTelegramUpdate): boolean {
+  if (update.callbackData !== undefined) {
+    const match = /^brief-item:([1-9]\d*):(read|button|ignore)$/.exec(update.callbackData);
+    if (!match) return false;
+    return ledger.recordTelegramFeedback({ botId: update.botId, chatId: update.chatId,
+      messageId: update.messageId, updateId: update.updateId, itemId: Number(match[1]),
+      reaction: match[2] === 'read' ? '열람' : match[2] === 'ignore' ? '무시' : '버튼' });
+  }
+  if (!update.text?.trim()) return false;
+  const text = update.text.trim();
+  const itemId = /^(?:#|항목\s*)([1-9]\d*)(?=\s|[:：]|$)/.exec(text)?.[1];
+  return ledger.recordTelegramFeedback({ botId: update.botId, chatId: update.chatId,
+    messageId: update.messageId, updateId: update.updateId,
+    ...(itemId ? { itemId: Number(itemId) } : {}),
+    reaction: /그게 아니라|(?:^|\s)정정\s*[:：]/.test(text) ? '정정' : '답장' });
+}
+
+/** Prefix each item line with `#<id>` so the 대표 can name the reply target ("#12 답장", "#12 그게 아니라 …"). */
+function withItemNumbers(text: string, itemLines: ReadonlyMap<string, readonly number[]>): string {
+  const linePositions = new Map<string, number>();
+  return text.split('\n').map(line => {
+    const ids = itemLines.get(line);
+    if (!ids) return line;
+    const position = linePositions.get(line) ?? 0;
+    linePositions.set(line, position + 1);
+    const itemId = ids[position];
+    return itemId === undefined ? line : `#${itemId} ${line}`;
+  }).join('\n');
+}
+
+/** Split only feedback-enabled pages; each Telegram message gets its own real item coordinate.
+ * Item lines carry their `#<id>` so a plain text reply can name its target item.
+ */
+function briefDeliveryParts(markdown: string, itemLines: ReadonlyMap<string, readonly number[]>): Array<{ text: string; itemId: number }> {
+  const parts: Array<{ text: string; itemId: number }> = [];
+  const linePositions = new Map<string, number>();
+  let pending = '';
+  for (const line of markdown.trimEnd().split('\n')) {
+    const ids = itemLines.get(line);
+    const position = linePositions.get(line) ?? 0;
+    const itemId = ids?.[position];
+    if (itemId === undefined) {
+      pending += `${line}\n`;
+      continue;
+    }
+    linePositions.set(line, position + 1);
+    const numbered = `#${itemId} ${line}`;
+    // Leave room for the Telegram sender's newline and keep a button on every fragment.
+    while (pending.length >= 3800) {
+      parts.push({ text: pending.slice(0, 3800), itemId });
+      pending = pending.slice(3800);
+    }
+    let remainder = pending + numbered;
+    do {
+      parts.push({ text: remainder.slice(0, 3800), itemId });
+      remainder = remainder.slice(3800);
+    } while (remainder.length);
+    pending = '';
+  }
+  if (pending && parts.length) {
+    const last = parts[parts.length - 1]!;
+    if (last.text.length + pending.length <= 3800) last.text += pending;
+    else {
+      const room = 3800 - last.text.length;
+      last.text += pending.slice(0, room);
+      for (let i = room; i < pending.length; i += 3800) parts.push({ text: pending.slice(i, i + 3800), itemId: last.itemId });
+    }
+  }
+  return parts;
+}
+
 export interface BriefCliDeps {
   ledger?: BriefItemsLedger;
   stateDir?: string;
@@ -11,6 +99,10 @@ export interface BriefCliDeps {
   output?: (line: string) => void;
   error?: (line: string) => void;
   send?: (markdown: string) => number | null;
+  /** Test seam for the Telegram button sender (one actual message per invocation). */
+  sendWithButtons?: (text: string, buttons: TgButton[][]) => number | null;
+  /** Allows an injected sender to exercise the same Telegram attribution as the real sender. */
+  telegramTarget?: { botToken: string; chatId: number };
 }
 
 export function registerBriefCommands(program: Command, deps: BriefCliDeps = {}): void {
@@ -31,18 +123,47 @@ export function registerBriefCommands(program: Command, deps: BriefCliDeps = {})
         output(`이번 주 브리핑 중 대표가 움직인 것 ${acted}/${total}`);
       } catch (cause) { fail('', cause); }
     });
-  const deliver = (slot: BriefSendSlot): string => ledger().withSendLock(slot, ({ markdown, ids }, markSent) => {
+  const deliver = (slot: BriefSendSlot): string => ledger().withSendLock(slot, ({ markdown, ids, itemLines }, markSent) => {
     if (ids.length === 0) return '(보낼 항목 없음)';
-    const send = deps.send ?? ((text: string) => {
-      const target = kindRouteTarget(getUserConfig(), 'ops-report');
-      if (!target) return null;
-      return sendTelegramReturningId(target.botToken, target.chatId, text);
-    });
-    const messageId = send(markdown);
-    if (typeof messageId !== 'number' || !Number.isFinite(messageId) || messageId <= 0) {
+    const target = deps.telegramTarget ?? (deps.send ? null : kindRouteTarget(getUserConfig(), 'ops-report'));
+    const numberedMarkdown = withItemNumbers(markdown, itemLines);
+    const oneMessage = numberedMarkdown.length + numberedMarkdown.split('\n').length <= 3900 && ids.length <= 30;
+    const send = (text: string, itemIds: readonly number[]) => deps.sendWithButtons
+      ? deps.sendWithButtons(text, briefFeedbackButtons(itemIds))
+      : deps.send ? deps.send(text)
+      : target ? sendTelegramButtonsTo(target.botToken, target.chatId, text, briefFeedbackButtons(itemIds)) : null;
+    const botId = target ? target.botToken.split(':')[0]! : '';
+    if (target && !oneMessage) {
+      // A sent fragment is not a completed item. Persist only items whose every fragment
+      // succeeded; an incomplete item must remain available to the next send.
+      const parts = briefDeliveryParts(markdown, itemLines);
+      const remainingParts = new Map<number, number>();
+      for (const part of parts) remainingParts.set(part.itemId, (remainingParts.get(part.itemId) ?? 0) + 1);
+      const coordinates: Array<{ botId: string; chatId: number; messageId: number; itemId: number }> = [];
+      let sendThrew = false;
+      let sendCause: unknown;
+      for (const part of parts) {
+        let partMessageId: number | null;
+        try { partMessageId = send(part.text, [part.itemId]); }
+        catch (cause) { sendThrew = true; sendCause = cause; break; }
+        if (typeof partMessageId !== 'number' || !Number.isSafeInteger(partMessageId) || partMessageId <= 0) break;
+        coordinates.push({ botId, chatId: target.chatId, messageId: partMessageId, itemId: part.itemId });
+        remainingParts.set(part.itemId, remainingParts.get(part.itemId)! - 1);
+      }
+      const deliveredIds = [...new Set(coordinates.map(row => row.itemId))].filter(id => remainingParts.get(id) === 0);
+      if (deliveredIds.length > 0) markSent(deliveredIds, slot, coordinates.filter(row => deliveredIds.includes(row.itemId)));
+      if (coordinates.length < parts.length) {
+        if (sendThrew) throw sendCause;
+        throw new Error(`발송 실패: ${deliveredIds.length}/${ids.length} 항목 전송 후 중단 — 나머지는 다음 발송에서 이어진다`);
+      }
+      const lastMessageId = coordinates[coordinates.length - 1]!.messageId;
+      return `sent ${lastMessageId} (${ids.length} items)`;
+    }
+    const messageId = target ? send(numberedMarkdown, ids) : send(markdown, ids);
+    if (typeof messageId !== 'number' || !Number.isSafeInteger(messageId) || messageId <= 0) {
       throw new Error('발송 실패: 양수 메시지 id 없음');
     }
-    markSent(ids, slot);
+    markSent(ids, slot, target ? { botId, chatId: target.chatId, messageId } : undefined);
     return `sent ${messageId} (${ids.length} items)`;
   });
 

package/src/cli/claims-cli.ts

@@ -1,6 +1,7 @@
 import type { Command } from 'commander';
 import { ClaimsInputError, ClaimsLedger, type ClaimsLedgerOptions, type ClaimRow, type ClaimDetail } from '../claims/claims-ledger.js';
 import { renderClaims, queueStaleRechecks, type ClaimSurface } from '../claims/claims-render.js';
+import { PatentLedger, PatentsInputError, type PatentStatus, type PatentTrack } from '../patents/ledger.js';
 
 function actor(explicit?: string): string {
   const by = explicit?.trim() || process.env.AI_AGENT?.trim();
@@ -19,7 +20,7 @@ function handle<Args extends unknown[]>(command: string, action: (...args: Args)
   return (...args) => {
     try { action(...args); }
     catch (error) {
-      if (!(error instanceof ClaimsInputError)) throw error;
+      if (!(error instanceof ClaimsInputError) && !(error instanceof PatentsInputError)) throw error;
       const message = error.message.replace(/\r/g, '\\r').replace(/\n/g, '\\n')
         .replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
       process.stderr.write(`claims ${command}: ${message}\n`);
@@ -41,7 +42,19 @@ function detail(row: ClaimDetail): string {
 export function registerClaimsCommands(program: Command, options: ClaimsLedgerOptions & { instanceRoot?: string } = {}, out: Pick<Console, 'log'> = console): void {
   const root = program.command('claims').description('소구점 · 실측 근거 원장');
   const ledger = () => new ClaimsLedger(options);
+  const patentLedger = () => new PatentLedger(options);
   const emit = (value: unknown, json: boolean | undefined, text: string) => out.log(json ? JSON.stringify(value) : text);
+  const patents = root.command('patents').description('비공개 특허 후보 원장');
+  patents.command('add <id>').requiredOption('--title <title>').requiredOption('--track <track>')
+    .option('--deadline <YYYY-MM-DD>').action(handle('patents add', (id: string, o: { title: string; track: PatentTrack; deadline?: string }) => {
+      const row = patentLedger().add({ id, title: o.title, track: o.track, ...(o.deadline ? { deadline: o.deadline } : {}) });
+      emit(row, false, `${row.id} · ${row.status}`);
+    }));
+  patents.command('status <id>').requiredOption('--status <status>')
+    .action(handle('patents status', (id: string, o: { status: PatentStatus }) => {
+      const row = patentLedger().setStatus(id, o.status);
+      emit(row, false, `${row.id} · ${row.status}`);
+    }));
   root.command('add <id>').requiredOption('--claim <text>').requiredOption('--audience <list>').requiredOption('--owner <seat>')
     .option('--contrast <text>').action(handle('add', (id: string, o: { claim: string; audience: string; owner: string; contrast?: string }) => {
       const row = ledger().add({ id, claim: o.claim, audience: o.audience, owner: o.owner, ...(o.contrast ? { contrast: o.contrast } : {}) });
@@ -79,9 +92,16 @@ export function registerClaimsCommands(program: Command, options: ClaimsLedgerOp
     emit(row, o.json, detail(row));
   }));
   root.command('render').requiredOption('--surface <surface>', 'deck | site | notice')
-    .option('--audience <audience>').option('--json')
-    .action(handle('render', (o: { surface: ClaimSurface; audience?: string; json?: boolean }) => {
-      const result = renderClaims(ledger(), { surface: o.surface, ...(o.audience ? { audience: o.audience } : {}) });
+    .option('--audience <audience>').option('--include-patents', '명시적으로 공개 허용 특허 후보를 포함')
+    .option('--patent-owner <owner>', '특허 후보의 확인된 담당').option('--json')
+    .action(handle('render', (o: { surface: ClaimSurface; audience?: string; includePatents?: boolean; patentOwner?: string; json?: boolean }) => {
+      if (o.includePatents && (!o.patentOwner?.trim() || !o.audience?.trim())) {
+        throw new ClaimsInputError('--include-patents requires --patent-owner and --audience');
+      }
+      if (!o.includePatents && o.patentOwner) throw new ClaimsInputError('--patent-owner requires --include-patents');
+      const patents = o.includePatents
+        ? { ledger: patentLedger(), owner: o.patentOwner!, audience: o.audience! } : undefined;
+      const result = renderClaims(ledger(), { surface: o.surface, ...(o.audience ? { audience: o.audience } : {}), ...(patents ? { patents } : {}) });
       // Review follow-up: rendering is where stale claims surface — queue their re-measurement in the same act.
       const rechecks = result.excluded.some(item => item.reason === 'stale')
         ? queueStaleRechecks(ledger(), { root: options.instanceRoot, now: options.now?.() }) : 0;

package/src/cli/control-cli.ts

@@ -31,6 +31,35 @@ function reasonFor(error: unknown, token?: string): string {
   return token ? message.replaceAll(token, '[redacted]') : message;
 }
 
+/** Doctor's read-only live source. One malformed Nexus machine row invalidates the whole
+ *  reading: doctor reports unmeasured rather than treating a partial registry as complete. */
+export async function listMachineResources(options: { primaryUrl?: string; queryToken?: string; port?: string; root?: string; fetch?: (input: URL | RequestInfo, init?: RequestInit) => Promise<Response> } = {}): Promise<ResourceView[]> {
+  const portOverride = options.port ?? (process.env.ELANOUS_CONTROL_PORT?.trim() || undefined);
+  const primary = await resolvePrimary({
+    role: 'query',
+    ...(options.root ? { root: options.root } : {}),
+    config: { url: options.primaryUrl, tokens: options.queryToken ? { query: options.queryToken } : undefined },
+    ...(portOverride !== undefined ? { port: Number(portOverride) } : {}),
+  });
+  const token = primary.token;
+  if (!token) throw new Error('control query token unavailable');
+  const url = new URL('/v1/resources', primary.url);
+  url.searchParams.set('kind', 'machine');
+  const response = await (options.fetch ?? globalThis.fetch)(url, {
+    headers: { authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(5000),
+  });
+  if (!response.ok) throw new Error(`control HTTP ${response.status}`);
+  const body: unknown = await response.json();
+  if (!body || typeof body !== 'object' || !('resources' in body) || !Array.isArray(body.resources) ||
+      body.resources.some((row: unknown) => !row || typeof row !== 'object' ||
+        (row as ResourceView).kind !== 'machine' || typeof (row as ResourceView).machine !== 'string' ||
+        typeof (row as ResourceView).name !== 'string' || typeof (row as ResourceView).expired !== 'boolean' ||
+        !((row as ResourceView).attrs && typeof (row as ResourceView).attrs === 'object'))) {
+    throw new Error('invalid machine resource response');
+  }
+  return body.resources as ResourceView[];
+}
+
 export async function runResourcesQuery(options: { where?: string; kind?: string; port?: string; primaryUrl?: string; queryToken?: string; json?: boolean }): Promise<number> {
   let base = '';
   let token: string | undefined;

package/src/cli/doctor-cli.ts

@@ -27,7 +27,7 @@ import {
   type ReadinessReport,
   type SubstrateSignals,
 } from './doctor-readiness.js';
-import { debug } from '../debug/log.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { resolveDaemonEndpoint, type ResolveDaemonEndpointOpts } from '../nexus/daemon-endpoint.js';
 import { applyDoctorFixes, applyGitInstall, applyServiceRestart, applySudoFixes, planDoctorFixes, type DoctorFixDeps, type DoctorFixItem } from './doctor-fix.js';
 import { ADVISABLE_DOCTOR_FIX_IDS, adviseDoctorFixes, type DoctorAdvice } from './doctor-llm-assist.js';
@@ -40,7 +40,10 @@ import type { LlmInventory } from '../llm/local-manager/types.js';
 import { buildDoctorBundle } from './doctor-bundle.js';
 import { uploadDoctorBundle } from './doctor-bundle-upload.js';
 import { checkNodeModules, formatNodeModulesCheck, nodeModulesTrees } from './doctor-node-modules.js';
-import { formatHostDoctorLines, runHostDoctor, type HostDoctorExpected, type HostDoctorRemote } from '../fleet/host-doctor.js';
+import { formatHostDoctorLines, runHostDoctor, type HostDoctorExpected, type HostDoctorOptions, type HostDoctorRemote } from '../fleet/host-doctor.js';
+import { listMachineResources } from './control-cli.js';
+import type { ResourceView } from '../control-plane/ledger.js';
+import { loadMachineLedger } from '../machines/machine-ledger.js';
 
 function defaultCheckPythonEnv(): { status: 'ok' | 'fixable' | 'manual'; evidence: string; remedy?: string } {
   const c = checkPythonEnv(false);
@@ -203,9 +206,14 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   hostDoctorRemote?: HostDoctorRemote;
   /** `doctor host` 가 대조할 HQ 실측값(설치 판 · 이미지 핀) — 없으면 해당 점검은 unmeasured. */
   hostDoctorExpected?: HostDoctorExpected;
+  /** HQ membership readings; injected tests need no live Nexus. */
+  hostDoctorMembership?: () => Promise<NonNullable<HostDoctorOptions['membership']>>;
+  /** Nexus machine query seam; tests can exercise the default assembly without contacting a live service. */
+  hostDoctorMachineResources?: () => Promise<ResourceView[]>;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
+const observationError = (error: unknown): string => redactSecretText(error instanceof Error ? error.message : String(error)).slice(0, 200);
 const tavilyNames = new Set(['TAVILY_API_KEY', 'TAVILY_KEY']);
 
 function defaultCodeRevision(): string | undefined {
@@ -1211,6 +1219,52 @@ function formatDoctorAdvice(advice: DoctorAdvice): string {
   ].join('\n');
 }
 
+function formatDoctorAdviceProposal(advice: DoctorAdvice, report: DoctorReport): { text: string; itemId: string; observedValue: string } | null {
+  const proposal = advice.ok ? advice.order[0] : undefined;
+  if (!proposal) return null;
+  const observation = report.readiness?.items.find((item) => item.id === proposal.readinessId);
+  if (!observation) return null;
+  const observedValue = `${observation.status}: ${observation.evidence}`;
+  return {
+    itemId: proposal.readinessId,
+    observedValue,
+    text: [
+      `LLM 제안: ${proposal.why}`,
+      `운영 팩 항목 id: ${proposal.readinessId}`,
+      `현재 관측값: ${observedValue}`,
+    ].join('\n'),
+  };
+}
+
+async function recordDoctorAdviceResponse(
+  proposal: { itemId: string; observedValue: string },
+  accepted: boolean,
+): Promise<void> {
+  debug.log('doctor.advise', accepted ? 'accepted' : 'rejected', {
+    itemId: proposal.itemId,
+    observedValue: proposal.observedValue,
+    applied: 0,
+  });
+}
+
+async function presentDoctorAdviceProposal(
+  advice: DoctorAdvice,
+  report: DoctorReport,
+  deps: DoctorCliDeps,
+  json: boolean,
+  announce: (text: string) => void,
+): Promise<{ proposal: { itemId: string; observedValue: string }; response: boolean | null; text: string } | null> {
+  const formatted = formatDoctorAdviceProposal(advice, report);
+  if (!formatted) return null;
+  const proposal = { itemId: formatted.itemId, observedValue: formatted.observedValue };
+  const interactive = deps.adviceInteractive ?? (process.stdin.isTTY === true && (json ? process.stderr.isTTY === true : process.stdout.isTTY === true));
+  if (!interactive) return { proposal, response: null, text: formatted.text };
+  announce(formatted.text);
+  const accepted = await (deps.confirmAdvice ?? ((message) => confirmDoctorAdvice(message, json)))('이 제안을 수락할까요? [y/N] ');
+  await recordDoctorAdviceResponse(proposal, accepted);
+  return { proposal, response: accepted, text: `${formatted.text}\n응답: ${accepted ? '수락' : '거절'}` };
+}
+
 async function confirmDoctorAdvice(message: string, json: boolean): Promise<boolean> {
   const prompt = createInterface({ input: process.stdin, output: json ? process.stderr : process.stdout });
   try { return /^(y|yes)$/i.test((await prompt.question(message)).trim()); }
@@ -1246,18 +1300,39 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
       if (checks.some((check) => check.status !== 'ok')) setExitCode(1);
     });
   doctor.command('host')
-    .description('Check whether a fleet host stands ready for its role (read-only · setup-status shape)')
-    .argument('<host>', "ssh name, or 'local' for this machine")
+    .description('Check whether a fleet host stands ready (read-only; membership needs a repository checkout and a named remote worker)')
+    .argument('<host>', "SSH name in fleet intent; an unknown name fails membership; 'local' checks readiness without membership")
     .option('--role <role>', 'host role: worker or hq', 'worker')
     .option('--json', 'structured output')
-    .action((host: string, opts: { role: string; json?: boolean }, command: Command) => {
+    .action(async (host: string, opts: { role: string; json?: boolean }, command: Command) => {
       if (opts.role !== 'worker' && opts.role !== 'hq') {
         err.error('--role must be worker or hq');
         setExitCode(1);
         return;
       }
       const json = opts.json === true || command.parent?.opts().json === true;
-      const report = runHostDoctor({ host, role: opts.role, remote: deps.hostDoctorRemote, expected: deps.hostDoctorExpected });
+      let membership: HostDoctorOptions['membership'];
+      if (opts.role === 'worker' && host !== 'local') {
+        if (deps.hostDoctorMembership) membership = await deps.hostDoctorMembership();
+        else {
+          let intent: NonNullable<HostDoctorOptions['membership']>['intent'] = null;
+          let machines: NonNullable<HostDoctorOptions['membership']>['machines'] = null;
+          let parentHosts: NonNullable<HostDoctorOptions['membership']>['parentHosts'] = null;
+          let intentError: string | undefined;
+          let machinesError: string | undefined;
+          let parentHostsError: string | undefined;
+          try { intent = loadMachineLedger(deps.repositoryRoot ?? repositoryRoot); } catch (error) { intentError = observationError(error); }
+          try { machines = await (deps.hostDoctorMachineResources ?? listMachineResources)(); } catch (error) { machinesError = observationError(error); }
+          try {
+            // UserConfig permits one parent object or an array of parent objects, never a bare host string.
+            const configured = (deps.userConfig ?? (deps.getUserConfig ?? getUserConfig)()).taskAgent?.parentHost;
+            if (configured === null) parentHostsError = 'taskAgent.parentHost is null';
+            else parentHosts = configured === undefined ? [] : Array.isArray(configured) ? configured : [configured];
+          } catch (error) { parentHostsError = observationError(error); }
+          membership = { intent, machines, parentHosts, intentError, machinesError, parentHostsError };
+        }
+      }
+      const report = runHostDoctor({ host, role: opts.role, remote: deps.hostDoctorRemote, expected: deps.hostDoctorExpected, membership });
       out.log(json ? JSON.stringify(report, null, 2) : formatHostDoctorLines(report).join('\n'));
       if (!report.ok) setExitCode(1);
     });
@@ -1404,10 +1479,17 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
       // Planning never writes; existing repairs require --yes, while git alone can use affirmative TTY consent.
       const plan = planDoctorFixes(fixes);
       const advice = opts.advise ? await requestDoctorAdvice(report, plan, deps) : undefined;
+      const proposal = advice && !opts.fix ? await presentDoctorAdviceProposal(advice, report, deps, opts.json === true, (text) => {
+        if (opts.json) err.error(text);
+        else out.log(text);
+      }) : null;
       if (!opts.fix) {
         out.log(opts.json
-          ? JSON.stringify({ ...report, advise: advice }, null, 2)
-          : [formatDoctorReport(report, { credentials: opts.credentials }), formatDoctorAdvice(advice!)].join('\n'));
+          ? JSON.stringify({ ...report, advise: advice, ...(proposal ? { adviceProposal: { itemId: proposal.proposal.itemId, observedValue: proposal.proposal.observedValue, response: proposal.response } } : {}) }, null, 2)
+          : [
+            formatDoctorReport(report, { credentials: opts.credentials }),
+            proposal?.response === null ? proposal.text : proposal ? `응답: ${proposal.response ? '수락' : '거절'}` : formatDoctorAdvice(advice!),
+          ].join('\n'));
         if (report.requiredMissing?.length) setExitCode(1);
         return;
       }