elanous 0.2.8 → 0.2.10

package/src/seat-dispatch/ceo-commands.ts

@@ -0,0 +1,98 @@
+// The owner hands a seat a task from Telegram: /coo /cto /cmo /cxo → one «[대표] → <seat>» line on the coordination PR,
+// one 'ceo-task' message in the seat store, and a «받음» reply. The Telegram entrypoint writes only for the owner in a private chat.
+// Goal: 내부 문서 `ASK-the-ceo-cannot-hand-a-seat-a-task-from-telegram-2026-10-02` (C2 phase 1).
+import { debug } from '../debug/log.js';
+import type { MessageEnvelope } from '../msg/msg-store.js';
+
+export const CEO_SEAT_COMMANDS = { coo: 'OP', cto: 'TC', cmo: 'MK', cxo: 'UX' } as const;
+export type CeoSeatCommand = keyof typeof CEO_SEAT_COMMANDS;
+
+export interface CeoCommandContext { chatId: number | string; userId: number | string }
+
+export interface CeoCommandDeps {
+  /** Telegram user id of the owner (`telegramDecisionOwner`), null when none is configured. */
+  ownerId: string | null;
+  /** `decisions.replyGhPr` — "owner/repo#N". */
+  replyTarget: string | null;
+  runGh: (args: string[], stdin: string) => Promise<number>;
+  append: (message: MessageEnvelope) => unknown;
+  /** Whether the seat inbox already holds a message carrying this request ref (retry after a crash must not deliver twice). */
+  hasMessage?: (seat: string, ref: string) => boolean;
+  now?: () => Date;
+}
+
+function kstStamp(at: Date): string {
+  return new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'short' }).format(at);
+}
+
+export function ceoTaskLine(seat: string, task: string, at: Date): string {
+  return `**[대표]** ${kstStamp(at)} KST → ${seat} · ${task}`;
+}
+
+export async function handleCeoSeatCommand(command: CeoSeatCommand, args: string[], ctx: CeoCommandContext, deps: CeoCommandDeps): Promise<string> {
+  const seat = CEO_SEAT_COMMANDS[command];
+  if (!deps.ownerId || String(ctx.userId) !== deps.ownerId) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'not-owner' });
+    return '소유자만 쓸 수 있습니다.';
+  }
+  // A group would show the task to every member — private chat only (same rule as /decisions).
+  if (String(ctx.chatId) !== String(ctx.userId)) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'not-private' });
+    return '개인 대화에서만 쓸 수 있습니다.';
+  }
+  const task = args.join(' ').replace(/\s+/g, ' ').trim();
+  if (!task) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'empty' });
+    return `사용법: /${command} <할 일>`;
+  }
+  return (await dispatchCeoTask(seat, task, deps)).reply;
+}
+
+export interface CeoTaskExtra {
+  attachments?: Array<{ name: string; path: string }>;
+  /** Paths supplied by callers that do not have attachment names. */
+  attachmentPaths?: readonly string[];
+  via?: 'telegram' | 'discord' | 'pwa';
+  /** Request ref written into the message body; with `deps.hasMessage` it makes delivery idempotent per request. */
+  ref?: string;
+}
+
+export interface CeoTaskResult { reply: string; channel: 'posted' | 'failed' | 'unknown'; channelError?: string }
+
+/** Dispatch an already-authorized seat request; callers must authenticate before invoking this helper. */
+export async function dispatchCeoTask(seat: string, text: string, deps: CeoCommandDeps, extra: CeoTaskExtra = {}): Promise<CeoTaskResult> {
+  const task = text.replace(/\s+/g, ' ').trim();
+  if (!task) {
+    debug.log('seat.dispatch', 'refused', { seat, reason: 'empty' });
+    return { reply: '할 일을 입력해 주세요.', channel: 'unknown' };
+  }
+  const attachments = extra.attachments ?? [];
+  const attachmentPaths = extra.attachmentPaths ?? [];
+  const body = `${task}${attachments.map(({ name, path }) => `\n첨부: ${name} — ${path}`).join('')}${attachmentPaths.length ? `\n\n첨부 파일:\n${attachmentPaths.join('\n')}` : ''}${extra.ref ? `\n요청: ${extra.ref}` : ''}`;
+  if (extra.ref && deps.hasMessage?.(seat, extra.ref)) {
+    // A retry after a crash between delivery and the journal outcome: the message is already there, and whether
+    // the channel line went out is unknown — say so instead of posting it again or claiming it was posted.
+    debug.log('seat.dispatch', 'ceo-task-already-delivered', { seat, via: extra.via });
+    return { reply: `받음 — ${seat} 메시지함에 이미 있습니다.`, channel: 'unknown' };
+  }
+  deps.append({ from: 'CEO', to: seat, body, kind: 'ceo-task' });
+  debug.log('seat.dispatch', 'ceo-task', { seat, ...(extra.via ? { via: extra.via, attachments: attachments.length + attachmentPaths.length } : {}) });
+  const channelError = await postToChannel(seat, task, deps, extra);
+  if (channelError) {
+    debug.log('seat.dispatch', 'channel-failed', { seat, reason: channelError }, { level: 'warn' });
+    return { reply: `받음 — ${seat} 메시지함에는 넣었습니다. 다만 조율 채널에 못 남겼습니다(${channelError}).`, channel: 'failed', channelError };
+  }
+  return { reply: `받음 — ${seat}에 전했습니다.`, channel: 'posted' };
+}
+
+async function postToChannel(seat: string, task: string, deps: CeoCommandDeps, extra: CeoTaskExtra): Promise<string | null> {
+  const target = /^([\w.-]+\/[\w.-]+)#(\d+)$/.exec(deps.replyTarget?.trim() ?? '');
+  if (!target) return deps.replyTarget ? 'decisions.replyGhPr 형식이 owner/repo#N 이 아님' : 'decisions.replyGhPr 미설정';
+  try {
+    const attachmentCount = (extra.attachments?.length ?? 0) + (extra.attachmentPaths?.length ?? 0);
+    const code = await deps.runGh(['pr', 'comment', target[2]!, '--repo', target[1]!, '--body-file', '-'], `${ceoTaskLine(seat, task, deps.now?.() ?? new Date())}${attachmentCount ? ` · 첨부 ${attachmentCount}` : ''}${extra.via === 'pwa' ? ' (PWA)' : ''}`);
+    return code === 0 ? null : `gh 종료 코드 ${code}`;
+  } catch (error) {
+    return error instanceof Error ? error.message.slice(0, 80) : 'gh 실행 실패';
+  }
+}

package/src/seat-dispatch/ceo-intent.ts

@@ -0,0 +1,38 @@
+import { runGh } from '../decisions/decision-cards.js';
+import { openMsgStore } from '../msg/msg-store.js';
+import type { UserConfig } from '../user-config.js';
+import type { CeoCommandDeps } from './ceo-commands.js';
+
+/** Endings are ordered from explicit punctuation to Korean question endings. Every row has a test example. */
+export const CEO_QUESTION_ENDINGS = [
+  /[?？]$/,
+  /야$/,
+  /니$/,
+  /나요$/,
+  /까요$/,
+  /인가요$/,
+  /어때$/,
+  /알려\s?줘$/,
+  /보여줘$/,
+  /상황$/,
+  /어디까지$/,
+] as const;
+
+export function classifyCeoIntent(text: string): 'question' | 'task' {
+  const body = text.trim();
+  return CEO_QUESTION_ENDINGS.some((ending) => ending.test(body)) ? 'question' : 'task';
+}
+
+/** The same channel + seat inbox delivery dependencies used by /coo, /cto, /cmo and /cxo. */
+export function ceoTaskDeps(cfg: UserConfig, ownerId: string | null): CeoCommandDeps {
+  const replyTarget = (cfg.raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+  return {
+    ownerId,
+    replyTarget: typeof replyTarget === 'string' ? replyTarget : null,
+    runGh,
+    append: (message) => {
+      const store = openMsgStore();
+      try { return store.append(message); } finally { store.close(); }
+    },
+  };
+}

package/src/seat-loop/seat-loop.ts

@@ -0,0 +1,231 @@
+import { execFile } from 'node:child_process';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { Database } from 'bun:sqlite';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { TRACK_AGENT_FORBIDDEN_ACTION_REGEX, universeLaunch } from '../autopilot/track-agent.js';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
+import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
+import { listChecklist } from '../release-loop/checklist.js';
+import { readSchedules } from '../release-loop/feature-store.js';
+
+// `kind`/`createdAt` are the V3 shadow-compare keys (내부 문서 `METHOD-v3-shadow-compare-2026-10-02` · MK 10-02 18:54).
+export type SeatItem = { source: 'request' | 'checklist'; kind?: 'request' | 'cell'; id: string; title: string; text: string; version?: string; queuedAt?: string; createdAt?: string };
+export type SeatInputs = { requests: SeatItem[]; checklist: SeatItem[]; role: string };
+// V3 ledger row: `ts` · `item.id` · `item.kind` · `item.createdAt` · `action` (door or skipped-*) · `reason` (forbidden word for a decision).
+export type SeatAction = 'decision' | 'harness' | 'skipped-budget' | 'skipped-empty';
+export type SeatEntry = { seat: string; ts?: string; at: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'launched' | 'hitl' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; action?: SeatAction; reason?: string; runId?: string };
+export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off' };
+export type SeatDeps = {
+  root?: string;
+  repo?: string;
+  config?: SeatLoopConfig;
+  now?: () => Date;
+  read?: (path: string) => string;
+  run?: (args: string[]) => Promise<string>;
+  append?: (path: string, entry: SeatEntry) => void;
+  versions?: () => string[];
+  /** Checklist items of one version — default reads the release ledger DB (checklist.json is only a legacy import source since REL5b). */
+  checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null }>;
+  ledgerFiles?: (directory: string) => string[];
+  lockContended?: () => void;
+};
+
+const repoRoot = resolve(import.meta.dir, '../..');
+const exec = promisify(execFile);
+const defaultRead = (path: string): string => {
+  try { return readFileSync(path, 'utf8'); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return ''; throw error; }
+};
+const defaultRun = async (args: string[]): Promise<string> => {
+  const { argv, env } = universeLaunch(args);
+  const { stdout } = await exec('bun', argv, {
+    cwd: repoRoot, env, encoding: 'utf8',
+    timeout: args[0] === 'harness' && args[1] === 'say' ? 3_600_000 : 120_000, maxBuffer: 4 * 1024 * 1024,
+  });
+  return stdout;
+};
+const defaultAppend = (path: string, entry: SeatEntry): void => {
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+};
+const observe = (event: string, data: Record<string, unknown>): void => {
+  try { debug.log('seat.loop', event, data); } catch { /* logging cannot change execution */ }
+};
+
+// SQLite's OS lock survives the awaited external call and is released if the process exits.
+async function withSeatLock<T>(directory: string, action: () => Promise<T>, contended?: () => void): Promise<T> {
+  mkdirSync(directory, { recursive: true });
+  const path = join(directory, '.once.mutex.sqlite');
+  const db = new Database(path, { create: true, strict: true });
+  try {
+    chmodSync(path, 0o600);
+    const deadline = Date.now() + 120_000;
+    let signalled = false;
+    while (true) {
+      try { db.exec('BEGIN IMMEDIATE'); break; }
+      catch (error) {
+        if ((error as { code?: string }).code !== 'SQLITE_BUSY' || Date.now() >= deadline) throw error;
+        if (!signalled) { contended?.(); signalled = true; }
+        await new Promise((done) => setTimeout(done, 25));
+      }
+    }
+    try { return await action(); }
+    finally { db.exec('ROLLBACK'); }
+  } finally { db.close(); }
+}
+
+export function seatDay(now: Date): string {
+  return new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(now);
+}
+
+export function seatLedgerPath(seat: string, root: string, now: Date): string {
+  return join(root, 'seat-loop', seat, `${seatDay(now)}.jsonl`);
+}
+
+function rows(text: string): Record<string, unknown>[] {
+  return text.split('\n').filter(Boolean).map((line) => JSON.parse(line) as Record<string, unknown>);
+}
+
+function versionOrder(a: string, b: string): number {
+  const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
+  return (aa[0]! - bb[0]!) || (aa[1]! - bb[1]!) || (aa[2]! - bb[2]!);
+}
+
+export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}): Promise<SeatInputs> {
+  const read = deps.read ?? defaultRead;
+  const root = deps.root ?? effectiveInstanceRoot();
+  const requests = new Map<string, Record<string, unknown>>();
+  for (const row of rows(read(join(root, 'seat-requests', 'requests.jsonl')))) {
+    if (typeof row.key === 'string') requests.set(row.key, row);
+  }
+  const pending = [...requests.values()]
+    .filter((row) => row.seat === seat && (row.status === 'pending' || row.status === 'queued') && typeof row.text === 'string')
+    .map((row) => ({ source: 'request' as const, kind: 'request' as const, id: String(row.key), title: String(row.text), text: String(row.text), queuedAt: String(row.queuedAt ?? ''), createdAt: String(row.queuedAt ?? '') }))
+    .sort((a, b) => a.queuedAt.localeCompare(b.queuedAt) || a.id.localeCompare(b.id));
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  const versions = deps.versions ?? (() => {
+    const dir = join(releaseRoot, 'release');
+    const fromDirs = existsSync(dir) ? readdirSync(dir).filter((v) => /^\d+\.\d+\.\d+$/.test(v)) : [];
+    let fromSchedule: string[] = [];
+    try { fromSchedule = readSchedules().map((row) => row.version); } catch { /* ledger unreadable — directories only */ }
+    return [...new Set([...fromDirs, ...fromSchedule])].filter((v) => /^\d+\.\d+\.\d+$/.test(v));
+  });
+  const itemsOf = deps.checklistItems ?? ((version: string) => listChecklist(version).items);
+  const checklist: SeatItem[] = [];
+  for (const version of versions().sort(versionOrder)) {
+    let items: ReturnType<typeof itemsOf>;
+    try { items = itemsOf(version); } catch (error) {
+      debug.log('seat.loop', 'checklist-unreadable', { seat, version, error: String(error).slice(0, 200) });
+      continue;
+    }
+    for (const item of items) {
+      if (item.owner === seat && (item.status === 'yellow' || item.status === 'red')) {
+        checklist.push({ source: 'checklist', kind: 'cell', version, id: item.id, title: item.title, text: item.title });
+      }
+    }
+  }
+  checklist.sort((a, b) => versionOrder(a.version!, b.version!) || a.id.localeCompare(b.id));
+  return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
+}
+
+function itemKey(item: SeatItem): string { return `${item.source}:${item.version ?? ''}:${item.id}`; }
+
+// In shadow mode a shadowed item counts as handled, so a rehearsal day walks the queue like the seat would.
+export function pickNext(inputs: SeatInputs, ledger: readonly SeatEntry[], opts: { shadow?: boolean } = {}): SeatItem | null {
+  const handled = new Set(ledger.filter((entry) => entry.status === 'launched' || entry.status === 'hitl' || entry.status === 'attempting' || entry.status === 'outcome-unknown' || (opts.shadow === true && entry.status === 'shadow'))
+    .filter((entry): entry is SeatEntry & { item: SeatItem } => !!entry.item && !!entry.item.source && typeof entry.item.id === 'string').map((entry) => itemKey(entry.item)));
+  return [...inputs.requests, ...inputs.checklist].find((item) => !handled.has(itemKey(item))) ?? null;
+}
+
+export function planAction(item: SeatItem, seat?: string): { kind: 'decision' | 'harness'; text: string; reason?: string } {
+  const hit = `${item.id}\n${item.title}\n${item.text}`.match(TRACK_AGENT_FORBIDDEN_ACTION_REGEX);
+  const kind = hit ? 'decision' : 'harness';
+  return { kind, text: seat && kind === 'harness' ? seatTaskText(seat, item) : `${item.id} ${item.title}`, ...(hit ? { reason: hit[0] } : {}) };
+}
+
+// The launched sentence names the seat, the source and the release so same-named items stay distinct.
+export function seatTaskText(seat: string, item: SeatItem): string {
+  const where = item.source === 'checklist' ? `${item.version ?? '?'} 체크리스트 칸 ${item.id}` : `자리 요청 ${item.id}`;
+  return `[${seat} 자리 · ${where} · 역할 docs/roles/${seat}.md] ${item.title.replace(/[\r\n]+/g, ' ')}`;
+}
+
+export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promise<SeatLoopResult> {
+  if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
+  const config = deps.config ?? getUserConfig().loops?.seat ?? { mode: 'off' };
+  if (config.mode === 'off' || !(config.seats ?? ['MK']).includes(seat)) {
+    observe('skipped-off', { seat });
+    return { seat, status: 'skipped-off' };
+  }
+  const now = (deps.now ?? (() => new Date()))();
+  const path = seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now);
+  const directory = dirname(path);
+  return withSeatLock(directory, async () => {
+  const files = deps.ledgerFiles?.(directory) ?? (existsSync(directory) ? readdirSync(directory) : []);
+  const ledger = files.filter((name) => /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name <= `${seatDay(now)}.jsonl`)
+    .flatMap((name) => rows((deps.read ?? defaultRead)(join(directory, name))) as SeatEntry[]);
+  const inputs = await gatherSeatInputs(seat, deps);
+  const item = pickNext(inputs, ledger, { shadow: config.mode === 'shadow' });
+  if (item) observe('picked', { seat, item, date: seatDay(now) });
+  const planned = item ? planAction(item, seat) : undefined;
+  const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: item ? 'shadow' : 'skipped-empty',
+    ...(item ? { item, action: planned!.kind, ...(planned!.reason ? { reason: planned!.reason } : {}) } : { action: 'skipped-empty' as const }) };
+  const append = deps.append ?? defaultAppend;
+  if (config.mode === 'shadow' || !item) {
+    append(path, entry);
+    if (config.mode === 'shadow') observe('shadow', { seat, item, status: entry.status });
+    return entry;
+  }
+  const run = deps.run ?? defaultRun;
+  let outcome: string | undefined;
+  try { outcome = (JSON.parse(await run(['harness', 'budget', '--json'])) as { outcome?: string }).outcome; }
+  catch { /* failed budget observation is never permission to launch */ }
+  if (outcome !== 'proceed' && outcome !== 'next-provider') {
+    entry.status = 'skipped-budget';
+    entry.action = 'skipped-budget';
+    delete entry.reason;
+    append(path, entry);
+    observe('skipped-budget', { seat, item, outcome: outcome ?? 'unavailable' });
+    return entry;
+  }
+  const action = planned!;
+  // Persist the intent before crossing the process boundary: an unreturned call may already have acted.
+  append(path, { ...entry, status: 'attempting' });
+  try {
+    if (action.kind === 'decision') {
+      const title = `${seat}: ${action.text.replace(/[\r\n]+/g, ' ')}`;
+      const raised = await run(['decisions', 'raise', '--title', title, '--category', 'other',
+        '--s', `${seat} 배정 항목: ${action.text.replace(/[\r\n]+/g, ' ')}\n역할: ${inputs.role}`, '--c', '자동 실행 금지 문면에 해당하여 사람 결정이 필요하다',
+        '--option', 'a=사람 승인:승인 후 별도로 집행', '--option', 'b=보류:집행하지 않음',
+        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--agent', 'seat-loop', '--json']);
+      const decision: unknown = JSON.parse(raised.trim());
+      if (!decision || typeof decision !== 'object' || typeof (decision as { id?: unknown }).id !== 'string') {
+        throw new Error('decisions raise returned no decision id');
+      }
+      entry.status = 'hitl';
+      append(path, entry);
+      observe('hitl', { seat, item });
+      return entry;
+    }
+    const output = await run(['harness', 'say', action.text, '--substrate', 'pod', '--pod-pool', config.podPool ?? 'pool-node-b@node-b:8', '--base', 'main', '--json']);
+    const results: unknown = JSON.parse(output.trim());
+    if (!Array.isArray(results) || results.length === 0 || results.some((result) =>
+      !result || typeof result !== 'object' || (result as { status?: unknown }).status !== 'done')) {
+      throw new Error('harness say did not complete successfully');
+    }
+    const runId = (results[0] as { runId?: unknown }).runId;
+    if (typeof runId !== 'string' || !/^run-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(runId)) {
+      throw new Error('harness say output has no runId');
+    }
+    entry.status = 'launched';
+    entry.runId = runId;
+    append(path, entry);
+    observe('launched', { seat, item, runId });
+    return entry;
+  } catch (error) {
+    append(path, { ...entry, status: 'outcome-unknown' });
+    throw error;
+  }
+  }, deps.lockContended);
+}

package/src/seat-loop/seat-report.ts

@@ -0,0 +1,64 @@
+import { execFile } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
+import { seatDay, seatLedgerPath, type SeatEntry } from './seat-loop.js';
+
+export type SeatReportDeps = {
+  root?: string;
+  repo?: string;
+  now?: () => Date;
+  read?: (path: string) => string;
+  config?: SeatLoopConfig;
+  post?: boolean;
+  send?: (body: string, seat: string, pr: number) => Promise<void> | void;
+};
+export type SeatReportResult = { seat: string; date: string; body: string; posted: boolean };
+const repoRoot = resolve(import.meta.dir, '../..');
+const exec = promisify(execFile);
+
+async function defaultSend(body: string, seat: string, pr: number, repo: string): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), 'seat-report-'));
+  try {
+    const file = join(dir, 'body.md');
+    writeFileSync(file, body);
+    await exec('bash', [join(repo, 'scripts', 'coord-post.sh'), file], {
+      cwd: repo, env: { ...process.env, COORD_ID: seat, CH_PR: String(pr) }, timeout: 30_000,
+    });
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promise<SeatReportResult> {
+  if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
+  const now = (deps.now ?? (() => new Date()))();
+  const date = seatDay(now);
+  let raw = '';
+  try { raw = (deps.read ?? ((path) => readFileSync(path, 'utf8')))(seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now)); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  const entries = raw.split('\n').filter(Boolean).map((line) => JSON.parse(line) as SeatEntry);
+  // One line per item, its last state wins: an `attempting` row followed by `launched` is not «unconfirmed».
+  const latest = new Map<string, SeatEntry>();
+  for (const entry of entries) {
+    const key = entry.item ? `${entry.item.source}:${entry.item.version ?? ''}:${entry.item.id}` : `none:${entry.status}`;
+    latest.delete(key);
+    latest.set(key, entry);
+  }
+  const detail = [...latest.values()].map((entry) => {
+    const label = entry.item ? `${entry.item.version ? `${entry.item.version} ` : ''}${entry.item.id} ${entry.item.title}`.replace(/\s+/g, ' ').trim() : '배정 없음';
+    if (entry.status === 'launched') return `발사 ${label} (${entry.runId ?? 'runId 없음'})`;
+    if (entry.status === 'hitl') return `결정 상정 ${label}`;
+    if (entry.status === 'shadow') return `shadow ${label}`;
+    if (entry.status === 'attempting' || entry.status === 'outcome-unknown') return `결과 확인 필요 ${entry.status} ${label}`;
+    return `건너뜀 ${entry.status} ${label}`;
+  });
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || '원장 기록 없음'}`;
+  const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
+  const posted = deps.post === true && pr !== undefined;
+  if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);
+  try { debug.log('seat.loop', 'reported', { seat, date, entries: entries.length, posted }); } catch { /* observation is fail-soft */ }
+  return { seat, date, body, posted };
+}

package/src/self-dev/decompose.ts

@@ -156,6 +156,8 @@ interface SelfDevSubtaskGradeRationale {
 }
 
 export interface SelfDevDecompositionObservation extends SelfDevDecompositionMeta {
+  /** Number of registration-only goals folded into their dependency. */
+  foldedRegistration: number;
   /** Number of retained subtasks whose original feature text grades `too_large`. */
   tooLargeSubtaskCount: number;
   /** Number of retained subtasks whose original feature text grades `too_small`. */
@@ -250,7 +252,7 @@ function observeDecomposerSelection(selection: SelfDevDecomposerSelection, obser
 }
 
 function applyGoalDefaultsAndHotPaths(goals: SelfDevGoal[], defaults: { base?: string; autoMerge?: boolean }): SelfDevGoal[] {
-  return pruneDanglingDependencies(goals.map((goal) => {
+  return goals.map((goal) => {
     const hotPaths = [...new Set([...(goal.hotPaths ?? []), ...inferHotPaths(goal.feature ?? '')])];
     return {
       ...goal,
@@ -258,7 +260,55 @@ function applyGoalDefaultsAndHotPaths(goals: SelfDevGoal[], defaults: { base?: s
       ...(defaults.base !== undefined ? { base: defaults.base } : {}),
       ...(defaults.autoMerge !== undefined ? { autoMerge: defaults.autoMerge } : {}),
     };
-  }));
+  });
+}
+
+const REGISTRATION_FILES = new Set([
+  'src/nexus/api/http-server.ts',
+  'src/index.ts',
+  'src/telegram-commands.ts',
+]);
+
+function isRegistrationFile(path: string): boolean {
+  return REGISTRATION_FILES.has(path) || /^graphs\/(?:[^/]+\/)*[^/]+\.yaml$/.test(path);
+}
+
+/** Fold only registration-only goals into their one retained dependency. */
+export function foldRegistrationOnlyGoals(goals: SelfDevGoal[]): SelfDevGoal[] {
+  let remaining = [...goals];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const registration of remaining) {
+      const files = registration.hotPaths ?? [];
+      if (files.length === 0 || !files.every(isRegistrationFile) || registration.dependsOn?.length !== 1) continue;
+      const dependencyId = registration.dependsOn[0];
+      const targetIndex = remaining.findIndex((goal) => goal.id === dependencyId && goal !== registration);
+      if (targetIndex < 0) continue;
+      const target = remaining[targetIndex]!;
+      remaining = remaining.filter((goal) => goal !== registration).map((goal) => {
+        if (goal === target) {
+          const dependsOn = goal.dependsOn?.filter((id) => id !== registration.id && id !== goal.id);
+          const { dependsOn: _old, ...rest } = goal;
+          return {
+            ...rest,
+            ...(dependsOn?.length ? { dependsOn } : {}),
+            feature: `${goal.feature}\nAlso register: ${registration.feature}`,
+            hotPaths: [...new Set([...(goal.hotPaths ?? []), ...files])],
+          };
+        }
+        if (!goal.dependsOn?.includes(registration.id!)) return goal;
+        const dependsOn = [...new Set(goal.dependsOn.map((id) => id === registration.id ? target.id! : id))]
+          .filter((id) => id !== goal.id);
+        const { dependsOn: _old, ...rest } = goal;
+        return dependsOn.length ? { ...rest, dependsOn } : rest;
+      });
+      debug.log('self-dev.decompose', 'fold-registration', { from: registration.id, into: target.id, files });
+      changed = true;
+      break;
+    }
+  }
+  return remaining;
 }
 
 function observeDecomposition(
@@ -267,12 +317,14 @@ function observeDecomposition(
   arcClassification?: { arcs: SelfDevArc[]; hintDeviation?: { requested: number; actual: number } },
   observationContext: SelfDevDecompositionObservationContext = {},
   pathGroundingOptions?: DecomposePathGroundingOptions,
+  foldedRegistration = 0,
 ): SelfDevDecomposition {
   const retainedSubtasks = decomposition.outcome === 'decomposed' ? goals : [];
   const gradedSubtasks = retainedSubtasks.map(gradeRetainedSubtask);
   const tooLargeSubtaskCount = gradedSubtasks.filter(({ grade }) => grade.verdict === 'too_large').length;
   const observation: SelfDevDecompositionObservation & { goalId: string | null; runId: string | null } = {
     ...decomposition,
+    foldedRegistration,
     tooLargeSubtaskCount,
     tooSmallSubtaskCount: gradedSubtasks.filter(({ grade }) => grade.verdict === 'too_small').length,
     hasMultipleTooLargeSubtasks: tooLargeSubtaskCount >= 2,
@@ -467,14 +519,15 @@ async function finalizeDecomposition(
   decomposition: SelfDevDecompositionMeta,
   opts: SelfDevDecomposeOptions,
   arcHint: number | undefined,
+  foldedRegistration = 0,
 ): Promise<SelfDevDecomposition> {
-  if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+  if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   try {
     const arcLlm = opts.arcLlm ?? opts.llm ?? (await defaultDecomposeLlm(opts.model));
     const tasks = goals.map((goal) => ({ id: goal.id ?? '', title: goal.feature ?? '', description: goal.feature, dependsOn: goal.dependsOn }));
     const grouping = parseSelfDevArcGrouping(await arcLlm(buildSelfDevArcClassifyPrompt(feature, tasks, arcHint)));
     const classification = grouping ? deriveSelfDevArcsFromGrouping(tasks, grouping, arcHint) : null;
-    if (!classification) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+    if (!classification) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
     const arcByTask = new Map(classification.arcs.flatMap((arc) => arc.taskIds.map((taskId) => [taskId, arc])));
     const taskIdsForArc = new Map(classification.arcs.map((arc) => [arc.id, arc.taskIds]));
     const orderedGoals = goals.map((goal) => {
@@ -482,9 +535,9 @@ async function finalizeDecomposition(
       const dependsOn = [...new Set([...(goal.dependsOn ?? []), ...arcDependencies])].filter((id) => id !== goal.id);
       return dependsOn.length ? { ...goal, dependsOn } : goal;
     });
-    return observeDecomposition(pruneDanglingDependencies(orderedGoals), decomposition, classification, opts.observation, opts.pathGrounding);
+    return observeDecomposition(pruneDanglingDependencies(orderedGoals), decomposition, classification, opts.observation, opts.pathGrounding, foldedRegistration);
   } catch {
-    return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+    return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   }
 }
 
@@ -514,17 +567,18 @@ export async function decomposeSelfDevGoal(
     }
     observeDecomposerSelection('fabric', opts.observation);
     const actualTaskCount = result.goals.length;
-    const goals = actualTaskCount > 0
+    const prepared = actualTaskCount > 0
       ? applyGoalDefaultsAndHotPaths(result.goals.slice(0, hardMaxTasks), defaults)
       : [single];
-    return finalizeDecomposition(feature, goals, {
+    const goals = foldRegistrationOnlyGoals(prepared);
+    return finalizeDecomposition(feature, pruneDanglingDependencies(goals), {
       recommendedMaxTasks: maxTasks,
       actualTaskCount,
       truncatedAtHardMax: actualTaskCount > hardMaxTasks,
       exceededRecommendedMax: actualTaskCount > maxTasks,
       outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed',
       omittedGoalCount: result.omittedGoalCount,
-    }, opts, actualTaskCount > 0 ? arcHint : undefined);
+    }, opts, actualTaskCount > 0 ? arcHint : undefined, prepared.length - goals.length);
   }
 
   observeDecomposerSelection('default', opts.observation);
@@ -539,8 +593,9 @@ export async function decomposeSelfDevGoal(
   const actualTaskCount = rawSubtasks.length;
   const decomposition: SelfDevDecompositionMeta = { recommendedMaxTasks: maxTasks, actualTaskCount, truncatedAtHardMax: actualTaskCount > hardMaxTasks, exceededRecommendedMax: actualTaskCount > maxTasks, outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed' };
   const parsedGoals = parseSelfDevDecomposition(JSON.stringify({ subtasks: rawSubtasks.slice(0, hardMaxTasks) }), defaults);
-  const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(parsedGoals) : [single];
-  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined);
+  const foldedGoals = foldRegistrationOnlyGoals(parsedGoals);
+  const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(foldedGoals) : [single];
+  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
 /** Default LLM seam — lazy `streamLLM` wire (kept out of the test path). */

package/src/self-dev/run-store.ts

@@ -111,6 +111,8 @@ function runPath(runId: string, dir: string): string {
   return path;
 }
 
+const loggedAbsentCheckpoints = new Set<string>();
+
 function loadSelfDevRunFromPath(path: string): SelfDevRunState | null {
   const runId = path.slice(path.lastIndexOf(sep) + 1, -'.json'.length);
   try {
@@ -118,7 +120,14 @@ function loadSelfDevRunFromPath(path: string): SelfDevRunState | null {
     if (o && typeof o.runId === 'string' && Array.isArray(o.results)) return o;
     try { debug.log('self-dev.run-store', 'read-failed', { runId, reason: 'invalid checkpoint shape' }); } catch { /* preserve fail-soft reads */ }
   } catch (error) {
-    try { debug.log('self-dev.run-store', 'read-failed', { runId, reason: String(error) }); } catch { /* preserve fail-soft reads */ }
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if (!loggedAbsentCheckpoints.has(runId)) {
+        loggedAbsentCheckpoints.add(runId);
+        try { debug.log('self-dev.run-store', 'checkpoint-absent', { runId }); } catch { /* preserve fail-soft reads */ }
+      }
+    } else {
+      try { debug.log('self-dev.run-store', 'read-failed', { runId, reason: String(error) }); } catch { /* preserve fail-soft reads */ }
+    }
   }
   return null;
 }