elanous 0.2.10 → 0.2.11

package/src/mss/logging/log-store.ts

@@ -125,6 +125,9 @@ export interface LogQuery {
   /** event/data/category LIKE 부분 일치. */
   grep?: string;
   sessionId?: string;
+  /** Trace ownership: explicit row projectId takes precedence over session ownership. */
+  projectId?: string;
+  projectSessionIds?: readonly string[];
   sinceMs?: number;
   untilMs?: number;
   /** 증분 커서 — id > afterId 를 오름차순으로(SSE 드레인). */
@@ -397,6 +400,18 @@ export class LogStore {
       params.push(needle, needle, needle);
     }
     if (q.sessionId) { where.push('session_id = ?'); params.push(q.sessionId); }
+    if (q.projectId !== undefined) {
+      const sessionIds = [...new Set(q.projectSessionIds ?? [])];
+      // An explicit project tag wins, even if the row's session belongs to another project.
+      // Guard JSON extraction so malformed and absent payloads cannot match by accident.
+      const tagged = "CASE WHEN json_valid(data) THEN json_extract(data, '$.projectId') ELSE NULL END";
+      const session = "CASE WHEN json_valid(data) THEN json_extract(data, '$.sessionId') ELSE NULL END";
+      const untagged = "CASE WHEN json_valid(data) THEN json_type(data, '$.projectId') IS NULL ELSE 1 END";
+      where.push(`(${tagged} = ? OR (${untagged} AND (${sessionIds.length
+        ? `session_id IN (${sessionIds.map(() => '?').join(',')}) OR ${session} IN (${sessionIds.map(() => '?').join(',')})`
+        : '0'})))`);
+      params.push(q.projectId, ...sessionIds, ...sessionIds);
+    }
     if (q.sinceMs !== undefined) { where.push('ts_ms >= ?'); params.push(q.sinceMs); }
     if (q.untilMs !== undefined) { where.push('ts_ms <= ?'); params.push(q.untilMs); }
     if (q.afterId !== undefined) { where.push('id > ?'); params.push(q.afterId); }

package/src/nexus/api/config-model-tier.ts

@@ -39,7 +39,7 @@ function jsonResponse(body: unknown, status = 200): Response {
 
 import {
   isModelTier,
-  isModelTierPersona,
+  isModelTierProfile,
   type BudgetUserConfig,
   type ModelTier,
   type ModelTierUserConfig,
@@ -74,9 +74,10 @@ function normalizeModelTier(v: unknown): ModelTierUserConfig | undefined | 'inva
   if (!v || typeof v !== 'object' || Array.isArray(v)) return 'invalid';
   const r = v as Record<string, unknown>;
   const out: ModelTierUserConfig = {};
-  if (r.persona !== undefined) {
-    if (!isModelTierPersona(r.persona)) return 'invalid';
-    out.persona = r.persona;
+  const profile = r.profile === undefined ? r.persona : r.profile;
+  if (profile !== undefined) {
+    if (!isModelTierProfile(profile)) return 'invalid';
+    out.profile = profile;
   }
   if (r.preset !== undefined) {
     if (typeof r.preset !== 'string' || r.preset.trim().length === 0) return 'invalid';

package/src/nexus/api/fabric-plans.ts

@@ -0,0 +1,53 @@
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import {
+  approveFabricPlan,
+  createFabricPlan,
+  loadFabricPlan,
+  type FabricPlan,
+} from '../../self-dev/fabric-plan-core.js';
+import { jsonResponse } from './json-response.js';
+
+export interface FabricPlansRouteOpts {
+  create?: (root: string, request: string) => Promise<FabricPlan>;
+}
+
+/** This route never launches a plan. Only approval writes the fabric execution-candidate ledger. */
+export async function handleFabricPlans(req: Request, opts: FabricPlansRouteOpts = {}): Promise<Response> {
+  const pathname = new URL(req.url).pathname;
+  const root = effectiveInstanceRoot();
+  if (pathname === '/v1/fabric/decompose') {
+    if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    let body: unknown;
+    try { body = await req.json(); }
+    catch { return jsonResponse({ error: 'invalid_json' }, 400); }
+    const request = body && typeof body === 'object' && !Array.isArray(body)
+      ? (body as Record<string, unknown>).request : undefined;
+    if (typeof request !== 'string' || !request.trim()) return jsonResponse({ error: 'invalid_request' }, 400);
+    try {
+      const plan = await (opts.create ?? createFabricPlan)(root, request);
+      return jsonResponse({ plan }, 201);
+    } catch (error) {
+      return jsonResponse({ error: 'decomposition_failed', reason: error instanceof Error ? error.message : String(error) }, 422);
+    }
+  }
+  const match = /^\/v1\/fabric\/plans\/([^/]+)(\/approve)?$/.exec(pathname);
+  if (!match) return jsonResponse({ error: 'not-found' }, 404);
+  let id: string;
+  try { id = decodeURIComponent(match[1]!); }
+  catch { return jsonResponse({ error: 'invalid_plan_id' }, 400); }
+  if (!/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(id)) return jsonResponse({ error: 'invalid_plan_id' }, 400);
+  if (!match[2]) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    const plan = loadFabricPlan(root, id);
+    return plan ? jsonResponse({ plan }) : jsonResponse({ error: 'not-found' }, 404);
+  }
+  if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  // The ledger transition is atomic and rejects a second approval; no draft is executable.
+  try {
+    return jsonResponse({ candidate: approveFabricPlan(root, id) });
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('fabric plan not found:')) return jsonResponse({ error: 'not-found' }, 404);
+    if (error instanceof Error && error.message === 'fabric plan already approved') return jsonResponse({ error: 'already-approved' }, 409);
+    throw error;
+  }
+}

package/src/nexus/api/harness-api.ts

@@ -19,6 +19,7 @@ import { resolveHarnessTarget } from '../../self-implement/harness-target-option
 import { queryRunningRuns, type RunningRunsResult } from '../../self-implement/running-runs.js';
 import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
 import { createSeqTracker, makeEnvelope, type FeedbackEnvelope } from '../../feedback/envelope.js';
+import { publishInsideEvent } from './inside-events.js';
 
 const JSON_HEADERS = { 'content-type': 'application/json; charset=utf-8' };
 const ASK_USAGE = 'usage: POST /v1/harness/ask with JSON body {"text":"<ask>"} — optional "target":"<path>" (홈 안의 git repo·디렉터리·파일)';
@@ -248,7 +249,10 @@ export async function handleHarnessAskPost(req: Request, _metaApi: HarnessMetaAp
   }
 
   const acceptanceId = deps.createAcceptanceId?.() ?? crypto.randomUUID();
-  const log = deps.log ?? ((event, data) => debug.log('harness-http', event, data));
+  const log = (event: string, data: Record<string, unknown>) => {
+    (deps.log ?? ((name: string, payload: Record<string, unknown>) => debug.log('harness-http', name, payload)))(event, data);
+    publishInsideEvent({ ...data, kind: 'harness-run', event });
+  };
   const suppliedOrigin = (body as { origin?: unknown }).origin;
   const origin = suppliedOrigin === undefined ? null
     : readReportOrigin({ [REPORT_ORIGIN_ENV]: JSON.stringify(suppliedOrigin) });

package/src/nexus/api/health.ts

@@ -128,6 +128,8 @@ export function handleHealth(
     universeRoot: safeUniverseRoot(),
     testUniverse: safeTestUniverse(),
     bindHost: safeBindHost(bind),
+    // W4 — POST /v1/workflows/:name/run understands onlyNode · fromNode+fromRunId · mode (PWA enables its run-mode buttons on this).
+    workflowRunModes: true as const,
     ...(setup?.mode === true
       ? { setupMode: true as const, setupMissing: setup.missing }
       : {}),

package/src/nexus/api/http-server.ts

@@ -21,6 +21,7 @@ import type { TelegramEvent } from '../../workflow-runtime/triggers/telegram-sou
 import { spawnSync } from 'node:child_process';
 import { isAbsolute } from 'node:path';
 import { createProject, listProjects } from '../../project/project-store.js';
+import { handleOutputsGet, type OutputsDeps } from './outputs-route.js';
 import { compareTokenConstTime } from '../../acp/transport/auth.js';
 import { ensureAuthToken } from '../../auth/acp-token.js';
 import type { NexusState } from '../state/state.js';
@@ -42,6 +43,7 @@ import { OPENAI_RELAY_PATH, tryHandleOpenAiRelay } from './openai-relay.js';
 import { handleHealth, type HealthSetupContext } from './health.js';
 import { handleTabsList, handleTabDetail, handleNexusSnapshot } from './tabs.js';
 import { handleSseEvents } from './events.js';
+import { handleInsideEvents, INSIDE_EVENTS_PATH, startInsideEventRelay } from './inside-events.js';
 import { dispatchIntentPredictionRoute } from './intent-prediction.js';
 import { handleNotificationAction } from './notification-action.js';
 import { handleUserIntentEmit, handleUserIntentBatch } from './user-intents.js';
@@ -157,6 +159,7 @@ import {
 } from './vault-api.js';
 import { handleBuildsGet, parseBuildsPath } from './builds-api.js';
 import { handleHarnessAskPost, handleHarnessAskStatusGet, handleHarnessRunEventsGet, handleHarnessRunScreenGet, handleHarnessRunsGet, handleHarnessStopPost } from './harness-api.js';
+import { handleFabricPlans, type FabricPlansRouteOpts } from './fabric-plans.js';
 import { dispatchPersonaRoute } from './personas.js';
 import { handleMe } from './operator.js';
 import { handleOpsApi } from './ops-api.js';
@@ -178,6 +181,7 @@ import { handleChannelBotsGet, handleChannelBotSet } from './setup-channel-bot.j
 import { handleLlmRoutePredict } from './llm-route-predict.js';
 import type { MissionRouter } from '../../llm/mission-router.js';
 import { handleContextFetchUrl } from './context-url.js';
+import { contextNow } from '../../context-bus/context-now.js';
 import type { IntentPredictionService } from '../../intent-prediction/index.js';
 import type { NotificationActionLoopback } from '../../web-push/notification-action-loopback.js';
 import { handlePlatforms } from './platforms.js';
@@ -461,8 +465,11 @@ export function probeNexusHttpPort(
 export type NexusWsBridgeInit = Omit<WsBridgeOpts, 'hostname' | 'port'>;
 
 export interface NexusHttpServerOpts {
+  /** Optional fabric-plan ledger and decomposition seam; production uses the instance root and existing fabric decomposer. */
+  fabricPlans?: FabricPlansRouteOpts;
   /** Optional installer state root for isolated API consumers and tests. */
   pluginStateRoot?: string;
+  outputs?: OutputsDeps;
   execRequests?: ExecRequestRunner;
   seatRequests?: SeatRequestsDeps;
   consultRequests?: ConsultRequestsDeps;
@@ -790,11 +797,13 @@ export function startNexusHttpServer(opts: NexusHttpServerOpts): NexusHttpServer
   }
 
   const url = `http://${hostname}:${resolvedPort}`;
+  const stopInsideRelay = startInsideEventRelay();
   return {
     port: resolvedPort,
     hostname,
     url,
     stop() {
+      stopInsideRelay();
       try { server!.stop(true); } catch { /* idempotent */ }
       setInProcessOutbound(null);
     },
@@ -984,6 +993,11 @@ export async function routeRequest(
     }
   }
 
+  if (pathname === INSIDE_EVENTS_PATH) {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleInsideEvents(req);
+  }
+
   if (pathname === LIVE_SHIPPED_PATH) {
     return handleLiveShipped(req, { authorize: (request) => !!opts.metaApi && checkAuth(request, opts.metaApi) });
   }
@@ -1312,11 +1326,21 @@ export async function routeRequest(
     return handleGraphsValidatePost(req, opts.metaApi);
   }
 
+  if (pathname === '/v1/fabric/decompose' || pathname.startsWith('/v1/fabric/plans/')) {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleFabricPlans(req, opts.fabricPlans);
+  }
+
   if (pathname === '/v1/projects' && (method === 'GET' || method === 'POST')) {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
     return method === 'GET' ? handleProjectsGet() : handleProjectsPost(req);
   }
 
+  if (method === 'GET' && pathname === '/v1/outputs') {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return handleOutputsGet(req, opts.outputs);
+  }
+
   if (pathname === '/v1/config/chat-fast-path' && (method === 'GET' || method === 'PUT')) {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
     return handleChatFastPathConfig(req);
@@ -1328,6 +1352,14 @@ export async function routeRequest(
     return (opts.usageHandler ?? handleUsageGet)();
   }
 
+  // SK2 (PWA) list — GET must be routed before the non-GET block below; the original route sat inside it,
+  // so the PWA banner's GET always fell through to «not-found» (found by the DEMO-RUNa rehearsal · 10-03).
+  if (method === 'GET' && pathname === '/v1/skills/problems') {
+    if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
+    const { handleSkillProblems } = await import('./skill-problems.js');
+    return handleSkillProblems(req, opts.metaApi);
+  }
+
   // Mutation routes (PR ι) — POST/PATCH/DELETE on /v1/nexus/tabs[/:id[/action]].
   // Templates POST handled here too (PR κ).
   // Config / secrets PUT/POST/DELETE here too (PR μ).
@@ -2775,6 +2807,10 @@ export async function routeRequest(
     const result = await dispatchPersonaRoute(req, pathname);
     if (result) return result;
   }
+  if (pathname === '/v1/context/now') {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return jsonResponse(contextNow({ ...(url.searchParams.has('topic') ? { topic: url.searchParams.get('topic') ?? '' } : {}) }));
+  }
   // §6.3 (2026-05-09) — context URL fetch (showroom).
   // POST /v1/context/fetch-url
   if (pathname === '/v1/context/fetch-url') {

package/src/nexus/api/inside-events.ts

@@ -0,0 +1,226 @@
+import { randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, openSync, closeSync, readSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { StringDecoder } from 'node:string_decoder';
+import { debug } from '../../debug/log.js';
+import { nexusRootDir } from '../paths.js';
+import { SSE_HEARTBEAT_MS } from './sse-heartbeat.js';
+
+/** The node envelope matches apps/pwa/src/lib/inside-events.ts without importing browser code. */
+export interface InsideNodeEvent {
+  kind: 'node';
+  graphId: string;
+  runId: string;
+  nodeId: string;
+  phase: 'start' | 'ok' | 'fail';
+  ts: string;
+  seconds?: number;
+}
+
+/** Other producers can add their own domain fields without changing the transport. */
+export type InsideLiveEvent = InsideNodeEvent | ({ kind: string; ts: string } & Record<string, unknown>);
+export type InsideEventInput = { kind: string; ts?: string } & Record<string, unknown>;
+
+export const INSIDE_EVENTS_PATH = '/v1/inside/events';
+const MAX_PENDING_FRAMES = 16;
+const MAX_FRAME_BYTES = 64 * 1024;
+const MASK = '[REDACTED]';
+const SECRET_KEY = /(?:secret|password|passwd|token|api[_-]?key|authorization|credential|private[_-]?key|cookie|session[_-]?key)/i;
+const INLINE_SECRET = /\b((?:Bearer|Basic)\s+|(?:sk|ghp|gho|ghu|ghs|ghr|github_pat|glpat|xox[baprs])[-_])[^\s"'`,;]+/gi;
+const ASSIGNMENT_SECRET = /\b((?:api[_-]?key|(?:access[_-]?)?token|secret|password|authorization)\s*[:=]\s*)(?:(["'])[^\r\n]*?\2|[^\s"'`,;]+)/gi;
+
+function maskString(value: string): string {
+  return value.replace(INLINE_SECRET, `$1${MASK}`)
+    .replace(ASSIGNMENT_SECRET, (_match, prefix: string, quote?: string) => `${prefix}${quote ?? ''}${MASK}${quote ?? ''}`);
+}
+
+/** Sanitize before fan-out; never put an unmasked payload in the subscriber queue. */
+export function maskInsideEventValue(value: unknown, seen = new WeakSet<object>()): unknown {
+  if (typeof value === 'string') return maskString(value);
+  if (!value || typeof value !== 'object') return value;
+  if (seen.has(value)) return MASK;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value.map((item) => maskInsideEventValue(item, seen));
+    seen.delete(value);
+    return result;
+  }
+  const result: Record<string, unknown> = {};
+  for (const [key, item] of Object.entries(value)) {
+    result[key] = SECRET_KEY.test(key) ? MASK : maskInsideEventValue(item, seen);
+  }
+  seen.delete(value);
+  return result;
+}
+
+type Listener = (event: InsideLiveEvent) => void;
+const listeners = new Set<Listener>();
+const RELAY_INTERVAL_MS = 20;
+const RELAY_MAX_RECORD_BYTES = 64 * 1024;
+const RELAY_ROTATE_BYTES = 4 * 1024 * 1024;
+const RELAY_RETIRE_GRACE_MS = 2000;
+const relayIdentity = randomUUID();
+
+function relayPaths() {
+  const root = nexusRootDir();
+  return { root, pointer: join(root, 'inside-events-relay.json') };
+}
+
+function dispatch(event: InsideLiveEvent): void {
+  for (const listener of listeners) {
+    try { listener(event); } catch { /* a disconnected observer must not stop a run */ }
+  }
+}
+
+/** Each daemon owns its journal; child processes append masked records to that journal.
+ *  The journal rotates once fully consumed past RELAY_ROTATE_BYTES: the pointer moves to a fresh file and the old one is
+ *  drained for a grace period (producers that read the old pointer may still append) before it is removed. */
+export function startInsideEventRelay(opts: { rotateBytes?: number; retireGraceMs?: number } = {}): () => void {
+  const { root, pointer } = relayPaths();
+  mkdirSync(root, { recursive: true });
+  const rotateBytes = opts.rotateBytes ?? RELAY_ROTATE_BYTES;
+  const retireGraceMs = opts.retireGraceMs ?? RELAY_RETIRE_GRACE_MS;
+  type Journal = { file: string; offset: number; pending: string; decoder: StringDecoder; retireAt?: number };
+  const journals: Journal[] = [];
+  let descriptor = '';
+  const open = (): Journal => {
+    const id = randomUUID();
+    const file = join(root, `inside-events-${id}.jsonl`);
+    writeFileSync(file, '', { mode: 0o600, flag: 'wx' });
+    descriptor = JSON.stringify({ pid: process.pid, id });
+    writeFileSync(pointer, descriptor, { mode: 0o600 });
+    const journal: Journal = { file, offset: 0, pending: '', decoder: new StringDecoder('utf8') };
+    journals.push(journal);
+    return journal;
+  };
+  let current = open();
+  const drain = (journal: Journal): void => {
+    const size = statSync(journal.file).size;
+    if (size < journal.offset) { journal.offset = 0; journal.pending = ''; journal.decoder = new StringDecoder('utf8'); }
+    while (size > journal.offset) {
+      const count = Math.min(size - journal.offset, 1024 * 1024);
+      const chunk = Buffer.alloc(count);
+      const fd = openSync(journal.file, 'r');
+      let length: number;
+      try { length = readSync(fd, chunk, 0, count, journal.offset); }
+      finally { closeSync(fd); }
+      if (length <= 0) break;
+      journal.offset += length;
+      // A chunk boundary may split a multi-byte character; the decoder carries the partial bytes into the next read.
+      journal.pending += journal.decoder.write(chunk.subarray(0, length));
+      const lines = journal.pending.split('\n');
+      journal.pending = lines.pop() ?? '';
+      if (journal.pending.length > RELAY_MAX_RECORD_BYTES) journal.pending = '';
+      for (const line of lines) {
+        if (line.length > RELAY_MAX_RECORD_BYTES) continue;
+        try {
+          const record = JSON.parse(line) as { origin?: string; event?: InsideEventInput };
+          if (record.origin === relayIdentity || !record.event || typeof record.event.kind !== 'string'
+            || !/^[a-z][a-z0-9._-]*$/i.test(record.event.kind)) continue;
+          dispatch(maskInsideEventValue(record.event) as InsideLiveEvent);
+        } catch { /* malformed producer record */ }
+      }
+    }
+  };
+  const remove = (journal: Journal): void => {
+    try { unlinkSync(journal.file); } catch { /* already removed */ }
+    journals.splice(journals.indexOf(journal), 1);
+  };
+  const timer = setInterval(() => {
+    for (const journal of [...journals]) {
+      try { drain(journal); } catch { /* journal disappeared during shutdown */ }
+      if (journal.retireAt !== undefined && Date.now() >= journal.retireAt && journal.pending === '') remove(journal);
+    }
+    if (current.offset >= rotateBytes && current.pending === '') {
+      try {
+        current.retireAt = Date.now() + retireGraceMs;
+        current = open();
+        debug.log('inside.events', 'relay-rotated', { journals: journals.length });
+      } catch { /* keep appending to the current journal */ }
+    }
+  }, RELAY_INTERVAL_MS);
+  timer.unref();
+  return () => {
+    clearInterval(timer);
+    try { if (readFileSync(pointer, 'utf8') === descriptor) unlinkSync(pointer); } catch { /* another daemon owns it */ }
+    for (const journal of [...journals]) remove(journal);
+  };
+}
+
+/** Ordered local delivery plus best-effort cross-process delivery to the current daemon. */
+export function publishInsideEvent(event: InsideEventInput): void {
+  if (!event || typeof event.kind !== 'string' || !/^[a-z][a-z0-9._-]*$/i.test(event.kind)) return;
+  const safe = maskInsideEventValue({ ...event, ts: event.ts ?? new Date().toISOString() }) as InsideLiveEvent;
+  dispatch(safe);
+  try {
+    const { root, pointer } = relayPaths();
+    if (!existsSync(pointer)) return;
+    const descriptor = JSON.parse(readFileSync(pointer, 'utf8')) as { pid?: number; id?: string };
+    if (!Number.isSafeInteger(descriptor.pid) || typeof descriptor.id !== 'string' || !/^[a-f0-9-]{36}$/.test(descriptor.id)) return;
+    process.kill(descriptor.pid!, 0);
+    const file = join(root, `inside-events-${descriptor.id}.jsonl`);
+    const line = JSON.stringify({ origin: relayIdentity, event: safe }) + '\n';
+    if (Buffer.byteLength(line) > RELAY_MAX_RECORD_BYTES) return;
+    appendFileSync(file, line, { mode: 0o600, flag: 'a' });
+  } catch { /* a missing daemon must not interrupt the producer */ }
+}
+
+export function subscribeInsideEvent(listener: Listener): () => void {
+  listeners.add(listener);
+  return () => { listeners.delete(listener); };
+}
+
+/** No history/replay: the stream starts at the moment a client subscribes. */
+export function handleInsideEvents(req: Request): Response {
+  if (req.method !== 'GET') return new Response(null, { status: 405, headers: { allow: 'GET' } });
+  const encoder = new TextEncoder();
+  let cleanup: (() => void) | undefined;
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      let closed = false;
+      let unsubscribe = () => {};
+      let heartbeat: ReturnType<typeof setInterval> | undefined;
+      const onAbort = () => close();
+      cleanup = () => {
+        if (closed) return;
+        closed = true;
+        if (heartbeat !== undefined) clearInterval(heartbeat);
+        unsubscribe();
+        req.signal.removeEventListener('abort', onAbort);
+      };
+      const close = () => {
+        cleanup?.();
+        try { controller.close(); } catch { /* cancelled already */ }
+      };
+      const send = (text: string): void => {
+        if (closed) return;
+        const bytes = encoder.encode(text);
+        if (bytes.byteLength > MAX_FRAME_BYTES || (controller.desiredSize ?? 0) <= 0) {
+          close();
+          return;
+        }
+        try { controller.enqueue(bytes); } catch { close(); }
+      };
+      if (req.signal.aborted) {
+        close();
+        return;
+      }
+      unsubscribe = subscribeInsideEvent((event) => {
+        send(`event: ${event.kind}\ndata: ${JSON.stringify(event)}\n\n`);
+      });
+      heartbeat = setInterval(() => send(': ping\n\n'), SSE_HEARTBEAT_MS);
+      req.signal.addEventListener('abort', onAbort, { once: true });
+      if (req.signal.aborted) close();
+      else send(': inside events stream\n\n');
+    },
+    cancel() { cleanup?.(); },
+  }, { highWaterMark: MAX_PENDING_FRAMES, size: () => 1 });
+  return new Response(stream, {
+    headers: {
+      'content-type': 'text/event-stream; charset=utf-8',
+      'cache-control': 'no-cache, no-transform',
+      'x-accel-buffering': 'no',
+      connection: 'keep-alive',
+    },
+  });
+}

package/src/nexus/api/meta-api.ts

@@ -81,6 +81,7 @@ import { createPwaConfirmChannel, createPwaQuestionChannel } from './hitl-pwa-ch
 import type { NexusEventBus } from './event-bus.js';
 import { jsonResponse } from './http-server.js';
 import { defaultChatEventBus } from './chat-event-bus.js';
+import { resolveSessionProjectContext } from '../../project/session-context.js';
 
 const MIME_BY_EXT: Record<string, string> = {
   '.png': 'image/png',
@@ -803,13 +804,18 @@ export async function handlePromptPost(
 ): Promise<Response> {
   if (!checkAuth(req, opts)) return authFailureResponse(req, opts);
   if (!opts.history) return jsonResponse({ error: RUNTIME_NOT_WIRED }, 503);
-  let body: DaemonPromptBody;
+  let rawBody: unknown;
   try {
-    body = (await req.json()) as DaemonPromptBody;
+    rawBody = await req.json();
   } catch {
     return badRequest('invalid JSON body');
   }
-  const parsed = parseDaemonPromptBody(body, opts.systemPrompt);
+  if (!rawBody || typeof rawBody !== 'object' || Array.isArray(rawBody)) {
+    return badRequest('userText or userContent required');
+  }
+  const body = rawBody as DaemonPromptBody;
+  const projectContext = resolveSessionProjectContext(typeof body.sessionId === 'string' ? body.sessionId : undefined);
+  const parsed = parseDaemonPromptBody(body, projectContext?.instructions ? [opts.systemPrompt, projectContext.instructions].filter(Boolean).join('\n\n') : opts.systemPrompt);
   if (!parsed.ok) return badRequest(parsed.reason);
   const submit = createDaemonPromptTurnSubmit({
     kind: 'submit-turn',
@@ -843,7 +849,8 @@ export async function handlePromptPost(
         ...((owner) => owner ? { verifiedOwner: owner } : {})(promptVerifiedOwner(req, opts)),
         ...(resolvePromptHitlChannels(typeof body.sessionId === 'string' ? body.sessionId : '', opts) ?? {}),
         ...(effectiveSurface ? { toolSurface: effectiveSurface } : {}),
-        ...(opts.toolCwd ? { toolCwd: opts.toolCwd } : {}),
+        ...(projectContext?.cwd || opts.toolCwd ? { toolCwd: projectContext?.cwd ?? opts.toolCwd } : {}),
+        ...(projectContext?.instructions ? { projectInstructions: projectContext.instructions } : {}),
         dispatchToolErrorMessage: 'NEXUS prompt runtime has no tool surface (start nexus with `--tools readonly|webterm`)',
         });
       },
@@ -930,13 +937,18 @@ export async function handlePromptStreamPost(
 ): Promise<Response> {
   if (!checkAuth(req, opts)) return authFailureResponse(req, opts);
   if (!opts.history) return jsonResponse({ error: RUNTIME_NOT_WIRED }, 503);
-  let body: DaemonPromptBody;
+  let rawBody: unknown;
   try {
-    body = (await req.json()) as DaemonPromptBody;
+    rawBody = await req.json();
   } catch {
     return badRequest('invalid JSON body');
   }
-  const parsed = parseDaemonPromptBody(body, opts.systemPrompt);
+  if (!rawBody || typeof rawBody !== 'object' || Array.isArray(rawBody)) {
+    return badRequest('userText or userContent required');
+  }
+  const body = rawBody as DaemonPromptBody;
+  const projectContext = resolveSessionProjectContext(typeof body.sessionId === 'string' ? body.sessionId : undefined);
+  const parsed = parseDaemonPromptBody(body, projectContext?.instructions ? [opts.systemPrompt, projectContext.instructions].filter(Boolean).join('\n\n') : opts.systemPrompt);
   if (!parsed.ok) return badRequest(parsed.reason);
   // M6 PR 1 (PLAN-rich-dev-feedback-multi-surface · 2026-05-13) — opt-in
   // debug-tap. PWA `/chat?debug-tap=on` propagates the query down to
@@ -1201,7 +1213,8 @@ export async function handlePromptStreamPost(
                 ...((owner) => owner ? { verifiedOwner: owner } : {})(promptVerifiedOwner(req, opts)),
                 ...(resolvePromptHitlChannels(typeof body.sessionId === 'string' ? body.sessionId : '', opts) ?? {}),
                 ...(effectiveSurface ? { toolSurface: effectiveSurface } : {}),
-                ...(opts.toolCwd ? { toolCwd: opts.toolCwd } : {}),
+                ...(projectContext?.cwd || opts.toolCwd ? { toolCwd: projectContext?.cwd ?? opts.toolCwd } : {}),
+                ...(projectContext?.instructions ? { projectInstructions: projectContext.instructions } : {}),
                 signal: turnAbortController.signal,
                 onTextDelta: dualEmitTextDelta,
                 onImageBlock: dualEmitImageBlock,

package/src/nexus/api/missions.ts

@@ -20,6 +20,7 @@
  * Query params (list):
  *   status=<MissionStatus>   filter by status (active / planning / ...)
  *   goalSlug=<slug>          filter by goal binding
+ *   projectId=<id>          filter by project association
  *
  * Cross-ref:
  *   src/task-orchestrator/store.ts (listMissions · getMission ·
@@ -53,6 +54,7 @@ export interface MissionCardWire {
   status: MissionStatus;
   priority: Mission['priority'];
   goalSlug: string | null;
+  projectId?: string;
   taskCount: number;
   /** Counts so the PWA mission lane shows progress at a glance. */
   taskStatusCounts: Record<string, number>;
@@ -85,6 +87,7 @@ export function summarise(mission: Mission, tasks: readonly Task[]): MissionCard
     status: mission.status,
     priority: mission.priority,
     goalSlug: mission.goalSlug ?? null,
+    ...(mission.projectId !== undefined ? { projectId: mission.projectId } : {}),
     taskCount: tasks.length,
     taskStatusCounts,
     surfaceKindCounts,
@@ -103,9 +106,11 @@ export function handleMissionsList(
   const url = new URL(req.url);
   const statusParam = url.searchParams.get('status');
   const goalSlug = url.searchParams.get('goalSlug') ?? undefined;
-  const filter: { status?: MissionStatus; goalSlug?: string } = {};
+  const projectId = url.searchParams.get('projectId') ?? undefined;
+  const filter: { status?: MissionStatus; goalSlug?: string; projectId?: string } = {};
   if (statusParam && isMissionStatus(statusParam)) filter.status = statusParam;
   if (goalSlug) filter.goalSlug = goalSlug;
+  if (projectId !== undefined) filter.projectId = projectId;
 
   const store = new TaskStore();
   try {