elanous 0.2.27 → 0.2.29

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

@@ -189,6 +189,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 +285,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 +293,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 +448,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 +528,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 +669,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",
@@ -734,6 +741,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 +769,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",
@@ -1239,6 +1249,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",
@@ -1395,6 +1406,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "surface.resolve",
   "sweep",
   "swept",
+  "switch",
   "switch-off",
   "sync",
   "syncLogWidgetState",

package/src/cli/msg-cli.ts

@@ -1,13 +1,26 @@
 import type { Command } from 'commander';
-import { canonicalSeatId, openMsgStore, type Message, type MsgStore } from '../msg/msg-store.js';
+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;
+  openReadStore?: () => MsgStore;
   out?: Pick<Console, 'log' | 'error'>;
   readStdin?: () => Promise<string>;
   sleep?: (ms: number) => Promise<void>;
   setExitCode?: (code: number) => void;
   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>;
 }
 
 type CommonOptions = { json?: boolean };
@@ -26,13 +39,20 @@ 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. */
 export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): void {
   const open = deps.openStore ?? (() => openMsgStore());
+  const openRead = deps.openReadStore ?? (() => openMsgStoreReadOnly());
   const out = deps.out ?? console;
   const readStdin = deps.readStdin ?? (() => Bun.stdin.text());
   const sleep = deps.sleep ?? ((ms: number) => new Promise<void>(resolve => setTimeout(resolve, ms)));
@@ -58,17 +78,49 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
 
   msg.command('post [body]').description('Post a message; use - or omit body to read stdin')
     .option('--from <seat>').option('--to <seat>').option('--kind <kind>').option('--body <text>')
+    .option('--reply-to <id>', 'point this reply at a question message ID')
     .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; originKey?: string }) => run(async () => {
+    .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());
-      const envelope = { from, to, body: text, ...(opts.kind === undefined ? {} : { kind: opts.kind }) };
+      const envelope = { from, to, body: text,
+        ...(opts.kind === undefined ? {} : { kind: opts.kind }),
+        ...(opts.replyTo === undefined ? {} : { replyTo: integer(opts.replyTo, '--reply-to', 0, 1, Number.MAX_SAFE_INTEGER) }) };
       const posted = withStore(store => opts.originKey === undefined
         ? store.post(envelope)
         : store.appendWithProvenance(envelope, opts.originKey));
       emit(posted, opts.json, () => out.log(formatMessage(posted)));
+      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')
@@ -110,12 +162,13 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
       });
     })());
 
-  msg.command('watch').description('Poll for new messages without acknowledging them (Ctrl-C to stop)')
+  msg.command('watch').description('Watch durable messages; SSE accelerates delivery and polling covers outages')
     .option('--to <seat>').option('--after <id>', 'exclusive message ID (default: acknowledged cursor)')
     .option('--since-ack', 'start from the recipient seat’s acknowledged cursor')
     .option('--interval <ms>', 'poll interval in milliseconds', '1000')
+    .option('--sse <url>', 'post office base URL (fall back to ledger polling on disconnect)')
     .option('--once', 'poll once and exit').option('--json')
-    .action((opts: RecipientOptions & { interval?: string; once?: boolean; sinceAck?: boolean }) => run(async () => {
+    .action((opts: RecipientOptions & { interval?: string; once?: boolean; sinceAck?: boolean; sse?: string }) => run(async () => {
       if (opts.sinceAck && opts.after !== undefined) throw new Error('--since-ack cannot be used with --after');
       const to = seat(opts.to, '--to');
       const interval = integer(opts.interval, '--interval', 1000, 1, 60000);
@@ -123,7 +176,7 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
       const store = open();
       try {
         let cursor = after ?? store.getCursor(to);
-        do {
+        const poll = () => {
           let messages: Message[];
           do {
             messages = store.list(to, cursor, 1000);
@@ -132,12 +185,158 @@ export function registerMsgCommands(program: Command, deps: MsgCliDeps = {}): vo
               cursor = message.id;
             }
           } while (messages.length === 1000 && !deps.signal?.aborted);
-          if (opts.once || deps.signal?.aborted) break;
-          await sleep(interval);
-        } while (!deps.signal?.aborted);
+        };
+        if (!opts.sse || opts.once) {
+          do {
+            poll();
+            if (opts.once || deps.signal?.aborted) break;
+            await sleep(interval);
+          } while (!deps.signal?.aborted);
+        } else {
+          const url = new URL('/stream', opts.sse);
+          if (!['http:', 'https:'].includes(url.protocol)) throw new Error('--sse requires an HTTP URL');
+          if (url.protocol === 'http:' && !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))
+            throw new Error('--sse requires HTTPS outside localhost');
+          url.searchParams.set('to', to);
+          const token = (deps.authToken ?? (() => ensureAuthToken().token))();
+          let outage = false;
+          while (!deps.signal?.aborted) {
+            poll();
+            url.searchParams.set('since', String(cursor));
+            const controller = new AbortController();
+            const onAbort = () => controller.abort();
+            deps.signal?.addEventListener('abort', onAbort, { once: true });
+            try {
+              let connectTimer: ReturnType<typeof setTimeout> | undefined;
+              const response = await Promise.race([
+                (deps.fetch ?? fetch)(url, { headers: {
+                  Authorization: `Bearer ${token}`, 'Last-Event-ID': String(cursor),
+                }, signal: controller.signal }),
+                new Promise<never>((_, reject) => { connectTimer = setTimeout(() => {
+                  controller.abort();
+                  reject(new Error('SSE connect timeout'));
+                }, Math.max(1000, Math.min(5000, interval * 2))); }),
+              ]).finally(() => clearTimeout(connectTimer));
+              if (response.status === 401) throw new Error('SSE unauthorized (401)');
+              if (!response.ok || !response.body) throw new Error(`SSE unavailable (${response.status})`);
+              outage = false;
+              const reader = response.body.getReader();
+              const decoder = new TextDecoder();
+              let pending = '';
+              while (!deps.signal?.aborted) {
+                let idleTimer: ReturnType<typeof setTimeout> | undefined;
+                const chunk = await Promise.race([
+                  reader.read(),
+                  new Promise<never>((_, reject) => { idleTimer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error('SSE idle timeout'));
+                  }, Math.max(1000, Math.min(5000, interval * 2))); }),
+                ]).finally(() => clearTimeout(idleTimer));
+                if (chunk.done) break;
+                pending += decoder.decode(chunk.value, { stream: true });
+                pending = pending.replace(/\r\n/g, '\n');
+                if (pending.length > 1_000_000) throw new Error('SSE event exceeds limit');
+                let boundary: number;
+                while ((boundary = pending.indexOf('\n\n')) >= 0) {
+                  const event = pending.slice(0, boundary);
+                  pending = pending.slice(boundary + 2);
+                  if (event.split('\n').some((line) => line.startsWith('id: '))) poll();
+                }
+              }
+            } catch (error) {
+              if (error instanceof Error && error.message === 'SSE unauthorized (401)') throw error;
+              if (!outage && !deps.signal?.aborted) out.error(`msg: SSE disconnected; polling ledger (${error instanceof Error ? error.message : String(error)})`);
+              outage = true;
+            } finally { deps.signal?.removeEventListener('abort', onAbort); controller.abort(); }
+            if (deps.signal?.aborted) break;
+            poll();
+            await sleep(interval);
+          }
+        }
       } finally { store.close(); }
     })());
 
+  msg.command('ask <recipient> <question>').description('Post a question and wait for its first reply')
+    .option('--from <seat>', 'asking seat (required)').option('--wait <seconds>', 'seconds to wait for a reply (default 60)', '60')
+    .option('--json')
+    .action((recipient: string, question: string, opts: CommonOptions & { from?: string; wait?: string }) => run(async () => {
+      const from = seat(opts.from, '--from');
+      const to = canonicalSeatId(recipient);
+      const waitSeconds = integer(opts.wait, '--wait', 60, 0, 86400);
+      const interrupt = deps.signal === undefined ? new AbortController() : undefined;
+      const signal = deps.signal ?? interrupt!.signal;
+      const onInterrupt = () => interrupt?.abort();
+      if (interrupt) {
+        process.once('SIGINT', onInterrupt);
+        process.once('SIGTERM', onInterrupt);
+      }
+      let store: MsgStore | undefined;
+      try {
+        const asked = withStore(ledger => ledger.post({ from, to, body: question }));
+        const deadline = Date.now() + waitSeconds * 1000;
+        let reply: Message | undefined;
+        store = open();
+        do {
+          reply = store.listReplies(asked.id, 1)[0];
+          if (reply !== undefined || signal.aborted || Date.now() >= deadline) break;
+          await sleep(1000);
+        } while (true);
+        if (reply === undefined && signal.aborted) throw new Error(`ask interrupted after posting #${asked.id}`);
+        if (reply === undefined) throw new Error(`no reply to #${asked.id} within ${waitSeconds}s`);
+        emit(reply, opts.json, () => out.log(formatMessage(reply)));
+      } finally {
+        store?.close();
+        if (interrupt) {
+          process.removeListener('SIGINT', onInterrupt);
+          process.removeListener('SIGTERM', onInterrupt);
+        }
+      }
+    })());
+
+  msg.command('thread <id>').description('Show one question and its replies in time order')
+    .option('--json')
+    .action((id: string, opts: CommonOptions) => run(() => {
+      const target = integer(id, 'message ID', 0, 1, Number.MAX_SAFE_INTEGER);
+      const thread = withStore(store => {
+        const question = store.getMessage(target);
+        if (question === null) throw new Error(`message not found: #${target}`);
+        // Keep paging until a short page so a thread longer than one store page is never truncated.
+        const replies: Message[] = [];
+        let after = 0;
+        let page: Message[];
+        do {
+          page = store.listReplies(target, 100, after);
+          replies.push(...page);
+          after = page.at(-1)?.id ?? after;
+        } while (page.length === 100);
+        return { question, replies };
+      });
+      emit(thread, opts.json, () => {
+        out.log(formatMessage(thread.question));
+        for (const reply of thread.replies) out.log(formatMessage(reply));
+      });
+    })());
+
+  msg.command('serve').description('Run the independent, read-only post office SSE service')
+    .option('--sse', 'serve GET /stream')
+    .option('--port <port>', 'port (or ELANOUS_MSG_SSE_PORT)')
+    .option('--host <host>', 'bind address', '127.0.0.1')
+    .action((opts: { sse?: boolean; port?: string; host?: string }) => run(() => {
+      if (!opts.sse) throw new Error('serve requires --sse');
+      const rawPort = opts.port ?? process.env.ELANOUS_MSG_SSE_PORT;
+      if (rawPort === undefined) throw new Error('--port or ELANOUS_MSG_SSE_PORT is required');
+      const port = integer(rawPort, '--port', 0, 0, 65535);
+      const store = openRead();
+      try {
+        const service = startMsgSseServer({ store, token: (deps.authToken ?? (() => ensureAuthToken().token))(),
+          port, hostname: opts.host });
+        out.log(`msg SSE listening on ${opts.host}:${service.port}`);
+        const stop = () => { service.stop(); store.close(); };
+        process.once('SIGINT', stop);
+        process.once('SIGTERM', stop);
+      } catch (error) { store.close(); throw error; }
+    })());
+
   // Commander reports option/argument errors before action handlers run. Scope their exit code
   // to msg so unrelated commands keep their own error and help behavior.
   for (const command of [msg, ...msg.commands]) {

package/src/cli/plugin-cli.ts

@@ -6,7 +6,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { userConfigPath } from '../user-config.js';
 import { debug, redactSecretText } from '../debug/log.js';
-import { addMarket, ensureInternalMarketIndex, listMarkets, MarketFetchError, updateMarket } from '../plugins/install/market-fetch.js';
+import { addMarket, codexPluginPackagePath, ensureInternalMarketIndex, listMarkets, MarketFetchError, updateMarket } from '../plugins/install/market-fetch.js';
+import { readCodexPluginList } from '../acp/codex-plugins.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { OFFICIAL_INDEX_KEYS } from '../market/official-keys.js';
 import { installPlugin, listInstalledPlugins, PluginInstallError, removePlugin, type InstallEvent } from '../plugins/install/plugin-install.js';
@@ -118,15 +119,22 @@ export function registerPluginCommands(program: Command): void {
       }
     });
   plugin.command('add <spec>').description('Install a local path, pinned git plugin or signed market plugin')
+    .option('--from-codex', 'Import an installed Codex plugin by name@marketplace')
     .option('--yes', 'Accept requested capabilities')
     .option('--json', 'NDJSON progress events')
     .option('--allow-unsigned', 'Allow unsigned marketplace indices')
     .option('--refresh', 'Refresh the signed marketplace index before installing')
-    .action(async (spec: string, opts: { yes?: boolean; json?: boolean; allowUnsigned?: boolean; refresh?: boolean }) => {
+    .action(async (spec: string, opts: { yes?: boolean; json?: boolean; allowUnsigned?: boolean; refresh?: boolean; fromCodex?: boolean }) => {
       try {
         const root = elanousStateRoot();
         const nodeCount = { value: 0 };
-        await installPlugin(spec, {
+        let source = spec;
+        if (opts.fromCodex) {
+          const match = /^([a-z0-9][a-z0-9-]{1,39})@([a-z0-9][a-z0-9-]{1,39})$/.exec(spec);
+          if (!match) throw new PluginInstallError('io', 'Codex import requires name@marketplace');
+          source = codexPluginPackagePath(await readCodexPluginList(), match[1]!, match[2]!);
+        }
+        await installPlugin(source, {
           root, marketDir: join(root, 'plugins', 'markets'), trustedKeys: keys(),
           yes: opts.yes, allowUnsigned: opts.allowUnsigned, refresh: opts.refresh,
           onEvent: event => outputEvent(event, !!opts.json, nodeCount),