elanous 0.2.9 → 0.2.11

package/src/nexus/api/ops-seats-sources.ts

@@ -1,9 +1,10 @@
 // Live sources for /v1/ops/seats: the coordination PR and merged PRs through gh (automation App identity, proxy variables
 // removed — same rule as decision replies), the release checklist, and the decision ledger. Each failure becomes null upstream.
 import { DecisionLedger } from '../../decisions/decision-ledger.js';
+import { listCoordEvents, type CoordEvent } from '../../context-bus/coord-events.js';
 import { devVersion, listChecklist, type ChecklistItem } from '../../release-loop/checklist.js';
 import { getUserConfig } from '../../user-config.js';
-import { kstDayRange, type ChannelComment, type MergedPr, type SeatsSources } from './ops-seats.js';
+import { SEATS, kstDayRange, type ChannelComment, type ChannelSource, type MergedPr, type SeatsSources } from './ops-seats.js';
 
 const GH_TIMEOUT_MS = 20_000;
 
@@ -29,19 +30,48 @@ function channelTarget(): { repo: string; pr: string } | null {
   return m ? { repo: m[1]!, pr: m[2]! } : null;
 }
 
+export async function channelCommentsSince(sinceIso: string): Promise<Array<{ body: string; createdAt: string; url: string }> | null> {
+  const target = channelTarget();
+  if (!target) return null;
+  const lines = await ghLines(['api', '--paginate', `repos/${target.repo}/issues/${target.pr}/comments?since=${sinceIso}&per_page=100`,
+    '--jq', '.[] | {body: .body, createdAt: .created_at, url: .html_url} | tojson']);
+  return lines?.map((line) => JSON.parse(line) as { body: string; createdAt: string; url: string }) ?? null;
+}
+
 function nextPatch(version: string): string {
   const [major, minor, patch] = version.split('.').map(Number);
   return `${major}.${minor}.${patch! + 1}`;
 }
 
-export function liveSeatsSources(): SeatsSources {
+export function liveSeatsSources(deps: { listEvents?: typeof listCoordEvents; githubChannel?: typeof channelCommentsSince } = {}): SeatsSources {
   return {
     async channel(date) {
-      const target = channelTarget();
-      if (!target) return null;
-      const lines = await ghLines(['api', '--paginate', `repos/${target.repo}/issues/${target.pr}/comments?since=${kstDayRange(date).start}&per_page=100`,
-        '--jq', '.[] | {body: .body, createdAt: .created_at} | tojson']);
-      return lines?.map((line) => JSON.parse(line) as ChannelComment) ?? null;
+      const since = kstDayRange(date).start;
+      let events: CoordEvent[] = [];
+      try { events = (deps.listEvents ?? listCoordEvents)({ since }); } catch { /* GitHub fallback */ }
+      const latest = new Map<string, CoordEvent>();
+      for (const event of events) {
+        if (!SEATS.some(({ seat }) => seat === event.refs.seat)) continue;
+        const prior = latest.get(event.refs.seat);
+        if (!prior || event.at > prior.at) latest.set(event.refs.seat, event);
+      }
+      const seatSources: Partial<Record<(typeof SEATS)[number]['seat'], ChannelSource>> = {};
+      if (latest.size) {
+        const comments: ChannelComment[] = [];
+        for (const { seat } of SEATS) {
+          const event = latest.get(seat);
+          if (!event) { seatSources[seat] = 'unknown'; continue; }
+          comments.push({ body: `**[${seat}]** ${event.text}`, createdAt: event.at, url: event.refs.url ?? '' });
+          seatSources[seat] = 'ledger';
+        }
+        return { source: 'ledger', comments, seatSources };
+      }
+      let github: ChannelComment[] | null;
+      try { github = await (deps.githubChannel ?? channelCommentsSince)(since); }
+      catch { github = null; }
+      if (github === null) return null;
+      for (const { seat } of SEATS) seatSources[seat] = 'github';
+      return { source: 'github', comments: github, seatSources };
     },
     async merged(date) {
       const target = channelTarget();

package/src/nexus/api/ops-seats.ts

@@ -1,39 +1,49 @@
 // GET /v1/ops/seats?date=YYYY-MM-DD — one row per seat: latest channel line, PRs landed that day, red items, open decisions.
 // A source that could not be read is null, never 0 («못 읽음» ≠ «없음»). Contract: 내부 문서 `DESIGN-ops3-seat-board-and-public-demo-2026-10-02` §1.
 import { debug, redactSecretText } from '../../debug/log.js';
-import type { ChecklistItem } from '../../release-loop/checklist.js';
+import { parseOwner, type ChecklistItem } from '../../release-loop/checklist.js';
 import { canonicalSeatId } from '../../msg/msg-store.js';
+import { listSubSeatCharters, type SubSeatCharter } from './sub-seat-charters.js';
 
 export const SEATS = [
   { seat: 'OP', role: 'COO' }, { seat: 'TC', role: 'CTO' }, { seat: 'MK', role: 'CMO' }, { seat: 'UX', role: 'CXO' },
 ] as const;
 export const SEATS_CACHE_MS = 60_000;
 
-export interface ChannelComment { body: string; createdAt: string }
+export interface ChannelComment { body: string; createdAt: string; url?: string }
+export type ChannelSource = 'ledger' | 'github' | 'unreadable' | 'unknown';
+export type ChannelResult = ChannelComment[] | {
+  comments: ChannelComment[];
+  source: 'ledger' | 'github';
+  seatSources?: Partial<Record<(typeof SEATS)[number]['seat'], ChannelSource>>;
+} | null;
 export interface MergedPr { number: number; title: string; body: string; mergedAt: string }
 export interface SeatsSources {
   /** Coordination-channel comments created on `date` (KST) or later; null when unreadable. */
-  channel(date: string): Promise<ChannelComment[] | null>;
+  channel(date: string): Promise<ChannelResult>;
   /** PRs merged on `date` (KST); null when unreadable. */
   merged(date: string): Promise<MergedPr[] | null>;
   /** Checklist items of the version being worked on (counts, red) and of every version known (id → owner). */
   checklist(): { current: ChecklistItem[]; all: ChecklistItem[] } | null;
   /** `raisedBy.agent` of every open decision. */
   openDecisionRaisers(): string[] | null;
+  charters?(): SubSeatCharter[] | null;
 }
 
 export interface SeatRow {
   seat: string; role: string;
+  channelSource: ChannelSource;
   now: { text: string; at: string } | null;
   landed: Array<{ pr: number; title: string; at: string; checklistId: string | null }> | null;
   blocked: Array<{ id: string; title: string; status: 'red' }> | null;
   pendingDecisions: number | null;
   checklist: { green: number; yellow: number; red: number; done: number } | null;
+  subSeats: Array<{ id: string; title: string; open: number | null; landed: number | null; blocked: Array<{ id: string; title: string }> | null }> | null;
 }
 
 function seatOf(value: string | undefined): string | null {
   if (!value) return null;
-  try { return canonicalSeatId(value); } catch { return null; }
+  try { return canonicalSeatId(value.includes('/') ? parseOwner(value).seat : value); } catch { return null; }
 }
 
 const clip = (text: string, max: number) => redactSecretText(text).slice(0, max);
@@ -49,30 +59,54 @@ function checklistIdOf(pr: MergedPr, ids: string[]): string | null {
 }
 
 export async function buildSeatsBoard(date: string, sources: SeatsSources): Promise<{ date: string; seats: SeatRow[] }> {
-  const [channel, merged] = await Promise.all([
+  const [channelResult, merged] = await Promise.all([
     sources.channel(date).catch(() => null), sources.merged(date).catch(() => null),
   ]);
+  const channel = Array.isArray(channelResult) ? channelResult : channelResult?.comments ?? null;
+  const channelSource: ChannelSource = channelResult === null ? 'unreadable' : 'unknown';
   let checklist: ReturnType<SeatsSources['checklist']> = null;
   try { checklist = sources.checklist(); } catch { checklist = null; }
   let raisers: string[] | null = null;
   try { raisers = sources.openDecisionRaisers(); } catch { raisers = null; }
+  let charters: SubSeatCharter[] | null = null;
+  try {
+    if (sources.charters) charters = sources.charters();
+    else {
+      let unreadable = false;
+      const listed = listSubSeatCharters(undefined, () => { unreadable = true; });
+      charters = unreadable ? null : listed;
+    }
+  } catch { charters = null; }
 
   const owners = new Map<string, string>();
   for (const item of checklist?.all ?? []) { const seat = seatOf(item.owner); if (seat) owners.set(item.id, seat); }
   const ids = [...owners.keys()];
   const landedBySeat = new Map<string, NonNullable<SeatRow['landed']>>();
+  const landedBySub = new Map<string, number>();
+  const subOwner = (owner: string | undefined, charter: SubSeatCharter): boolean => {
+    if (!owner) return false;
+    try { const parsed = parseOwner(owner); return owner === charter.id && parsed.seat === charter.seat && parsed.sub === charter.sub; }
+    catch { return false; }
+  };
+  const subOwners = new Map(checklist?.all.flatMap((item) => {
+    const charter = charters?.find((candidate) => subOwner(item.owner, candidate));
+    return charter ? [[item.id, charter.id] as const] : [];
+  }) ?? []);
   for (const pr of merged ?? []) {
     const id = checklistIdOf(pr, ids);
     const seat = id ? owners.get(id) : undefined;
     if (!seat) continue; // ⛔ not by commit author — every seat lands through the same account.
     landedBySeat.set(seat, [...(landedBySeat.get(seat) ?? []), { pr: pr.number, title: clip(pr.title, 80), at: pr.mergedAt, checklistId: id }]);
+    const sub = id ? subOwners.get(id) : undefined;
+    if (sub) landedBySub.set(sub, (landedBySub.get(sub) ?? 0) + 1);
   }
 
   const seats = SEATS.map(({ seat, role }): SeatRow => {
     const latest = channel?.filter((c) => c.body.trimStart().startsWith(`**[${seat}]**`)).sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
     const mine = checklist?.current.filter((item) => seatOf(item.owner) === seat);
     return {
-      seat, role,
+      seat, role, channelSource: channelResult && !Array.isArray(channelResult)
+        ? channelResult.seatSources?.[seat] ?? channelSource : channelSource,
       now: latest ? { text: clip(latest.body.trimStart().split('\n')[0]!, 120), at: latest.createdAt } : null,
       landed: merged === null || checklist === null ? null : (landedBySeat.get(seat) ?? []).sort((a, b) => a.at.localeCompare(b.at)),
       blocked: mine ? mine.filter((item) => item.status === 'red').map((item) => ({ id: item.id, title: clip(item.title, 80), status: 'red' as const })) : null,
@@ -81,6 +115,15 @@ export async function buildSeatsBoard(date: string, sources: SeatsSources): Prom
         green: mine.filter((i) => i.status === 'green').length, yellow: mine.filter((i) => i.status === 'yellow').length,
         red: mine.filter((i) => i.status === 'red').length, done: mine.filter((i) => i.status === 'done').length,
       } : null,
+      subSeats: charters?.filter((charter) => charter.seat === seat).map((charter) => {
+        const items = checklist?.current.filter((item) => subOwner(item.owner, charter));
+        return {
+          id: charter.id, title: clip(charter.title, 80),
+          open: items ? items.filter((item) => item.status !== 'done').length : null,
+          landed: merged !== null && checklist !== null ? landedBySub.get(charter.id) ?? 0 : null,
+          blocked: items ? items.filter((item) => item.status === 'red').map((item) => ({ id: item.id, title: clip(item.title, 80) })) : null,
+        };
+      }) ?? null,
     };
   });
   debug.log('ops.seats', 'built', {

package/src/nexus/api/outputs-route.ts

@@ -0,0 +1,44 @@
+import { basename } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { OUTPUT_KINDS } from '../../exec-requests/default-outputs.js';
+import { listOutputs } from '../../outputs/ledger.js';
+import { jsonResponse } from './json-response.js';
+
+export interface OutputsDeps {
+  list?: typeof listOutputs;
+}
+
+export function handleOutputsGet(req: Request, deps: OutputsDeps = {}): Response {
+  const params = new URL(req.url).searchParams;
+  const rawLimit = params.get('limit');
+  if (rawLimit !== null && (!/^[1-9]\d*$/.test(rawLimit) || Number(rawLimit) > 200)) {
+    return jsonResponse({ error: 'invalid_limit' }, 400);
+  }
+  const limit = rawLimit === null ? 50 : Number(rawLimit);
+  const rawSource = params.get('source');
+  if (rawSource !== null && rawSource !== 'exec' && rawSource !== 'field-reel' && rawSource !== 'field-feed') {
+    return jsonResponse({ error: 'invalid_source' }, 400);
+  }
+  const source = rawSource ?? undefined;
+  const rawSince = params.get('since');
+  if (rawSince !== null && (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(rawSince)
+    || !Number.isFinite(Date.parse(rawSince))
+    || !Number.isFinite(Date.parse(`${rawSince.slice(0, 10)}T00:00:00Z`))
+    || new Date(`${rawSince.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) !== rawSince.slice(0, 10))) {
+    return jsonResponse({ error: 'invalid_since' }, 400);
+  }
+  const since = rawSince ? new Date(rawSince).toISOString() : undefined;
+  const rows = (deps.list ?? listOutputs)({ limit, ...(source ? { source } : {}), ...(since ? { since } : {}) });
+  const outputs = rows.map(({ kind, title, path, url, source: entrySource, seat, at }) => ({
+    kind,
+    kindLabel: kind === 'file' ? '파일' : OUTPUT_KINDS[kind]?.cardTitle ?? '파일',
+    title,
+    ...(path ? { fileName: basename(path) } : {}),
+    ...(url ? { url } : {}),
+    source: entrySource,
+    ...(seat ? { seat } : {}),
+    at,
+  }));
+  debug.log('outputs.route', 'listed', { count: outputs.length, source, limit });
+  return jsonResponse({ outputs });
+}

package/src/nexus/api/seat-requests.ts

@@ -1,12 +1,19 @@
 import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { createHash, randomUUID } from 'node:crypto';
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { debug } from '../../debug/log.js';
+import { resolveAttachmentPath } from '../../boot/attachment-store.js';
+import { runGh } from '../../decisions/decision-cards.js';
+import { openMsgStore, canonicalSeatId } from '../../msg/msg-store.js';
+import { dispatchCeoTask, type CeoCommandDeps } from '../../seat-dispatch/ceo-commands.js';
+import { acknowledgeSeatAnswers, askSeat, deliverSeatAnswers, parseSeatAsk, type SeatAskDeps } from '../../seat-dispatch/seat-ask.js';
+import { getUserConfig } from '../../user-config.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
 import { submitIntakeWork } from '../../intake-plane/submit-intake-work.js';
 import { parseSeatAddress, resolveSeat } from '../../seat-address/seat-address.js';
 import trackData from '../../../scripts/coord-tracks.json';
 import { jsonResponse } from './json-response.js';
+import { publishInsideEvent } from './inside-events.js';
 
 export const SEAT_REQUESTS_PATH = '/v1/seat-requests';
 
@@ -16,6 +23,9 @@ interface SeatRequestItem {
   text: string;
   queuedAt: string;
   status: 'queued';
+  attachments?: string[];
+  channel?: 'posted' | 'failed' | 'unknown';
+  channelError?: string;
 }
 
 interface PendingRequest {
@@ -25,6 +35,7 @@ interface PendingRequest {
   text: string;
   queuedAt: string;
   ref: string;
+  attachments?: string[];
 }
 
 interface RejectedRequest extends Omit<PendingRequest, 'status'> {
@@ -38,10 +49,18 @@ export interface SeatRequestsDeps {
   submit?: typeof submitIntakeWork;
   now?: () => string;
   append?: (path: string, entry: RecordEntry) => void;
+  resolveAttachment?: typeof resolveAttachmentPath;
+  dispatch?: typeof dispatchCeoTask;
+  ceoDeps?: () => CeoCommandDeps;
+  askDeps?: SeatAskDeps;
 }
 
 const seats = trackData.tracks.filter((entry): entry is typeof entry & { title: string } => 'title' in entry)
   .map(({ id, title }) => ({ id, title }));
+
+function requestSeat(address: string) {
+  return resolveSeat(address) ?? trackData.tracks.find((entry) => entry.id.toLowerCase() === address.replace(/^@/, '').toLowerCase());
+}
 const inFlight = new Map<string, { payload: string; task: Promise<Response> }>();
 
 function unknownSeat(): Response {
@@ -140,7 +159,28 @@ function persistOutcome(path: string, entry: RecordEntry, write: typeof append):
 }
 
 function receipt(item: SeatRequestItem): Response {
-  return jsonResponse({ receiptId: item.receiptId, seat: item.seat, queuedAt: item.queuedAt }, 202);
+  return jsonResponse({ receiptId: item.receiptId, seat: item.seat, queuedAt: item.queuedAt,
+    // Only a CEO-seat dispatch knows whether the channel line went out; anything else is reported as unknown.
+    attachments: item.attachments?.length ?? 0, channel: item.channel ?? 'unknown',
+    ...(item.channelError ? { channelError: item.channelError } : {}) }, 202);
+}
+
+function defaultCeoDeps(): CeoCommandDeps {
+  const cfg = getUserConfig();
+  const replyTarget = (cfg.raw?.decisions as { replyGhPr?: unknown } | undefined)?.replyGhPr;
+  return { ownerId: null, replyTarget: typeof replyTarget === 'string' ? replyTarget : null, runGh,
+    append: (message) => { const store = openMsgStore(); try { return store.append(message); } finally { store.close(); } },
+    hasMessage: (seat, ref) => {
+      const store = openMsgStore();
+      try {
+        return store.db.query("SELECT 1 FROM msg_messages WHERE recipient = ? AND kind = 'ceo-task' AND body LIKE ? LIMIT 1")
+          .get(seat, `%\n요청: ${ref}`) !== null;
+      } finally { store.close(); }
+    } };
+}
+
+function canonicalSeatIdSafe(id: string): string {
+  try { return canonicalSeatId(id); } catch { return id; }
 }
 
 function unavailable(): Response {
@@ -152,8 +192,20 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
   const path = file((deps.root ?? effectiveInstanceRoot)());
   if (req.method === 'GET') {
     const params = new URL(req.url).searchParams;
+    if (params.get('answers') === '1') {
+      const clientId = req.headers.get('x-seat-ask-client');
+      if (!clientId || !/^[a-f0-9-]{36}$/i.test(clientId)) return jsonResponse({ error: 'bad_request' }, 400);
+      const base = deps.askDeps;
+      const messages: Array<{ id: string; text: string; status: 'answered' | 'expired' }> = [];
+      await deliverSeatAnswers({ ...base, channel: 'pwa', clientId, send: async (origin, text) => {
+        if (origin.channel !== 'pwa' || origin.clientId !== clientId) return;
+        const match = /\(([^)]+)\)/.exec(text);
+        if (match) messages.push({ id: match[1]!, text, status: text.startsWith('CTO 답변') ? 'answered' : 'expired' });
+      } });
+      return jsonResponse({ items: messages });
+    }
     const requestedSeat = params.get('seat');
-    const seat = requestedSeat ? resolveSeat(requestedSeat) : undefined;
+    const seat = requestedSeat ? requestSeat(requestedSeat) : undefined;
     if (requestedSeat && !seat) return unknownSeat();
     const rawLimit = params.get('limit');
     const limit = rawLimit === null ? 20 : Number(rawLimit);
@@ -167,6 +219,19 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
   }
   if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
 
+  if (new URL(req.url).searchParams.get('answers') === 'ack') {
+    const clientId = req.headers.get('x-seat-ask-client');
+    if (!clientId || !/^[a-f0-9-]{36}$/i.test(clientId)) return jsonResponse({ error: 'bad_request' }, 400);
+    let body: unknown;
+    try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request' }, 400); }
+    const ids = (body as { ids?: unknown } | null)?.ids;
+    if (!Array.isArray(ids) || ids.length > 100 || ids.some((id) => typeof id !== 'string' || !/^[a-f0-9-]{36}$/i.test(id))) {
+      return jsonResponse({ error: 'bad_request' }, 400);
+    }
+    acknowledgeSeatAnswers(clientId, ids as string[], deps.askDeps?.open);
+    return jsonResponse({ ok: true });
+  }
+
   let body: unknown;
   try { body = await req.json(); }
   catch { return jsonResponse({ error: 'bad_request' }, 400); }
@@ -182,19 +247,43 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
   const prefix = parsed ? `@${parsed.seats.join(',')}` : '';
   const firstAddress = parsed && input.text.startsWith(prefix)
     && (input.text.length === prefix.length || /[ \t\r\n]/.test(input.text[prefix.length]!)) ? parsed : null;
-  const address = input.seat ?? (firstAddress?.seats.length === 1 ? firstAddress.seats[0] : undefined);
-  const seat = address ? resolveSeat(address) : undefined;
+  const address = input.seat ?? (firstAddress?.seats.length === 1 ? firstAddress.seats[0] : undefined)
+    ?? (parseSeatAsk(input.text) ? 'TC' : undefined);
+  const seat = address ? requestSeat(address) : undefined;
   if (!seat) return unknownSeat();
-  const text = input.seat === undefined ? firstAddress!.body.trim() : input.text.trim();
+  const text = input.seat === undefined ? (firstAddress?.body ?? input.text).trim() : input.text.trim();
+  if (canonicalSeatIdSafe(seat.id) === 'TC' && parseSeatAsk(text)) {
+    if (input.attachments !== undefined) return jsonResponse({ error: 'attachments-unsupported' }, 400);
+    const clientId = req.headers.get('x-seat-ask-client');
+    if (!clientId || !/^[a-f0-9-]{36}$/i.test(clientId)) return jsonResponse({ error: 'bad_request' }, 400);
+    let ask: string;
+    try {
+      ask = await askSeat(text, { channel: 'pwa', clientId }, (deps.ceoDeps ?? defaultCeoDeps)(),
+        deps.askDeps ?? { channel: 'pwa', send: async () => { throw new Error('PWA seat ask requires polling'); } });
+    } catch { return unavailable(); }
+    return jsonResponse({ reply: ask }, 202);
+  }
   if (!text) {
     debug.log('seat-address.pwa', 'rejected', { reason: 'empty-text', seat: seat.id });
     return jsonResponse({ error: 'bad_request' }, 400);
   }
+  if (input.attachments !== undefined && (!Array.isArray(input.attachments) || input.attachments.length > 4
+    || input.attachments.some((attachment: unknown) => !attachment || typeof attachment !== 'object' || Array.isArray(attachment)
+      || typeof (attachment as { id?: unknown }).id !== 'string' || !(attachment as { id: string }).id.trim()))) {
+    debug.log('seat.dispatch', 'refused', { seat: seat.id, reason: 'invalid-attachments' });
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  const attachmentIds = (input.attachments as Array<{ id: string }> | undefined)?.map(({ id }) => id) ?? [];
+  // Intake (non-CEO seats) carries text only — refuse attachments there instead of accepting and dropping them.
+  if (attachmentIds.length && !['OP', 'TC', 'MK', 'UX'].includes(canonicalSeatIdSafe(seat.id))) {
+    debug.log('seat.dispatch', 'refused', { seat: seat.id, reason: 'attachments-unsupported' });
+    return jsonResponse({ error: 'attachments-unsupported', seat: seat.id }, 400);
+  }
   debug.log('seat-address.pwa', 'parsed', { seat: seat.id, textLength: text.length });
   const now = (deps.now ?? (() => new Date().toISOString()))();
   const header = req.headers.get('idempotency-key');
   if (header !== null && (!header.trim() || header.length > 200)) return jsonResponse({ error: 'bad_request' }, 400);
-  const payload = `${seat.id}\0${text}`;
+  const payload = JSON.stringify([seat.id, text, attachmentIds]);
   const key = header === null ? createHash('sha256').update(randomUUID()).digest('hex')
     : createHash('sha256').update(`client\0${header}`).digest('hex');
   const lock = `${path}\0${key}`;
@@ -213,11 +302,23 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
     try { existing = records(path).get(key); }
     catch { return unavailable(); }
     if (existing) {
-      if (existing.seat !== seat.id || existing.text !== text) return jsonResponse({ error: 'idempotency-conflict' }, 409);
+      if (existing.seat !== seat.id || existing.text !== text
+        || JSON.stringify(existing.attachments ?? []) !== JSON.stringify(attachmentIds)) return jsonResponse({ error: 'idempotency-conflict' }, 409);
       if (existing.status === 'queued') return receipt(existing);
     }
+    const attachments: Array<{ name: string; path: string }> = [];
+    for (const id of attachmentIds) {
+      const resolved = (deps.resolveAttachment ?? resolveAttachmentPath)(id);
+      if (!resolved) {
+        debug.log('seat.dispatch', 'refused', { seat: seat.id, reason: 'unknown-attachment' });
+        return jsonResponse({ error: 'unknown-attachment', id }, 400);
+      }
+      const metadata = (input.attachments as Array<{ name?: unknown }>)[attachments.length];
+      attachments.push({ name: typeof metadata?.name === 'string' && metadata.name.trim() ? metadata.name : basename(resolved), path: resolved });
+    }
     const intent: PendingRequest = existing?.status === 'pending'
-      ? existing : { key, seat: seat.id, text, queuedAt: now, status: 'pending', ref: `pwa:${randomUUID()}` };
+      ? existing : { key, seat: seat.id, text, queuedAt: now, status: 'pending', ref: `pwa:${randomUUID()}`,
+        ...(attachmentIds.length ? { attachments: attachmentIds } : {}) };
     if (existing?.status !== 'pending') {
       try {
         (deps.append ?? append)(path, intent);
@@ -227,6 +328,25 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
         }
       } catch { return unavailable(); }
     }
+    const ceoSeat = canonicalSeatId(seat.id);
+    if (['OP', 'TC', 'MK', 'UX'].includes(ceoSeat)) {
+      let result: Awaited<ReturnType<typeof dispatchCeoTask>>;
+      try {
+        result = await (deps.dispatch ?? dispatchCeoTask)(ceoSeat, text, (deps.ceoDeps ?? defaultCeoDeps)(), { attachments, via: 'pwa', ref: intent.ref });
+      } catch {
+        debug.log('seat.dispatch', 'refused', { seat: seat.id, reason: 'dispatch-failed' });
+        return unavailable();
+      }
+      const item: RecordEntry & SeatRequestItem = {
+        key, receiptId: intent.ref, seat: seat.id, text, queuedAt: intent.queuedAt, status: 'queued',
+        ...(attachmentIds.length ? { attachments: attachmentIds } : {}), channel: result.channel,
+        ...(result.channelError ? { channelError: result.channelError } : {}),
+      };
+      try { persistOutcome(path, item, deps.append ?? append); }
+      catch { return unavailable(); }
+      publishInsideEvent({ kind: 'seat', seat: item.seat, receiptId: item.receiptId, status: item.status, ts: item.queuedAt });
+      return receipt(item);
+    }
     let result: Awaited<ReturnType<typeof submitIntakeWork>>;
     try {
       result = await (deps.submit ?? submitIntakeWork)({
@@ -241,10 +361,12 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
       catch { return unavailable(); }
       return unavailable();
     }
-    const item: RecordEntry & SeatRequestItem = { key, receiptId: result.acceptanceId, seat: seat.id, text, queuedAt: intent.queuedAt, status: 'queued' };
+    const item: RecordEntry & SeatRequestItem = { key, receiptId: result.acceptanceId, seat: seat.id, text, queuedAt: intent.queuedAt,
+      status: 'queued', ...(attachmentIds.length ? { attachments: attachmentIds } : {}) };
     try { persistOutcome(path, item, deps.append ?? append); }
     catch { return unavailable(); }
     debug.log('seat-address.pwa', 'enqueued', { seat: seat.id, receiptId: item.receiptId });
+    publishInsideEvent({ kind: 'seat', seat: item.seat, receiptId: item.receiptId, status: item.status, ts: item.queuedAt });
     return receipt(item);
   })();
   inFlight.set(lock, { payload, task });

package/src/nexus/api/sessions-store.ts

@@ -18,6 +18,9 @@ import {
   isHarnessSessionOrigin,
   type SessionMeta,
 } from '../../session/index.js';
+import { getProject } from '../../project/project-store.js';
+import { sessionRoot, updateSessionMeta } from '../../session/index.js';
+import { debug } from '../../debug/log.js';
 import { checkAuth, type MetaApiOpts } from './meta-api.js';
 import { jsonResponse } from './http-server.js';
 
@@ -32,6 +35,7 @@ export interface SessionStoreCard {
    *  `harness` = 하니스 자식이 만든 세션. 기본 목록에서 숨기고 includeHarness=1 로 포함. */
   origin?: string;
   sourceKind?: string;
+  projectId?: string;
   createdAt: string;
   updatedAt: string;
   messageCount: number;
@@ -50,6 +54,7 @@ function toCard(m: SessionMeta, preview: string, nowMs: number): SessionStoreCar
     source: m.source,
     ...(m.origin ? { origin: m.origin } : {}),
     ...(m.sourceKind ? { sourceKind: m.sourceKind } : {}),
+    ...(m.projectId !== undefined ? { projectId: m.projectId } : {}),
     createdAt: m.createdAt,
     updatedAt: m.updatedAt,
     messageCount: m.messageCount,
@@ -82,11 +87,13 @@ export function handleSessionsStoreList(req: Request, opts: MetaApiOpts): Respon
   // 하니스 자식 세션(origin:'harness')은 기본 숨김 — includeHarness=1 로 포함.
   // 신분이 없는 옛 세션은 사람 대화로 본다(숨기지 않음). 제목 문면으로 판정하지 않는다.
   const includeHarness = url.searchParams.get('includeHarness') === '1';
+  const projectId = url.searchParams.get('projectId');
   const limit = Math.min(Math.max(Number(url.searchParams.get('limit')) || 100, 1), 300);
   const nowMs = Date.now();
 
   let metas = listSessions({
     limit: 600,
+    ...(projectId !== null ? { projectId } : {}),
     ...(includeOperational ? {} : { excludeSourceKinds: ['scheduled'] }),
     ...(includeHarness ? {} : { excludeOrigins: [HARNESS_SESSION_ORIGIN] }),
   }); // 이미 updatedAt DESC
@@ -157,6 +164,41 @@ export async function handleSessionsStoreFork(
   );
 }
 
+/** PATCH /v1/sessions/store/:id — only project membership; leave transcript and other meta untouched. */
+export async function handleSessionsStorePatch(req: Request, id: string, opts: MetaApiOpts): Promise<Response> {
+  if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
+  if (!id || id.includes('/') || id.includes('\\') || id.includes('..')) {
+    return jsonResponse({ ok: false, error: 'invalid_session_id' }, 400);
+  }
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return jsonResponse({ ok: false, error: 'invalid_json' }, 400); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)
+    || !Object.hasOwn(body, 'projectId')
+    || Object.keys(body).some((key) => key !== 'projectId')) {
+    return jsonResponse({ ok: false, error: 'invalid_project_id' }, 400);
+  }
+  const projectId = (body as { projectId: unknown }).projectId;
+  if (projectId !== null && typeof projectId !== 'string') {
+    return jsonResponse({ ok: false, error: 'invalid_project_id' }, 400);
+  }
+  // 모양은 맞는데 없는 프로젝트 = 찾을 수 없음(404) — 요청 형식 오류(400)와 가른다(IA1b).
+  if (projectId !== null && !getProject(projectId)) {
+    return jsonResponse({ ok: false, error: 'project-not-found' }, 404);
+  }
+
+  let previous: string | null = null;
+  // 잠금 안에서 최신 목록 위에 고친다 — 동시 appendMessage 가 이 projectId 를 덮지 않는다.
+  const meta = updateSessionMeta(id, (m) => {
+    previous = m.projectId ?? null;
+    if (projectId === null) delete m.projectId;
+    else m.projectId = projectId;
+  }, sessionRoot());
+  if (!meta) return jsonResponse({ ok: false, error: 'not_found' }, 404);
+  debug.log('project', 'assign', { sessionId: id, projectId, previous });
+  return jsonResponse({ ok: true, meta }, 200);
+}
+
 /** DELETE /v1/sessions/store/:id — on-disk 세션 삭제(index.json + <id>.jsonl 제거).
  *  파괴적·복구불가. in-flight turn abort + in-memory history forget 도 fail-soft 로 동반. */
 export function handleSessionsStoreDelete(req: Request, id: string, opts: MetaApiOpts): Response {