elanous 0.2.9 → 0.2.11

package/src/memory.ts

@@ -35,6 +35,7 @@ import { randomUUID, createHash } from 'node:crypto';
 import { debug } from './debug/log.js';
 import { estimateTokens } from './tokens.js';
 import { budgetModel } from './llm/model-defaults.js';
+import { getAppliedGlobalTestRoot } from './cli/test-flag.js';
 
 /**
  * 임시 파일 → fsync → rename → 폴더 fsync. rename 만으로는 «원자적»이지만 «내구적»이 아니다.
@@ -86,14 +87,16 @@ export interface MemoryEntry {
    *  Use for core / safety / reference-location facts that must always be
    *  in context. Costs tokens every turn, so keep pinned bodies short. */
   pinned: boolean;
+  /** Optional pinned-memory freshness window; absent memories retain their original injection text. */
+  staleAfterMinutes?: number;
 }
 
 // ── Paths ────────────────────────────────────────────────────────────
 
 export function memoryRoot(): string {
-  const base = process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.trim()
+  const base = getAppliedGlobalTestRoot() ?? (process.env.XDG_DATA_HOME && process.env.XDG_DATA_HOME.trim()
     ? process.env.XDG_DATA_HOME
-    : join(homedir(), '.local', 'share');
+    : join(homedir(), '.local', 'share'));
   return join(base, 'elanous', 'memory');
 }
 
@@ -124,6 +127,12 @@ function parseFrontmatter(raw: string): { fm: Record<string, string>; body: stri
   return { fm, body };
 }
 
+function parseStaleAfterMinutes(value: string | number | undefined): number | undefined {
+  if (value === undefined || value === '') return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+
 function renderFrontmatter(fm: Record<string, string>, body: string): string {
   const lines = ['---'];
   for (const [k, v] of Object.entries(fm)) lines.push(`${k}: ${v}`);
@@ -179,6 +188,8 @@ export interface SaveMemoryOpts {
   priority?: number;
   /** Always-inject (bypass keyword gate). Default false — or preserve on update. */
   pinned?: boolean;
+  /** Pinned injection warns after this many minutes; preserved on update. */
+  staleAfterMinutes?: number;
   /** Override the generated id (tests). */
   id?: string;
 }
@@ -195,16 +206,19 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   let createdAt = now;
   let existingPriority: number | undefined;
   let existingPinned: boolean | undefined;
+  let existingStaleAfterMinutes: number | undefined;
   if (existsSync(path)) {
     try {
       const parsed = parseFrontmatter(readFileSync(path, 'utf-8'));
       if (parsed.fm.created) createdAt = parsed.fm.created;
       if (parsed.fm.priority) existingPriority = parseInt(parsed.fm.priority, 10) || 0;
       if (parsed.fm.pinned) existingPinned = parsed.fm.pinned === 'true';
+      existingStaleAfterMinutes = parseStaleAfterMinutes(parsed.fm['stale-after-minutes']);
     } catch { /* keep new createdAt */ }
   }
   const priority = opts.priority ?? existingPriority ?? 0;
   const pinned = opts.pinned ?? existingPinned ?? false;
+  const staleAfterMinutes = parseStaleAfterMinutes(opts.staleAfterMinutes) ?? existingStaleAfterMinutes;
   const frontmatter: Record<string, string> = {
     name: opts.name,
     description: opts.description,
@@ -214,6 +228,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   };
   if (priority > 0) frontmatter.priority = String(Math.floor(priority));
   if (pinned) frontmatter.pinned = 'true';
+  if (staleAfterMinutes !== undefined) frontmatter['stale-after-minutes'] = String(staleAfterMinutes);
   const raw = renderFrontmatter(frontmatter, opts.body);
   writeFileDurable(path, raw);
 
@@ -232,6 +247,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
     keywords: extractKeywords(`${opts.name} ${opts.description}`),
     priority,
     pinned,
+    staleAfterMinutes,
   };
 }
 
@@ -257,6 +273,7 @@ function parseMemoryFile(path: string): MemoryEntry | null {
     keywords: extractKeywords(`${fm.name} ${fm.description ?? ''}`),
     priority: fm.priority ? (parseInt(fm.priority, 10) || 0) : 0,
     pinned: fm.pinned === 'true',
+    staleAfterMinutes: parseStaleAfterMinutes(fm['stale-after-minutes']),
   };
 }
 
@@ -432,6 +449,17 @@ export function readIndex(root: string = memoryRoot()): string {
 
 // ── Injection heuristic ──────────────────────────────────────────────
 
+function pinnedChunk(e: MemoryEntry): string {
+  const header = `### 📌 [${e.type}] ${e.name}\n\n`;
+  const body = (e.body || '').trim() || e.description;
+  const updated = Date.parse(e.updatedAt);
+  if (e.staleAfterMinutes === undefined || !Number.isFinite(updated)) return header + body;
+  const ageMinutes = (Date.now() - updated) / 60_000;
+  if (ageMinutes <= e.staleAfterMinutes) return header + body;
+  const hours = Math.floor(ageMinutes / 60);
+  return header + `⚠️ 이 기억은 ${hours}시간 전 것이다 — 답하기 전에 원장 도구 release_status(판 일정·칸) · decisions_pending(미결 결정) · ops_seats(자리 현황)로 다시 확인하고, 확인 전에는 «확인 중»이라고 말한다.\n${body}`;
+}
+
 export interface InjectionResult {
   /** Markdown block to prepend to the system prompt (or '' when empty). */
   block: string;
@@ -490,7 +518,7 @@ export function buildMemoryInjection(
   const pinnedMems = listMemories({}, root).filter(m => m.pinned).sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
-    const chunk = `### 📌 [${e.type}] ${e.name}\n\n${(e.body || '').trim() || e.description}`;
+    const chunk = pinnedChunk(e);
     const tok = estimateTokens(chunk);
     if (usedTokens + tok > maxTokens) break;
     pinnedParts.push(chunk);
@@ -653,7 +681,7 @@ export async function buildMemoryInjectionLLM(
   const pinnedMems = listMemories({}, root).filter((m) => m.pinned).sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
-    const chunk = `### 📌 [${e.type}] ${e.name}\n\n${(e.body || '').trim() || e.description}`;
+    const chunk = pinnedChunk(e);
     const tok = estimateTokens(chunk);
     if (usedTokens + tok > maxTokens) break;
     pinnedParts.push(chunk); injected.push(e.id); usedTokens += tok;

package/src/model-tier/index.ts

@@ -7,12 +7,12 @@ export {
   MODEL_TIER_LABELS,
   TTS_VOICE_CONTEXTS,
   isModelTier,
-  isModelTierPersona,
+  isModelTierProfile,
   isTtsVoiceContext,
   modelTierRank,
   type BudgetUserConfig,
   type ModelTier,
-  type ModelTierPersona,
+  type ModelTierProfile,
   type ModelTierSurface,
   type ModelTierUserConfig,
   type ModelTierVoiceConfig,

package/src/model-tier/tier-resolver.ts

@@ -4,7 +4,7 @@
 // Precedence (high → low):
 //   1. `modelTier.voice.stt` (per-surface override · §3.4a.1)
 //   2. `modelTier.preset` (Phase 2 preset catalog · undefined today)
-//   3. `modelTier.persona`-based default (casual & power both ↦ Balanced
+//   3. `modelTier.profile`-based default (casual & power both ↦ Balanced
 //      today; Phase 3 can broaden)
 //   4. DEFAULT_MODEL_TIER ('balanced')
 //
@@ -40,7 +40,7 @@ export type SttTierSource =
   | 'session-override'
   | 'user-config-surface'
   | 'preset'
-  | 'persona'
+  | 'profile'
   | 'default';
 
 export interface ResolvedSttTier extends SttTierSpec {
@@ -83,14 +83,14 @@ export function resolveSttTier(
     };
   }
 
-  // 3. Persona-driven default — casual and power both land on
+  // 3. Profile-driven default — casual and power both land on
   //    Balanced today (PLAN §3.0.3). `custom` keeps the same default
   //    until an override or preset is set.
-  if (modelTier?.persona) {
+  if (modelTier?.profile) {
     return {
       ...STT_TIER_MAP[DEFAULT_MODEL_TIER],
       tier: DEFAULT_MODEL_TIER,
-      source: 'persona',
+      source: 'profile',
     };
   }
 
@@ -108,7 +108,7 @@ export type LlmTierSource =
   | 'session-override'
   | 'user-config-surface'
   | 'preset'
-  | 'persona'
+  | 'profile'
   | 'default';
 
 export interface ResolvedLlmTier extends LlmTierSpec {
@@ -126,7 +126,7 @@ export type TtsTierSource =
   | 'session-override'
   | 'user-config-surface'
   | 'preset'
-  | 'persona'
+  | 'profile'
   | 'default';
 
 export interface ResolvedTtsTier extends TtsTierSpec {
@@ -153,13 +153,13 @@ export function resolveTtsTier(
   if (modelTier?.preset) {
     return { ...TTS_TIER_MAP[DEFAULT_MODEL_TIER], tier: DEFAULT_MODEL_TIER, source: 'preset' };
   }
-  if (modelTier?.persona) {
-    return { ...TTS_TIER_MAP[DEFAULT_MODEL_TIER], tier: DEFAULT_MODEL_TIER, source: 'persona' };
+  if (modelTier?.profile) {
+    return { ...TTS_TIER_MAP[DEFAULT_MODEL_TIER], tier: DEFAULT_MODEL_TIER, source: 'profile' };
   }
   return { ...TTS_TIER_MAP[DEFAULT_MODEL_TIER], tier: DEFAULT_MODEL_TIER, source: 'default' };
 }
 
-/** Resolve LLM tier. Precedence mirrors STT (surface → preset → persona
+/** Resolve LLM tier. Precedence mirrors STT (surface → preset → profile
  *  → default) — diverges only in that the resolver needs the active
  *  `llm.provider` to expand the tier ladder. */
 export function resolveLlmTier(
@@ -196,12 +196,12 @@ export function resolveLlmTier(
       provider,
     };
   }
-  // 3. Persona-driven default.
-  if (modelTier?.persona) {
+  // 3. Profile-driven default.
+  if (modelTier?.profile) {
     return {
       ...lookupLlmTierSpec(provider, DEFAULT_MODEL_TIER),
       tier: DEFAULT_MODEL_TIER,
-      source: 'persona',
+      source: 'profile',
       provider,
     };
   }
@@ -220,7 +220,7 @@ export type EmbeddingTierSource =
   | 'session-override'
   | 'user-config-surface'
   | 'preset'
-  | 'persona'
+  | 'profile'
   | 'default';
 
 export interface ResolvedEmbeddingTier extends EmbeddingTierSpec {
@@ -230,7 +230,7 @@ export interface ResolvedEmbeddingTier extends EmbeddingTierSpec {
 }
 
 /** Resolve the embedding tier. Same precedence chain as LLM: session
- *  override → per-surface (modelTier.embedding) → preset → persona →
+ *  override → per-surface (modelTier.embedding) → preset → profile →
  *  default. The provider is supplied by the caller — typical wiring
  *  reads `cfg.embedding?.provider` (future field) and falls back to
  *  'openai'. */
@@ -273,11 +273,11 @@ export function resolveEmbeddingTier(
       provider,
     };
   }
-  if (modelTier?.persona) {
+  if (modelTier?.profile) {
     return {
       ...lookupEmbeddingTierSpec(provider, DEFAULT_MODEL_TIER),
       tier: DEFAULT_MODEL_TIER,
-      source: 'persona',
+      source: 'profile',
       provider,
     };
   }
@@ -295,7 +295,7 @@ export type VisionTierSource =
   | 'session-override'
   | 'user-config-surface'
   | 'preset'
-  | 'persona'
+  | 'profile'
   | 'default';
 
 export interface ResolvedVisionTier extends VisionTierSpec {
@@ -337,11 +337,11 @@ export function resolveVisionTier(
       provider,
     };
   }
-  if (modelTier?.persona) {
+  if (modelTier?.profile) {
     return {
       ...lookupVisionTierSpec(provider, DEFAULT_MODEL_TIER),
       tier: DEFAULT_MODEL_TIER,
-      source: 'persona',
+      source: 'profile',
       provider,
     };
   }

package/src/model-tier/types.ts

@@ -61,15 +61,15 @@ export function modelTierRank(t: ModelTier): number {
  *  adds `llm` and `tts`. Embedding / vision land in Phase 3. */
 export type ModelTierSurface = 'stt' | 'llm' | 'tts';
 
-// ── Persona ────────────────────────────────────────────────────────
+// ── Model tier profile ─────────────────────────────────────────────
 
-/** Zero-config baseline (§3.0 of the PLAN) — two-persona framework.
+/** Zero-config baseline (§3.0 of the PLAN) — model tier profiles.
  *  - `casual`: never touches settings; surfaces minimal UI.
  *  - `power`: opens slider / picker / preset etc.
  *  - `custom`: preset or per-surface overrides decide. */
-export type ModelTierPersona = 'casual' | 'power' | 'custom';
+export type ModelTierProfile = 'casual' | 'power' | 'custom';
 
-export function isModelTierPersona(v: unknown): v is ModelTierPersona {
+export function isModelTierProfile(v: unknown): v is ModelTierProfile {
   return v === 'casual' || v === 'power' || v === 'custom';
 }
 
@@ -112,9 +112,9 @@ export function isTtsVoiceContext(v: unknown): v is TtsVoiceContext {
 
 /** Root `modelTier` sub-tree of UserConfig. Sparse — every field is
  *  optional so the resolver can fall through (surface override → preset
- *  → persona → default). */
+ *  → profile → default). */
 export interface ModelTierUserConfig {
-  persona?: ModelTierPersona;
+  profile?: ModelTierProfile;
   preset?: string;
   voice?: ModelTierVoiceConfig;
   llm?: ModelTier;

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/exec-requests.ts

@@ -1,5 +1,9 @@
-import { extname } from 'node:path';
+import { realpathSync, statSync } from 'node:fs';
+import { extname, isAbsolute, join, sep } from 'node:path';
 import { ExecRequestRunner } from '../../exec-requests/runner.js';
+import type { ExecAttachment } from '../../exec-requests/store.js';
+import { getElanousConfigDir } from '../../elanous-config-dir.js';
+import { defaultAttachmentBaseDir } from '../../boot/attachment-store.js';
 import { jsonResponse } from './json-response.js';
 
 const mime: Record<string, string> = {
@@ -8,7 +12,21 @@ const mime: Record<string, string> = {
   '.md': 'text/markdown; charset=utf-8', '.txt': 'text/plain; charset=utf-8',
 };
 
-export async function handleExecRequests(req: Request, runner: ExecRequestRunner): Promise<Response> {
+function resolveAttachment(path: string, roots: string[]): string | null {
+  if (!isAbsolute(path)) return null;
+  try {
+    const real = realpathSync(path);
+    if (!statSync(real).isFile()) return null;
+    return roots.some(root => {
+      try {
+        const base = realpathSync(root);
+        return real.startsWith(`${base}${sep}`);
+      } catch { return false; }
+    }) ? real : null;
+  } catch { return null; }
+}
+
+export async function handleExecRequests(req: Request, runner: ExecRequestRunner, uploadDir = defaultAttachmentBaseDir(), fieldDir = join(getElanousConfigDir(), 'field')): Promise<Response> {
   const path = new URL(req.url).pathname;
   if (path === '/v1/exec-requests') {
     if (req.method === 'POST') {
@@ -16,7 +34,19 @@ export async function handleExecRequests(req: Request, runner: ExecRequestRunner
       try { body = await req.json(); } catch { return jsonResponse({ error: 'bad_request' }, 400); }
       const text = body && typeof body === 'object' && !Array.isArray(body) ? (body as { text?: unknown }).text : undefined;
       if (typeof text !== 'string' || !text.trim()) return jsonResponse({ error: 'bad_request', reason: 'text required' }, 400);
-      const item = runner.submit(text.trim());
+      const supplied = (body as { attachments?: unknown }).attachments;
+      if (supplied !== undefined && (!Array.isArray(supplied) || supplied.some(entry =>
+        !entry || typeof entry !== 'object' || Array.isArray(entry)
+        || typeof entry.name !== 'string' || !entry.name.trim() || typeof entry.path !== 'string'))) {
+        return jsonResponse({ error: 'bad_request', reason: 'attachments must be [{name,path}]' }, 400);
+      }
+      const roots = [uploadDir, fieldDir];
+      const resolved: Array<{ name: string; path: string | null }> | undefined = supplied?.map((entry: ExecAttachment) => ({
+        name: entry.name, path: resolveAttachment(entry.path, roots),
+      }));
+      if (resolved?.some(entry => !entry.path)) return jsonResponse({ error: 'attachment-outside' }, 400);
+      const attachments: ExecAttachment[] | undefined = resolved?.map(entry => ({ name: entry.name, path: entry.path! }));
+      const item = runner.submit(text.trim(), attachments);
       return jsonResponse({ id: item.id, status: 'planning' }, 202);
     }
     if (req.method === 'GET') return jsonResponse({ items: runner.store.list().map(item => {

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 }
       : {}),