elanous 0.2.28 → 0.2.29

package/src/loops/msg-wake.ts

@@ -0,0 +1,282 @@
+// ── 우편 깨움 — 글을 저장한 «뒤» 받는 몸을 한 번 두드린다 ──
+//
+// 주소에 «답할 몸»(replyBody)이 있어도 «깨울 길»이 없으면 죽은 주소다(10-14 grok OP 16분 정지).
+// 종류(`MessageWake`)마다 하는 일:
+//   sse        — 아무것도 안 한다(구독자가 이미 듣는다)
+//   cron       — 다음 틱에 읽는다 · `wake-deferred` 로그만
+//   pty-inject — elanous TUI(pty 별명 = 자리 소문자)가 턴 idle 일 때만 한 줄 주입
+//   herdr      — 자리 폴더 `herdr.pane` 의 pane 이 agent_status=idle 일 때만 한 줄 주입
+//   none       — stderr 경고 한 줄 · 해석 실패는 «모름»으로 남긴다(«없다»로 위장 금지)
+// ⛔ 우편은 입력칸에 넣지 않는다(대표 10-15 01:20) — 기본은 입력칸 주입 0. 10-15 01:10 사고: 대표 가 치던 문장에
+//    깨움 한 줄 ⊕ Enter 가 섞여 제출됐다(«에이전트 idle ≠ 사람이 안 친다»). 자리 폴더에서 푼 대상(pty 별명·
+//    pty.ref·herdr.pane)은 `<seat-state>/<자리>/wake-inject` 일반 파일이 있을 때만 주입하고, 없으면
+//    `msg.wake skipped{reason}` 만 남긴다.
+//    ⚠️ wake-inject 는 «사람이 치지 않는 pane»(무인 에이전트 전용)에만 둔다 — 사람이 치는 pane 에는 켜지 말 것.
+// ⛔ 깨움은 post 의 성패를 바꾸지 않는다 — 실패·시간 초과는 결과 값으로만 돌아온다.
+// ⛔ 시험 우주에서는 실제 pty/herdr 호출 0 — `ELANOUS_MSG_WAKE_LIVE=1` 로만 연다(격리 실물 시험용).
+
+import { spawn } from 'node:child_process';
+import { Database } from 'bun:sqlite';
+import { randomUUID } from 'node:crypto';
+import { existsSync, lstatSync, mkdirSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
+import { listPtyManifestRows } from '../pty-shell/pty-manifest.js';
+import { messageRouteFor, type MessageWake } from './msg-address.js';
+
+export const WAKE_DEBOUNCE_MS = 5 * 60_000;
+export const WAKE_TIMEOUT_MS = 3_000;
+/** Seat-folder file that opts a human pane in to wake injection (presence is the switch). */
+const WAKE_OPT_IN_FILE = 'wake-inject';
+
+export interface WakeResolution {
+  wake: MessageWake;
+  /** pty id (pty-inject) or herdr pane id (herdr). */
+  target?: string;
+  /** Where the answer came from — `unresolved` means «모름», not a measured absence. */
+  source: 'loop-table' | 'pty-name' | 'pty.ref' | 'herdr.pane' | 'unresolved';
+  reason?: string;
+  /** For a seat-folder target: the seat opted in to injection (`<seat>/wake-inject` exists). Absent = not a seat target. */
+  optIn?: boolean;
+}
+
+export type WakeResult = 'none-sse' | 'wake-deferred' | 'injected' | 'busy' | 'debounced' | 'skipped' | 'skipped-reply'
+  | 'skipped-self' | 'skipped-test-universe' | 'no-wake' | 'failed' | 'timeout';
+
+export interface WakeOutcome extends WakeResolution { address: string; msgId: number; result: WakeResult }
+
+export interface WakeDeps {
+  /** Seat folders (`<root>/<SEAT>/pty.ref` · `herdr.pane`). Prod: ~/elanous-hq/seat-state · test universe: <root>/seat-state. */
+  seatStateRoot?: string;
+  /** Debounce claims live here (`<stateRoot>/msg/wake-claims.db`). */
+  stateRoot?: string;
+  now?: () => number;
+  /** Real pty/herdr calls are allowed (default: prod universe or ELANOUS_MSG_WAKE_LIVE=1). */
+  live?: boolean;
+  timeoutMs?: number;
+  listPtys?: () => Array<{ id: string; nickname?: string; alive: boolean; turnState?: 'busy' | 'idle' }>;
+  /** Reads one seat-folder file (`pty.ref` · `herdr.pane`); null when absent. */
+  readPane?: (path: string) => string | null;
+  /** Does this seat-folder opt-in file exist (`<seat>/wake-inject`)? */
+  hasOptIn?: (path: string) => boolean;
+  /** Loads the pty writer (the CLI module is heavy, so it is imported only when a pty wake is due). */
+  ptyInjector?: () => Promise<(ptyId: string, line: string) => Promise<void>>;
+  herdrStatus?: (paneId: string, signal: AbortSignal) => Promise<string>;
+  herdrInject?: (paneId: string, line: string, signal: AbortSignal) => Promise<void>;
+  warn?: (line: string) => void;
+}
+
+function isLive(deps: WakeDeps): boolean {
+  if (deps.live !== undefined) return deps.live;
+  return effectiveInstanceRoot() === prodInstanceRoot() || process.env.ELANOUS_MSG_WAKE_LIVE === '1';
+}
+
+function seatStateRoot(deps: WakeDeps): string {
+  if (deps.seatStateRoot) return deps.seatStateRoot;
+  const root = effectiveInstanceRoot();
+  return root === prodInstanceRoot() ? join(homedir(), 'elanous-hq', 'seat-state') : join(root, 'seat-state');
+}
+
+/** The opt-in must be a regular file — a directory, a symlink or anything else at that name does not open injection. */
+function isRegularFile(path: string): boolean {
+  // lstat — 링크는 따라가지 않는다(자리 자체의 일반 파일만 opt-in).
+  try { return lstatSync(path).isFile(); } catch { return false; }
+}
+
+/** The seat's own opt-in, read independently of whatever target the seat folder points at now. */
+function seatOptedIn(address: string, deps: WakeDeps): boolean {
+  return (deps.hasOptIn ?? isRegularFile)(join(seatStateRoot(deps), address.trim().toUpperCase(), WAKE_OPT_IN_FILE));
+}
+
+function readPaneFile(path: string): string | null {
+  try { return existsSync(path) ? readFileSync(path, 'utf8').trim() || null : null; }
+  catch { return null; }
+}
+
+/** How a post to `address` would wake its reader — table first, then a live pty named after the seat, then herdr. */
+export function resolveWake(address: string, deps: WakeDeps = {}): WakeResolution {
+  const name = address.trim().toUpperCase();
+  if (name === 'ALL') return { wake: 'none', source: 'unresolved', reason: 'topic' };
+  const route = messageRouteFor(name);
+  if (route?.wake) return { wake: route.wake, source: 'loop-table' };
+  // 호스트 해석은 표에 선언된 자리 줄(wakeFrom: 'host')만 — 모르는 주소는 같은 이름의 pty 가 있어도 깨우지 않는다.
+  if (route?.wakeFrom !== 'host') return { wake: 'none', source: 'unresolved', reason: 'undeclared-address' };
+  // ⭐ 별명은 «정확히» 같은 것만 — pty ref 해석의 부분 일치(op ⊂ opt)로 남의 TUI 에 넣지 않는다.
+  const lower = name.toLowerCase();
+  let ptys: ReturnType<NonNullable<WakeDeps['listPtys']>> = [];
+  try { ptys = (deps.listPtys ?? listPtyManifestRows)(); } catch { ptys = []; }
+  const named = ptys.filter(row => row.alive && (row.nickname ?? '').toLowerCase() === lower);
+  const optIn = seatOptedIn(name, deps);
+  if (named.length === 1) return { wake: 'pty-inject', target: named[0]!.id, source: 'pty-name', optIn };
+  // seat-inbox.sh 와 같은 자리 폴더 파일: pty.ref(살아 있는 행의 id·별명과 정확히 같을 때만) → herdr.pane.
+  const readSeatFile = deps.readPane ?? readPaneFile;
+  const ref = readSeatFile(join(seatStateRoot(deps), name, 'pty.ref'))?.toLowerCase();
+  const byRef = ref ? ptys.filter(row => row.alive && (row.id.toLowerCase() === ref || (row.nickname ?? '').toLowerCase() === ref)) : [];
+  if (byRef.length === 1) return { wake: 'pty-inject', target: byRef[0]!.id, source: 'pty.ref', optIn };
+  const pane = readSeatFile(join(seatStateRoot(deps), name, 'herdr.pane'));
+  if (pane) return { wake: 'herdr', target: pane, source: 'herdr.pane', optIn };
+  return { wake: 'none', source: 'unresolved', reason: named.length > 1 ? `pty-name-ambiguous:${named.length}` : 'no-pty-name-no-herdr-pane' };
+}
+
+function claimDbPath(deps: WakeDeps): string {
+  return join(deps.stateRoot ?? effectiveInstanceRoot(), 'msg', 'wake-claims.db');
+}
+
+interface WakeClaim { db: string; address: string; token: string }
+
+/**
+ * Atomically claim the 5-minute wake window for one address. One SQLite upsert decides it under the
+ * write lock — the row is replaced only when the held claim is older than the window — so two
+ * concurrent `msg post` processes cannot both win, including when both saw an expired claim.
+ */
+export function claimWake(db: string, address: string, now: number): WakeClaim | null {
+  mkdirSync(dirname(db), { recursive: true });
+  const token = `${now} ${process.pid} ${randomUUID()}`;
+  const conn = new Database(db);
+  try {
+    conn.exec('PRAGMA busy_timeout = 2000');
+    conn.exec('CREATE TABLE IF NOT EXISTS wake_claims (address TEXT PRIMARY KEY, at INTEGER NOT NULL, token TEXT NOT NULL)');
+    const changed = conn.query(`INSERT INTO wake_claims (address, at, token) VALUES (?1, ?2, ?3)
+      ON CONFLICT(address) DO UPDATE SET at = excluded.at, token = excluded.token WHERE wake_claims.at <= ?2 - ?4`)
+      .run(address, now, token, WAKE_DEBOUNCE_MS).changes;
+    return changed === 1 ? { db, address, token } : null;
+  } finally { conn.close(); }
+}
+
+/** Give the window back when nothing was injected (busy · timeout · failure) — only our own claim. */
+function releaseClaim(claim: WakeClaim): void {
+  try {
+    const conn = new Database(claim.db);
+    try { conn.exec('PRAGMA busy_timeout = 2000'); conn.query('DELETE FROM wake_claims WHERE address = ?1 AND token = ?2').run(claim.address, claim.token); }
+    finally { conn.close(); }
+  } catch { /* a stale claim only delays the next wake by one window */ }
+}
+
+function run(cmd: string, args: string[], timeoutMs: number, signal: AbortSignal): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) { reject(new Error(`${cmd} aborted`)); return; }
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], signal });
+    let out = '';
+    const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error(`${cmd} timeout`)); }, timeoutMs);
+    child.stdout.on('data', chunk => { out += String(chunk); });
+    child.on('error', error => { clearTimeout(timer); reject(error); });
+    child.on('close', code => { clearTimeout(timer); code === 0 ? resolve(out) : reject(new Error(`${cmd} exit ${code}`)); });
+  });
+}
+
+async function defaultHerdrStatus(paneId: string, signal: AbortSignal): Promise<string> {
+  const parsed = JSON.parse(await run('herdr', ['pane', 'get', paneId], WAKE_TIMEOUT_MS, signal)) as { result?: { pane?: { agent_status?: unknown } } };
+  const status = parsed.result?.pane?.agent_status;
+  return typeof status === 'string' ? status : 'unknown';
+}
+
+async function defaultHerdrInject(paneId: string, line: string, signal: AbortSignal): Promise<void> {
+  // `pane run` = send-text ⊕ Enter 한 번에.
+  await run('herdr', ['pane', 'run', paneId, line], WAKE_TIMEOUT_MS, signal);
+}
+
+async function defaultPtyInjector(): Promise<(ptyId: string, line: string) => Promise<void>> {
+  const { runPtyText } = await import('../cli/pty-takeover-cli.js');
+  return async (ptyId, line) => {
+    const result = await runPtyText(ptyId, line, true);
+    if (result.exitCode !== 0) throw new Error(result.message);
+  };
+}
+
+export function wakeLine(from: string, address: string, msgId: number): string {
+  return `[우편 깨움] ${from} → ${address} #${msgId} — eln msg list --to ${address} 로 읽고 처리`;
+}
+
+export const NO_WAKE_NOTICE = '이 주소는 깨울 길이 없다 — 받는 몸이 스스로 읽을 때까지 쌓인다';
+
+/**
+ * Wake the reader of a just-saved message. Never throws; the caller's post outcome is already final.
+ * `message.from`/`kind` decide the skips (a reply or a self-addressed note never wakes anyone).
+ */
+export async function wakeRecipient(address: string, msgId: number, message: { from: string; kind?: string }, deps: WakeDeps = {}): Promise<WakeOutcome> {
+  const timeoutMs = deps.timeoutMs ?? WAKE_TIMEOUT_MS;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let resolution: WakeResolution = { wake: 'none', source: 'unresolved', reason: 'not-resolved' };
+  const controller = new AbortController();
+  // 마감은 «진입» 시각 기준 — 동기 작업(claim 잠금 대기 등)이 늦어 타이머가 못 울려도 넘기면 주입하지 않는다.
+  const deadline = Date.now() + timeoutMs;
+  const expired = () => controller.signal.aborted || Date.now() >= deadline;
+  let claim: WakeClaim | null = null;
+  let injecting = false;
+  const attempt = (async (): Promise<WakeOutcome> => {
+    const done = (result: WakeResult, reason?: string): WakeOutcome =>
+      ({ ...resolution, ...(reason ? { reason } : {}), address, msgId, result });
+    if (message.kind === 'reply') return done('skipped-reply', 'kind=reply');
+    if (message.from.toUpperCase() === address.toUpperCase()) return done('skipped-self', 'from=to');
+    resolution = resolveWake(address, deps);
+    if (resolution.wake === 'sse') return done('none-sse');
+    if (resolution.wake === 'cron') return done('wake-deferred');
+    if (resolution.wake === 'none') return done('no-wake');
+    // 사람이 앉는 pane 은 명시 opt-in 이 없으면 주입 0 — 에이전트가 idle 이어도 사람이 치는 중일 수 있다.
+    if (resolution.optIn === false) return done('skipped', 'human-pane-no-opt-in');
+    if (!isLive(deps)) return done('skipped-test-universe');
+    claim = claimWake(claimDbPath(deps), address, (deps.now ?? Date.now)());
+    if (!claim) return done('debounced');
+    try {
+      const line = wakeLine(message.from, address, msgId);
+      if (resolution.wake === 'pty-inject') {
+        // 모듈을 «먼저» 불러오고, 그 뒤에 턴을 읽는다 — 로드 사이 busy 로 바뀐 TUI 에 넣지 않는다.
+        const inject = await (deps.ptyInjector ?? defaultPtyInjector)();
+        // turnState 는 TUI 가 스스로 적은 값(#27485) — 살아 있고 idle 이 «기록»돼 있을 때만 넣는다(모름 = 넣지 않음).
+        // 로드 사이 별명·pty.ref 가 다른 행으로 옮겨 갔으면 넣지 않는다 — 주소→대상을 다시 푼다.
+        const again = resolveWake(address, deps);
+        // opt-in 은 주입 직전에 «먼저» 다시 본다 — 기다리는 사이 `wake-inject` 를 지웠으면(대상이 바뀌었어도) 주입 0.
+        if (!seatOptedIn(address, deps)) { resolution = { ...resolution, optIn: false }; return done('skipped', 'human-pane-no-opt-in'); }
+        if (again.wake !== 'pty-inject' || again.target !== resolution.target) return done('busy', `target-moved:${again.target ?? again.wake}`);
+        const row = (deps.listPtys ?? listPtyManifestRows)().find(item => item.id === resolution.target);
+        if (!row?.alive || row.turnState !== 'idle') return done('busy', `turn=${row?.alive === false ? 'dead' : row?.turnState ?? 'unknown'}`);
+        // ⛔ 마감이 지났으면 새 주입을 시작하지 않는다.
+        if (expired()) return done('timeout');
+        injecting = true;
+        await inject(resolution.target!, line);
+      } else {
+        const status = await (deps.herdrStatus ?? defaultHerdrStatus)(resolution.target!, controller.signal);
+        if (status !== 'idle') return done('busy', `agent_status=${status}`);
+        // 조회 사이 자리의 pane 이 바뀌었으면 옛 pane 에 넣지 않는다 — 주소→대상을 다시 푼다.
+        const again = resolveWake(address, deps);
+        // opt-in 은 주입 직전에 «먼저» 다시 본다 — 기다리는 사이 `wake-inject` 를 지웠으면(대상이 바뀌었어도) 주입 0.
+        if (!seatOptedIn(address, deps)) { resolution = { ...resolution, optIn: false }; return done('skipped', 'human-pane-no-opt-in'); }
+        if (again.wake !== 'herdr' || again.target !== resolution.target) return done('busy', `target-moved:${again.target ?? again.wake}`);
+        // ⛔ 마감은 «주입 바로 앞»에서 — 재해석이 늦어 넘겼어도 새 주입 0.
+        if (expired()) return done('timeout');
+        injecting = true;
+        await (deps.herdrInject ?? defaultHerdrInject)(resolution.target!, line, controller.signal);
+      }
+      return done('injected');
+    } catch (error) {
+      // 주입이 «시작»됐다 실패하면 들어갔는지 모른다 — 창을 돌려줘 다음 글이 다시 깨우게 한다.
+      injecting = false;
+      throw error;
+    } finally { if (!injecting && claim) releaseClaim(claim); }
+  })();
+  let outcome: WakeOutcome;
+  try {
+    outcome = await Promise.race([attempt, new Promise<WakeOutcome>(resolve => {
+      timer = setTimeout(() => {
+        controller.abort();
+        // 시간 초과면 창을 돌려준다 — 주입 전이면 들어간 것이 없고, 주입 중 멈췄으면 들어갔는지 «모른다».
+        // 모를 때는 다음 글이 다시 두드리게 둔다(내용 없는 한 줄의 중복은 무해, 깨움 누락은 16분 정지).
+        if (claim) releaseClaim(claim);
+        resolve({ ...resolution, address, msgId, result: 'timeout' });
+      }, timeoutMs);
+    })]);
+  } catch (error) {
+    outcome = { ...resolution, address, msgId, result: 'failed', reason: error instanceof Error ? error.message : String(error) };
+  } finally { clearTimeout(timer); }
+  attempt.catch(() => { /* a late failure after timeout is already reported as timeout */ });
+  try {
+    if (outcome.result === 'no-wake') (deps.warn ?? (line => console.error(line)))(
+      outcome.source === 'unresolved' ? `${NO_WAKE_NOTICE} (wake=none · 모름: ${outcome.reason})` : `${NO_WAKE_NOTICE} (wake=none)`);
+    debug.log('msg.wake', outcome.result === 'skipped' ? 'skipped' : outcome.wake, { address, msgId, wake: outcome.wake, result: outcome.result, reason: outcome.reason ?? outcome.source,
+      ...(outcome.target ? { target: outcome.target } : {}) });
+  } catch { /* reporting never turns a wake outcome into a throw */ }
+  return outcome;
+}

package/src/loops/orchestrator/inbox.ts

@@ -1,10 +1,26 @@
 import { openMsgStore, type Message, type MsgStore } from '../../msg/msg-store.js';
 import { classifySeatTrafficProposal } from '../../seat-loop/traffic-signal.js';
 import { debug } from '../../debug/log.js';
+import { LOOP_MESSAGE_ROUTES } from '../msg-address.js';
+import { replyWithAgent, type AgentReplyInput } from '../agent-reply.js';
+import type { RoleLlmSpec } from '../../user-config.js';
+import type { LLMProvider } from '../../llm.js';
 
-const RECIPIENT = 'COORDINATOR';
+const RECIPIENT = LOOP_MESSAGE_ROUTES.orchestrator.msgAddress;
 
 export interface CoordinatorInboxResult { replied: number; acknowledged: number }
+export interface CoordinatorAgentInboxOptions {
+  role: RoleLlmSpec;
+  pack: string;
+  store?: MsgStore;
+  path?: string;
+  root?: string;
+  limit?: number;
+  runAgent?: AgentReplyInput['runAgent'];
+  provider?: LLMProvider;
+  /** Only the ordered tick scan may advance the durable inbox cursor. */
+  acknowledge?: boolean;
+}
 
 function trafficProposal(request: Message): 'hold' | 'UNHOLD' | null {
   // A question mentioning a signal is not evidence that the signal occurred.
@@ -26,10 +42,10 @@ export function coordinatorReply(request: Message): string {
 function writeCoordinatorReply(store: MsgStore, request: Message): { id: number; posted: boolean } {
   const marker = `re #${request.id}`;
   const linked = store.db.query(`SELECT id FROM msg_messages WHERE sender = ? AND recipient = ?
-    AND reply_to = ? ORDER BY id LIMIT 1`).get(RECIPIENT, request.from, request.id) as { id: number } | null;
+    AND reply_to = ? AND kind = 'reply' ORDER BY id LIMIT 1`).get(RECIPIENT, request.from, request.id) as { id: number } | null;
   if (linked) return { id: linked.id, posted: false };
   const legacy = store.db.query(`SELECT id FROM msg_messages WHERE sender = ? AND recipient = ?
-    AND reply_to IS NULL AND (body = ? OR substr(body, 1, ?) = ?) ORDER BY id LIMIT 1`)
+    AND reply_to IS NULL AND kind = 'reply' AND (body = ? OR substr(body, 1, ?) = ?) ORDER BY id LIMIT 1`)
     .get(RECIPIENT, request.from, marker, marker.length + 1, `${marker}\n`) as { id: number } | null;
   if (legacy) return { id: legacy.id, posted: false };
   const reply = store.post({ from: RECIPIENT, to: request.from,
@@ -71,3 +87,44 @@ export function runCoordinatorInbox(inputStore?: MsgStore, limit = 100, path?: s
     return { replied, acknowledged };
   } finally { if (ownStore) store.close(); }
 }
+
+/** One SSE delivery or tick scan uses the same durable handler. At-least-once wake is safe. */
+export async function handleCoordinatorAgentMessage(
+  request: Message, input: CoordinatorAgentInboxOptions,
+): Promise<CoordinatorInboxResult> {
+  const store = input.store ?? openMsgStore(input.path);
+  const ownStore = input.store === undefined;
+  const acknowledge = input.acknowledge === true;
+  try {
+    if (request.to !== RECIPIENT || request.from === RECIPIENT ||
+      (request.kind !== undefined && request.kind !== 'request' && request.kind !== 'question')) {
+      if (acknowledge) store.ack(RECIPIENT, request.id);
+      return { replied: 0, acknowledged: acknowledge ? 1 : 0 };
+    }
+    // With explicit role selection, every request goes through the agent body.
+    const result = await replyWithAgent({ address: RECIPIENT, request, role: input.role,
+      pack: input.pack, store, observationRoot: input.root,
+      ...(input.provider ? { provider: input.provider } : {}),
+      ...(input.runAgent ? { runAgent: input.runAgent } : {}) });
+    if (result.replyId === null) throw new Error(`coordinator agent returned no reply for #${request.id}`);
+    if (acknowledge) store.ack(RECIPIENT, request.id);
+    return { replied: result.posted ? 1 : 0, acknowledged: acknowledge ? 1 : 0 };
+  } finally { if (ownStore) store.close(); }
+}
+
+/** Configured body path; callers must check the explicit roleLlm opt-in before invoking it. */
+export async function runCoordinatorAgentInbox(input: CoordinatorAgentInboxOptions): Promise<CoordinatorInboxResult> {
+  const store = input.store ?? openMsgStore(input.path);
+  const ownStore = input.store === undefined;
+  const result = { replied: 0, acknowledged: 0 };
+  try {
+    const requests = store.listByRecipient(RECIPIENT, store.getCursor(RECIPIENT), input.limit ?? 100);
+    for (const request of requests) {
+      const one = await handleCoordinatorAgentMessage(request, { ...input, store, acknowledge: true });
+      result.replied += one.replied;
+      result.acknowledged += one.acknowledged;
+    }
+    debug.log('loop.coordinator-inbox', 'agent-tick', result);
+    return result;
+  } finally { if (ownStore) store.close(); }
+}

package/src/loops/orchestrator/tick.ts

@@ -5,7 +5,7 @@ import { CardStore, taskCardsDir, type TaskCard } from '../../task-cards/card-st
 import { Database } from 'bun:sqlite';
 import { type ChecklistItem } from '../../release-loop/checklist.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
-import { getUserConfig, type OrchestratorLoopConfig } from '../../user-config.js';
+import { getUserConfig, resolveConfiguredAgentRoleLlm, type OrchestratorLoopConfig } from '../../user-config.js';
 import { rubricPriority } from '../../release-loop/rubric.js';
 import { debug } from '../../debug/log.js';
 import { emitLoopHeartbeat } from '../neighbor-runtime.js';
@@ -15,14 +15,23 @@ import { addHarnessQueue, harnessQueueOutcome, setQueuedPoolHint } from '../../h
 import { placeOnGrid, type GridHost } from './grid-place.js';
 import { checkPodPool, parsePodPool, resolvePodPoolSpec } from '../../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl } from '../../task-orchestrator/surfaces/pod-lease.js';
+import type { TrafficSeatRow } from './traffic.js';
 import { readTaskAgentState, TASK_SEATS, type HandTaskOptions, type TaskCard as TaskAgentCard, type HandTaskResult, type TaskLauncher, type TaskSeat } from '../../task-agent/task-hand.js';
-import { runCoordinatorInbox } from './inbox.js';
+import { runCoordinatorAgentInbox, runCoordinatorInbox, type CoordinatorInboxResult } from './inbox.js';
+import { loadAgentRolePack, type AgentReplyInput } from '../agent-reply.js';
+import type { LLMProvider } from '../../llm.js';
 
 export type Window = '08' | '12' | '18';
 export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'launch' | 'reconcile' | 'report';
 export type Mode = 'off' | 'shadow' | 'live';
 const SEAT_LOOP_IDS: Readonly<Record<string, string>> = { OP: 'op-seat', MK: 'cmo-seat', TC: 'tc-seat', UX: 'ux-seat' };
 export interface Cell { id: string; title: string; kind?: string; seat?: string; host?: string; gridHost?: boolean; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2' | 'P3' | 'P4'; predecessors?: string[] }
+/** Pure launch decision over observed traffic; dispatch-c will wire it into the periodic launch path. */
+export function isLaunchEligible(row: Pick<TrafficSeatRow, 'nextCell' | 'running' | 'launchCap'>,
+  skipReason?: string): boolean {
+  return row.nextCell !== null && row.running < row.launchCap &&
+    skipReason !== 'degraded-skip' && skipReason !== 'cap-deferred';
+}
 export interface TickState {
   runId: string; window: Window; mode: Mode; day: string;
   cards: TaskCard[]; skippedCards: Array<{ id: string; reason: string }>; cells: Cell[]; placed: number; unplaced?: number; delegated: number; wouldDelegate: number; rebalanced?: number; rebalanceBlocked?: Array<{ id: string; reason: string }>;
@@ -73,7 +82,10 @@ export interface TickDeps {
   handTask?: (opts: HandTaskOptions) => Promise<HandTaskResult>;
   taskLauncher?: TaskLauncher;
   /** Coordinator inbox seam; the real intake reads and replies on the durable message bus. */
-  coordinatorInbox?: () => { replied: number; acknowledged: number };
+  coordinatorInbox?: () => CoordinatorInboxResult | Promise<CoordinatorInboxResult>;
+  /** Production still uses the restricted turn; tests can supply a deterministic turn. */
+  coordinatorAgentRun?: AgentReplyInput['runAgent'];
+  coordinatorAgentProvider?: LLMProvider;
 }
 
 /** ORCH-TA-HAND ledger — one row per handed `orch:<card>:<cell>` key so a cell is handed once across ticks and processes. */
@@ -475,7 +487,15 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   // A graph node may be replayed with the same runId, and 12/18 skip intake.
   // Drain the bus on every tick command; the message transaction prevents duplicate answers.
   if (mode !== 'off') {
-    const inbox = (deps.coordinatorInbox ?? (() => runCoordinatorInbox(undefined, 100, join(root, 'msg', 'messages.db'))))();
+    const inboxPath = join(root, 'msg', 'messages.db');
+    const inbox = await (deps.coordinatorInbox ?? (() => {
+      const role = resolveConfiguredAgentRoleLlm('coordinator');
+      return role
+        ? runCoordinatorAgentInbox({ role, pack: loadAgentRolePack('coordinator'), path: inboxPath, root,
+            ...(deps.coordinatorAgentRun ? { runAgent: deps.coordinatorAgentRun } : {}),
+            ...(deps.coordinatorAgentProvider ? { provider: deps.coordinatorAgentProvider } : {}) })
+        : runCoordinatorInbox(undefined, 100, inboxPath);
+    }))();
     if (inbox.replied || inbox.acknowledged) {
       observe('exchange', 'coordinator-inbox-replied', inbox.replied);
       observe('exchange', 'coordinator-inbox-acknowledged', inbox.acknowledged);

package/src/loops/registry.ts

@@ -14,6 +14,9 @@ import { getUserConfig, type UserConfig } from '../user-config.js';
 import { runGraph, type GraphRunState } from '../graph-runner/runner.js';
 import { FENCE_ROLES } from '../hq/hq.js';
 import { dueBefore, type CheckEntry } from './checker.js';
+import { readUnreadCount } from '../msg/msg-store.js';
+import { loopMessageRoute, SEAT_MESSAGE_ROUTES, type LoopReplyBody, type MessageWake } from './msg-address.js';
+import { resolveWake, type WakeDeps, type WakeResolution } from './msg-wake.js';
 
 export interface LoopRun {
   at: string;
@@ -25,6 +28,12 @@ export interface LoopRun {
 }
 export interface LoopEntry {
   id: string;
+  msgAddress?: string | null;
+  replyBody?: LoopReplyBody;
+  wake?: MessageWake;
+  /** Where `wake` came from — `unresolved` is «모름», not a measured absence. */
+  wakeSource?: WakeResolution['source'];
+  unreadCount?: number | null;
   title: string;
   description: string | null;
   owner?: string | null;
@@ -48,6 +57,20 @@ export interface LoopRegistryOptions {
   scheduleAction?: (action: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => Promise<unknown>;
   /** Home used to expand `~`/`$HOME` in cron redirects; tests inject a temp dir instead of writing the real HOME. */
   home?: string;
+  /** Seat wake resolution (pty manifest ⊕ seat folders); tests inject fixed rows. */
+  wakeDeps?: WakeDeps;
+}
+
+function messageFields(id: string, stateRoot: string): { msgAddress: string | null; replyBody: LoopReplyBody; wake: MessageWake; wakeSource?: WakeResolution['source']; unreadCount: number | null } {
+  const route = loopMessageRoute(id);
+  return { ...route, ...(route.msgAddress ? { wakeSource: 'loop-table' as const } : {}), unreadCount: route.msgAddress ? readUnreadCount(route.msgAddress, join(stateRoot, 'msg', 'messages.db')) : null };
+}
+
+/** A seat row is addressed by its seat; its wake path is resolved on this host (pty name → herdr pane → 모름). */
+function seatMessageFields(seat: string, stateRoot: string, wakeDeps?: WakeDeps): { msgAddress: string; replyBody: LoopReplyBody; wake: MessageWake; wakeSource: WakeResolution['source']; unreadCount: number | null } {
+  const wake = resolveWake(seat, wakeDeps);
+  return { msgAddress: seat, replyBody: 'agent', wake: wake.wake, wakeSource: wake.source,
+    unreadCount: readUnreadCount(seat, join(stateRoot, 'msg', 'messages.db')) };
 }
 
 function graphFiles(dir: string): string[] {
@@ -216,7 +239,7 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
     const active = matched.filter(row => !!row.enabled && !!row.cron);
     const next = active.map(row => nextLoopFire(row.cron!, opts.now ?? new Date())).filter((v): v is string => v !== null).sort()[0] ?? null;
     const title = typeof header?.title === 'string' ? header.title : doc.graph_id;
-    const entry: LoopEntry = { id: doc.graph_id, title,
+    const entry: LoopEntry = { id: doc.graph_id, title, ...messageFields(doc.graph_id, stateRoot),
       description: typeof header?.description === 'string' ? header.description : null,
       ...resolveOwner(doc.graph_id, title, config, header?.owner),
       mode: typeof header?.mode === 'string' ? header.mode : null, file: relative(root, file),
@@ -229,6 +252,12 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
 }
 
 export interface AllLoopEntry extends CheckEntry {
+  msgAddress?: string | null;
+  replyBody?: LoopReplyBody;
+  wake?: MessageWake;
+  /** Where `wake` came from — `unresolved` is «모름», not a measured absence. */
+  wakeSource?: WakeResolution['source'];
+  unreadCount?: number | null;
   kind: 'graph' | 'seat' | 'cron-shell' | 'orchestrator' | 'unregistered';
   title: string;
   cron?: string;
@@ -589,6 +618,7 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
     const declaredHost = typeof header.host === 'string' && header.host ? header.host : undefined;
     const declaredCategory = typeof header.observationCategory === 'string' && header.observationCategory ? header.observationCategory : undefined;
     return { kind: 'graph', id: loop.id, title: loop.title, owner: loop.owner ?? undefined, ownerSource: loop.ownerSource,
+      msgAddress: loop.msgAddress, replyBody: loop.replyBody, wake: loop.wake, ...(loop.wakeSource ? { wakeSource: loop.wakeSource } : {}), unreadCount: loop.unreadCount,
       ...(declaredHost || installed.length ? { host: declaredHost ?? hostname() } : {}),
       observationCategory: declaredCategory ?? 'graph.runner',
       ...(fenceRole ? { fenceRole } : {}),
@@ -599,6 +629,7 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
       recentStatuses: runs.map(run => run.status) };
   });
   const namedIds = namedCronIds(rows, claimed);
+  const seatOf = new Map<AllLoopEntry, string>();
   for (const row of rows) {
     if (claimed.has(row.id)) continue;
     const command = row.command ?? '';
@@ -622,7 +653,7 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
     const picked = logMtime && (!recorded || Date.parse(logMtime) >= Date.parse(recorded)) ? 'log-mtime'
       : recorded ? 'registry' : 'none';
     debug.log('loops.registry', 'cron-last-run', { id, targets, picked });
-    all.push({ kind, id, title,
+    const pushed: AllLoopEntry = { kind, id, title,
       ...resolveOwner(id, title, config, undefined, seatArg ?? seat, seatArg ? 'seat-arg' : 'seat'), ...(fenceRole ? { fenceRole } : {}),
       host: hostname(), observationCategory: row.category,
       enabled: !!row.enabled, registered: true,
@@ -632,7 +663,11 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
       ...(picked === 'log-mtime' ? { lastRunAt: logMtime, evidence: picked }
         : picked === 'registry' ? { lastRunAt: recorded, evidence: picked } : {}),
       ...(row.last_status ? { lastStatus: row.last_status } : {}),
-      recentStatuses: row.last_status ? [row.last_status] : [] });
+      recentStatuses: row.last_status ? [row.last_status] : [] };
+    all.push(pushed);
+    const seatName = (seatArg ?? seat)?.toUpperCase();
+    // 선언된 자리 줄만 자리 주소로 공개한다 — 모르는 `--seat FOO` 는 종전처럼 주소 없음.
+    if (kind === 'seat' && seatName && Object.hasOwn(SEAT_MESSAGE_ROUTES, seatName)) seatOf.set(pushed, seatName);
   }
   const warnings = unregisteredCronLoops(all, graphOpts);
   for (const row of warnings) {
@@ -647,7 +682,10 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
   for (const loop of all) bySource[loop.ownerSource!]++;
   debug.log('loop.check', 'ownership', { total: all.length, bySource });
   debug.log('loops.registry', 'list-all', { count: all.length });
-  return all;
+  const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
+  return all.map(entry => entry.kind === 'graph' ? entry
+    : seatOf.has(entry) ? { ...entry, ...seatMessageFields(seatOf.get(entry)!, stateRoot, opts.wakeDeps) }
+      : { ...entry, ...messageFields(entry.id, stateRoot) });
 }
 
 /** An unclaimed cron line with any elanous marker must surface as an unregistered warning. */

package/src/memory.ts

@@ -444,7 +444,12 @@ const INDEX_MAX_LINES = 200;
  */
 export function rebuildIndex(root: string = memoryRoot()): void {
   ensureRoot(root);
-  const entries = listMemories({}, root);
+  writeFileDurable(memoryIndexPath(root), renderMemoryIndex(listMemories({}, root)));
+}
+
+/** The MEMORY.md text for a set of entries — rebuildIndex writes it for the whole store,
+ *  a scoped injection renders it for the entries its filter keeps. */
+export function renderMemoryIndex(entries: readonly MemoryEntry[]): string {
   const byType: Record<MemoryType, MemoryEntry[]> = {
     user: [], feedback: [], project: [], reference: [],
   };
@@ -468,7 +473,7 @@ export function rebuildIndex(root: string = memoryRoot()): void {
     }
     lines.push('');
   }
-  writeFileDurable(memoryIndexPath(root), lines.join('\n'));
+  return lines.join('\n');
 }
 
 /** Read the MEMORY.md index verbatim. Returns '' when missing (e.g.
@@ -512,6 +517,11 @@ export interface InjectOpts {
   minScore?: number;
   /** Always include the MEMORY.md index even if no keyword hits. */
   alwaysIncludeIndex?: boolean;
+  /** Scope filter. When set, only kept entries are injected and the index is rendered from
+   *  them instead of read from MEMORY.md (which lists every entry, other seats' cards included). */
+  filter?: (entry: MemoryEntry) => boolean;
+  /** Inject these bodies like pinned ones (e.g. the current seat's context cards). */
+  alwaysInject?: (entry: MemoryEntry) => boolean;
 }
 
 /** Build the memory-injection block for a user turn. Always prepends
@@ -531,7 +541,9 @@ export function buildMemoryInjection(
   const minScore = opts.minScore ?? 2;
   const alwaysIdx = opts.alwaysIncludeIndex !== false;
 
-  const index = readIndex(root);
+  const filter = opts.filter;
+  const scoped = filter ? listMemories({}, root).filter(m => m.contextCard?.status !== 'retired' && filter(m)) : null;
+  const index = scoped ? (scoped.length > 0 ? renderMemoryIndex(scoped) : '') : readIndex(root);
   if (!index) return { block: '', tokens: 0, injectedIds: [] };
 
   const parts: string[] = [];
@@ -548,7 +560,10 @@ export function buildMemoryInjection(
 
   // 📌 pinned 기억 — 키워드 무관 항상 주입(relevance gate bypass · Letta pinned block /
   //    claude-code MEMORY.md tier 동형). priority 높은 순. core/safety/ref-location 사실용.
-  const pinnedMems = listMemories({}, root).filter(m => m.pinned && m.contextCard?.status !== 'retired').sort((a, b) => b.priority - a.priority);
+  const alwaysInject = opts.alwaysInject;
+  const pinnedMems = (scoped ?? listMemories({}, root))
+    .filter(m => (m.pinned || alwaysInject?.(m) === true) && m.contextCard?.status !== 'retired')
+    .sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
     const chunk = pinnedChunk(e);
@@ -566,7 +581,7 @@ export function buildMemoryInjection(
   const hits = lowContext
     ? []
     : searchMemories(userText, { limit: maxHits + pinnedParts.length }, root)
-        .filter(h => h.score >= minScore && !injected.includes(h.entry.id))
+        .filter(h => h.score >= minScore && !injected.includes(h.entry.id) && (!filter || filter(h.entry)))
         .slice(0, maxHits);
   const bodyParts: string[] = [];
   for (const hit of hits) {