elanous 0.2.0 → 0.2.4

package/src/cli/mcp-login.ts

@@ -2,8 +2,16 @@ import { execFile } from 'node:child_process';
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
 import { promisify } from 'node:util';
 import { getUserConfig, reloadUserConfig, saveUserConfig, type McpServerSpec } from '../user-config.js';
-import { exchangeAuthorizationCode, prepareMcpOAuthAuthorization, type McpOAuthFetch } from '../mcp/mcp-oauth.js';
+import {
+  discoverMcpOAuth,
+  exchangeAuthorizationCode,
+  loadStoredRegistration,
+  loopbackRedirectPort,
+  prepareMcpOAuthAuthorization,
+  type McpOAuthFetch,
+} from '../mcp/mcp-oauth.js';
 import { parseWwwAuthenticate } from '../mcp/client.js';
+import { debug } from '../debug/log.js';
 
 const CALLBACK_PATH = '/oauth/callback';
 const DEFAULT_TIMEOUT_MS = 120_000;
@@ -58,20 +66,25 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
 
   let server: Server | undefined;
   try {
-    const listener = await listenForCallback(opts.createListener);
-    server = listener.server;
+    const early = await listenForCallback(opts.createListener, 0);
+    server = early.server;
     const challenge = await requestChallenge(spec.url, opts.fetch);
     if (!challenge.resourceMetadata) {
       out.error(`✗ server '${opts.serverId}' did not provide a 401 Bearer resource_metadata challenge`);
       return { exitCode: 1 };
     }
-    const authorization = await prepareMcpOAuthAuthorization({
+    const opened = await openLoginListener({
+      early,
+      serverId: opts.serverId,
       resourceMetadataUrl: challenge.resourceMetadata,
-      scope: challenge.scope,
-      redirectUri: listener.redirectUri,
+      ...(challenge.scope ? { scope: challenge.scope } : {}),
       resourceUrl: spec.url,
       ...(opts.fetch ? { fetch: opts.fetch } : {}),
+      ...(opts.createListener ? { createListener: opts.createListener } : {}),
     });
+    const listener = opened.listener;
+    server = listener.server;
+    const authorization = opened.authorization;
     const callbackPromise = listener.wait(authorization.request.state, opts.timeoutMs ?? DEFAULT_TIMEOUT_MS);
     // Browser launch can synchronously trigger the loopback callback; mark its
     // rejection handled before awaiting the launch so OAuth errors stay in this flow.
@@ -115,6 +128,12 @@ export async function runMcpLogin(opts: McpLoginOpts): Promise<McpLoginResult> {
     out.log(`  도는 데몬에 반영하려면: elanous mcp reload`);
     return { exitCode: 0 };
   } catch (error) {
+    const stage = loginFailureStage(error);
+    debug.log('mcp.login', 'failed', {
+      serverId: opts.serverId,
+      stage,
+      reason: error instanceof Error ? error.message : String(error),
+    });
     out.error(`✗ MCP login failed: ${error instanceof Error ? error.message : String(error)}`);
     return { exitCode: 1 };
   } finally {
@@ -132,7 +151,96 @@ async function requestChallenge(url: string, fetchFn?: McpOAuthFetch): Promise<{
   return parseWwwAuthenticate(response.headers.get('www-authenticate') ?? '');
 }
 
-async function listenForCallback(createListener: McpLoginOpts['createListener']): Promise<{
+function loginFailureStage(error: unknown): 'authorization' | 'token' | 'login' {
+  const code = error && typeof error === 'object' && 'code' in error ? String((error as { code: unknown }).code) : '';
+  if (code === 'token' || code === 'refresh' || code === 'state-mismatch') return 'token';
+  if (code === 'registration' || code === 'discovery' || code === 'identity-mismatch' || code === 's256-unsupported') {
+    return 'authorization';
+  }
+  return 'login';
+}
+
+async function openLoginListener(opts: {
+  serverId: string;
+  resourceMetadataUrl: string;
+  scope?: string;
+  resourceUrl: string;
+  fetch?: McpOAuthFetch;
+  createListener?: McpLoginOpts['createListener'];
+  early: Awaited<ReturnType<typeof listenForCallback>>;
+}): Promise<{ listener: Awaited<ReturnType<typeof listenForCallback>>; authorization: Awaited<ReturnType<typeof prepareMcpOAuthAuthorization>> }> {
+  const prior = await priorRegistration(opts);
+  const preferred = loopbackRedirectPort(prior?.redirectUri);
+  if (preferred === null && (prior === null || prior.redirectUri)) {
+    const listener = opts.early;
+    debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'fresh' });
+    const authorization = await prepareMcpOAuthAuthorization({
+      resourceMetadataUrl: opts.resourceMetadataUrl,
+      scope: opts.scope,
+      redirectUri: listener.redirectUri,
+      resourceUrl: opts.resourceUrl,
+      ...(opts.fetch ? { fetch: opts.fetch } : {}),
+    });
+    return { listener, authorization };
+  }
+  await closeServer(opts.early.server);
+  if (preferred !== null) {
+    try {
+      const listener = await listenForCallback(opts.createListener, preferred);
+      debug.log('mcp.login', 'callback-port', { serverId: opts.serverId, source: 'registered' });
+      const authorization = await prepareMcpOAuthAuthorization({
+        resourceMetadataUrl: opts.resourceMetadataUrl,
+        scope: opts.scope,
+        redirectUri: listener.redirectUri,
+        resourceUrl: opts.resourceUrl,
+        ...(opts.fetch ? { fetch: opts.fetch } : {}),
+      });
+      return { listener, authorization };
+    } catch (error) {
+      if (!isAddressInUse(error)) throw error;
+    }
+  }
+  const listener = await listenForCallback(opts.createListener, 0);
+  debug.log('mcp.login', 'callback-port', {
+    serverId: opts.serverId,
+    source: 'reregistered',
+    reason: preferred === null ? 'missing-redirect-uri' : 'port-in-use',
+  });
+  const authorization = await prepareMcpOAuthAuthorization({
+    resourceMetadataUrl: opts.resourceMetadataUrl,
+    scope: opts.scope,
+    redirectUri: listener.redirectUri,
+    resourceUrl: opts.resourceUrl,
+    ...(opts.fetch ? { fetch: opts.fetch } : {}),
+    forceReregister: true,
+  });
+  return { listener, authorization };
+}
+
+async function priorRegistration(opts: {
+  resourceMetadataUrl: string;
+  resourceUrl: string;
+  fetch?: McpOAuthFetch;
+}): Promise<ReturnType<typeof loadStoredRegistration>> {
+  try {
+    const discovered = await discoverMcpOAuth(opts.resourceMetadataUrl, {
+      resourceUrl: opts.resourceUrl,
+      ...(opts.fetch ? { fetch: opts.fetch } : {}),
+    });
+    return loadStoredRegistration(discovered.metadata.issuer);
+  } catch {
+    return null;
+  }
+}
+
+function isAddressInUse(error: unknown): boolean {
+  return Boolean(error && typeof error === 'object' && 'code' in error && (error as { code: unknown }).code === 'EADDRINUSE');
+}
+
+async function listenForCallback(
+  createListener: McpLoginOpts['createListener'],
+  port: number,
+): Promise<{
   server: Server;
   redirectUri: string;
   wait: (expectedState: string, timeoutMs: number) => Promise<Callback>;
@@ -209,7 +317,7 @@ async function listenForCallback(createListener: McpLoginOpts['createListener'])
     };
     server.once('error', onError);
     server.once('listening', onListening);
-    server.listen(0, '127.0.0.1');
+    server.listen(port, '127.0.0.1');
   });
   const address = server.address();
   if (!address || typeof address === 'string') throw new Error('loopback listener did not provide a TCP port');

package/src/cli/mcp-reload.ts

@@ -14,8 +14,8 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
 
-const DEFAULT_NEXUS_BASE = 'http://127.0.0.1:31415';
 const ADMIN_MCP_RELOAD_PATH = '/v1/nexus/admin/mcp-reload';
 
 interface ServerRow {
@@ -23,6 +23,8 @@ interface ServerRow {
   toolCount?: unknown;
   /** `McpServerBootResult.reason` 과 같은 이름 — 실패 사유. */
   reason?: unknown;
+  /** `McpServerBootResult.reasonClass` — 실패 분류. */
+  reasonClass?: unknown;
 }
 
 /** Fail-soft read of the loopback ACP token the rest of the CLI already uses. */
@@ -61,7 +63,11 @@ export async function runMcpReload(opts: McpReloadCliOpts = {}): Promise<McpRelo
     log: (s: string) => process.stdout.write(`${s}\n`),
     error: (s: string) => process.stderr.write(`${s}\n`),
   };
-  const base = opts.nexusBaseUrl ?? DEFAULT_NEXUS_BASE;
+  const base = opts.nexusBaseUrl ?? resolveDaemonEndpoint()?.baseUrl;
+  if (base === undefined) {
+    rawOut.error('✗ 데몬 주소를 모른다 — `elanous nexus show`');
+    return { exitCode: 1 };
+  }
   const fetchFn = opts.fetchFn ?? fetch;
   const url = `${base}${ADMIN_MCP_RELOAD_PATH}`;
   const token = readAcpToken();
@@ -126,7 +132,18 @@ export async function runMcpReload(opts: McpReloadCliOpts = {}): Promise<McpRelo
   const registered = typeof rec.registered === 'number' ? rec.registered : 0;
   const perServer = (rec.perServer ?? {}) as Record<string, ServerRow>;
   const ids = Object.keys(perServer).sort();
-  out.log(`✓ MCP 재장전 완료 — 서버 ${ids.length}개 · 도구 ${registered}개 등록`);
+  const failedIds = ids.filter((id) => String(perServer[id]?.status ?? '') === 'failed');
+  if (failedIds.length > 0) {
+    const named = failedIds
+      .map((id) => {
+        const cls = perServer[id]?.reasonClass;
+        return typeof cls === 'string' && cls.length > 0 ? `${id}(${cls})` : id;
+      })
+      .join(' · ');
+    out.log(`⚠ 끊긴 서버 ${failedIds.length}개 — ${named}`);
+  } else {
+    out.log(`✓ MCP 재장전 완료 — 서버 ${ids.length}개 · 도구 ${registered}개 등록`);
+  }
   let failed = 0;
   for (const id of ids) {
     const row = perServer[id] ?? {};

package/src/cli/nexus-dist.ts

@@ -10,7 +10,9 @@ import { spawnSync } from 'node:child_process';
 import { copyFile, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
-import { DIST_DIR, DIST_META_FILE, IPA_PATH_PREFIX, MANIFEST_PATH, readDistMeta } from '../nexus/api/dist.js';
+import { DIST_DIR, DIST_META_FILE, IPA_PATH_PREFIX, MANIFEST_PATH, readDistMeta, type DistMeta } from '../nexus/api/dist.js';
+import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
+import { tailscaleExecEnv } from '../nexus/onboarding/tailscale-probe.js';
 
 interface PublishOpts {
   ipa: string;
@@ -115,7 +117,7 @@ export async function runDistPublish(opts: PublishOpts): Promise<PublishResult>
   console.log(`✓ published ${file} (${bundleId} v${version}${build ? ` build ${build}` : ''})`);
   console.log(`  dist dir: ${DIST_DIR}`);
   console.log('');
-  await printInstallLinks();
+  await printInstallLinks(meta);
   return { exitCode: 0 };
 }
 
@@ -123,17 +125,20 @@ interface LinkResult {
   exitCode: number;
 }
 
-async function printInstallLinks(): Promise<void> {
-  const meta = await readDistMeta();
-  if (!meta) {
-    console.error('  (no dist.json yet — publish first)');
+async function printInstallLinks(meta: DistMeta, tailnetHostFn = resolveTailnetHost): Promise<void> {
+  // 배포본(`DIST_DIR`)은 운영 `~/.elanous/dist` 에 고정이라 링크도 운영 데몬을 가리켜야 한다 — 작업 트리(시험 우주)에서 쳐도.
+  // ⇒ «watch»: 지금 우주에 데몬이 없으면 운영 데몬으로 떨어진다(쓰기가 아니다 · 링크를 «보여 줄» 뿐).
+  const endpoint = resolveDaemonEndpoint({ purpose: 'watch' });
+  if (!endpoint) {
+    console.log('  데몬 주소를 모른다 — 데몬을 먼저 띄워라 (`elanous nexus run`)');
     return;
   }
-  const tailnetHost = await resolveTailnetHost();
-  const loopback = 'http://127.0.0.1:31415';
+  const tailnetHost = await tailnetHostFn();
+  const loopback = endpoint.baseUrl;
   const lines: string[] = [];
   if (tailnetHost) {
-    const origin = `https://${tailnetHost}:31415`;
+    const daemonPort = new URL(loopback).port;
+    const origin = `https://${tailnetHost}${daemonPort ? `:${daemonPort}` : ''}`;
     const manifestUrl = `${origin}${MANIFEST_PATH}`;
     const installUrl = `itms-services://?action=download-manifest&url=${encodeURIComponent(manifestUrl)}`;
     lines.push(`  Safari install link (iPad):`);
@@ -151,8 +156,8 @@ async function printInstallLinks(): Promise<void> {
   for (const line of lines) console.log(line);
 }
 
-export async function runDistLink(): Promise<LinkResult> {
-  const meta = await readDistMeta();
+export async function runDistLink(opts: { readMetaFn?: typeof readDistMeta; tailnetHostFn?: typeof resolveTailnetHost } = {}): Promise<LinkResult> {
+  const meta = await (opts.readMetaFn ?? readDistMeta)();
   if (!meta) {
     console.error('elanous nexus dist link: no IPA published yet. Run: elanous nexus dist publish <path>');
     return { exitCode: 1 };
@@ -160,7 +165,7 @@ export async function runDistLink(): Promise<LinkResult> {
   console.log(`Published: ${meta.title} ${meta.version}${meta.build ? ` (build ${meta.build})` : ''} · ${meta.bundleId}`);
   console.log(`Updated:   ${meta.publishedAt}`);
   console.log('');
-  await printInstallLinks();
+  await printInstallLinks(meta, opts.tailnetHostFn);
   return { exitCode: 0 };
 }
 
@@ -168,7 +173,7 @@ export async function runDistLink(): Promise<LinkResult> {
  *  and returns this node's MagicDNSName (without trailing dot). Returns
  *  null when tailscale isn't installed / running / shared. */
 async function resolveTailnetHost(): Promise<string | null> {
-  const proc = spawnSync('tailscale', ['status', '--json'], { encoding: 'utf8' });
+  const proc = spawnSync('tailscale', ['status', '--json'], { encoding: 'utf8', env: tailscaleExecEnv() });
   if (proc.status !== 0) return null;
   try {
     const data = JSON.parse(proc.stdout) as { Self?: { DNSName?: string } };

package/src/cli/nexus-ios-bind.ts

@@ -23,6 +23,7 @@ import { spawnSync as defaultSpawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
 import { readNexusRuntime, type NexusRuntimeMeta } from '../nexus/runtime.js';
 
 export interface IosBindOpts {
@@ -58,8 +59,6 @@ export interface IosBindOpts {
   readTokenFn?: () => string | null;
   /** Test seam — host fallback (production daily driver 의 default). */
   hostFallback?: string;
-  /** Test seam — port fallback. */
-  portFallback?: number;
 }
 
 export interface IosBindResult {
@@ -79,7 +78,6 @@ export interface IosBindResult {
 
 const DEFAULT_BUNDLE_ID = 'com.elanvitalai.elanous.ios';
 const DEFAULT_HOST_FALLBACK = 'localhost';
-const DEFAULT_PORT_FALLBACK = 31415;
 
 /** `~/.elanous/acp-token` 읽기. 부재 시 null. */
 function defaultReadToken(): string | null {
@@ -120,18 +118,33 @@ export function runNexusIosBind(opts: IosBindOpts = {}): IosBindResult {
   const readRuntime = opts.readRuntimeFn ?? readNexusRuntime;
   const readToken = opts.readTokenFn ?? defaultReadToken;
   const hostFallback = opts.hostFallback ?? DEFAULT_HOST_FALLBACK;
-  const portFallback = opts.portFallback ?? DEFAULT_PORT_FALLBACK;
   const dryRun = opts.dryRun ?? false;
 
   // 1) daemon 현재 host/port — override 가 우선 · 없으면 runtime sidecar ·
-  //    그것도 없으면 fallback (localhost:31415).
+  //    port 가 없으면 현재 우주의 daemon endpoint 를 조회한다.
   // daemon httpHost 가 `0.0.0.0` (모든 interface bind) 이면 simulator 입장에서
   // connect 가능한 loopback alias 로 치환. iOS simulator 는 host Mac 의 stack
   // 공유 → `localhost` / `127.0.0.1` 두 alias 모두 OK.
   const runtime = readRuntime();
-  const rawHost = opts.hostOverride ?? runtime?.httpHost ?? hostFallback;
+  const endpoint = opts.portOverride === undefined && runtime?.httpPort === undefined
+    ? resolveDaemonEndpoint()
+    : null;
+  const endpointUrl = endpoint ? new URL(endpoint.baseUrl) : null;
+  const resolvedPort = endpointUrl?.port ? Number(endpointUrl.port) : undefined;
+  const port = opts.portOverride ?? runtime?.httpPort ?? resolvedPort;
+  const rawHost = opts.hostOverride ?? runtime?.httpHost ?? endpointUrl?.hostname ?? hostFallback;
   const host = (rawHost === '0.0.0.0' || rawHost === '::') ? hostFallback : rawHost;
-  const port = opts.portOverride ?? runtime?.httpPort ?? portFallback;
+  if (port === undefined) {
+    return {
+      ok: false,
+      message: 'elanous nexus ios-bind: 데몬 주소를 모른다 — 데몬을 먼저 띄워라 (`elanous nexus run`)',
+      host,
+      port: 0,
+      tokenInjected: false,
+      tokenLength: 0,
+      bundleId,
+    };
+  }
 
   // 2) Token (선택)
   const tokenRaw = opts.noToken ? null : readToken();

package/src/cli/ops-cli.ts

@@ -0,0 +1,225 @@
+import type { Command } from 'commander';
+import * as ui from '../ui.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+export function registerOpsCommands(program: Command): void {
+const opsCmd = program.command('ops')
+  .description('운영 관측(READ-ONLY) — 미션·태스크·계약 루프·오케스트레이터 현재 상태·이상·전이. --json 프로그래매틱.');
+
+interface OpsOpts { id?: string; entityType?: string; event?: string; sinceHours?: string; limit?: string; json?: boolean }
+
+// ops 연합(fleet · --all-instances) — 각 인스턴스에 opsSnapshot 을 인스턴스별 스토어 경로로
+// 호출해 미션·태스크뿐 아니라 loops(계약루프)·스케줄·오케스트레이션까지 전체 종합한다.
+// 경로 주입이 opsSnapshot 의 부작용/편향을 자동 우회한다:
+//   · schedulesDbPath 주입 → crontab inventory skip(ops-status.ts `if(!opts.schedulesDbPath)`)
+//   · mandate 명시 주입 → loadMandate() 기본(prod) 미호출(ops-status.ts `opts.mandate!==undefined`)
+// loadMandate(path) 는 파일 부재 시 DEFAULT_MANDATE(DISARMED) fail-soft — test 인스턴스 안전.
+// prod 는 instanceStorePaths(~/.elanous)==기본 경로라 종전 loops/스케줄이 그대로 보인다(무회귀).
+async function runOpsFleet(json: boolean, includeTest = false): Promise<never> {
+  const { buildFleetView, instanceStorePaths } = await import('../domains/fleet.js');
+  const { TaskStore } = await import('../task-orchestrator/store.js');
+  const { opsSnapshot } = await import('../domains/ops-status.js');
+  const { loadMandate } = await import('../domains/trade-mandate.js');
+  // 격리 test 인스턴스는 기본 제외(데이터 오염 방지 · Phase A) — --include-test 로 opt-in.
+  const view = buildFleetView().filter((v) => v.stores.tasks && (includeTest || v.kind !== 'test'));
+  const rows: Array<{ name: string; kind: string; stateDir: string; snapshot: import('../domains/ops-status.js').OpsSnapshot }> = [];
+  for (const i of view) {
+    let store: InstanceType<typeof TaskStore> | null = null;
+    try {
+      const p = instanceStorePaths(i.stateDir, i.configDir);
+      store = new TaskStore({ path: p.tasks });
+      const snapshot = opsSnapshot({
+        opsDbPath: p.opsEvents,
+        schedulesDbPath: p.schedules,
+        mandate: loadMandate(p.mandate),   // 파일 부재 → DEFAULT(DISARMED) fail-soft
+        missionStore: store,
+      });
+      rows.push({ name: i.name, kind: i.kind, stateDir: i.stateDir, snapshot });
+    } catch { /* skip 손상/락 db */ } finally { store?.close?.(); }
+  }
+  if (json) { await writeStdoutJson(JSON.stringify(rows, null, 2) + '\n'); process.exit(0); }
+  ui.header(`ops · fleet (${rows.length} instances · read-only union · loops/스케줄/오케스트레이션 포함)`);
+  for (const { name, kind, snapshot: s } of rows) {
+    const kindTag = kind === 'test' ? ui.dim(' [test]') : '';
+    const sched = s.schedules ? `${s.schedules.elanousTotal}개(stale ${s.schedules.stale.length}·err ${s.schedules.errored.length})` : '—';
+    console.log(`  ${name.padEnd(22)}${kindTag} 미션 ${String(s.missions.total).padStart(3)} ${JSON.stringify(s.missions.byStatus)}`);
+    console.log(ui.dim(`  ${''.padEnd(22)} 태스크 ${String(s.tasks.total).padStart(3)} ${JSON.stringify(s.tasks.byStatus)} — 스케줄실행 ${s.tasks.scheduleBacked}(최근 ${s.tasks.recentlyActive}) · blocked ${s.tasks.blocked.length}`));
+    console.log(ui.dim(`  ${''.padEnd(22)} 루프 ${s.loops.loops.length}개 armed=${s.loops.armed}${s.loops.live ? '·LIVE' : ''} mode=${s.loops.executionMode} · 오케스트 ${s.orchestration.recent.length}건 · 스케줄 ${sched}`));
+  }
+  ui.info(ui.dim('연합=미션/태스크/loops/스케줄/오케스트레이션 전체 종합(스토어 경로 주입). 단일 인스턴스 상세=`elanous ops status`.'));
+  process.exit(0);
+}
+
+async function runOps(action: string, opts: OpsOpts): Promise<never> {
+  const { dispatchOpsStatus } = await import('../domains/ops-status-tool.js');
+  const result = await dispatchOpsStatus({
+    action,
+    ...(opts.id ? { id: opts.id } : {}),
+    ...(opts.entityType ? { entityType: opts.entityType } : {}),
+    ...(opts.event ? { event: opts.event } : {}),
+    ...(opts.sinceHours ? { sinceHours: Number(opts.sinceHours) } : {}),
+    ...(opts.limit ? { limit: Number(opts.limit) } : {}),
+  });
+  const isErr = !!result && typeof result === 'object' && 'error' in (result as object);
+  if (opts.json || isErr) {
+    await writeStdoutJson(JSON.stringify(result, null, 2) + '\n');
+  } else if (action === 'mission') {
+    const r = result as { mission: { goal: string; disposition: string; source: string; engine: string | null; rationale: string | null; createdAt: string } | null; derived: Array<{ kind: string; name: string; status: string; detail?: string }>; transitions: Array<{ ts: string; event: string; toState: string | null }>; phases: Array<{ index: number; title: string; status: string; failClass?: string; diagnosis?: { narrative: string; rootCause: string; heal: string; confidence: string }; prUrl?: string }>; runLogPath: string | null; planDraft: string | null; note: string };
+    if (!r.mission) { console.log(r.note); }
+    else {
+      ui.header(`미션 상세 · ${r.mission.disposition}`);
+      console.log(`  목표    ${r.mission.goal}`);
+      console.log(`  출처    ${r.mission.source}${r.mission.engine ? ` · engine=${r.mission.engine}` : ''}  · 생성 ${r.mission.createdAt.slice(0, 16)}`);
+      if (r.mission.rationale) console.log(`  근거    ${r.mission.rationale}`);
+      if (r.planDraft) { console.log(`\n  ── 멀티페이즈 플랜 (승인 전 검토) ──`); for (const line of r.planDraft.split('\n')) console.log(`  ${line}`); console.log(''); }
+      // ★ 페이즈 + 저장 진단(P1) — 실패 페이즈는 failClass·근본원인·권장 힐을 그대로(재계산 없음).
+      if (r.phases?.length) {
+        console.log(`  페이즈 ${r.phases.length}건:`);
+        for (const p of r.phases) {
+          const mark = p.status === 'done' ? '✅' : p.status === 'failed' ? '❌' : p.status === 'running' ? '🔧' : '·';
+          console.log(`    ${mark} ${p.index}. [${p.status}${p.failClass ? `·${p.failClass}` : ''}] ${p.title}${p.prUrl ? ` · PR ${p.prUrl}` : ''}`);
+          if (p.diagnosis) {
+            console.log(`       🧭 ${p.diagnosis.rootCause}`);
+            console.log(`       💡 권장: ${p.diagnosis.heal}(${p.diagnosis.confidence})`);
+          }
+        }
+      }
+      if (r.runLogPath) console.log(`  실행 로그  ${r.runLogPath}`);
+      console.log(`  관련 파생물 (태스크/스케줄/자율행동) ${r.derived.length}건:`);
+      for (const d of r.derived) console.log(`    [${d.kind}] ${d.name}  — ${d.status}${d.detail ? ` (${d.detail})` : ''}`);
+      if (r.transitions.length) {
+        console.log(`  상태 전이 ${r.transitions.length}건:`);
+        for (const t of r.transitions) console.log(`    ${t.ts.slice(0, 16)}  ${t.event} ${t.toState ?? ''}`);
+      }
+    }
+  } else if (action === 'health') {
+    const r = result as { healthy: boolean; anomalies: Array<{ kind: string; entity: string; detail: string }>; note: string };
+    ui.header(r.healthy ? '운영 상태: 정상 ✓' : `운영 상태: 이상 ${r.anomalies.length}건 ⚠`);
+    for (const a of r.anomalies) console.log(`  [${a.kind}] ${a.entity} — ${a.detail}`);
+    console.log(`  ${r.note}`);
+  } else if (action === 'timeline') {
+    const r = result as { count: number; timeline: Array<{ ts: string; entityType: string; entityId: string; event: string; toState: string | null }> };
+    ui.header(`운영 전이 타임라인 (${r.count})`);
+    for (const e of r.timeline) console.log(`  ${e.ts}  ${e.entityType.padEnd(13)} ${e.event.padEnd(14)} ${e.toState ?? ''}  ${e.entityId}`);
+  } else {
+    const r = result as {
+      missions: { total: number; byStatus: Record<string, number>; active: Array<{ status: string; disposition: string; goal: string }> };
+      tasks: { total: number; byStatus: Record<string, number>; scheduleBacked: number; recentlyActive: number; dispatchPending: number; blocked: unknown[]; dispatchable: Array<{ title: string }> };
+      loops: { loops: unknown[]; armed: boolean; executionMode: string }; health: { healthy: boolean; anomalyCount: number; anomalies: Array<{ kind: string; entity: string; detail: string }> };
+    };
+    ui.header('운영 상태 스냅샷');
+    console.log(`  미션    ${r.missions.total}건  ${JSON.stringify(r.missions.byStatus)}  (대부분 승인대기·HITL)`);
+    console.log(`  태스크  ${r.tasks.total}건 — 스케줄실행 ${r.tasks.scheduleBacked}(최근발화 ${r.tasks.recentlyActive}) · 디스패치대기 ${r.tasks.dispatchPending} · blocked ${r.tasks.blocked.length}`);
+    if (r.tasks.dispatchable.length) console.log(`          대기: ${r.tasks.dispatchable.map((t) => t.title).slice(0, 3).join(' · ')}`);
+    console.log(`  루프    ${r.loops.loops.length}개 활성  armed=${r.loops.armed}  mode=${r.loops.executionMode}`);
+    console.log(`  건강    ${r.health.healthy ? '정상 ✓' : `이상 ${r.health.anomalyCount}건 ⚠`}`);
+    // 이상 상세도 스냅샷에서 바로 — "무엇이" 이상인지 ops health 재조회 없이(관측 갭 해소).
+    if (!r.health.healthy) for (const a of r.health.anomalies) console.log(`          ⚠ [${a.kind}] ${a.entity} — ${a.detail}`);
+  }
+  process.exit(isErr ? 1 : 0);
+}
+
+// ── SE 격리 빌드 관측 CLI(PLAN B3) — list/스냅샷/--follow(tail -f 스트리밍) ──
+interface OpsBuildOpts { all?: boolean; follow?: boolean; stop?: boolean; tail?: string; json?: boolean }
+async function runOpsBuild(buildId: string | undefined, opts: OpsBuildOpts): Promise<never> {
+  const { dispatchSeBuild, buildSnapshot } = await import('../domains/se-build-tool.js');
+  const { buildLogPath } = await import('../autopilot/se-build-registry.js');
+  // --stop (빌드 컨트롤 — 실행중 빌드 중단)
+  if (buildId && opts.stop) {
+    const r = await dispatchSeBuild({ action: 'stop', buildId }) as { ok?: boolean; error?: string; killedPids?: number[]; missionId?: string; note?: string };
+    if (opts.json) { await writeStdoutJson(JSON.stringify(r, null, 2) + '\n'); process.exit(r.ok ? 0 : 1); }
+    if (r.ok) console.log(`⏹ 빌드 중단: ${buildId}${r.killedPids ? ` (SIGTERM pid ${r.killedPids.join(',')})` : ''}\n  미션 ${r.missionId} — 재개는 재구현/재실행으로.`);
+    else console.log(`중단 실패: ${r.error}`);
+    process.exit(r.ok ? 0 : 1);
+  }
+  // list (buildId 없음)
+  if (!buildId) {
+    const r = await dispatchSeBuild({ action: 'list', all: opts.all === true }) as { builds: Array<{ buildId: string; status: string; phase: string; backend: string; attempt: number }>; note: string };
+    if (opts.json) { await writeStdoutJson(JSON.stringify(r, null, 2) + '\n'); process.exit(0); }
+    ui.header('SE 격리 빌드');
+    if (!r.builds.length) console.log(`  ${r.note}`);
+    for (const b of r.builds) console.log(`  ${b.buildId}  [${b.status}]  ${b.backend}·시도${b.attempt}  ${b.phase.slice(0, 40)}`);
+    process.exit(0);
+  }
+  // --follow (tail -f 스트리밍·adb logcat 스타일)
+  if (opts.follow) {
+    const { readFileSync, existsSync, statSync } = await import('node:fs');
+    const snap = buildSnapshot(buildId, { tail: 1 });
+    const logPath = snap?.build.logPath ?? buildLogPath(buildId);
+    console.log(`── follow ${buildId} · ${logPath} (Ctrl-C 종료) ──`);
+    let offset = 0;
+    if (existsSync(logPath)) { const buf = readFileSync(logPath); process.stdout.write(buf); offset = buf.length; }
+    for (;;) {
+      await new Promise((res) => setTimeout(res, 1000));
+      try {
+        if (!existsSync(logPath)) continue;
+        const size = statSync(logPath).size;
+        if (size > offset) { const buf = readFileSync(logPath); process.stdout.write(buf.subarray(offset)); offset = buf.length; }
+        else if (size < offset) { offset = 0; } // 로그 회전 감지 → 처음부터
+      } catch { /* fail-soft·계속 폴링 */ }
+    }
+  }
+  // 스냅샷
+  const snap = buildSnapshot(buildId, { tail: opts.tail ? Number(opts.tail) : 40 });
+  if (opts.json) { await writeStdoutJson(JSON.stringify(snap, null, 2) + '\n'); process.exit(snap ? 0 : 1); }
+  if (!snap) { console.log(`빌드 없음: ${buildId}`); process.exit(1); }
+  ui.header(`SE 빌드 · ${snap.build.status}`);
+  console.log(`  ${snap.build.buildId}  ${snap.build.backend}·시도${snap.build.attemptSeq}·maxTurns${snap.build.maxTurns ?? '?'}`);
+  console.log(`  페이즈  ${snap.build.phaseTitle}`);
+  console.log(`  worktree  ${snap.worktree ?? '(없음)'}`);
+  if (snap.diffStat) { console.log(`  ── 변경(diff --stat) ──`); for (const l of snap.diffStat.split('\n')) console.log(`  ${l}`); }
+  console.log(`  ── 로그 tail ──`);
+  for (const l of snap.logTail) console.log(`  ${l}`);
+  process.exit(0);
+}
+
+opsCmd.command('status').description('현재 상태 종합(미션·태스크·루프·오케스트레이션·스케줄) · --all-instances 로 fleet 전체 종합(미션/태스크/loops/스케줄/오케스트레이션) · -r/--remote 로 원격 GET 조립')
+  .option('--json').option('--all-instances', '등록 인스턴스 전체 종합(미션/태스크/loops/스케줄/오케스트레이션 · fleet · read-only · §10)')
+  .option('--include-test', '연합에 격리 test 인스턴스도 포함(기본 제외)')
+  // ⛔ `-r` 은 값을 받지 않는다 — default 북마크만. 이름은 `--remote <name>` 으로만 준다.
+  .option('-r', 'query ops status on the default remote bookmark (does not take a value)')
+  .option('--remote <name>', 'query ops status on a named remote bookmark via GET /v1/missions · /v1/tasks · /v1/autopilot/arming')
+  .action(async (o: OpsOpts & { allInstances?: boolean; includeTest?: boolean; r?: boolean; remote?: string }) => {
+    if (o.remote !== undefined || o.r === true) {
+      const { runOpsStatusRemote } = await import('./ops-status-remote.js');
+      const result = await runOpsStatusRemote({
+        args: process.argv.slice(2),
+        remote: o.remote !== undefined ? o.remote : true,
+        json: o.json === true,
+        allInstances: o.allInstances === true,
+      });
+      process.exitCode = result.classification === 'ok' ? 0 : 1;
+      return;
+    }
+    return o.allInstances ? runOpsFleet(o.json === true, o.includeTest === true) : runOps('snapshot', o);
+  });
+opsCmd.command('health').description('이상 판정만(blocked·errored·stale)').option('--json')
+  .action((o: OpsOpts) => runOps('health', o));
+opsCmd.command('timeline').description('상태 전이 최근순 통합')
+  .option('--entity-type <t>', 'mission|task|loop|orchestration')
+  .option('--event <e>', 'created|status_change|cycle_start|cycle_end|merge|alloc|blocked')
+  .option('--since-hours <n>', '조회 기간(기본 48)').option('--limit <n>', '건수(기본 40)').option('--json')
+  .action((o: OpsOpts) => runOps('timeline', o));
+opsCmd.command('mission <id>').description('미션 1건 상세 — 내용 + 페이즈별 진단(failClass·권장 힐) + 관련 태스크/스케줄/자율행동 fan-in + 전이')
+  .option('--json').action((id: string, o: OpsOpts) => runOps('mission', { ...o, id }));
+// P5 (2026-07-13) — 미션별 영속 run.log tail(O3 의 표면 완결·READ-ONLY). 빌드 단위 실시간
+// follow 는 `elanous ops build --follow`(B3) — 여긴 미션 레벨 스냅샷 tail.
+opsCmd.command('mission-log <id>').description('미션 실행 로그(run.log) tail — 진단 근거의 실체(재부팅에도 영속)')
+  .option('-n, --lines <n>', '마지막 N줄(기본 40·최대 200)').option('--json')
+  .action(async (id: string, o: { lines?: string; json?: boolean }) => {
+    const { dispatchAutopilotMissions } = await import('../autopilot/mission-tool.js');
+    const r = await dispatchAutopilotMissions({ action: 'log', id, ...(o.lines ? { tail: Number(o.lines) } : {}) }) as
+      { error?: string; exists?: boolean; lines?: string[]; runLogPath?: string; note?: string };
+    if (o.json || r.error) { await writeStdoutJson(JSON.stringify(r, null, 2) + '\n'); process.exit(r.error ? 1 : 0); }
+    if (!r.exists) { console.log(r.note ?? '로그 없음'); process.exit(0); }
+    for (const line of r.lines ?? []) console.log(line);
+    console.log(`\n· ${r.note ?? r.runLogPath ?? ''}`);
+    process.exit(0);
+  });
+opsCmd.command('build [buildId]').description('SE 격리 빌드 관측/컨트롤 — 없으면 list, buildId 지정 시 스냅샷. --follow=tail -f 스트리밍, --stop=실행중 빌드 중단')
+  .option('--stop', '실행중 빌드 중단(미션 프로세스 SIGTERM·재개는 재구현/재실행)')
+  .option('--all', '종결 포함 전체(list)').option('--follow', 'tail -f 스트리밍(adb logcat 스타일)')
+  .option('--tail <n>', '로그 tail 줄 수(기본 40)').option('--json')
+  .action((buildId: string | undefined, o: OpsBuildOpts) => runOpsBuild(buildId, o));
+
+}