elanous 0.2.13 → 0.2.15

package/src/nexus/api/loop-edges.ts

@@ -0,0 +1,173 @@
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { listCoordEvents } from '../../context-bus/coord-events.js';
+import { CardStore, cardIndexPath, type TaskCard } from '../../task-cards/card-store.js';
+import { loadRunLedger, resolveFederatedRunLedgerDirectories, type RunLedgerEntry } from '../../self-implement/run-ledger.js';
+import { listLoops } from '../../loops/registry.js';
+import { listSubSeatCharters } from './sub-seat-charters.js';
+import { SEATS } from './ops-seats.js';
+import { jsonResponse } from './json-response.js';
+
+export interface LoopEdge {
+  at: string;
+  kind: 'request' | 'decision' | 'report' | 'card' | 'run';
+  from: string;
+  to: string;
+  ref: string;
+}
+
+export interface LoopEdgesDeps {
+  listCoord?: typeof listCoordEvents;
+  cardRoot?: string;
+  ledgerDir?: string;
+  listCards?: () => TaskCard[];
+  listRunStarts?: (since: string) => Array<{ runId: string; at: string; seat: string }>;
+  listLoopOwners?: () => Array<{ id: string; owner?: string | null }>;
+  seatIds?: () => string[];
+}
+
+const ID = /^[a-zA-Z0-9_-]{1,128}$/;
+const SURFACES = new Set(['telegram', 'pwa', 'linear', 'tui', 'discord', 'api', 'cli', 'voice', 'folder', 'wish']);
+const KINDS: Record<string, LoopEdge['kind']> = { '요청': 'request', '결정': 'decision', '보고': 'report' };
+
+function seat(value: unknown, seats: ReadonlySet<string>): value is string {
+  return typeof value === 'string' && seats.has(value);
+}
+function surface(value: unknown): value is string {
+  return typeof value === 'string' && SURFACES.has(value);
+}
+function object(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+function parse(content: string): Record<string, unknown> | null {
+  try { return object(JSON.parse(content) as unknown); } catch { return null; }
+}
+function inWindow(at: string, since: number, now: number): boolean {
+  const ms = Date.parse(at);
+  return Number.isFinite(ms) && ms >= since && ms <= now;
+}
+
+function cardEdges(card: TaskCard, since: number, now: number, seats: ReadonlySet<string>): LoopEdge[] {
+  if (!card.goalId.startsWith('wish:') || !ID.test(card.id)) return [];
+  const node = `card:${card.id}`;
+  const ref = card.id;
+  const edges: LoopEdge[] = [];
+  const intake = card.sections.find(s => s.key === 'intake:wish:0');
+  const intakeData = intake && parse(intake.content);
+  if (intake && surface(intakeData?.source) && inWindow(intake.createdAt, since, now)) {
+    edges.push({ at: intake.createdAt, kind: 'card', from: `surface:${intakeData.source}`, to: node, ref });
+  }
+  const split = card.sections.find(s => s.key === 'flow:split:0');
+  const splitData = split && parse(split.content);
+  const cells = Array.isArray(splitData?.cells) ? splitData.cells : [];
+  const owners = new Map<string, string>();
+  for (const item of cells) {
+    const cell = object(item);
+    if (typeof cell?.id === 'string' && ID.test(cell.id) && seat(cell.owner, seats)) owners.set(cell.id, cell.owner);
+  }
+  const placedOwners = new Set<string>();
+  for (const section of card.sections) {
+    if (!section.key.startsWith('flow:placed:')) continue;
+    const cellId = section.key.slice('flow:placed:'.length);
+    const saved = parse(section.content);
+    const placement = object(saved?.decision);
+    const owner = owners.get(cellId);
+    if (!owner || !placement || placement.id !== cellId || !ID.test(cellId)
+      || typeof placement.version !== 'string' || !/^\d+\.\d+\.\d+$/.test(placement.version)) continue;
+    placedOwners.add(owner);
+    if (inWindow(section.createdAt, since, now)) {
+      const cellNode = `loop:${cellId}`;
+      edges.push({ at: section.createdAt, kind: 'card', from: node, to: cellNode, ref });
+      edges.push({ at: section.createdAt, kind: 'card', from: cellNode, to: owner, ref });
+    }
+  }
+  const reply = card.sections.find(s => s.key === 'intake:reply:0');
+  const replyData = reply && parse(reply.content);
+  // The destination section alone is not a send; flow:result records a completed card flow.
+  const result = card.sections.find(s => s.key === 'flow:result:0');
+  if (result && reply && surface(replyData?.surface) && inWindow(result.createdAt, since, now)) {
+    for (const owner of placedOwners) {
+      edges.push({ at: result.createdAt, kind: 'card', from: owner, to: `surface:${replyData.surface}`, ref });
+    }
+  }
+  return edges;
+}
+
+function runStarts(since: string, dir: string, owners: ReadonlyMap<string, string>, seats: ReadonlySet<string>): Array<{ runId: string; at: string; seat: string }> {
+  if (!existsSync(dir)) return [];
+  const result: Array<{ runId: string; at: string; seat: string }> = [];
+  let names: string[];
+  try { names = readdirSync(dir); } catch { return []; }
+  for (const name of names) {
+    if (!/^run-[a-zA-Z0-9-]+\.jsonl$/.test(name)) continue;
+    const path = join(dir, name);
+    try { if (!statSync(path).isFile() || statSync(path).size > 5 * 1024 * 1024) continue; }
+    catch { continue; }
+    const runId = name.slice(0, -6);
+    let entries: RunLedgerEntry[] | null;
+    try { entries = loadRunLedger(runId, dir); } catch { continue; }
+    const start = entries?.find(entry => entry.event === 'start' && entry.runId === runId);
+    const feature = typeof start?.data.feature === 'string' ? start.data.feature : '';
+    const launchSeat = start?.data.launchSeat ?? start?.data.seat ?? owners.get(feature)
+      ?? start?.data.originAgent ?? start?.data.controller;
+    if (start?.timestamp && start.timestamp >= since && seat(launchSeat, seats)) {
+      result.push({ runId, at: start.timestamp, seat: launchSeat });
+    }
+  }
+  return result;
+}
+
+/** GET only; project an allowlist of fields from the three ledgers. Never serialize ledger records. */
+export function handleLoopEdgesGet(req: Request, deps: LoopEdgesDeps = {}): Response {
+  const params = new URL(req.url).searchParams;
+  const rawSince = params.get('since');
+  const since = rawSince === null ? Date.now() - 60 * 60 * 1000 : Date.parse(rawSince);
+  const rawLimit = params.get('limit');
+  const limit = rawLimit === null ? 100 : Number(rawLimit);
+  const now = Date.now();
+  if (rawSince !== null && !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d+)?(?:Z|[+-]\d\d:\d\d)$/.test(rawSince)
+    || !Number.isFinite(since) || since > now || !Number.isSafeInteger(limit) || limit < 1 || limit > 500) {
+    return jsonResponse({ error: 'usage: GET /v1/loops/edges?since=<ISO>&limit=<1..500>' }, 400);
+  }
+  const sinceIso = new Date(since).toISOString();
+  const seats = new Set((deps.seatIds ?? (() => [...SEATS.map(s => s.seat), ...listSubSeatCharters().map(s => s.id)]))());
+  const edges: LoopEdge[] = [];
+  for (const event of (deps.listCoord ?? listCoordEvents)({ since: sinceIso, channelOnly: true })) {
+    if (!seat(event.refs.seat, seats) || !inWindow(event.at, since, now)) continue;
+    const kind = KINDS[event.refs.kind ?? ''];
+    if (!kind || !Array.isArray(event.refs.recipients)) continue;
+    const ref = typeof event.refs.url === 'string' && /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/(?:pull|issues)\/\d+#issuecomment-\d+$/.test(event.refs.url)
+      ? event.refs.url : event.id;
+    if (!ID.test(ref) && !ref.startsWith('https://github.com/')) continue;
+    for (const recipient of new Set(event.refs.recipients)) {
+      if (seat(recipient, seats)) edges.push({ at: event.at, kind, from: event.refs.seat, to: recipient, ref });
+    }
+  }
+  if (deps.listCards) {
+    for (const card of deps.listCards()) edges.push(...cardEdges(card, since, now, seats));
+  } else {
+    const root = deps.cardRoot;
+    if (existsSync(cardIndexPath(root))) {
+      const store = new CardStore(root, true);
+      try { for (const card of store.listCards()) edges.push(...cardEdges(card, since, now, seats)); }
+      finally { store.close(); }
+    }
+  }
+  const readStarts = deps.listRunStarts ?? ((from: string) => {
+    const owners = new Map<string, string>();
+    try {
+      for (const entry of (deps.listLoopOwners ?? (() => listLoops()))()) {
+        if (seat(entry.owner, seats)) owners.set(entry.id, entry.owner);
+      }
+    } catch { /* A registry outage does not erase explicit launch-seat evidence. */ }
+    return (deps.ledgerDir ? [deps.ledgerDir] : resolveFederatedRunLedgerDirectories({ includeTest: false }))
+      .flatMap(dir => runStarts(from, dir, owners, seats));
+  });
+  for (const run of readStarts(sinceIso)) {
+    if (seat(run.seat, seats) && ID.test(run.runId) && inWindow(run.at, since, now)) {
+      edges.push({ at: run.at, kind: 'run', from: run.seat, to: `loop:${run.runId}`, ref: run.runId });
+    }
+  }
+  edges.sort((a, b) => b.at.localeCompare(a.at) || a.kind.localeCompare(b.kind) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  return jsonResponse({ edges: edges.slice(0, limit) });
+}

package/src/nexus/api/merge-approvals-gate.ts

@@ -53,7 +53,7 @@ export function startApprovalGate(input: ApprovalGateInput, deps: ApprovalGateDe
     void Promise.resolve().then(() => (deps.runHostRegate ?? runHostRegate)({
       prNumber: input.prNumber, headCommit: input.headSha, repoRoot: input.repoRoot, verifyOnly: true,
     })).then(async (result) => {
-      let status = result.status ?? (result.passed ? 'passed' : 'failed');
+      let status: ApprovalGateStatus = result.status === 'frozen' ? 'unmeasured' : result.status ?? (result.passed ? 'passed' : 'failed');
       let failures = result.failures.map(({ step, detail }) => `${step} — ${detail.replace(/\s+/g, ' ')}`.slice(0, 800));
       if (status === 'passed') {
         const current = await (deps.readPr ?? readPr)(input);

package/src/nexus/api/schedules-read.ts

@@ -15,6 +15,7 @@ import { tasksDbPath } from '../../task-orchestrator/paths.js';
 import { jsonResponse } from './http-server.js';
 import { checkAuth, type MetaApiOpts } from './meta-api.js';
 import { listScheduleRuns } from '../../domains/schedule-runs.js';
+import { listLoops } from '../../loops/registry.js';
 
 export interface SchedulesReadDeps {
   rows?: () => ScheduleRow[];
@@ -24,6 +25,7 @@ export interface SchedulesReadDeps {
   logsPath?: () => string;
   /** 발화 이력 원천(`schedule_runs`) — 기본은 schedules.db 를 읽기 전용으로 연다. */
   schedulesDbPath?: () => string;
+  loopOwners?: () => Array<{ id: string; title: string; owner?: string | null; enabled: boolean; lastRun: { at: string; status: string } | null; jobs: Array<{ id: string }> }>;
   now?: () => Date;
 }
 
@@ -193,10 +195,25 @@ function inventory(deps: SchedulesReadDeps): { cards: ScheduleCard[]; names: Map
   return { cards, names };
 }
 
+export function readSchedulesInventory(deps: SchedulesReadDeps = {}): ScheduleCard[] {
+  return inventory(deps).cards;
+}
+
 export function handleSchedulesList(req: Request, opts: MetaApiOpts, deps: SchedulesReadDeps = {}): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
-  const { cards } = inventory(deps);
+  const cards = readSchedulesInventory(deps);
   const schedules = new URL(req.url).searchParams.get('includeOff') === '1' ? cards : cards.filter(c => c.state !== 'off');
+  if (new URL(req.url).searchParams.get('includeOwners') === '1') {
+    try {
+      const owners = (deps.loopOwners ?? (() => listLoops({ schedules: registryRows() })))().map(loop => ({ id: loop.id, title: redactSecretText(loop.title), owner: loop.owner ?? null,
+        enabled: loop.enabled, lastRun: loop.lastRun ? { at: loop.lastRun.at, status: loop.lastRun.status } : null,
+        jobs: loop.jobs.map(job => job.id) }));
+      return jsonResponse({ schedules, count: schedules.length, owners }, 200);
+    } catch {
+      // The ordinary inventory stays readable; an opted-in map must not mistake an outage for unowned loops.
+      return jsonResponse({ schedules, count: schedules.length, owners: null }, 200);
+    }
+  }
   return jsonResponse({ schedules, count: schedules.length }, 200);
 }
 

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

@@ -6,6 +6,7 @@ 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 { appendSeatRequestRows, withSeatRequestLedgerLock } from '../../seat-dispatch/seat-request-ledger.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';
@@ -36,10 +37,12 @@ interface PendingRequest {
   queuedAt: string;
   ref: string;
   attachments?: string[];
+  reason?: string;
+  closedAt?: string;
 }
 
 interface RejectedRequest extends Omit<PendingRequest, 'status'> {
-  status: 'rejected';
+  status: 'rejected' | 'done';
 }
 
 type RecordEntry = (SeatRequestItem & { key: string }) | PendingRequest | RejectedRequest;
@@ -73,19 +76,7 @@ function file(root: string): string {
 }
 
 function append(path: string, entry: RecordEntry): void {
-  mkdirSync(dirname(path), { recursive: true });
-  // Atomically replace the journal so a failed write cannot leave a truncated JSON line.
-  const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
-  const temp = `${path}.${randomUUID()}.tmp`;
-  try {
-    writeFileSync(temp, `${previous}${JSON.stringify(entry)}\n`);
-    const fd = openSync(temp, 'r');
-    try { fsyncSync(fd); } finally { closeSync(fd); }
-    renameSync(temp, path);
-  } catch (error) {
-    try { unlinkSync(temp); } catch { /* no temp file to remove */ }
-    throw error;
-  }
+  appendSeatRequestRows(path, [entry]);
 }
 
 function records(path: string): Map<string, RecordEntry> {
@@ -100,7 +91,7 @@ function records(path: string): Map<string, RecordEntry> {
     if (!line) continue;
     const entry = JSON.parse(line) as RecordEntry;
     if (typeof entry.key !== 'string' || typeof entry.seat !== 'string' || typeof entry.text !== 'string'
-      || typeof entry.queuedAt !== 'string' || !['pending', 'queued', 'rejected'].includes(entry.status)
+      || typeof entry.queuedAt !== 'string' || !['pending', 'queued', 'rejected', 'done'].includes(entry.status)
       || (entry.status === 'queued' && typeof entry.receiptId !== 'string')
       || (entry.status !== 'queued' && typeof entry.ref !== 'string')) {
       throw new Error('invalid seat request journal');
@@ -121,7 +112,7 @@ function records(path: string): Map<string, RecordEntry> {
       throw new Error('invalid seat request outcome');
     }
     const current = entries.get(item.key);
-    if (current?.status === 'queued') continue;
+    if (current?.status === 'queued' || current?.status === 'done' || current?.closedAt) continue;
     if (current?.status === 'pending') {
       if (item.status === 'rejected' && current.ref !== item.ref) continue;
       if (item.status === 'queued' && current.queuedAt !== item.queuedAt) continue;
@@ -135,27 +126,32 @@ function outcomeFile(path: string, key: string): string {
   return join(dirname(path), 'outcomes', `${key}.json`);
 }
 
-function persistOutcome(path: string, entry: RecordEntry, write: typeof append): void {
-  try {
-    write(path, entry);
-    const sidecar = outcomeFile(path, entry.key);
-    if (existsSync(sidecar)) unlinkSync(sidecar);
-  } catch {
-    // The primary journal may be unavailable while the outcome is already committed
-    // to the intake queue. Keep a durable sidecar rather than a process-local receipt.
-    const target = outcomeFile(path, entry.key);
-    mkdirSync(dirname(target), { recursive: true });
-    const temp = `${target}.${randomUUID()}.tmp`;
+function persistOutcome(path: string, entry: RecordEntry, write: typeof append): RecordEntry {
+  return withSeatRequestLedgerLock(path, () => {
+    const current = records(path).get(entry.key);
+    if (current && ('closedAt' in current || current.status === 'done')) return current;
+    if (current?.status === 'queued') return current;
     try {
-      writeFileSync(temp, JSON.stringify(entry));
-      const fd = openSync(temp, 'r');
-      try { fsyncSync(fd); } finally { closeSync(fd); }
-      renameSync(temp, target);
-    } catch (error) {
-      try { unlinkSync(temp); } catch { /* no temp file */ }
-      throw error;
+      write(path, entry);
+      const sidecar = outcomeFile(path, entry.key);
+      if (existsSync(sidecar)) unlinkSync(sidecar);
+    } catch {
+      // A committed external delivery still needs a durable outcome if the journal write failed.
+      const target = outcomeFile(path, entry.key);
+      mkdirSync(dirname(target), { recursive: true });
+      const temp = `${target}.${randomUUID()}.tmp`;
+      try {
+        writeFileSync(temp, JSON.stringify(entry));
+        const fd = openSync(temp, 'r');
+        try { fsyncSync(fd); } finally { closeSync(fd); }
+        renameSync(temp, target);
+      } catch (error) {
+        try { unlinkSync(temp); } catch { /* no temp file */ }
+        throw error;
+      }
     }
-  }
+    return entry;
+  });
 }
 
 function receipt(item: SeatRequestItem): Response {
@@ -298,13 +294,18 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
   const gate = new Promise<void>((resolve) => { start = resolve; });
   const task = (async (): Promise<Response> => {
     await gate;
-    let existing: RecordEntry | undefined;
-    try { existing = records(path).get(key); }
+    // A settled request answers from the journal before attachments are resolved — a retry
+    // must return its receipt even when the uploaded file is gone. The locked re-check below still guards races.
+    let settled: RecordEntry | undefined;
+    try { settled = records(path).get(key); }
     catch { return unavailable(); }
-    if (existing) {
-      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);
+    if (settled) {
+      if (settled.seat !== seat.id || settled.text !== text
+        || JSON.stringify(settled.attachments ?? []) !== JSON.stringify(attachmentIds)) return jsonResponse({ error: 'idempotency-conflict' }, 409);
+      if ('closedAt' in settled || settled.status === 'done') {
+        return jsonResponse({ error: 'request-closed', status: settled.status, reason: 'reason' in settled ? settled.reason : undefined }, 409);
+      }
+      if (settled.status === 'queued') return receipt(settled);
     }
     const attachments: Array<{ name: string; path: string }> = [];
     for (const id of attachmentIds) {
@@ -316,18 +317,36 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
       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()}`,
-        ...(attachmentIds.length ? { attachments: attachmentIds } : {}) };
-    if (existing?.status !== 'pending') {
-      try {
-        (deps.append ?? append)(path, intent);
-        if (existing?.status === 'rejected') {
-          const sidecar = outcomeFile(path, key);
-          if (existsSync(sidecar)) unlinkSync(sidecar);
+    let initial: { intent?: PendingRequest; response?: Response };
+    try {
+      initial = withSeatRequestLedgerLock(path, () => {
+        const existing = records(path).get(key);
+        if (existing) {
+          if (existing.seat !== seat.id || existing.text !== text
+            || JSON.stringify(existing.attachments ?? []) !== JSON.stringify(attachmentIds)) {
+            return { response: jsonResponse({ error: 'idempotency-conflict' }, 409) };
+          }
+          if ('closedAt' in existing || existing.status === 'done') {
+            return { response: jsonResponse({ error: 'request-closed', status: existing.status,
+              reason: 'reason' in existing ? existing.reason : undefined }, 409) };
+          }
+          if (existing.status === 'queued') return { response: receipt(existing) };
         }
-      } catch { return unavailable(); }
-    }
+        const intent: PendingRequest = existing?.status === 'pending'
+          ? existing : { key, seat: seat.id, text, queuedAt: now, status: 'pending', ref: `pwa:${randomUUID()}`,
+            ...(attachmentIds.length ? { attachments: attachmentIds } : {}) };
+        if (existing?.status !== 'pending') {
+          (deps.append ?? append)(path, intent);
+          if (existing?.status === 'rejected') {
+            const sidecar = outcomeFile(path, key);
+            if (existsSync(sidecar)) unlinkSync(sidecar);
+          }
+        }
+        return { intent };
+      });
+    } catch { return unavailable(); }
+    if (initial.response) return initial.response;
+    const intent = initial.intent!;
     const ceoSeat = canonicalSeatId(seat.id);
     if (['OP', 'TC', 'MK', 'UX'].includes(ceoSeat)) {
       let result: Awaited<ReturnType<typeof dispatchCeoTask>>;
@@ -342,10 +361,12 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
         ...(attachmentIds.length ? { attachments: attachmentIds } : {}), channel: result.channel,
         ...(result.channelError ? { channelError: result.channelError } : {}),
       };
-      try { persistOutcome(path, item, deps.append ?? append); }
+      let persisted: RecordEntry;
+      try { persisted = persistOutcome(path, item, deps.append ?? append); }
       catch { return unavailable(); }
+      if (persisted.status !== 'queued') return jsonResponse({ error: 'request-closed', status: persisted.status, reason: persisted.reason }, 409);
       publishInsideEvent({ kind: 'seat', seat: item.seat, receiptId: item.receiptId, status: item.status, ts: item.queuedAt });
-      return receipt(item);
+      return receipt(persisted);
     }
     let result: Awaited<ReturnType<typeof submitIntakeWork>>;
     try {
@@ -363,11 +384,13 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
     }
     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); }
+    let persisted: RecordEntry;
+    try { persisted = persistOutcome(path, item, deps.append ?? append); }
     catch { return unavailable(); }
+    if (persisted.status !== 'queued') return jsonResponse({ error: 'request-closed', status: persisted.status, reason: persisted.reason }, 409);
     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);
+    return receipt(persisted);
   })();
   inFlight.set(lock, { payload, task });
   start();

package/src/nexus/api/task-cards-api.ts

@@ -1,4 +1,8 @@
-import { CardStore } from '../../task-cards/card-store.js';
+import { Database } from 'bun:sqlite';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { CardStore, type TaskCard } from '../../task-cards/card-store.js';
+import { releaseLedgerRoot } from '../../instance/resolve.js';
 import { createWishCard } from '../../intake-plane/wish-card.js';
 import { jsonResponse } from './json-response.js';
 
@@ -7,19 +11,53 @@ export async function handleTaskCardsWishPost(req: Request, root?: string): Prom
   try { body = await req.json(); }
   catch { return jsonResponse({ error: 'bad_request' }, 400); }
   if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
-  const { text, ref } = body as Record<string, unknown>;
-  if (typeof text !== 'string' || !text.trim() || typeof ref !== 'string' || !ref.trim()) {
+  const { text, ref, sessionId } = body as Record<string, unknown>;
+  if (typeof text !== 'string' || !text.trim() || typeof ref !== 'string' || !ref.trim()
+    || typeof sessionId !== 'string' || !sessionId.trim()) {
     return jsonResponse({ error: 'bad_request' }, 400);
   }
   const store = new CardStore(root);
   try {
-    const card = createWishCard({ text, source: 'pwa', ref }, store);
+    const card = createWishCard({ text, source: 'pwa', ref, replyTo: { surface: 'pwa', sessionId } }, store);
     return jsonResponse(card, card.created ? 201 : 200);
   } finally {
     store.close();
   }
 }
 
+export interface WishPlacement { cellId: string; cellTitle: string; version: string; status: 'green' | 'yellow' | 'red' | 'done' }
+
+export function isSplitCell(cell: unknown): cell is { id: string } {
+  return cell !== null && typeof cell === 'object' && 'id' in cell
+    && typeof cell.id === 'string' && cell.id.trim().length > 0;
+}
+
+/** Join the live checklist to the wish card by the split cell ID, never by title or card status. */
+export function wishPlacements(card: TaskCard, root?: string): WishPlacement[] {
+  if (!card.goalId.startsWith('wish:')) return [];
+  const split = [...card.sections].reverse().find(section => section.key === 'orch:split');
+  if (!split) return [];
+  let cells: unknown;
+  try { cells = JSON.parse(split.content); } catch { return []; }
+  if (!Array.isArray(cells)) return [];
+  const ids = [...new Set(cells.filter(isSplitCell).map(cell => cell.id.trim()))];
+  if (!ids.length) return [];
+  const ledgerRoot = root ?? releaseLedgerRoot();
+  const path = join(ledgerRoot, 'release', 'features.sqlite');
+  if (!existsSync(path)) return [];
+  const db = new Database(path, { readonly: true, strict: true });
+  try {
+    const placements: WishPlacement[] = [];
+    for (const cellId of ids) {
+      const rows = db.query('SELECT a.version, a.status, COALESCE(a.title_override, f.title) AS title FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.feature_id = ? ORDER BY a.version').all(cellId) as Array<{ version: string; status: string; title: string }>;
+      for (const row of rows) if (['green', 'yellow', 'red', 'done'].includes(row.status)) {
+        placements.push({ cellId, cellTitle: row.title, version: row.version, status: row.status as WishPlacement['status'] });
+      }
+    }
+    return placements;
+  } finally { db.close(); }
+}
+
 /** Read-only card API; route registration and authorization belong to the HTTP server. */
 export function handleTaskCardsGet(pathname: string, root?: string): Response {
   if (pathname !== '/v1/task-cards' && !/^\/v1\/task-cards\/[^/]+$/.test(pathname)) {
@@ -46,7 +84,8 @@ export function handleTaskCardsGet(pathname: string, root?: string): Response {
   const store = new CardStore(root);
   try {
     const card = store.getCard(id);
-    return card ? jsonResponse({ card }) : jsonResponse({ error: 'not_found' }, 404);
+    return card ? jsonResponse({ card, ...(card.goalId.startsWith('wish:') ? { placements: wishPlacements(card, root) } : {}) })
+      : jsonResponse({ error: 'not_found' }, 404);
   } finally {
     store.close();
   }

package/src/nexus/api/workflows.ts

@@ -302,6 +302,7 @@ export async function handleWorkflowPut(
   }
   const r = saveWorkflow(name, yamlText, { scope });
   if (!r.ok) {
+    if (r.readonly) return jsonResponse({ error: 'readonly_workflow', reason: r.error }, 409);
     return jsonResponse(
       {
         error: 'invalid_workflow',
@@ -323,7 +324,7 @@ export function handleWorkflowDelete(
   const url = new URL(req.url);
   const scope = url.searchParams.get('scope') === 'global' ? 'global' : 'project';
   const r = deleteWorkflow(name, { scope });
-  if (!r.ok) return jsonResponse({ error: 'delete_failed', reason: r.error }, 404);
+  if (!r.ok) return jsonResponse({ error: r.readonly ? 'readonly_workflow' : 'delete_failed', reason: r.error }, r.readonly ? 409 : 404);
   return jsonResponse({ ok: true, path: r.path, scope }, 200);
 }
 

package/src/prompt-enhance/enhance.ts

@@ -99,6 +99,8 @@ export interface EnhanceOpts {
   reasoningEffort?: 'low' | 'medium' | 'high';
   /** 산출물 유형 힌트(선택) — 예: 'PPT 발표덱', 'PLAN 문서'. 제약 문구 조정. */
   deliverableHint?: string;
+  /** Optional usage observer for the caller's authoring phase; missing usage stays unknown. */
+  onUsage?: (usage: LLMUsage) => void;
   /** 인핸싱 끄기(순수 verbatim). true 면 원문만 fenced 로 감싸 반환. */
   disabled?: boolean;
   /** Ask 원문 밖 스캐폴드에만 렌더할, 저작기가 관측한 디렉터리 실물 수. */
@@ -368,7 +370,10 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
     const rawOut = await streamLLM(messages, () => {}, {
       model,
       reasoningEffort: opts.reasoningEffort ?? 'high',
-      onUsage: (usage) => logLlmUsage(model, usage),
+      onUsage: (usage) => {
+        logLlmUsage(model, usage);
+        try { opts.onUsage?.(usage); } catch { /* usage observation must not change enhancement */ }
+      },
     });
     const parsed = parseEnhanceJson(rawOut);
     if (parsed) {

package/src/release-loop/auto-start.ts

@@ -0,0 +1,51 @@
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { releaseReadiness, type ReleaseReadiness } from '../../scripts/release-loop/release-readiness.js';
+import { listSchedules, type ReleaseSchedule } from './release-schedule.js';
+
+/** Cuts become eligible at cutAt and remain eligible through the end of the window. */
+export function selectScheduledCut(schedules: readonly ReleaseSchedule[], now: Date, windowMinutes: number): ReleaseSchedule | null {
+  if (!Number.isFinite(windowMinutes) || windowMinutes <= 0) throw new Error('windowMinutes must be positive and finite');
+  const current = now.getTime();
+  if (!Number.isFinite(current)) throw new Error('now must be a valid date');
+  return schedules
+    .filter((schedule) => {
+      const cut = Date.parse(schedule.cutAt);
+      return Number.isFinite(cut) && cut <= current && current - cut <= windowMinutes * 60_000;
+    })
+    .sort((a, b) => Date.parse(a.cutAt) - Date.parse(b.cutAt) || a.version.localeCompare(b.version))[0] ?? null;
+}
+
+export type AutoStartDeferral = { deferred: true; reason: Exclude<ReleaseReadiness, { ready: true }>['reason'] | 'frozen' };
+
+export type AutoStartResult =
+  | { status: 'no-cut' }
+  | { status: 'planned'; version: string; cutAt: string }
+  | { status: 'skipped'; version: string; reason: AutoStartDeferral['reason'] }
+  | { status: 'started'; version: string; cutAt: string };
+
+export interface AutoStartOptions {
+  windowMinutes: number;
+  apply?: boolean;
+  now?: Date;
+  ledgerRoot?: string;
+  schedules?: (root: string) => ReleaseSchedule[];
+  readiness?: (version: string, ledgerRoot: string, now: Date) => ReleaseReadiness;
+  launch?: (version: string) => void | AutoStartDeferral | Promise<void | AutoStartDeferral>;
+}
+
+/** Select from the release schedule; the existing `release run --if-ready` owns the launch-time lock and guards. */
+export async function autoStartScheduledRelease(options: AutoStartOptions): Promise<AutoStartResult> {
+  const root = options.ledgerRoot ?? releaseLedgerRoot();
+  const now = options.now ?? new Date();
+  // Validate the window even when the ledger has no rows.
+  const schedule = selectScheduledCut((options.schedules ?? listSchedules)(root), now, options.windowMinutes);
+  if (!schedule) return { status: 'no-cut' };
+  const { version, cutAt } = schedule;
+  if (!options.apply) return { status: 'planned', version, cutAt };
+  const readiness = (options.readiness ?? ((v, ledgerRoot, at) => releaseReadiness(v, { ledgerRoot, now: () => at })))(version, root, now);
+  if (!readiness.ready) return { status: 'skipped', version, reason: readiness.reason };
+  if (!options.launch) throw new Error('auto-start apply requires a launch callback');
+  const launched = await options.launch(version);
+  if (launched?.deferred) return { status: 'skipped', version, reason: launched.reason };
+  return { status: 'started', version, cutAt };
+}