elanous 0.2.28 → 0.2.31

package/src/cli/decisions-cli.ts

@@ -11,6 +11,7 @@ import { getUserConfig } from '../user-config.js';
 import { projectDecisionsToLinear } from '../decisions/decision-linear-projection.js';
 import { DecisionLedger, importDecisionMarkdown, type DecisionCategory, type DecisionLedgerOptions, type DecisionOption, type DecisionTrack, type DecisionEntry, type Seat, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { formatProactMeter, readProactMeter } from '../decisions/proact-meter.js';
+import { CROWN_MARK, CROWN_THRESHOLD_CATEGORIES, CONSENSUS_CATEGORIES, ConsensusEngine, MAX_REVIEW_ROUND_TRIPS, categoryLabel, representativeLabel, type ConsensusCategory, type ConsensusRepresentative, type CrownCard, type ProposalCard } from '../loops/consensus.js';
 import { writeStdoutFully } from './stdout-flush.js';
 
 const repeat = (value: string, values: string[]) => [...values, value];
@@ -62,6 +63,14 @@ export function formatSeatDecisionRow(e: SeatDecisionRecord): string {
   return `${e.id} · 결정: ${e.decidedAt ? kst(e.decidedAt) : '시각 미상'} · 기록: ${e.recordedAt ? kst(e.recordedAt) : '시각 미상'} · ${e.seat} 결정 · 사후 보고 · ${e.title} → ${e.decision} · 위임: ${e.delegation}${e.refs?.length ? ` · 참조: ${e.refs.join(' · ')}` : ''}`;
 }
 
+export function formatProposalRow(p: ProposalCard): string {
+  return `${p.id} · ${categoryLabel(p.category)} · ${p.title} · 사실 ${p.factId} · 비용 ${p.cost} · 되돌리기 ${p.undo}${p.thresholds.length ? ` · ${CROWN_MARK} 몫 ${p.thresholds.join('|')}` : ''} · 제안 ${representativeLabel(p.proposedBy)} · ${kst(p.proposedAt)} · 왕복 ${p.roundTrips}/${MAX_REVIEW_ROUND_TRIPS} · ${p.status === 'open' ? '검토 중' : p.status === 'agreed' ? '합의·실행·기록' : '불합의'}`;
+}
+
+export function formatCrownCardRow(c: CrownCard): string {
+  return `${c.id} · ${CROWN_MARK} ${c.reason === 'disagreement' ? '불합의' : '임계 승인'} · 제안 ${c.proposalId} · 조율자 주장: ${c.coordinatorClaim} | 수호자 주장: ${c.guardianClaim}${c.decisionId ? ` · 결정 카드 ${c.decisionId}` : ''}`;
+}
+
 export function registerDecisionsCommands(program: Command, config: DecisionLedgerOptions = {}, out: Pick<Console, 'log'> = console, hqDeps: HqDeps = {}): void {
   const noXcheck = new Option('--no-xcheck <이유>', '교차 확인 생략 이유');
   // This flag takes a reason, not Commander's negated boolean default.
@@ -176,14 +185,24 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (!o.auto && (o.delegation || o.track || o.agent)) throw new Error('delegation/track/agent require --auto');
       const by = o.auto ? { kind: 'auto' as const, agent: agent(o.agent), delegation: o.delegation!, ...(o.track ? { track: o.track } : {}) } : { kind: 'human' as const };
       if (!mayWrite('decide', o.hqOverride)) return;
-      const { entry, delivery } = new DecisionLedger(config).decideWithDelivery(id, choice, by, o.note);
-      if (delivery && !delivery.ok) {
-        // The decision is recorded; only the answer to the waiting run failed — say so and how to retry, never «success».
-        const hint = `⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`;
+      const { entry, delivery, notice } = new DecisionLedger(config).decideWithDelivery(id, choice, by, o.note);
+      const failures = [
+        ...(delivery && !delivery.ok ? [`⚠ 답 전달 실패(${delivery.questionId} · ${delivery.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-answer ${entry.id}`] : []),
+        ...(notice.status === 'failed' ? [`⚠ 자리 우편 실패(${notice.seat} · ${notice.reason}) — 결정은 기록됐다 · 다시: elanous decisions retry-notify ${entry.id}`] : []),
+      ];
+      if (failures.length) {
         process.exitCode = 3;
-        return emit({ ...entry, delivery }, o.json, `결정: ${formatDecisionDetail(entry)}\n${hint}`);
+        return emit({ ...entry, ...(delivery ? { delivery } : {}), notice }, o.json, `결정: ${formatDecisionDetail(entry)}\n${failures.join('\n')}`);
       }
-      return emit(delivery ? { ...entry, delivery } : entry, o.json, `결정: ${formatDecisionDetail(entry)}`);
+      const sent = notice.status === 'sent' ? `\n자리 우편: ${notice.seat} #${notice.messageId}` : '';
+      return emit({ ...entry, ...(delivery ? { delivery } : {}), notice }, o.json, `결정: ${formatDecisionDetail(entry)}${sent}`);
+    }));
+  root.command('retry-notify <id>').description('기록된 결정의 올린 자리 우편만 중복 없이 재시도한다').option('--json').option('--hq-override')
+    .action((id: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('retry-notify', o.hqOverride)) return;
+      const notice = new DecisionLedger(config).retryNotice(id);
+      if (notice.status === 'failed') process.exitCode = 3;
+      return emit(notice, o.json, notice.status === 'sent' ? `자리 우편: ${notice.seat} #${notice.messageId}` : notice.status === 'skipped' ? '올린 자리 없음 — 우편 대상 없음' : `⚠ 자리 우편 실패(${notice.seat} · ${notice.reason})`);
     }));
   root.command('retry-answer <id>').description('기록된 결정의 대기 질문 답 전달만 재시도한다').option('--json').option('--hq-override')
     .action((id: string, o: { json?: boolean; hqOverride?: boolean }) => fail(() => {
@@ -209,4 +228,59 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       if (result.unread.length) process.exitCode = 1;
       return emit(result, o.json, `가져옴 ${result.imported.length} · 기존 ${result.existing.length} · 불완전 ${result.incomplete.length} · 못 읽음 ${result.unread.length}${result.incomplete.length ? `\n${result.incomplete.join('\n')}` : ''}${result.unread.length ? `\n${result.unread.join('\n')}` : ''}`);
     }));
+  const consensusRoot = root.command('consensus').description('두 대표 합의 — 조율자(일의 흐름)·수호자(몸)의 다섯 범주는 «둘의 합의» 뒤에 실행');
+  const consensusEngine = () => new ConsensusEngine({ stateDir: config.stateDir, now: config.now, resolveVersion: config.resolveVersion });
+  consensusRoot.command('propose').description('제안 카드를 올린다 — 사실 id·비용·되돌리기')
+    .requiredOption('--by <representative>', '제안 대표 (coordinator|guardian)')
+    .requiredOption('--category <category>', `합의 범주 (${CONSENSUS_CATEGORIES.join('|')})`)
+    .requiredOption('--title <text>').requiredOption('--fact-id <id>', '사실 id')
+    .requiredOption('--cost <text>', '비용').requiredOption('--undo <text>', '되돌리기')
+    .option('--threshold <category>', `${CROWN_MARK} 몫 임계 범주 (반복: ${CROWN_THRESHOLD_CATEGORIES.join('|')})`, repeat, [])
+    .option('--provider <name>', 'LLM 제공자 표식 — 가능하면 상대와 다른 제공자 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((o: { by: string; category: string; title: string; factId: string; cost: string; undo: string; threshold: string[]; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus propose', o.hqOverride)) return;
+      const proposal = consensusEngine().propose({
+        by: o.by as ConsensusRepresentative, category: o.category as ConsensusCategory, title: o.title, factId: o.factId, cost: o.cost, undo: o.undo,
+        thresholds: o.threshold.map(threshold => threshold as DecisionCategory), provider: o.provider,
+      });
+      return emit(proposal, o.json, `제안: ${formatProposalRow(proposal)}`);
+    }));
+  consensusRoot.command('review <id>').description('상대 검토 왕복을 남긴다 — 최대 2왕복, 마지막 왕복은 결론으로')
+    .requiredOption('--by <representative>', '검토 대표 — 제안한 대표의 상대 (coordinator|guardian)')
+    .requiredOption('--claim <text>', '검토 주장')
+    .option('--provider <name>', 'LLM 제공자 표식 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((id: string, o: { by: string; claim: string; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus review', o.hqOverride)) return;
+      const proposal = consensusEngine().review(id, { by: o.by as ConsensusRepresentative, claim: o.claim, provider: o.provider });
+      return emit(proposal, o.json, `검토 ${proposal.roundTrips}/${MAX_REVIEW_ROUND_TRIPS}왕복: ${formatProposalRow(proposal)}`);
+    }));
+  consensusRoot.command('agree <id>').description(`상대 대표의 합의 — 실행·합의 원장 기록 (임계 범주면 ${CROWN_MARK} 카드도 함께)`)
+    .requiredOption('--by <representative>', '합의 대표 — 제안한 대표의 상대 (coordinator|guardian)')
+    .option('--claim <text>', '합의 주장 (생략 시 제안대로 실행)')
+    .option('--provider <name>', 'LLM 제공자 표식 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((id: string, o: { by: string; claim?: string; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus agree', o.hqOverride)) return;
+      const { proposal, crownCard } = consensusEngine().agree(id, { by: o.by as ConsensusRepresentative, claim: o.claim, provider: o.provider });
+      return emit({ proposal, ...(crownCard ? { crownCard } : {}) }, o.json,
+        `합의: ${formatProposalRow(proposal)}${crownCard ? `\n${CROWN_MARK} 카드: ${formatCrownCardRow(crownCard)}` : ''}`);
+    }));
+  consensusRoot.command('disagree <id>').description(`상대 대표의 불합의 — 양쪽 주장 나란히 ${CROWN_MARK} 결정 카드`)
+    .requiredOption('--by <representative>', '불합의 대표 — 제안한 대표의 상대 (coordinator|guardian)')
+    .requiredOption('--claim <text>', `불합의 주장 — ${CROWN_MARK} 카드에 나란히 실린다`)
+    .option('--provider <name>', 'LLM 제공자 표식 (메아리 방지)')
+    .option('--json').option('--hq-override')
+    .action((id: string, o: { by: string; claim: string; provider?: string; json?: boolean; hqOverride?: boolean }) => fail(() => {
+      if (!mayWrite('consensus disagree', o.hqOverride)) return;
+      const { proposal, crownCard } = consensusEngine().disagree(id, { by: o.by as ConsensusRepresentative, claim: o.claim, provider: o.provider });
+      return emit({ proposal, crownCard }, o.json, `불합의: ${formatProposalRow(proposal)}\n${CROWN_MARK} 카드: ${formatCrownCardRow(crownCard)}`);
+    }));
+  consensusRoot.command('crown').description(`${CROWN_MARK} 결정 카드 목록 — 불합의·임계 범주만 만든다`)
+    .option('--json')
+    .action((o: { json?: boolean }) => fail(() => {
+      const cards = consensusEngine().crownCards();
+      return emit(cards, o.json, cards.length ? cards.map(formatCrownCardRow).join('\n') : `${CROWN_MARK} 결정 카드 0건`);
+    }));
 }

package/src/cli/doctor-cli.ts

@@ -40,6 +40,16 @@ 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 {
+  DOCTOR_SYMPTOMS,
+  DOCTOR_VISIT_SOURCES,
+  doctorVisitRunExists,
+  isDoctorSymptom,
+  isDoctorVisitSource,
+  readDoctorVisits,
+  recordDoctorVisit,
+  type DoctorSymptom,
+} from '../self-implement/doctor-visit.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';
@@ -210,6 +220,8 @@ export interface DoctorCliDeps extends DoctorOptions, Pick<DoctorFixDeps, 'home'
   hostDoctorMembership?: () => Promise<NonNullable<HostDoctorOptions['membership']>>;
   /** Nexus machine query seam; tests can exercise the default assembly without contacting a live service. */
   hostDoctorMachineResources?: () => Promise<ResourceView[]>;
+  /** `doctor visit`/`doctor status` 원장 디렉터리(시험 seam) — 기본 = `runLedgerDir()`. */
+  doctorVisitLedgerDir?: string;
 }
 
 const repositoryRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../..');
@@ -1336,6 +1348,74 @@ export function registerDoctorCommand(program: Command, deps: DoctorCliDeps = {}
       out.log(json ? JSON.stringify(report, null, 2) : formatHostDoctorLines(report).join('\n'));
       if (!report.ok) setExitCode(1);
     });
+  doctor.command('visit')
+    .description('Record a doctor visit (triage symptom) in the run ledger of that run')
+    .argument('<runId>', 'run id whose ledger receives the visit')
+    .requiredOption('--symptom <symptom>', `closed symptom list: ${DOCTOR_SYMPTOMS.join(', ')}`)
+    .requiredOption('--from <who>', `closed sender list: ${DOCTOR_VISIT_SOURCES.join(', ')}`)
+    .option('--evidence <text>', 'free-text evidence recorded with the visit')
+    .option('--json', 'structured output')
+    .action((runId: string, opts: { symptom: string; from: string; evidence?: string; json?: boolean }, command: Command) => {
+      const json = opts.json === true || command.parent?.opts().json === true;
+      if (!isDoctorSymptom(opts.symptom)) {
+        const reason = `unknown symptom: ${opts.symptom} — closed list: ${DOCTOR_SYMPTOMS.join(', ')}`;
+        if (json) out.log(JSON.stringify({ status: 'rejected', reason }));
+        else err.error(reason);
+        setExitCode(1);
+        return;
+      }
+      if (!isDoctorVisitSource(opts.from)) {
+        const reason = `unknown from: ${opts.from} — closed list: ${DOCTOR_VISIT_SOURCES.join(', ')}`;
+        if (json) out.log(JSON.stringify({ status: 'rejected', reason }));
+        else err.error(reason);
+        setExitCode(1);
+        return;
+      }
+      try {
+        const visit = recordDoctorVisit({
+          runId,
+          from: opts.from,
+          symptom: opts.symptom,
+          ...(opts.evidence !== undefined ? { evidence: opts.evidence } : {}),
+          ...(deps.doctorVisitLedgerDir !== undefined ? { dir: deps.doctorVisitLedgerDir } : {}),
+        });
+        out.log(json ? JSON.stringify(visit) : `doctor visit recorded: runId=${runId} from=${opts.from} symptom=${opts.symptom}${visit.evidence !== undefined ? ` evidence=${visit.evidence}` : ''}`);
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        if (json) out.log(JSON.stringify({ status: 'rejected', reason }));
+        else err.error(reason);
+        setExitCode(1);
+      }
+    });
+  doctor.command('status')
+    .description('Summarize recorded doctor visits by symptom with recent visit lines')
+    .option('--run <runId>', 'limit the summary to one run ledger')
+    .option('--json', 'structured output')
+    .action((opts: { run?: string; json?: boolean }, command: Command) => {
+      const json = opts.json === true || command.parent?.opts().json === true;
+      const ledgerScope = deps.doctorVisitLedgerDir !== undefined ? { dir: deps.doctorVisitLedgerDir } : {};
+      if (opts.run !== undefined && !doctorVisitRunExists(opts.run, ledgerScope)) {
+        const reason = `없음: 런 원장이 없습니다 (runId=${opts.run})`;
+        if (json) out.log(JSON.stringify({ status: 'rejected', reason }));
+        else err.error(reason);
+        setExitCode(1);
+        return;
+      }
+      const visits = readDoctorVisits(opts.run, ledgerScope);
+      const counts = Object.fromEntries(DOCTOR_SYMPTOMS.map((symptom: DoctorSymptom) => [symptom, 0])) as Record<DoctorSymptom, number>;
+      for (const visit of visits) counts[visit.symptom] += 1;
+      if (json) {
+        out.log(JSON.stringify({ total: visits.length, counts, visits }, null, 2));
+        return;
+      }
+      out.log([
+        `Doctor visits: ${visits.length}`,
+        ...DOCTOR_SYMPTOMS.map((symptom: DoctorSymptom) => `  ${symptom}: ${counts[symptom]}`),
+        'Recent visits:',
+        ...visits.map((visit) => `  ${visit.timestamp ?? 'unknown-time'} runId=${visit.runId} from=${visit.from} symptom=${visit.symptom}${visit.evidence !== undefined ? ` evidence=${visit.evidence}` : ''}`),
+        ...(visits.length === 0 ? ['  none'] : []),
+      ].join('\n'));
+    });
   doctor
     .option('--credentials', 'show per-credential details in human-readable output')
     .option('--bundle', 'write a redacted diagnostics archive for support')

package/src/cli/log-event-names.ts

@@ -131,6 +131,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "base.stale-local",
   "baseline-invalidate",
   "baseline-reuse",
+  "batch-remaining-skipped",
   "begin",
   "bind",
   "blocked-accepted",
@@ -189,6 +190,8 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "capture.push.skip",
   "capture.start.begin",
   "capture.start.return",
+  "card-injected",
+  "card-skipped",
   "carry",
   "cascade-threshold",
   "catalog-envkey-conflict",
@@ -283,6 +286,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "control-processing-error",
   "control-result",
   "control-settled",
+  "conversation-start",
   "core-turn",
   "corpus",
   "cost.error",
@@ -290,6 +294,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "cost.skip-unregistered",
   "coverage",
   "coverage-exhausted",
+  "create-skipped",
   "create.labels-omitted",
   "created",
   "credential",
@@ -444,6 +449,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "edit.autorecovered",
   "edit.failed",
   "edit.path-resolved",
+  "edited",
   "effort-resolved",
   "emit",
   "emit-fail",
@@ -523,6 +529,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "fanout.out",
   "feedback",
   "final",
+  "final-supplement-withheld",
   "final.received",
   "finalize",
   "finalize.error",
@@ -663,6 +670,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "hold-wait-start",
   "hold-wait-timeout",
   "host-owned-passthrough",
+  "human-word-needs-provider",
   "idempotent",
   "identical-success-detected",
   "idle-pane-dispatch-consumed",
@@ -698,6 +706,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "initialize",
   "initialized",
   "inject-blocked",
+  "injected-key-stream-delivered",
   "input-loop-enter",
   "input-outcome",
   "input.miss",
@@ -734,6 +743,8 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "keyframe-fail",
   "kill.error",
   "kitty.write",
+  "last-session-skipped",
+  "last-session-written",
   "launch",
   "launch-overrides",
   "layered-load",
@@ -760,6 +771,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "llm.error",
   "llm.input",
   "loaded",
+  "local-over-cap",
   "log-sink-failed",
   "log-zone-click",
   "long-lived-live",
@@ -807,6 +819,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "merge-safety-tsc",
   "merge.gh",
   "merged",
+  "mirror-seed-skipped",
   "missing-ctrl",
   "missing-shift",
   "missing-widget-definition",
@@ -1223,6 +1236,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "select",
   "selected",
   "selection",
+  "selection-timed",
   "self-orchestrate-exposure",
   "self-turn",
   "send",
@@ -1239,6 +1253,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "session-list",
   "session-loaded",
   "session-new",
+  "session-pin-cleared",
   "session-resume",
   "session-runtime-tool-specs.return",
   "session-update.error",
@@ -1328,6 +1343,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "split-check",
   "stage-enter",
   "stage.route",
+  "stages",
   "start",
   "start.controller.refused",
   "start.enter",
@@ -1395,6 +1411,8 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "surface.resolve",
   "sweep",
   "swept",
+  "switch",
+  "switch-decision",
   "switch-off",
   "sync",
   "syncLogWidgetState",
@@ -1487,6 +1505,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "tool-loop.repair-phase.codex-grace-burned",
   "tool-loop.repair-phase.codex-immediate-stop",
   "tool-loop.search-only-streak-blocked",
+  "tool-loop.steered-rejection-not-failure",
   "tool-loop.synthesis-ignored.hard-stop",
   "tool-loop.tool-name.invalid",
   "tool-loop.tool-name.repaired",

package/src/cli/mcp-login.ts

@@ -91,9 +91,8 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
     const discovered = await discoverMcpOAuth(challenge.resourceMetadata, {
       resourceUrl: spec.url, ...oauthOpts,
     });
-    if ((why || !discovered.metadata.authorizationEndpoint) && discovered.metadata.deviceAuthorizationEndpoint) {
-      if (early?.server.listening) await closeServer(early.server);
-      if (why) out.log(why);
+    const loginWithDevice = async (): Promise<McpLoginResult> => {
+      if (server?.listening) await closeServer(server);
       const stored = loadStoredRegistration(discovered.metadata.issuer, oauthOpts);
       const deviceRegistration = await ensureClientRegistration(discovered.metadata, { ...oauthOpts, deviceCode: true });
       const authorizeDevice = (registration: typeof deviceRegistration) => authorizeMcpDevice(discovered.metadata, registration, {
@@ -119,6 +118,10 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
       out.log(`✓ credentials saved for '${opts.serverId}' (${discovered.metadata.issuer})`);
       persistLoginDiscovery(opts, discovered.metadata, out);
       return { exitCode: 0 };
+    };
+    if ((why || !discovered.metadata.authorizationEndpoint) && discovered.metadata.deviceAuthorizationEndpoint) {
+      if (why) out.log(why);
+      return await loginWithDevice();
     }
     const callbackListener = early ?? await listenForCallback(opts.createListener, 0);
     server = callbackListener.server;
@@ -170,7 +173,17 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
         }
       }
     }
-    const callback = await callbackPromise;
+    let callback: Callback;
+    try {
+      callback = await callbackPromise;
+    } catch (error) {
+      // A missing browser callback can use the advertised device flow. An explicit
+      // denial, mismatched state, or malformed callback must never silently fall back.
+      if (!discovered.metadata.deviceAuthorizationEndpoint ||
+          !/^authorization callback timed out after \d+ms$/.test(error instanceof Error ? error.message : '')) throw error;
+      out.log(`Browser approval did not complete for '${opts.serverId}'; trying device code.`);
+      return await loginWithDevice();
+    }
     await exchangeAuthorizationCode(authorization.metadata, authorization.request, callback, oauthOpts);
     out.log(`✓ credentials saved for '${opts.serverId}' (${authorization.metadata.issuer})`);
     persistLoginDiscovery(opts, authorization.metadata, out);
@@ -424,7 +437,10 @@ async function listenForCallback(
       }
       settle = resolve;
       reject = rejectWait;
-      const timer = setTimeout(() => rejectWait(new Error(`authorization callback timed out after ${timeoutMs}ms`)), timeoutMs);
+      const timer = setTimeout(() => {
+        completed = true;
+        settleCallback(new Error(`authorization callback timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
       (timer as unknown as { unref?: () => void }).unref?.();
       // ⛔ 성공·실패 어느 쪽으로 끝나든 타이머를 «반드시» 거둔다.
       clearWaitTimer = () => clearTimeout(timer as unknown as ReturnType<typeof setTimeout>);

package/src/cli/msg-cli.ts

@@ -2,6 +2,8 @@ import type { Command } from 'commander';
 import { ensureAuthToken } from '../auth/acp-token.js';
 import { canonicalSeatId, openMsgStore, openMsgStoreReadOnly, type Message, type MsgStore } from '../msg/msg-store.js';
 import { startMsgSseServer } from '../msg/msg-sse-server.js';
+import { messageRouteFor, noReplyBodyNotice, unsupportedLoopAddressNotice } from '../loops/msg-address.js';
+import { resolveWake, wakeRecipient, type WakeDeps, type WakeOutcome } from '../loops/msg-wake.js';
 
 export interface MsgCliDeps {
   openStore?: () => MsgStore;
@@ -13,6 +15,20 @@ export interface MsgCliDeps {
   signal?: AbortSignal;
   fetch?: typeof fetch;
   authToken?: () => string;
+  /** Wake-path resolution for `msg route` (tests inject; default reads pty manifest ⊕ seat folders). */
+  wakeDeps?: WakeDeps;
+  /** Attach the logs.db sink so `msg.wake` reaches `elanous logs` (a short CLI otherwise writes only the file trail). */
+  registerLogSink?: () => Promise<unknown>;
+  /** Wake the recipient after a durable post; never changes the post outcome. */
+  wake?: (address: string, msgId: number, message: { from: string; kind?: string }, deps: WakeDeps) => Promise<WakeOutcome>;
+  /** Test seams for the existing self-send transport and the selected task-card ledger. */
+  readCard?: typeof import('../task-agent/task-hand.js').readTaskCard;
+  podFragmentsForRun?: typeof import('../harness/self-send-target.js').listPodFragmentsForRun;
+  sendPod?: typeof import('../harness/self-send-target.js').dispatchPodSelfSend;
+  runScreen?: typeof import('../self-implement/run-ledger.js').queryRunScreenKey;
+  sendMemo?: typeof import('../harness/control-inbox.js').enqueueControlMemo;
+  sendStop?: typeof import('../harness/control-inbox.js').enqueueSoftStop;
+  screenAlive?: (spaceId: string) => boolean;
 }
 
 type CommonOptions = { json?: boolean };
@@ -31,8 +47,14 @@ function integer(raw: string | undefined, flag: string, fallback: number, min: n
   return value;
 }
 
-function formatMessage(message: Message): string {
-  return `#${message.id} ${message.createdAt} ${message.from} → ${message.to}${message.kind ? ` [${message.kind}]` : ''}: ${message.body}`;
+/** Emoji prefix per known kind; the `[kind]` text itself stays because operating scripts grep for it. */
+const KIND_EMOJI: Readonly<Record<string, string>> = {
+  coord: '🤝', report: '📋', info: 'ℹ️', question: '❓', alert: '🚨', progress: '⏳', incident: '🔥', coach: '🎓',
+};
+
+export function formatMessage(message: Message): string {
+  const kind = message.kind ? ` ${Object.hasOwn(KIND_EMOJI, message.kind) ? KIND_EMOJI[message.kind] : ''}[${message.kind}]` : '';
+  return `#${message.id} ${message.createdAt} ${message.from} → ${message.to}${kind}: ${message.body}`;
 }
 
 /** Register the durable, recipient-addressed CLI. Reading never advances the acknowledgement cursor. */
@@ -45,6 +67,83 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
   const setExitCode = deps.setExitCode ?? ((code: number) => { process.exitCode = code; });
   const msg = program.command('msg').description('Durable seat-addressed messages');
 
+  // Called by both msg post and msg ask after their durable TA request is written.
+  const handleTaMessage = async (request: Message): Promise<void> => {
+    if (request.to !== 'TA' || request.from === 'TA' || request.replyTo !== undefined) return;
+    const command = /\b(stop|memo|status)\b/i.exec(request.body);
+    const cardId = /\bta-[a-zA-Z0-9][a-zA-Z0-9._-]*\b/.exec(request.body)?.[0]?.replace(/[.,!?]+$/, '');
+    if (!command || !cardId) return;
+    const { readTaskCard } = await import('../task-agent/task-hand.js');
+    const { queryRunScreenKey } = await import('../self-implement/run-ledger.js');
+    const { listHarnessScreens } = await import('../harness/harness-screen.js');
+    const { normalizeRunId } = await import('../harness/harness-space.js');
+    const { dispatchPodSelfSend, listPodFragmentsForRun } = await import('../harness/self-send-target.js');
+    const { enqueueControlMemo, enqueueSoftStop } = await import('../harness/control-inbox.js');
+    withStore(store => {
+      // Reserve one linked reply and pending delivery before touching another store or Pod.
+      const pending = store.db.transaction(() => {
+        // A concurrent sender may have claimed after an earlier read. Keep this
+        // check in the same write transaction as any pending reply change.
+        if (store.taDeliveryClaimState(request.id) === 'held') return null;
+        const reply = store.listReplies(request.id, 1)[0];
+        if (reply && store.taDeliveryStatus(request.id) !== 'pending') return null;
+        let delivery: (() => void) | undefined;
+        let deliveryReply: string | undefined;
+        let answer: string;
+        try {
+          const card = (deps.readCard ?? readTaskCard)(cardId);
+          if (!card) throw new Error(`카드 없음: ${cardId}`);
+          if (command[1]!.toLowerCase() === 'status') {
+            answer = `${card.id}: ${card.status}${card.runId ? ` · run ${card.runId}` : ''}`;
+          } else {
+            const runId = card.runId;
+            if (!runId || normalizeRunId(runId) !== runId) throw new Error(`${cardId}: 연결된 런 없음`);
+            const fragments = (deps.podFragmentsForRun ?? listPodFragmentsForRun)(runId);
+            const resolved = fragments.length === 0 ? (deps.runScreen ?? queryRunScreenKey)(runId) : null;
+            const screen = resolved?.logStoreStatus === 'read' ? resolved.screenKey : null;
+            if (fragments.length > 1 || (fragments.length === 0 && (!screen || !(deps.screenAlive ?? ((id: string) => listHarnessScreens().some(row => row.spaceId === id)))(screen)))) {
+              throw new Error(`${cardId}: 실행 중인 단일 런 공간을 찾을 수 없음`);
+            }
+            const space = fragments[0]?.spaceId ?? screen!;
+            const stop = command[1]!.toLowerCase() === 'stop';
+            const body = stop ? '' : request.body.replace(command[0], '').replace(cardId, '').trim().replace(/^[,.:;\s-]+/, '');
+            if (!stop && (!body || /[\r\n]/.test(body))) throw new Error('memo는 비어 있지 않은 한 줄이어야 한다');
+            const memo = { version: 1 as const, kind: 'supervisor', urgency: 'normal' as const, body };
+            answer = `${cardId}: run ${runId} 전달 여부 미확인 (${space}) — 자동 재시도 중지; 런 인박스를 확인하세요.`;
+            delivery = () => {
+              if (fragments.length) {
+                if (!(deps.sendPod ?? dispatchPodSelfSend)(space, stop ? { stop: true } : { memo })) throw new Error(`${cardId}: Pod 전달 실패`);
+              } else if (stop) (deps.sendStop ?? enqueueSoftStop)(space);
+              else (deps.sendMemo ?? enqueueControlMemo)(space, memo);
+            };
+            deliveryReply = stop ? `${cardId}: run ${runId} soft stop 요청 기록 (${space})`
+              : `${cardId}: run ${runId} 감독 메모 기록 (${space})`;
+          }
+        } catch (error) {
+          answer = `${cardId}: ${error instanceof Error ? error.message : String(error)}`;
+        }
+        if (delivery) store.setTaDeliveryStatus(request.id, 'pending');
+        if (reply) store.updateTaReply(request.id, answer);
+        else store.post({ from: 'TA', to: request.from, kind: 'reply', body: answer, replyTo: request.id });
+        return delivery && deliveryReply ? { delivery, reply: deliveryReply } : null;
+      }).immediate();
+      if (pending) {
+        const claim = store.claimTaDelivery(request.id);
+        if (!claim) return;
+        try {
+          pending.delivery();
+          store.settleTaDelivery(request.id, claim, pending.reply, true);
+        }
+        catch (error) {
+          // A transport error or failed DB settlement may follow a successful publication.
+          // Keep the claim and require inspection rather than send the same memo again.
+          store.markTaDeliveryUnknown(request.id, claim,
+            `${cardId}: 전달 여부 미확인 — 자동 재시도 중지: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    });
+  };
+
   const run = (action: () => void | Promise<void>) => async () => {
     try { await action(); }
     catch (error) {
@@ -68,6 +167,8 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
     .option('--origin-key <key>', 'deduplicate a channel mirror by coord:<commentId>:<recipient>').option('--json')
     .action((body: string | undefined, opts: CommonOptions & { from?: string; to?: string; kind?: string; body?: string; replyTo?: string; originKey?: string }) => run(async () => {
       const from = seat(opts.from, '--from');
+      const unsupported = opts.to === undefined ? null : unsupportedLoopAddressNotice(opts.to);
+      if (unsupported) out.error(unsupported);
       const to = seat(opts.to, '--to');
       if (body !== undefined && body !== '-' && opts.body !== undefined) throw new Error('provide body once (argument or --body)');
       const text = opts.body ?? (body !== undefined && body !== '-' ? body : await readStdin());
@@ -78,6 +179,34 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
         ? store.post(envelope)
         : store.appendWithProvenance(envelope, opts.originKey));
       emit(posted, opts.json, () => out.log(formatMessage(posted)));
+      await handleTaMessage(posted); // msg post: process the durable TA request (including pending retry).
+      const noBody = noReplyBodyNotice(to);
+      if (noBody) out.error(noBody);
+      // 저장 «뒤» 한 번 — 읽는 몸이 없다는 안내가 이미 나갔으면 깨움 경고는 겹쳐 내지 않는다.
+      // 깨움은 post 의 성패를 바꾸지 않는다 — 동기 예외까지 여기서 막는다.
+      // 로그 싱크 등록이 멈춰도 깨움·post 완료를 붙잡지 않는다(1초 상한).
+      try {
+        let sinkTimer: ReturnType<typeof setTimeout> | undefined;
+        await Promise.race([
+          (deps.registerLogSink ?? (async () => (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('cli')))(),
+          new Promise<void>(resolve => { sinkTimer = setTimeout(resolve, 1000); }),
+        ]).finally(() => clearTimeout(sinkTimer));
+      } catch { /* observability is fail-open */ }
+      try {
+        await (deps.wake ?? wakeRecipient)(to, posted.id, { from, ...(opts.kind === undefined ? {} : { kind: opts.kind }) },
+          { ...deps.wakeDeps, warn: noBody ? () => {} : line => out.error(line) });
+      } catch { /* the wake outcome is logged by wakeRecipient; the post is already durable */ }
+    })());
+
+  msg.command('route <address>').description('Show how a post to this address is read (replyBody) and woken (wake)')
+    .option('--json')
+    .action((address: string, opts: CommonOptions) => run(() => {
+      const to = canonicalSeatId(address);
+      const wake = resolveWake(to, deps.wakeDeps);
+      const row = { msgAddress: to, replyBody: messageRouteFor(to)?.replyBody ?? null, ...wake };
+      emit(row, opts.json, () => out.log(`${to}\treplyBody=${row.replyBody ?? '모름'}\twake=${wake.wake}`
+        + `${wake.target ? `\ttarget=${wake.target}` : ''}${wake.optIn === undefined ? '' : `\toptIn=${wake.optIn ? 'yes' : 'no(주입 0)'}`}`
+        + `\t(${wake.source}${wake.reason ? `: ${wake.reason}` : ''})`));
     })());
 
   msg.command('list').description('List messages for one recipient without acknowledging them')
@@ -230,6 +359,8 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
       let store: MsgStore | undefined;
       try {
         const asked = withStore(ledger => ledger.post({ from, to, body: question }));
+        // msg ask uses the same saved-message handler before waiting for its linked reply.
+        await handleTaMessage(asked);
         const deadline = Date.now() + waitSeconds * 1000;
         let reply: Message | undefined;
         store = open();