elanous 0.2.9 → 0.2.10

package/src/release-loop/feature-store.ts

@@ -1,5 +1,5 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { dirname, join } from 'node:path';
 import { Database } from 'bun:sqlite';
 import { releaseLedgerRoot } from '../instance/resolve.js';
@@ -17,8 +17,8 @@ function legacyVersions(): string[] {
   if (!existsSync(root)) return [];
   return readdirSync(root).filter((version) => /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(version) && existsSync(jsonPath(version)));
 }
-export function releasedVersion(): string {
-  const root = join(releaseLedgerRoot(), 'release');
+export function releasedVersion(ledgerRoot = releaseLedgerRoot()): string {
+  const root = join(ledgerRoot, 'release');
   if (!existsSync(root)) return '';
   return readdirSync(root).filter((version) => /^\d+\.\d+\.\d+$/.test(version) && existsSync(join(root, version, 'release.json')))
     .filter((version) => {
@@ -30,8 +30,8 @@ export function releasedVersion(): string {
     })[0] ?? '';
 }
 const walWait = new Int32Array(new SharedArrayBuffer(4));
-function open(): Database {
-  const path = join(releaseLedgerRoot(), 'release', 'features.sqlite');
+function open(root = releaseLedgerRoot()): Database {
+  const path = join(root, 'release', 'features.sqlite');
   mkdirSync(dirname(path), { recursive: true });
   const db = new Database(path, { create: true, strict: true });
   try {
@@ -52,11 +52,61 @@ function open(): Database {
     CREATE TABLE IF NOT EXISTS assignments (feature_id TEXT NOT NULL REFERENCES features(id), version TEXT NOT NULL, status TEXT NOT NULL, disposition TEXT, evidence TEXT, title_override TEXT, owner TEXT, kind TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL, PRIMARY KEY(feature_id, version));
     CREATE TABLE IF NOT EXISTS events (seq INTEGER PRIMARY KEY AUTOINCREMENT, at TEXT NOT NULL, by TEXT NOT NULL, feature_id TEXT NOT NULL, version TEXT NOT NULL, field TEXT NOT NULL, "from" TEXT, "to" TEXT, released TEXT NOT NULL, dev TEXT NOT NULL);
     CREATE TABLE IF NOT EXISTS evidence (feature_id TEXT NOT NULL, version TEXT NOT NULL, ref TEXT NOT NULL, at TEXT NOT NULL, by TEXT NOT NULL);
-    CREATE TABLE IF NOT EXISTS imported_versions (version TEXT PRIMARY KEY);`);
+    CREATE TABLE IF NOT EXISTS imported_versions (version TEXT PRIMARY KEY, json_hash TEXT, imported_at TEXT);`);
+    const columns = db.query('PRAGMA table_info(imported_versions)').all() as Array<{ name: string }>;
+    if (!columns.some((column) => column.name === 'json_hash')) db.exec('ALTER TABLE imported_versions ADD COLUMN json_hash TEXT');
+    if (!columns.some((column) => column.name === 'imported_at')) db.exec('ALTER TABLE imported_versions ADD COLUMN imported_at TEXT');
+    db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
     return db;
   } catch (error) { db.close(); throw error; }
 }
 
+export interface ScheduleRow { version: string; cutAt: string; landBy: string | null; updatedAt: string; updatedBy: string }
+type StoredSchedule = { version: string; cut_at: string; land_by: string | null; updated_at: string; updated_by: string };
+function scheduleRow(row: StoredSchedule): ScheduleRow {
+  return { version: row.version, cutAt: row.cut_at, landBy: row.land_by, updatedAt: row.updated_at, updatedBy: row.updated_by };
+}
+
+export function readSchedule(version: string, root?: string): ScheduleRow | null {
+  validateVersion(version);
+  if (!existsSync(join(root ?? releaseLedgerRoot(), 'release', 'features.sqlite'))) return null;
+  const db = open(root);
+  try {
+    const row = db.query('SELECT * FROM release_schedules WHERE version = ?').get(version) as StoredSchedule | null;
+    return row ? scheduleRow(row) : null;
+  } finally { db.close(); }
+}
+
+export function readSchedules(root?: string): ScheduleRow[] {
+  const db = open(root);
+  try { return (db.query('SELECT * FROM release_schedules ORDER BY version').all() as StoredSchedule[]).map(scheduleRow); }
+  finally { db.close(); }
+}
+
+export function writeSchedule(version: string, patch: { cutAt?: string; landBy?: string }, by: string, root?: string): ScheduleRow {
+  validateVersion(version);
+  const db = open(root);
+  try {
+    return transaction(db, () => {
+      const previous = db.query('SELECT * FROM release_schedules WHERE version = ?').get(version) as StoredSchedule | null;
+      const cutAt = patch.cutAt ?? previous?.cut_at;
+      if (!cutAt) throw new CliUserError('새 판에는 --cut-at 이 필요하다');
+      const landBy = patch.landBy ?? previous?.land_by ?? null;
+      if (previous && previous.cut_at === cutAt && previous.land_by === landBy) return scheduleRow(previous);
+      const at = new Date().toISOString();
+      db.query(`INSERT INTO release_schedules (version, cut_at, land_by, updated_at, updated_by) VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(version) DO UPDATE SET cut_at=excluded.cut_at, land_by=excluded.land_by, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+        .run(version, cutAt, landBy, at, by);
+      for (const [field, from, to] of [
+        ['cut_at', previous?.cut_at ?? null, cutAt], ['land_by', previous?.land_by ?? null, landBy],
+      ] as const) {
+        if (from !== to) record(db, version, { at, by, id: '@version', field, from, to, released: releasedVersion(root), dev: devVersion() });
+      }
+      return { version, cutAt, landBy, updatedAt: at, updatedBy: by };
+    });
+  } finally { db.close(); }
+}
+
 function transaction<T>(db: Database, work: () => T): T {
   db.exec('BEGIN IMMEDIATE');
   try { const result = work(); db.exec('COMMIT'); return result; }
@@ -105,14 +155,32 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
     ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
     .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.updatedAt, item.updatedBy);
 }
+function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
+
+/**
+ * When did the ledger take this item away from `version`? A `move` out of it, a `remove` at it, or (carry-forward
+ * without a move event) the item now living in another version. null = never left — a JSON-only item is new.
+ * OP 10-02: without this, an old build's checklist.json re-added items the ledger had moved or removed (duplicates).
+ */
+function ledgerLeftAt(db: Database, id: string, version: string): string | null {
+  const event = db.query(`SELECT MAX(at) AS at FROM events WHERE feature_id = ? AND
+    ((field = 'move' AND "from" = ?) OR (field = 'remove' AND version = ?))`).get(id, JSON.stringify(version), version) as { at: string | null };
+  const elsewhere = db.query('SELECT MAX(updated_at) AS at FROM assignments WHERE feature_id = ? AND version <> ?').get(id, version) as { at: string | null };
+  const times = [event.at, elsewhere.at].filter((t): t is string => typeof t === 'string');
+  return times.length ? times.sort().at(-1)! : null;
+}
+
 function importOnDb(db: Database, version: string): boolean {
-  if (db.query('SELECT 1 FROM imported_versions WHERE version = ?').get(version)) return false;
+  const previous = db.query('SELECT json_hash FROM imported_versions WHERE version = ?').get(version) as { json_hash: string | null } | null;
   const path = jsonPath(version);
   if (!existsSync(path)) {
-    db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
+    if (!previous) db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
     return false;
   }
-  const data = JSON.parse(readFileSync(path, 'utf8')) as Checklist;
+  const contents = readFileSync(path);
+  const hash = jsonHash(contents);
+  if (previous && previous.json_hash === hash) return false;
+  const data = JSON.parse(contents.toString('utf8')) as Checklist;
   if (data.version !== version) throw new CliUserError(`체크리스트 판 불일치: ${path}`);
   if (!Array.isArray(data.items) || !Array.isArray(data.history)) throw new CliUserError(`잘못된 체크리스트: ${path}`);
   const duplicate = new Set<string>();
@@ -120,25 +188,83 @@ function importOnDb(db: Database, version: string): boolean {
     if (!item.id?.trim() || !item.title?.trim() || duplicate.has(item.id) || !['green', 'yellow', 'red', 'done'].includes(item.status)) throw new CliUserError(`잘못된 체크리스트 칸: ${version} ${item.id}`);
     duplicate.add(item.id);
   }
+  if (!previous) {
+    for (const item of data.items) {
+      const existing = db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string } | null;
+      // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
+      if (!existing) putItem(db, version, item);
+      else {
+        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.updatedAt, item.updatedBy);
+      }
+    }
+    for (const entry of data.history) record(db, version, entry);
+    db.query('INSERT INTO imported_versions (version, json_hash, imported_at) VALUES (?, ?, ?)').run(version, hash, new Date().toISOString());
+    return true;
+  }
+
+  const ledger = new Map(items(db, version).map((item) => [item.id, item]));
+  const changed: string[] = [];
+  let added = 0;
+  const ledgerWonIds: string[] = [];
+  const leftIds: string[] = [];
   for (const item of data.items) {
-    const existing = db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string } | null;
-    // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
-    if (!existing) putItem(db, version, item);
-    else {
-      db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-        .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.updatedAt, item.updatedBy);
+    const current = ledger.get(item.id);
+    if (!current) {
+      // Moved or removed in the ledger: only a JSON edit made after that may bring it back.
+      const leftAt = ledgerLeftAt(db, item.id, version);
+      if (leftAt && !(Date.parse(item.updatedAt) > Date.parse(leftAt))) { leftIds.push(item.id); continue; }
+      const feature = db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string } | null;
+      putItem(db, version, item);
+      if (feature && feature.title !== item.title) db.query('UPDATE assignments SET title_override = ? WHERE feature_id = ? AND version = ?').run(item.title, item.id, version);
+      added++;
+      changed.push(item.id);
+      record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
+      continue;
+    }
+    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind'] as const;
+    const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
+    const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
+    const differs = fields.some((field) => field === 'evidence'
+      ? (!preserveRefs && current.evidence !== item.evidence)
+      : current[field] !== item[field]);
+    if (!differs) continue;
+    if (!(Date.parse(item.updatedAt) > Date.parse(current.updatedAt))) {
+      ledgerWonIds.push(item.id);
+      continue;
+    }
+    const incoming: ChecklistItem = { ...current, status: item.status, updatedAt: item.updatedAt, updatedBy: item.updatedBy };
+    for (const field of fields) {
+      if (field === 'status') continue;
+      if (field === 'evidence' && preserveRefs) continue;
+      if (item[field] === undefined) delete (incoming as unknown as Record<string, unknown>)[field];
+      else (incoming as unknown as Record<string, unknown>)[field] = item[field];
+    }
+    if (!preserveRefs) db.query('DELETE FROM evidence WHERE feature_id = ? AND version = ?').run(item.id, version);
+    const persisted = preserveRefs ? { ...incoming, evidence: baseEvidence } : incoming;
+    putItem(db, version, persisted);
+    if (incoming.title !== current.title) {
+      db.query('UPDATE assignments SET title_override = ? WHERE feature_id = ? AND version = ?')
+        .run(incoming.title === (db.query('SELECT title FROM features WHERE id = ?').get(item.id) as { title: string }).title ? null : incoming.title, item.id, version);
     }
+    changed.push(item.id);
+    record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: current, to: incoming, released: data.released, dev: data.dev });
   }
-  for (const entry of data.history) record(db, version, entry);
-  db.query('INSERT INTO imported_versions (version) VALUES (?)').run(version);
-  return true;
+  db.query('UPDATE imported_versions SET json_hash = ?, imported_at = ? WHERE version = ?').run(hash, new Date().toISOString(), version);
+  const ledgerWon = ledgerWonIds.length;
+  debug.log('release.features', 'reimported', { version, changed: changed.length - added, added, ledgerWon, notReadded: leftIds.length });
+  // Two separate lines: what was taken from the old build's JSON, and where the JSON differs but the ledger is newer
+  // (a conflict a person should know about even though nothing changed in the ledger).
+  if (changed.length) console.error(`⚠ checklist ${version}: 옛 판이 checklist.json 에 쓴 ${changed.length}칸을 다시 들였다(${changed.slice(0, 5).join(', ')})`);
+  if (leftIds.length) console.error(`⚠ checklist ${version}: 원장에서 옮기거나 지운 칸 ${leftIds.length}은 옛 판 checklist.json 에 남아 있어도 다시 넣지 않았다(${leftIds.slice(0, 5).join(', ')})`);
+  if (ledgerWon) console.error(`⚠ checklist ${version}: 옛 판 checklist.json 과 원장이 다르다 — 원장이 더 새로워 원장 값 유지 ${ledgerWon}칸(${ledgerWonIds.slice(0, 5).join(', ')})`);
+  return false;
 }
 export function importJson(version: string): boolean {
   validateVersion(version);
   if (!existsSync(jsonPath(version))) return false;
   const db = open();
   try {
-    if (db.query('SELECT 1 FROM imported_versions WHERE version = ?').get(version)) return false;
     const imported = transaction(db, () => importOnDb(db, version));
     if (imported) debug.log('release.features', 'imported', { version });
     return imported;
@@ -315,13 +441,20 @@ export function exportJson(version: string, released = releasedVersion(), dev =
   const path = jsonPath(version);
   mkdirSync(dirname(path), { recursive: true });
   const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  const contents = `${JSON.stringify(data, null, 2)}\n`;
   try {
-    writeFileSync(temp, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600 });
+    writeFileSync(temp, contents, { mode: 0o600 });
     chmodSync(temp, 0o600);
     renameSync(temp, path);
   } finally { if (existsSync(temp)) rmSync(temp); }
   const db = open();
-  try { transaction(db, () => { db.query('INSERT OR IGNORE INTO imported_versions (version) VALUES (?)').run(version); }); }
+  try { transaction(db, () => {
+    // Track only our bytes: a legacy replacement after rename must remain detectable.
+    const hash = jsonHash(contents);
+    db.query(`INSERT INTO imported_versions (version, json_hash, imported_at) VALUES (?, ?, ?)
+      ON CONFLICT(version) DO UPDATE SET json_hash = excluded.json_hash, imported_at = excluded.imported_at`)
+      .run(version, hash, new Date().toISOString());
+  }); }
   finally { db.close(); }
   return data;
 }

package/src/release-loop/release-schedule.ts

@@ -0,0 +1,53 @@
+import { CliUserError } from '../cli/cli-user-error.js';
+import { debug } from '../debug/log.js';
+import { readSchedule, readSchedules, writeSchedule, type ScheduleRow } from './feature-store.js';
+
+export type ReleaseSchedule = ScheduleRow;
+
+function utcIso(input: string): string {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})(?::(\d{2})(?:\.\d{1,3})?)?(Z|([+-])(\d{2}):(\d{2}))$/.exec(input);
+  if (!match) throw new CliUserError(`시각에는 ISO 오프셋 필요: ${input}`);
+  const hours = Number(match[6] ?? 0), minutes = Number(match[7] ?? 0);
+  const offset = (match[5] === '-' ? -1 : 1) * (hours * 60 + minutes);
+  const millis = Date.parse(input);
+  if (hours > 23 || minutes > 59 || !Number.isFinite(millis) ||
+      new Date(millis + offset * 60_000).toISOString().slice(0, 19) !== `${match[1]}T${match[2]}:${match[3] ?? '00'}`) {
+    throw new CliUserError(`잘못된 ISO 시각: ${input}`);
+  }
+  return new Date(millis).toISOString();
+}
+
+export function formatKst(utc: string): string {
+  const parts = new Intl.DateTimeFormat('ko-KR', { timeZone: 'Asia/Seoul', month: '2-digit', day: '2-digit', weekday: 'short', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).formatToParts(new Date(utc));
+  const get = (type: Intl.DateTimeFormatPartTypes) => parts.find((part) => part.type === type)!.value;
+  return `${get('month')}-${get('day')}(${get('weekday')}) ${get('hour')}:${get('minute')} KST`;
+}
+
+export function getSchedule(version: string, root?: string): ReleaseSchedule | null {
+  const schedule = readSchedule(version, root);
+  debug.log('release.schedule', 'read', { version, cutAt: schedule?.cutAt ?? null, landBy: schedule?.landBy ?? null });
+  return schedule;
+}
+
+export function listSchedules(root?: string): ReleaseSchedule[] {
+  const schedules = readSchedules(root);
+  for (const { version, cutAt, landBy } of schedules) debug.log('release.schedule', 'read', { version, cutAt, landBy });
+  return schedules;
+}
+
+export function setSchedule(version: string, patch: { cutAt?: string; landBy?: string }, by: string, root?: string): ReleaseSchedule {
+  const schedule = writeSchedule(version, {
+    ...(patch.cutAt !== undefined ? { cutAt: utcIso(patch.cutAt) } : {}),
+    ...(patch.landBy !== undefined ? { landBy: utcIso(patch.landBy) } : {}),
+  }, by, root);
+  debug.log('release.schedule', 'set', { version, cutAt: schedule.cutAt, landBy: schedule.landBy });
+  return schedule;
+}
+
+export function formatSchedule(schedule: ReleaseSchedule): string {
+  const cut = formatKst(schedule.cutAt);
+  const deadline = schedule.landBy ? formatKst(schedule.landBy) : null;
+  const sameDay = schedule.landBy && new Date(Date.parse(schedule.landBy) + 9 * 60 * 60_000).toISOString().slice(0, 10)
+    === new Date(Date.parse(schedule.cutAt) + 9 * 60 * 60_000).toISOString().slice(0, 10);
+  return `${schedule.version} 컷 ${cut}${deadline ? ` · 착지 마감 ${sameDay ? deadline.split(' ')[1] : deadline}` : ''}`;
+}

package/src/repl/index.ts

@@ -21,6 +21,7 @@ import { createInterface, type Interface as ReadlineInterface } from 'node:readl
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve as resolvePath, isAbsolute, basename } from 'node:path';
 import * as ui from '../ui.js';
+import { suggestProjectForFolder } from '../project/project-store.js';
 import { runTurn } from '../session/chat.js';
 import {
   ensureCliSession,
@@ -450,6 +451,12 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
   const session = ensureCliSession(cfg, initialId);
   setActiveSessionId(session.id);
   setAmbientSessionId(session.id);
+  if (!opts.jsonOutput && (!initialId || session.id !== initialId)) {
+    try {
+      const project = suggestProjectForFolder(process.cwd());
+      if (project) ui.info(`Project suggestion: ${project.name} (${project.id})`);
+    } catch { /* suggestions must not interrupt the REPL */ }
+  }
   const sessionIdRef = { current: session.id };
 
   const tools = opts.enableTools ? buildReplTools() : undefined;

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

@@ -1,5 +1,5 @@
 // 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. Nothing is written unless it is the owner in a private chat.
+// 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';
@@ -16,6 +16,8 @@ export interface CeoCommandDeps {
   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;
 }
 
@@ -43,21 +45,52 @@ export async function handleCeoSeatCommand(command: CeoSeatCommand, args: string
     debug.log('seat.dispatch', 'refused', { seat, reason: 'empty' });
     return `사용법: /${command} <할 일>`;
   }
-  deps.append({ from: 'CEO', to: seat, body: task, kind: 'ceo-task' });
-  const channelError = await postToChannel(seat, task, deps);
+  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 `받음 — ${seat} 메시지함에는 넣었습니다. 다만 조율 채널에 못 남겼습니다(${channelError}).`;
+    return { reply: `받음 — ${seat} 메시지함에는 넣었습니다. 다만 조율 채널에 못 남겼습니다(${channelError}).`, channel: 'failed', channelError };
   }
-  debug.log('seat.dispatch', 'ceo-task', { seat });
-  return `받음 — ${seat}에 전했습니다.`;
+  return { reply: `받음 — ${seat}에 전했습니다.`, channel: 'posted' };
 }
 
-async function postToChannel(seat: string, task: string, deps: CeoCommandDeps): Promise<string | null> {
+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 code = await deps.runGh(['pr', 'comment', target[2]!, '--repo', target[1]!, '--body-file', '-'], ceoTaskLine(seat, task, deps.now?.() ?? new Date()));
+    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(); }
+    },
+  };
+}