elanous 0.2.0 → 0.2.5

package/src/cli/pty-record-cli.ts

@@ -0,0 +1,63 @@
+import type { Command } from 'commander';
+import { getPty, listPty } from '../pty-shell/registry.js';
+import { listPtyManifest } from '../pty-shell/pty-manifest.js';
+import { resolvePtyRef } from '../pty-shell/pty-ref.js';
+import { requestRemotePtyControl } from '../pty-shell/pty-control-ipc.js';
+import { startPtyRecording, stopPtyRecording } from '../pty-shell/pty-recording.js';
+
+export interface PtyRecordDeps {
+  readonly local: typeof getPty;
+  readonly refs: () => readonly { id: string; kind: string; nickname?: string }[];
+  readonly remote: typeof requestRemotePtyControl;
+  readonly start: typeof startPtyRecording;
+  readonly stop: typeof stopPtyRecording;
+}
+
+const liveDeps: PtyRecordDeps = {
+  local: getPty,
+  refs: () => [
+    ...listPty().filter((handle) => handle.isAlive()).map(({ id, kind, nickname }) => ({ id, kind, nickname })),
+    ...listPtyManifest().filter((row) => row.alive && !getPty(row.id)).map(({ id, kind, nickname }) => ({ id, kind, nickname })),
+  ],
+  remote: requestRemotePtyControl,
+  start: startPtyRecording,
+  stop: stopPtyRecording,
+};
+
+export async function runPtyRecord(ref: string, options: { stop?: boolean; json?: boolean } = {}, deps: PtyRecordDeps = liveDeps): Promise<{ exitCode: 0 | 1; message: string }> {
+  const resolution = resolvePtyRef(ref, deps.refs());
+  if (!resolution.match) {
+    const reason = resolution.reason === 'ambiguous'
+      ? `ambiguous ref; candidates: ${resolution.candidates.map((item) => item.id).join(', ')}`
+      : 'PTY not found';
+    return { exitCode: 1, message: options.json ? JSON.stringify({ ok: false, reason }) : `pty record: ${ref}: ${reason}` };
+  }
+  const id = resolution.match.id;
+  const handle = deps.local(id);
+  const result = handle?.isAlive()
+    ? options.stop ? deps.stop(id) : deps.start(id, { cols: handle.cols, rows: handle.rows })
+    : await deps.remote(id, options.stop ? 'record-stop' : 'record-start');
+  const ok = 'ok' in result ? result.ok : 'status' in result && result.status === 'success' && typeof result.path === 'string';
+  const reason = !ok ? ('reason' in result ? result.reason : 'status' in result && result.status !== 'success' ? result.status : 'invalid-record-result') : undefined;
+  const payload = { ok, ptyId: id, ...('path' in result && result.path ? { path: result.path } : {}),
+    ...('recordingId' in result && result.recordingId ? { recordingId: result.recordingId } : {}),
+    ...('bytes' in result && result.bytes !== undefined ? { bytes: result.bytes } : {}),
+    ...('durationMs' in result && result.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
+    ...(reason ? { reason } : {}) };
+  const message = options.json ? JSON.stringify(payload) : ok
+    ? `${payload.path}${'bytes' in payload ? ` (${payload.bytes} bytes, ${payload.durationMs} ms)` : ''}`
+    : `pty record: ${id}: ${reason}`;
+  return { exitCode: ok ? 0 : 1, message };
+}
+
+export function registerPtyRecordCommand(pty: Command, deps: PtyRecordDeps = liveDeps): void {
+  pty.command('record <ref>')
+    .description('Record PTY output as asciicast v2; --stop saves the capture')
+    .option('--stop', 'stop recording and save the cast')
+    .option('--json', 'emit structured result')
+    .action(async (ref: string, options: { stop?: boolean; json?: boolean }) => {
+      const result = await runPtyRecord(ref, options, deps);
+      (result.exitCode === 0 ? process.stdout : process.stderr).write(`${result.message}\n`);
+      process.exitCode = result.exitCode;
+    });
+}

package/src/cli/pty-takeover-cli.ts

@@ -10,11 +10,13 @@ import { readPtyEventsAfter, readPtyEventsAfterAt, type PtyEventLogReadResult, t
 import { resolvePtyRef, type PtyRefItem } from '../pty-shell/pty-ref.js';
 import { parsePtyWriteActor, resolveRemoteControlActor, resolveTakeover, type PtyWriteActor } from '../pty-shell/pty-write-arbiter.js';
 import { registerPtyAttachDriveCommand } from './pty-drive-cli.js';
-import { resolveNexusPwa, type NexusPwaLinkSource, type NexusPwaResolution, type NexusPwaUnavailableReason } from './nexus-show.js';
+import { resolveNexusPwa, type NexusPwaResolution } from './nexus-show.js';
+import { formatPtyWebAddress, ptyWebAddress, type PtyWebAddress } from './pty-web-address.js';
 import { getHarnessRunId, normalizeRunIdSource, type RunIdSource } from '../harness/harness-space.js';
 import { inspectControlInbox, type ControlInboxSnapshot } from '../harness/control-inbox.js';
 import { requestRemotePtyControl, type PtyControlAction, type PtyControlPayload, type PtyControlRequestOptions, type PtyControlResult } from '../pty-shell/pty-control-ipc.js';
 import { resolvePtySpecialKey } from '../pty-shell/pty-special-keys.js';
+import { encodeSgrMouse, mouseModeOffReason, type PtyMouseInput } from '../pty-shell/pty-mouse.js';
 import { resizePtyWithOutcome, writePtyWithOutcome } from '../pty-shell/pty-write-outcome.js';
 import type { PtyControlTarget, PtyHandle } from '../pty-shell/registry.js';
 import { ptyEventLogTargets, ptyManifestTargets } from '../domains/fleet.js';
@@ -25,6 +27,7 @@ import { terminalTreeLabel } from '../pty-shell/terminal-tree.js';
 import { RemotesStore } from './remotes.js';
 import { bookmarkAttachDefaults } from './remote-resolve.js';
 import { classifyFrameState, type FrameState } from '../capture/frame-state-detect.js';
+import { installMissingTool, waitForPtyCompletion, type ToolInstallDeps, type ToolInstallResult } from '../agent-mission/tool-install.js';
 
 interface PtyTakeoverCommandResult { readonly exitCode: 0 | 1 | 2; readonly message: string; readonly notice?: string; }
 /** ⚠️ 내부 타입 — 파일 밖 소비자 없음(dead export 금지·review · `pty-control-ipc.ts:7` 선례).
@@ -419,6 +422,7 @@ export interface PtyTakeoverCommandDeps {
 
 type RemoteTerminalControlBody =
   | { readonly action: 'input-text' | 'input-key'; readonly chars: string }
+  | ({ readonly action: 'input-mouse' } & PtyMouseInput)
   | { readonly action: 'snapshot'; readonly ansi?: true };
 
 type RemoteTerminalControlFetchResult =
@@ -1177,24 +1181,6 @@ export function ptyListRunTermination(
   return runStoreResolution(runId, ledgerDirectories, readRunStore, alive, processStartedAt);
 }
 
-/** ⛔⭐⭐ **세 칸이 «언제나» 나온다 — 값이 없으면 `null` 이다.**
- *
- *  🩸 한때 이 셋을 «선택 키»로 뒀고, 그래서 로컬(등록됨)과 원격의 `Object.keys()` 가 갈렸다.
- *     나는 그것을 *"원격이 저쪽 PWA 주소를 지어내야 하니 원리상 불가"* 라고 적었는데 ***틀렸다*** —
- *     ***`webUrl: null` 이면 지어내지 않고도 키가 보존된다***(리뷰가 그 길을 줬다).
- *  ⇒ 이제 출처·상태와 무관하게 키 집합이 «하나»이고, 소비자는 분기하지 않는다.
- *  ⛔ `null` 과 「값 있음」을 구별하는 것은 소비자의 몫이고, 그 구별은 «값»으로 남는다. */
-interface PtyWebAddress {
-  /** ⭐ `'remote-not-queried'` 는 ***원격 행 전용***이다 — 저쪽 PWA 를 «묻지 않았다».
-   *  ⛔ `'pwa-url-unknown'`(데몬은 있는데 PWA 미등록)과 «다른 사실»이라 재사용하지 않는다.
-   *  ⛔ 공용 유니온(`NexusPwaUnavailableReason`)은 «안 넓힌다» — 이 파일의 계약만 넓힌다. */
-  readonly pwaUnavailableReason: NexusPwaUnavailableReason | 'remote-not-queried' | null;
-  readonly webUrl: string | null;
-  /** ⭐ 이 링크가 이 기계 «밖»에서 열리나 — `tailnet` 이면 다른 기기에서 열린다.
-   *  ⛔ 이 칸이 없으면 사람이 링크만 보고 그것을 «알 수 없다». */
-  readonly webUrlSource: NexusPwaLinkSource | null;
-}
-
 /** 원격 행의 웹 주소 — 우리는 저쪽 PWA 를 «묻지 않았다». 지어내지 않고 «모른다»를 값으로 낸다. */
 const REMOTE_WEB_ADDRESS: PtyWebAddress = {
   webUrl: null,
@@ -1209,25 +1195,6 @@ const UNRESOLVED_WEB_ADDRESS: PtyWebAddress = {
   pwaUnavailableReason: null,
 };
 
-function ptyWebAddress(ptyId: string, pwa: NexusPwaResolution): PtyWebAddress {
-  if ('url' in pwa) {
-    // ⛔⭐ `loopback` 이 아니라 `url` 을 읽는다 — 해석기가 「밖에서 여는 주소」를 이미 «골랐다».
-    //   종전엔 `loopback` 을 읽어, 해석기가 사설망 주소를 골라도 링크는 되돌이로 나왔다(`GOAL-T80`).
-    const url = new URL('term', pwa.url);
-    url.search = new URLSearchParams({ pty: ptyId }).toString();
-    return { webUrl: url.toString(), webUrlSource: pwa.source, pwaUnavailableReason: null };
-  }
-  return { webUrl: null, webUrlSource: null, pwaUnavailableReason: pwa.reason };
-}
-
-function formatPtyWebAddress(address: PtyWebAddress): string {
-  if (address.webUrl) {
-    return address.webUrlSource === 'tailnet' ? `${address.webUrl} (tailnet)` : address.webUrl;
-  }
-  // ⛔ `null` 사유(=해석 안 함)와 「사유가 있다」를 구별해 낸다 — 둘을 한 문면으로 접지 않는다.
-  return `web-unavailable=${address.pwaUnavailableReason ?? 'not-resolved'}`;
-}
-
 interface PtyManifestSourceRoot {
   readonly name: string;
   readonly dbPath: string;
@@ -1716,7 +1683,7 @@ function parseRemoteTerminalControl(body: unknown): PtyControlResult | null {
 }
 
 async function runPtyRemoteControl(
-  action: 'text' | 'key' | 'snapshot',
+  action: 'text' | 'key' | 'mouse' | 'snapshot',
   id: string,
   remote: string | boolean,
   body: RemoteTerminalControlBody,
@@ -2091,6 +2058,24 @@ export function runPtyKey(ref: string, key: string, repeat = 1, deps: PtyTakeove
   if (!Number.isInteger(repeat) || repeat < 1) return Promise.resolve({ exitCode: 1, message: 'pty key: repeat must be a positive integer' });
   try { const normalized = key.trim().toLowerCase(); return inject(ref, 'input-key', resolvePtySpecialKey(normalized).repeat(repeat), { key: normalized, repeat }, deps, actor); } catch (error) { return Promise.resolve({ exitCode: 1, message: `pty key: ${(error as Error).message}` }); }
 }
+export async function runPtyMouse(ref: string, input: PtyMouseInput, deps: PtyTakeoverCommandDeps = liveDeps, actor: PtyWriteActor = 'human'): Promise<PtyTakeoverCommandResult> {
+  let chars: string;
+  try { chars = encodeSgrMouse(input); }
+  catch (error) { return { exitCode: 1, message: `pty mouse: ${(error as Error).message}` }; }
+  const resolvedRef = resolveId(ref, 'mouse', deps);
+  if (typeof resolvedRef !== 'string') return resolvedRef;
+  const id = resolvedRef;
+  const observed = { x: input.x, y: input.y, kind: input.kind, button: input.button ?? 'left', actor };
+  const handle = deps.getPty(id);
+  if (!handle) return mapResult('mouse', id, await deps.requestRemote(id, 'input-mouse', input, { actor }), deps, observed);
+  const resolved = localActor(id, actor, deps);
+  if (typeof resolved !== 'string') return mapResult('mouse', id, { status: 'denied', reason: resolved.reason }, deps, observed);
+  const off = mouseModeOffReason(handle);
+  if (off) return mapResult('mouse', id, { status: 'denied', reason: off }, deps, observed);
+  const outcome = writePtyWithOutcome(handle, chars, resolved);
+  return mapResult('mouse', id, outcome === 'success' ? { status: 'success' } : outcome === 'denied' ? { status: 'denied', reason: 'write-arbiter' } : { status: 'write-failed', reason: 'adapter-write' }, deps, observed);
+}
+
 export async function runPtyResize(ref: string, cols: number, rows: number, deps: PtyTakeoverCommandDeps = liveDeps, actor: PtyWriteActor = 'human'): Promise<PtyTakeoverCommandResult> {
   if (!Number.isInteger(cols) || !Number.isInteger(rows) || cols < 1 || rows < 1) return { exitCode: 1, message: 'pty resize: cols and rows must be positive integers' };
   const refResult = resolveId(ref, 'resize', deps); if (typeof refResult !== 'string') return refResult;
@@ -2106,7 +2091,7 @@ export async function runPtyResize(ref: string, cols: number, rows: number, deps
       ? { status: 'denied', reason: 'write-arbiter' }
       : { status: 'failed', reason: 'resize-error' }, deps, observed);
 }
-export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverCommandDeps = liveDeps): void {
+export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverCommandDeps = liveDeps, toolInstallDeps: ToolInstallDeps = {}): void {
   const pty = program.command('pty').description(
     // ⭐ `<ref>` = id · nickname · unique prefix — **ref 를 받는 하위명령**이 resolvePtyRef 로 해석한다(`list` 는 인자 없음).
     //   종전 도움말은 `<ptyId>` 라 **실제보다 좁게** 적혀 있었다(구현은 처음부터 ref 를 받았다).
@@ -2159,6 +2144,28 @@ export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverC
   pty.command('wait <ref>').requiredOption('--until <state>', 'wait until idle, working, blocked, waiting, or done')
     .option('--timeout <ms>', 'timeout in milliseconds', '120000').option('--poll-ms <ms>', 'poll interval in milliseconds', '500')
     .description('Wait until the classified PTY screen reaches a state').action((id: string, opts: { until: string; timeout: string; pollMs: string }) => run(() => runPtyWait(id, opts.until, { timeoutMs: Number(opts.timeout), pollMs: Number(opts.pollMs) }, deps)));
+  pty.command('install-tool <ref> <tool>')
+    .description('Smoke-check a known tool in the PTY shell, install an unprivileged known remedy, and verify it')
+    .action((ref: string, tool: string) => run(async () => {
+      if (!['gh', 'rg', 'node', 'codex', 'jq', 'ffmpeg'].includes(tool)) {
+        return { exitCode: 2 as const, message: `pty install-tool: unsupported tool ${tool}` };
+      }
+      const inPty: ToolInstallDeps = {
+        typeLine: async (ptyRef, line) => {
+          const typed = await runPtyText(ptyRef, line, true, deps, 'agent');
+          if (typed.exitCode !== 0) throw new Error(typed.message);
+        },
+        waitIdle: (ptyRef, opts) => waitForPtyCompletion(ptyRef, opts, async (ref) => {
+          const snapshot = await runPtySnapshot(ref, deps);
+          if (snapshot.exitCode !== 0) throw new Error(snapshot.message);
+          return snapshot.message;
+        }),
+        ...toolInstallDeps,
+      };
+      const result: ToolInstallResult = await installMissingTool({ tool: tool as 'gh' | 'rg' | 'node' | 'codex' | 'jq' | 'ffmpeg', ptyRef: ref }, inPty);
+      return { exitCode: result.outcome === 'already' || result.outcome === 'installed' ? 0 as const : 1 as const,
+        message: `pty install-tool: ${result.outcome}: ${result.reason}${result.line ? ` · ${result.line}` : ''}${result.needsLogin && !result.reason.includes('codex authentication not verified') ? ' · codex authentication not verified; run codex login before authenticated work' : ''}` };
+    }));
   pty.command('snapshot <ref>').option('--ansi', 'reconstruct xterm cell attributes as terminal SGR sequences')
     .option('-r', 'render the PTY screen on the default remote bookmark (does not take a value)')
     .option('--remote <name>', 'render the PTY screen on a named remote bookmark')
@@ -2191,6 +2198,16 @@ export function registerPtyTakeoverCommands(program: Command, deps: PtyTakeoverC
         catch (error) { return Promise.resolve({ exitCode: 1, message: `pty key: ${(error as Error).message}` }); }
       });
     }));
+  pty.command('mouse <ref> <x> <y>').option('--button <button>', 'left, middle, or right', 'left').option('--scroll <direction>', 'up or down').option('-r', 'use default remote bookmark').option('--remote <name>', 'use named remote bookmark').option(...ACTOR_FLAG)
+    .description('Click or scroll a mouse-enabled SGR PTY (1-based column and row; disabled mode is refused by the owner)').action((id: string, x: string, y: string, opts: { button: string; scroll?: string; actor?: string; r?: boolean; remote?: string }) => run(() => withActor(opts, async (actor) => {
+      if (opts.scroll !== undefined && opts.scroll !== 'up' && opts.scroll !== 'down') return { exitCode: 1, message: 'pty mouse: --scroll must be up or down' };
+      if (opts.button !== 'left' && opts.button !== 'middle' && opts.button !== 'right') return { exitCode: 1, message: 'pty mouse: --button must be left, middle or right' };
+      const input: PtyMouseInput = { x: Number(x), y: Number(y), button: opts.button, kind: opts.scroll ? `scroll-${opts.scroll}` as 'scroll-up' | 'scroll-down' : 'click' };
+      try { encodeSgrMouse(input); } catch (error) { return { exitCode: 1, message: `pty mouse: ${(error as Error).message}` }; }
+      const remote = opts.remote ?? (opts.r === true ? true : undefined);
+      if (remote !== undefined && actor === 'agent') return { exitCode: 1, message: 'pty mouse: remote HTTP cannot verify same-run agent ownership; use the owner IPC instead' };
+      return remote === undefined ? runPtyMouse(id, input, deps, actor) : runPtyRemoteControl('mouse', id, remote, { action: 'input-mouse', ...input }, deps);
+    })));
   pty.command('resize <ref> <cols> <rows>').option(...ACTOR_FLAG)
     .description('Resize the PTY (gated by the same access matrix as input)').action((id: string, cols: string, rows: string, opts: { actor?: string }) => run(() => withActor(opts, (actor) => runPtyResize(id, Number(cols), Number(rows), deps, actor))));
 }

package/src/cli/pty-web-address.ts

@@ -0,0 +1,52 @@
+import { resolveDaemonEndpoint, type ResolveDaemonEndpointOpts } from '../nexus/daemon-endpoint.js';
+import { resolveNexusPwa, type NexusPwaLinkSource, type NexusPwaResolution, type NexusPwaUnavailableReason } from './nexus-show.js';
+
+/** All three fields are present even when the PWA was not queried or is unavailable. */
+export interface PtyWebAddress {
+  readonly pwaUnavailableReason: NexusPwaUnavailableReason | 'remote-not-queried' | null;
+  readonly webUrl: string | null;
+  readonly webUrlSource: NexusPwaLinkSource | null;
+  /** Set when the watch link came from the production daemon, not this universe. */
+  readonly productionDaemon?: boolean;
+}
+
+export function ptyWebAddress(ptyId: string, pwa: NexusPwaResolution): PtyWebAddress {
+  if ('url' in pwa) {
+    // Use the resolver-selected address, which may be reachable over tailnet.
+    const url = new URL('term', pwa.url);
+    url.search = new URLSearchParams({ pty: ptyId }).toString();
+    return { webUrl: url.toString(), webUrlSource: pwa.source, pwaUnavailableReason: null };
+  }
+  return { webUrl: null, webUrlSource: null, pwaUnavailableReason: pwa.reason };
+}
+
+export function formatPtyWebAddress(address: PtyWebAddress): string {
+  if (address.webUrl) {
+    const link = address.webUrlSource === 'tailnet' ? `${address.webUrl} (tailnet)` : address.webUrl;
+    return address.productionDaemon ? `${link} (production daemon)` : link;
+  }
+  return `web-unavailable=${address.pwaUnavailableReason ?? 'not-resolved'}`;
+}
+
+export function resolvePtyWebAddress(
+  ptyId: string,
+  resolvePwa: () => NexusPwaResolution = resolveNexusPwa,
+  endpointOpts?: ResolveDaemonEndpointOpts,
+): PtyWebAddress {
+  try {
+    const address = ptyWebAddress(ptyId, resolvePwa());
+    if (address.webUrl || address.pwaUnavailableReason !== 'daemon-absent') return address;
+    const production = resolveDaemonEndpoint({ ...endpointOpts, purpose: 'watch' });
+    if (production?.universe !== 'production') return address;
+    const watched = ptyWebAddress(ptyId, {
+      status: 'unregistered',
+      loopback: `${production.baseUrl}/app/`,
+      url: production.pwaUrl,
+      pid: 0,
+      source: 'local',
+    });
+    return { ...watched, productionDaemon: true };
+  } catch {
+    return { webUrl: null, webUrlSource: null, pwaUnavailableReason: 'pwa-query-failed' };
+  }
+}

package/src/cli/publish-cli.ts

@@ -0,0 +1,44 @@
+import type { Command } from 'commander';
+import { writeStdoutJson } from './stdout-json.js';
+
+export function registerPublishCommands(program: Command): void {
+// ── publish (external-markdown 게시 라이프사이클 GC) ──
+const publishCmd = program.command('publish').description('external-markdown 게시 라이프사이클 — 만료 게시물 GC(S3 콜드 백업·삭제 아님)');
+publishCmd
+  .command('gc')
+  .description('만료 게시물 GC — 1년 만료분을 S3 콜드(Glacier) 백업(삭제 아님)·permanent 자동보존. elanous schedule 크론용.')
+  .option('--root <dir>', '게시 저장 루트(기본 ~/.elanous/publishing·ELANOUS_PUBLISH_ROOT)')
+  .option('--json', '구조화 출력 {archived, kept, errors}')
+  .action(async (opts: { root?: string; json?: boolean }) => {
+    const { runPublishGc } = await import('../nexus/api/markdown-publish.js');
+    const r = await runPublishGc(opts.root ? { root: opts.root } : {});
+    if (opts.json) await writeStdoutJson(JSON.stringify(r) + '\n');
+    else console.log(`[publish gc] 콜드백업 ${r.archived.length}건 · 보존 ${r.kept}건 · 실패 ${r.errors.length}건${r.errors.length ? ' — ' + r.errors.map((e) => e.id).join(',') : ''}`);
+    process.exit(r.errors.length ? 1 : 0);
+  });
+publishCmd
+  .command('catalog')
+  .description('공개 콘텐츠 카탈로그(피드 보드 데이터) 빌드 — 전 게시물을 newest-first 공개 레코드로 프로젝션(만료·타깃없음 제외).')
+  .option('--root <dir>', '게시 저장 루트(기본 ~/.elanous/publishing·ELANOUS_PUBLISH_ROOT)')
+  .option('--json', '구조화 출력 — CatalogRecord[] JSON (피드/파이프라인용)')
+  .action(async (opts: { root?: string; json?: boolean }) => {
+    const { buildPublishCatalog } = await import('../nexus/api/markdown-publish.js');
+    const records = await buildPublishCatalog(opts.root ? { root: opts.root } : {});
+    if (opts.json) await writeStdoutJson(JSON.stringify(records) + '\n');
+    else console.log(`[publish catalog] ${records.length}건 · domain: ${[...new Set(records.map((r) => r.domain ?? 'other'))].join(', ')}`);
+    process.exit(0);
+  });
+publishCmd
+  .command('file <path>')
+  .description('마크다운 파일(Obsidian 등)을 외부 공개 게시하고 공개 URL 반환 — 공백·한글 경로 안전. skill/자동화용.')
+  .option('--json', '구조화 출력 {ok, url, path}')
+  .action(async (path: string, opts: { json?: boolean }) => {
+    const { publishObsidianFile } = await import('../skills/url-route-exec.js');
+    const url = publishObsidianFile(path);
+    if (opts.json) await writeStdoutJson(JSON.stringify({ ok: !!url, url, path }) + '\n');
+    else if (url) console.log(url);
+    else console.error('게시 실패 — 파일 없음·빈 파일·S3 미가용·게시 오류(elanous logs --category url-route.publish 확인)');
+    process.exit(url ? 0 : 1);
+  });
+
+}

package/src/cli/pwa-build.ts

@@ -68,8 +68,8 @@ export function resolvePwaCwd(argvBin: string): string | undefined {
  * the missing dep names (capped at 3 so the message stays short).
  *
  * 2026-07-11 — the required set is now derived from `apps/pwa/package.json`
- * `dependencies` (every runtime dep webpack must resolve) UNION a small core
- * safety list. The old hardcoded 3-item list only caught a missing dep if it
+ * `dependencies` (every runtime dep webpack must resolve) UNION `@types/*`
+ * devDependencies and a small core safety list. The old hardcoded 3-item list only caught a missing dep if it
  * happened to be one of those three: a stale tree missing `remark-wiki-link`
  * (but not dagre) sailed past the precheck straight into a cryptic webpack
  * "Module not found". Deriving from package.json makes the precheck
@@ -87,17 +87,17 @@ interface PwaBuildPrecheck {
   missing: string[];
 }
 
-/** Runtime deps webpack must resolve = `dependencies` from apps/pwa's
- *  package.json, unioned with the core safety list. Fail-soft: an unreadable
- *  package.json degrades to just the core list. */
+/** Runtime deps webpack must resolve plus @types devDependencies needed by tsc,
+ *  unioned with the core safety list. Fail-soft: an unreadable package.json
+ *  degrades to just the core list. */
 function pwaRequiredDeps(
   cwd: string,
   readFn: (p: string) => string,
 ): string[] {
   let declared: string[] = [];
   try {
-    const pkg = JSON.parse(readFn(joinPath(cwd, 'package.json'))) as { dependencies?: Record<string, string> };
-    declared = Object.keys(pkg.dependencies ?? {});
+    const pkg = JSON.parse(readFn(joinPath(cwd, 'package.json'))) as { dependencies?: Record<string, string>; devDependencies?: Record<string, string> };
+    declared = [...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {}).filter((dep) => dep.startsWith('@types/'))];
   } catch { /* unreadable/absent package.json → core list only */ }
   return [...new Set([...declared, ...PWA_BUILD_REQUIRED_DEPS])];
 }
@@ -113,7 +113,15 @@ export function checkPwaBuildDeps(
   }
   const missing: string[] = [];
   for (const dep of pwaRequiredDeps(cwd, readFn)) {
-    if (!existsFn(joinPath(nm, dep, 'package.json'))) missing.push(dep);
+    const pkgPath = joinPath(nm, dep, 'package.json');
+    if (!existsFn(pkgPath)) { missing.push(dep); continue; }
+    if (dep.startsWith('@types/')) {
+      try {
+        const pkg = JSON.parse(readFn(pkgPath)) as { types?: string; typings?: string };
+        const declaration = pkg.types ?? pkg.typings ?? 'index.d.ts';
+        if (!existsFn(joinPath(nm, dep, declaration))) missing.push(dep);
+      } catch { missing.push(dep); }
+    }
   }
   return { ok: missing.length === 0, missing };
 }
@@ -132,10 +140,8 @@ export async function runPwaBuild(opts: PwaBuildOpts = {}): Promise<PwaBuildResu
   // case before webpack does and emits a one-line fix.
   const deps = checkPwaBuildDeps(cwd);
   if (!deps.ok) {
-    out.error(`✗ elanous nexus build: missing node_modules in ${cwd}`);
-    out.error(`  not installed: ${deps.missing.slice(0, 3).join(', ')}${deps.missing.length > 3 ? ` (+${deps.missing.length - 3} more)` : ''}`);
-    out.error(`  fix:  cd "${cwd}" && bun install`);
-    out.error('       (the tree that owns `apps/pwa` here was likely never `bun install`-ed, or the lockfile was stripped).');
+    out.error(`✗ elanous nexus build: missing or incomplete node_modules in ${cwd}: ${deps.missing.slice(0, 3).join(', ')}${deps.missing.length > 3 ? ` (+${deps.missing.length - 3} more)` : ''}`);
+    out.error(`  fix:  cd "${cwd}" && bun install --force`);
     return { exitCode: 1, cwd, durationMs: 0 };
   }
 

package/src/cli/pwa-dev.ts

@@ -24,6 +24,7 @@ import { spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { join as joinPath } from 'node:path';
 
+import { resolveDaemonEndpoint, type ResolveDaemonEndpointOpts } from '../nexus/daemon-endpoint.js';
 import { resolvePwaCwd } from './pwa-build.js';
 import {
   isAliveNexusLock,
@@ -32,7 +33,6 @@ import {
 } from '../nexus/supervisor/lock.js';
 
 const ADMIN_DEV_PROXY_PATH = '/v1/nexus/admin/pwa-dev-proxy';
-const DEFAULT_NEXUS_BASE = 'http://127.0.0.1:31415';
 /** Bind interface for the next-dev child. Mirrors the nexus
  *  PWA_DEFAULT_HTTP_HOST in pwa-start.ts — both surfaces need to be
  *  reachable from Tailscale / LAN / container without extra flags. */
@@ -57,9 +57,12 @@ export interface PwaDevOpts {
   host?: string;
   /** When false, skip POST/DELETE to the admin endpoint. Default true. */
   autoConfig?: boolean;
-  /** Override the nexus base URL probed for hot-swap (default
-   *  `http://127.0.0.1:31415`). */
+  /** Override the nexus base URL probed for hot-swap. When omitted the
+   *  address comes from the daemon endpoint resolver; a missing daemon
+   *  is reported, not guessed. */
   nexusBaseUrl?: string;
+  /** Test seam — daemon address. `null` means this universe has no daemon. */
+  resolveEndpoint?: (opts?: ResolveDaemonEndpointOpts) => { baseUrl: string } | null;
   spawnFn?: (cmd: string, args: string[], cwd: string, env: NodeJS.ProcessEnv) => Promise<number>;
   out?: { log: (s: string) => void; error: (s: string) => void };
   skipNodeModulesCheck?: boolean;
@@ -167,7 +170,7 @@ export async function runPwaDev(opts: PwaDevOpts = {}): Promise<PwaDevResult> {
   const fetchFn = opts.fetchFn ?? fetch;
   const readLockFn = opts.readNexusLockFn ?? readNexusLock;
   const isAliveFn = opts.isAliveNexusLockFn ?? isAliveNexusLock;
-  const baseUrl = opts.nexusBaseUrl ?? DEFAULT_NEXUS_BASE;
+  const baseUrl = opts.nexusBaseUrl ?? (opts.resolveEndpoint ?? resolveDaemonEndpoint)()?.baseUrl ?? null;
 
   out.log(`elanous nexus pwa dev: ${cwd}`);
   const hostShown = opts.host ?? DEFAULT_DEV_HOST;
@@ -182,7 +185,9 @@ export async function runPwaDev(opts: PwaDevOpts = {}): Promise<PwaDevResult> {
   let lastSeenPid: number | null = null;
   let lastSeenStartedAt: string | null = null;
 
-  if (autoConfig) {
+  if (autoConfig && !baseUrl) {
+    out.error('  nexus: daemon address unknown — a port is not guessed. Pass --nexus-url or start the daemon.');
+  } else if (autoConfig && baseUrl) {
     const lock = readLockFn();
     if (lock && isAliveFn(lock)) {
       out.log(`  nexus: live lock detected (pid ${lock.pid}) — POST ${ADMIN_DEV_PROXY_PATH}`);
@@ -202,7 +207,7 @@ export async function runPwaDev(opts: PwaDevOpts = {}): Promise<PwaDevResult> {
     out.log('  --no-auto-config — admin endpoint untouched.');
   }
 
-  out.log(`  → single-origin (when nexus is up): ${baseUrl}/app/`);
+  out.log(`  → single-origin (when nexus is up): ${baseUrl ? `${baseUrl}/app/` : '(daemon address unknown)'}`);
   out.log(`  → cross-origin (always):           http://localhost:${port}/app/`);
   out.log('  Ctrl-C to stop.');
 
@@ -220,7 +225,7 @@ export async function runPwaDev(opts: PwaDevOpts = {}): Promise<PwaDevResult> {
   // race a poll cleanly. autoConfig=false skips the watcher (caller
   // opted out of admin-endpoint mutation entirely).
   const pollIntervalMs = opts.reregisterPollIntervalMs ?? DEFAULT_REREGISTER_POLL_INTERVAL_MS;
-  const watcherEnabled = autoConfig && pollIntervalMs > 0;
+  const watcherEnabled = autoConfig && baseUrl !== null && pollIntervalMs > 0;
   let reregisterCount = 0;
   let watcherTimer: ReturnType<typeof setInterval> | null = null;
   if (watcherEnabled) {
@@ -259,7 +264,7 @@ export async function runPwaDev(opts: PwaDevOpts = {}): Promise<PwaDevResult> {
     exitCode = await spawnFn('bun', ['run', 'dev'], cwd, env);
   } finally {
     if (watcherTimer) clearInterval(watcherTimer);
-    if (autoConfig && hotSwappedOnStart) {
+    if (autoConfig && baseUrl && hotSwappedOnStart) {
       const ok = await deleteDevProxy(baseUrl, fetchFn);
       if (ok) {
         clearedOnExit = true;

package/src/cli/pwa-registry.ts

@@ -50,6 +50,12 @@ export function resolvePwaLauncherProvenance(
 
   const serviceName = env.LAUNCH_JOB_NAME;
   if (serviceName) return { kind: 'service-manager', serviceName };
+  if (env.XPC_SERVICE_NAME?.startsWith('com.elanous.')) {
+    return { kind: 'service-manager', serviceName: env.XPC_SERVICE_NAME };
+  }
+  if (env.INVOCATION_ID && (env.SYSTEMD_EXEC_PID || env.JOURNAL_STREAM)) {
+    return { kind: 'service-manager', serviceName: 'systemd' };
+  }
 
   if (env.ELANOUS_NEXUS_BG_PARENT) return { kind: 'background-child' };
   if (isTTY) return { kind: 'human-terminal' };