elanous 0.2.10 → 0.2.11

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

@@ -3,6 +3,7 @@
 import { debug, redactSecretText } from '../../debug/log.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' },
@@ -26,6 +27,7 @@ export interface SeatsSources {
   checklist(): { current: ChecklistItem[]; all: ChecklistItem[] } | null;
   /** `raisedBy.agent` of every open decision. */
   openDecisionRaisers(): string[] | null;
+  charters?(): SubSeatCharter[] | null;
 }
 
 export interface SeatRow {
@@ -36,6 +38,7 @@ export interface SeatRow {
   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 {
@@ -65,16 +68,37 @@ export async function buildSeatsBoard(date: string, sources: SeatsSources): Prom
   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 => {
@@ -91,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

@@ -6,12 +6,14 @@ 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';
 
@@ -50,6 +52,7 @@ export interface SeatRequestsDeps {
   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)
@@ -189,6 +192,18 @@ 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 ? requestSeat(requestedSeat) : undefined;
     if (requestedSeat && !seat) return unknownSeat();
@@ -204,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); }
@@ -219,10 +247,22 @@ 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 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);
@@ -304,6 +344,7 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
       };
       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>>;
@@ -325,6 +366,7 @@ export async function handleSeatRequests(req: Request, deps: SeatRequestsDeps =
     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,11 +18,9 @@ import {
   isHarnessSessionOrigin,
   type SessionMeta,
 } from '../../session/index.js';
-import { existsSync, mkdirSync, readFileSync, renameSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
 import { getProject } from '../../project/project-store.js';
-import { sessionRoot } from '../../session/index.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';
 
@@ -181,43 +179,24 @@ export async function handleSessionsStorePatch(req: Request, id: string, opts: M
     return jsonResponse({ ok: false, error: 'invalid_project_id' }, 400);
   }
   const projectId = (body as { projectId: unknown }).projectId;
-  if (projectId !== null && (typeof projectId !== 'string' || !getProject(projectId))) {
+  if (projectId !== null && typeof projectId !== 'string') {
     return jsonResponse({ ok: false, error: 'invalid_project_id' }, 400);
   }
-
-  const root = sessionRoot();
-  const lock = join(root, '.index.lock');
-  const deadline = Date.now() + 10_000;
-  for (;;) {
-    try { mkdirSync(lock); break; }
-    catch {
-      if (!existsSync(lock)) continue;
-      try {
-        if (Date.now() - statSync(lock).mtimeMs > 30_000) { rmdirSync(lock); continue; }
-      } catch { continue; }
-      if (Date.now() >= deadline) throw new Error(`timed out acquiring lock ${lock}`);
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
-    }
-  }
-  try {
-    const path = join(root, 'index.json');
-    const entries = JSON.parse(readFileSync(path, 'utf8')) as SessionMeta[];
-    const pos = entries.findIndex((meta) => meta.id === id);
-    if (pos < 0) return jsonResponse({ ok: false, error: 'not_found' }, 404);
-    const meta = { ...entries[pos] };
-    if (projectId === null) delete meta.projectId;
-    else meta.projectId = projectId;
-    entries[pos] = meta;
-    const temp = `${path}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
-    writeFileSync(temp, JSON.stringify(entries, null, 2) + '\n', 'utf8');
-    renameSync(temp, path);
-    return jsonResponse({ ok: true, meta }, 200);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return jsonResponse({ ok: false, error: 'not_found' }, 404);
-    throw error;
-  } finally {
-    rmdirSync(lock);
+  // 모양은 맞는데 없는 프로젝트 = 찾을 수 없음(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 제거).

package/src/nexus/api/sub-seat-charters.ts

@@ -0,0 +1,34 @@
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+
+export interface SubSeatCharter { id: string; seat: string; sub: string; title: string }
+
+export function listSubSeatCharters(root = join(import.meta.dir, '..', '..', '..', 'docs', 'roles'), onUnreadable?: () => void): SubSeatCharter[] {
+  try {
+    readdirSync(root);
+    const charters: SubSeatCharter[] = [];
+    for (const seat of ['OP', 'MK', 'TC', 'UX']) {
+      let entries;
+      try { entries = readdirSync(join(root, seat), { withFileTypes: true }); }
+      catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        throw error;
+      }
+      for (const entry of entries) {
+        if (!entry.isFile() || !/^[a-z][a-z0-9-]{0,31}\.md$/.test(entry.name)) continue;
+        const sub = entry.name.slice(0, -3);
+        const id = `${seat}/${sub}`;
+        const content = readFileSync(join(root, seat, entry.name), 'utf8');
+        const heading = content.split(/\r?\n/).find((line) => line.startsWith('# '));
+        const title = heading?.slice(2).startsWith(`${id} — `) ? heading.slice(2 + id.length + 3).trim() || id : id;
+        charters.push({ id, seat, sub, title });
+      }
+    }
+    return charters.sort((a, b) => a.id.localeCompare(b.id));
+  } catch (error) {
+    debug.log('ops.seats', 'charters-unreadable', { root, error: error instanceof Error ? error.message : String(error) });
+    onUnreadable?.();
+    return [];
+  }
+}

package/src/nexus/api/tabs-mutations.ts

@@ -78,6 +78,8 @@ interface CreateTabBody {
   kind?: string;
   id?: string;
   label?: string;
+  /** Conversation owning a newly created webterm. */
+  sessionId?: string;
   /** Kind-specific factory opts (passed through to the factory). */
   kindOpts?: Record<string, unknown>;
   /** When true (default), supervisor.startTab is called immediately
@@ -95,7 +97,7 @@ function buildTabSpec(body: CreateTabBody, id: string): { spec: TabSpec; reason?
     case 'chat':
       return { spec: createChatTabSpec(opts as Parameters<typeof createChatTabSpec>[0]) };
     case 'webterm':
-      return { spec: createWebtermTabSpec(opts as Parameters<typeof createWebtermTabSpec>[0]) };
+      return { spec: createWebtermTabSpec({ ...opts, sessionId: body.sessionId ?? opts.sessionId } as Parameters<typeof createWebtermTabSpec>[0]) };
     case 'daemon':
       return { spec: createDaemonTabSpec(opts as Parameters<typeof createDaemonTabSpec>[0]) };
     case 'pwa-host':

package/src/nexus/api/trace.ts

@@ -9,6 +9,7 @@ import { checkAuth, type MetaApiOpts } from './meta-api.js';
 import { jsonResponse } from './json-response.js';
 import { runLedgerDir, runLedgerPath } from '../../self-implement/run-ledger.js';
 import { scanStoresForRun } from './trace-run-scan.js';
+import { listSessions } from '../../session/index.js';
 
 export type TraceLevel = 'L0' | 'L1' | 'L2' | 'L3';
 export interface TraceEvent {
@@ -17,6 +18,7 @@ export interface TraceEvent {
   universe: string;
   machine?: string;
   runId?: string;
+  projectId?: string;
   parentRunId?: string;
   phase?: string;
   shard?: string;
@@ -83,6 +85,7 @@ function eventFor(row: LogStoreRow): TraceEvent {
     id: evidenceRef(universe, row.id), ts: row.ts, universe,
     ...(machine ? { machine } : {}),
     ...(runId ? { runId } : {}),
+    ...(text(data.projectId) ? { projectId: text(data.projectId) } : {}),
     ...(text(data.parentRunId) ? { parentRunId: text(data.parentRunId) } : {}),
     ...(text(data.phase) ? { phase: text(data.phase) } : {}),
     ...(text(data.shard) ? { shard: text(data.shard) } : {}),
@@ -259,11 +262,15 @@ function options(url: URL): { level: TraceLevel; limit: number; from?: number; t
   if (from === null || to === null || (from !== undefined && to !== undefined && from > to)) return { level, limit: n, error: 'invalid time range' };
   return { level, limit: Math.min(n, TRACE_LIMIT), ...(from !== undefined ? { from } : {}), ...(to !== undefined ? { to } : {}) };
 }
-function matches(row: LogStoreRow, url: URL): boolean {
+function matches(row: LogStoreRow, url: URL, projectSessions?: ReadonlySet<string>): boolean {
   const data = dataFor(row);
   const runId = url.searchParams.get('runId');
   const universe = url.searchParams.get('universe');
   const kind = url.searchParams.get('kind');
+  const projectId = url.searchParams.get('projectId');
+  if (projectId !== null && (Object.hasOwn(data, 'projectId')
+    ? data.projectId !== projectId
+    : !projectSessions?.has(row.session_id ?? '') && !projectSessions?.has(text(data.sessionId) ?? ''))) return false;
   const q = url.searchParams.get('q')?.toLowerCase();
   if (runId && data.runId !== runId && data.run_id !== runId) return false;
   if (universe && row.instance !== universe) return false;
@@ -295,6 +302,8 @@ function findRunUniverse(runId: string, selected: readonly string[], deps: Trace
 export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {}): Response {
   if (!checkAuth(req, opts)) return jsonResponse({ error: 'unauthorized' }, 401);
   const url = new URL(req.url);
+  const projectId = url.searchParams.get('projectId');
+  const projectSessions = projectId === null ? undefined : new Set(listSessions({ projectId }).map(session => session.id));
   const parsed = options(url);
   if (parsed.error) return jsonResponse({ ok: false, error: 'bad_request', reason: parsed.error }, 400);
   const names = storeNames(url, deps);
@@ -315,7 +324,8 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
       for (const entry of stores) {
         if (!entry.store) { failures.push({ name: entry.name, reason: entry.error ?? 'log-store-unavailable' }); continue; }
         try {
-          const page = entry.store.aggregateRuns({ sinceMs: parsed.from, untilMs: parsed.to }, RUN_LIMIT);
+          const page = entry.store.aggregateRuns({ sinceMs: parsed.from, untilMs: parsed.to,
+            ...(projectId !== null ? { projectId, projectSessionIds: [...projectSessions!] } : {}) }, RUN_LIMIT);
           if (page.length >= RUN_LIMIT) runLimitReached = true;
           runs.push(...page.map((run) => ({ ...run, universe: entry.name })));
           opened++;
@@ -334,7 +344,8 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
     for (const entry of stores) {
       if (!entry.store) { failures.push({ name: entry.name, reason: entry.error ?? 'log-store-unavailable' }); continue; }
       try {
-        const query: LogQuery = { sinceMs: parsed.from, untilMs: parsed.to, limit: TRACE_LIMIT + 1 };
+        const query: LogQuery = { sinceMs: parsed.from, untilMs: parsed.to, limit: TRACE_LIMIT + 1,
+          ...(projectId !== null ? { projectId, projectSessionIds: [...projectSessions!] } : {}) };
         const search = url.searchParams.get('q');
         if (search) query.grep = search;
         // Restrict a run before paging; other JSON-only filters still apply to the bounded window.
@@ -349,7 +360,7 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
     const runId = url.searchParams.get('runId');
     let resolution: { universe?: string; checked: number; truncated?: boolean; unresolved?: boolean } | undefined;
     let resolvedFrom: 'ledger' | 'log-scan' | undefined;
-    if ((parsed.level === 'L2' || parsed.level === 'L3') && runId && !rows.some((row) => matches(row, url)) && !requestedUniverse) {
+    if ((parsed.level === 'L2' || parsed.level === 'L3') && runId && !rows.some((row) => matches(row, url, projectSessions)) && !requestedUniverse) {
       // A store with no log db at all («has no log store yet» — e.g. the daemon's own tree-derived universe) cannot
       // hold the run, so it must not block the ledger lookup. A store that exists but failed to open/read still does:
       // «could not read» is never answered as «not there». The reply keeps `failedStores` either way.
@@ -379,7 +390,8 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
         if (!entry?.store) return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: [{ name, reason: entry?.error ?? 'log-store-unavailable' }] }, 503);
         stores.push(entry);
         try {
-          const query: LogQuery = { sinceMs: parsed.from, untilMs: parsed.to, limit: TRACE_LIMIT + 1 };
+          const query: LogQuery = { sinceMs: parsed.from, untilMs: parsed.to, limit: TRACE_LIMIT + 1,
+            ...(projectId !== null ? { projectId, projectSessionIds: [...projectSessions!] } : {}) };
           const search = url.searchParams.get('q');
           if (search) query.grep = search;
           const page = entry.store.queryTraceRun(runId, query);
@@ -388,7 +400,7 @@ export function handleTrace(req: Request, opts: MetaApiOpts, deps: TraceDeps = {
         } catch (e) { return jsonResponse({ ok: false, error: 'log-store-unavailable', failedStores: [{ name, reason: e instanceof Error ? e.message : String(e) }] }, 503); }
       }
     }
-    const filtered = rows.filter((row) => matches(row, url)).sort(sortRows);
+    const filtered = rows.filter((row) => matches(row, url, projectSessions)).sort(sortRows);
     const trace = buildTrace(filtered.slice(0, parsed.limit), parsed.level, filtered.length > parsed.limit || candidateLimitReached || failures.length > 0 || resolution?.truncated === true);
     try { (deps.queryLog ?? ((details) => debug.log('logs.trace', 'query', details)))({ stores: names, level: parsed.level, count: trace.events.length, truncated: trace.truncated, mode: 'rows', runs: trace.nodes.filter((node) => node.level === 'L1' && node.count > 0).length }); } catch { /* query logging must not block reads */ }
     return jsonResponse({ ok: true, ...trace, stores: names, registeredStores: registeredStoreCount(deps), ...(resolution ? resolution.universe ? { resolvedFrom, runUniverse: resolution.universe, ...(resolvedFrom === 'log-scan' ? { checked: resolution.checked } : {}) } : { runUniverse: resolution.truncated || resolution.unresolved ? 'unresolved' as const : 'not-found' as const, checked: resolution.checked } : {}), ...(failures.length ? { failedStores: failures } : {}) }, 200);

package/src/nexus/api/workflow-run-event-bridge.ts

@@ -73,6 +73,7 @@ export function publishWorkflowRunEvent(
   const detail: Record<string, unknown> = {
     runId: ctx.runId,
     workflowName: ctx.workflowName,
+    ...(evt.mode !== undefined ? { mode: evt.mode } : {}),
   };
   if (evt.type === 'node_start' || evt.type === 'node_skipped' || evt.type === 'node_done') {
     detail.nodeId = evt.nodeId;

package/src/nexus/api/workflows.ts

@@ -40,8 +40,12 @@ import {
   parseWorkflowYaml,
   runWorkflow,
   saveWorkflow,
+  topoSort,
   type WorkflowDeps,
   type WorkflowEvent,
+  type WorkflowRunMode,
+  type NodeOutput,
+  type RunWorkflowOpts,
 } from '../../workflow-runtime/index.js';
 import { buildRunCft, buildRunSkill } from '../../workflow-runtime/deps-bridge.js';
 import {
@@ -59,6 +63,7 @@ import { runApprovalAcrossChannels } from './workflow-approval-multi-channel.js'
 interface RunRecord {
   runId: string;
   workflowName: string;
+  mode: WorkflowRunMode;
   startedAt: number;
   events: WorkflowEvent[];
   /** Settled state: undefined while running, true on workflow_done,
@@ -384,10 +389,51 @@ export async function handleWorkflowRunStart(
   // so the PWA "▶ Run now" button runs the dependent chain straight
   // through. Default false preserves the production wire.
   const dryRun: boolean = Boolean(body && typeof body === 'object' && (body as { dryRun?: unknown }).dryRun === true);
+  const input = body && typeof body === 'object' ? body as Record<string, unknown> : {};
+  const { onlyNode, fromNode, fromRunId } = input;
+  if ('usePins' in input || (onlyNode !== undefined && (fromNode !== undefined || fromRunId !== undefined))
+    || (onlyNode !== undefined && (typeof onlyNode !== 'string' || !onlyNode.trim()))
+    || (fromNode !== undefined && (typeof fromNode !== 'string' || !fromNode.trim()))
+    || (fromRunId !== undefined && (typeof fromRunId !== 'string' || !fromRunId.trim()))
+    || (fromNode === undefined) !== (fromRunId === undefined)
+    || (input.mode !== undefined && input.mode !== 'test')) {
+    return jsonResponse({ error: 'bad_request', reason: 'invalid run selection' }, 400);
+  }
+  if ((onlyNode && !entry.definition.nodes.some(n => n.id === onlyNode))
+    || (fromNode && !entry.definition.nodes.some(n => n.id === fromNode))) {
+    return jsonResponse({ error: 'bad_request', reason: 'unknown selected node' }, 400);
+  }
+  let previousOutputs: Record<string, NodeOutput> | undefined;
+  if (typeof fromRunId === 'string') {
+    const previous = RUN_REGISTRY.get(fromRunId);
+    if (previous) {
+      if (previous.workflowName !== name || previous.ok === undefined) {
+        return jsonResponse({ error: 'bad_request', reason: 'source run must be settled for this workflow' }, 400);
+      }
+      const terminal = previous.events.find(e => e.type === 'workflow_done' || e.type === 'workflow_failed');
+      previousOutputs = terminal?.type === 'workflow_done' ? terminal.outputs
+        : terminal?.type === 'workflow_failed' ? terminal.partial : {};
+    } else {
+      const disk = readRunOutputSnapshot(fromRunId);
+      if (!disk || disk.workflowName !== name || (disk.status !== 'done' && disk.status !== 'failed')) {
+        return jsonResponse({ error: 'bad_request', reason: 'source run must be settled for this workflow' }, 400);
+      }
+      previousOutputs = disk.outputs;
+    }
+    let order: string[];
+    try { order = topoSort(entry.definition.nodes); }
+    catch { return jsonResponse({ error: 'bad_request', reason: 'invalid workflow topology' }, 400); }
+    const upstream = order.slice(0, order.indexOf(fromNode as string));
+    if (upstream.some(id => previousOutputs?.[id] === undefined)) {
+      return jsonResponse({ error: 'bad_request', reason: 'source run missing upstream outputs' }, 400);
+    }
+  }
+  const mode: WorkflowRunMode = input.mode === 'test' ? 'test' : onlyNode ? 'only' : fromNode ? 'from' : 'full';
   const runId = `wf-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const record: RunRecord = {
     runId,
     workflowName: name,
+    mode,
     startedAt: Date.now(),
     events: [],
     ok: undefined,
@@ -400,10 +446,14 @@ export async function handleWorkflowRunStart(
   void (async () => {
     const deps = buildDefaultWorkflowDeps({ runId });
     try {
-      for await (const evt of runWorkflow(
-        { workflow: entry.definition, arguments: args, runId, dryRun },
-        deps,
-      )) {
+      const runOpts: RunWorkflowOpts = {
+        workflow: entry.definition, arguments: args, runId, dryRun, mode,
+        ...(typeof onlyNode === 'string' ? { onlyNode } : {}),
+        ...(typeof fromNode === 'string' ? { fromNode } : {}),
+        ...(previousOutputs ? { previousOutputs } : {}),
+      };
+      for await (const runtimeEvent of runWorkflow(runOpts, deps)) {
+        const evt = { ...runtimeEvent, mode };
         record.events.push(evt);
         // §15.8(b) — fan into NexusEventBus → PWA invalidates queries
         // on push instead of polling. No-op when bus is unwired
@@ -423,13 +473,14 @@ export async function handleWorkflowRunStart(
         type: 'workflow_failed' as const,
         error: err instanceof Error ? err.message : String(err),
         partial: {},
+        mode,
       };
       record.events.push(failEvt);
       publishWorkflowRunEvent({ runId, workflowName: name }, failEvt);
     }
   })();
 
-  return jsonResponse({ ok: true, runId }, 202);
+  return jsonResponse({ ok: true, runId, mode }, 202);
 }
 
 export function handleWorkflowRunGet(
@@ -444,6 +495,7 @@ export function handleWorkflowRunGet(
       {
         runId: rec.runId,
         workflowName: rec.workflowName,
+        mode: rec.mode,
         startedAt: rec.startedAt,
         ok: rec.ok,
         events: rec.events,
@@ -597,6 +649,21 @@ interface DiskRunSummary {
  *  enough that abandoned runs don't pollute the list across sessions. */
 const STALE_RUNNING_AFTER_MS = 30 * 60 * 1000;
 
+function readRunOutputSnapshot(runId: string): {
+  workflowName: string;
+  status: string;
+  outputs: Record<string, NodeOutput>;
+} | null {
+  if (!/^wf-[A-Za-z0-9-]+$/.test(runId) || runId.includes('..')) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(join(workflowsRunsRoot(), runId, 'run.json'), 'utf-8')) as {
+      workflowName?: string; status?: string; outputs?: Record<string, NodeOutput>;
+    };
+    if (!parsed.workflowName || !parsed.status || !parsed.outputs || typeof parsed.outputs !== 'object') return null;
+    return { workflowName: parsed.workflowName, status: parsed.status, outputs: parsed.outputs };
+  } catch { return null; }
+}
+
 /** Read `<root>/<runId>/run.json` and translate into the same shape as
  *  GET /runs/<id> serves from memory. Returns null when the file is
  *  missing or unreadable. Events are reconstructed minimally from the
@@ -608,6 +675,7 @@ function loadRunFromDisk(runId: string): {
   ok: boolean | undefined;
   events: WorkflowEvent[];
   outputs: Record<string, unknown>;
+  mode?: WorkflowRunMode;
 } | null {
   if (!runId || runId.includes('/') || runId.includes('..')) return null;
   const root = workflowsRunsRoot();
@@ -623,6 +691,7 @@ function loadRunFromDisk(runId: string): {
       completedAt?: number;
       ok?: boolean;
       status?: string;
+      mode?: WorkflowRunMode;
       outputs?: Record<string, { output?: unknown }>;
     };
     if (!parsed.runId || !parsed.workflowName) return null;
@@ -634,7 +703,8 @@ function loadRunFromDisk(runId: string): {
     // so a polling client still sees the node_done sequence even
     // though the live run.json doesn't store events.
     const events: WorkflowEvent[] = [];
-    events.push({ type: 'workflow_start', workflow: parsed.workflowName, runId: parsed.runId });
+    events.push({ type: 'workflow_start', workflow: parsed.workflowName, runId: parsed.runId,
+      ...(parsed.mode !== undefined ? { mode: parsed.mode } : {}) });
     const nodesDir = join(runDir, 'nodes');
     // Iterate `parsed.outputs` keys instead of `readdirSync(nodesDir)`
     // so the reconstructed node_done sequence is in execution order
@@ -673,6 +743,7 @@ function loadRunFromDisk(runId: string): {
       events.push({
         type: 'node_done',
         nodeId,
+        ...(parsed.mode !== undefined ? { mode: parsed.mode } : {}),
         result: {
           ok: nodeData.ok,
           output: nodeData.output ?? '',
@@ -684,6 +755,7 @@ function loadRunFromDisk(runId: string): {
     if (parsed.status === 'done') {
       events.push({
         type: 'workflow_done',
+        ...(parsed.mode !== undefined ? { mode: parsed.mode } : {}),
         outputs: Object.fromEntries(
           Object.entries(parsed.outputs ?? {}).map(([k, v]) => [
             k,
@@ -694,6 +766,7 @@ function loadRunFromDisk(runId: string): {
     } else if (parsed.status === 'failed') {
       events.push({
         type: 'workflow_failed',
+        ...(parsed.mode !== undefined ? { mode: parsed.mode } : {}),
         error: 'failed (see node events)',
         partial: Object.fromEntries(
           Object.entries(parsed.outputs ?? {}).map(([k, v]) => [
@@ -706,6 +779,7 @@ function loadRunFromDisk(runId: string): {
     return {
       runId: parsed.runId,
       workflowName: parsed.workflowName,
+      ...(parsed.mode !== undefined ? { mode: parsed.mode } : {}),
       startedAt: parsed.startedAt ?? 0,
       ok: parsed.status === 'done' ? true : parsed.status === 'failed' ? false : undefined,
       events,