@monster-orange/den 0.1.0 → 0.2.0

package/src/ui/server/graph-prefs.ts

@@ -0,0 +1,89 @@
+/**
+ * Graph preferences: how the Local Dev graph is laid out for this engineer.
+ * Stored in the user config as `graph:` and served by /api/settings, so the
+ * layout is remembered between sessions (the page mirrors it to localStorage
+ * so the first paint does not wait on the server).
+ */
+
+export interface GraphPrefs {
+  /** Layout direction: top-down or left-right. */
+  direction: "down" | "right";
+  /** The outer frames: by org or by application. */
+  group: "org" | "app";
+  /** Card size: detailed (236×104) or compact (176×52). */
+  density: "detailed" | "compact";
+  /** Details panel width in px. */
+  panelWidth: number;
+}
+
+export const GRAPH_DEFAULTS: GraphPrefs = {
+  direction: "down",
+  group: "org",
+  density: "detailed",
+  panelWidth: 440,
+};
+
+const CHOICES = {
+  direction: ["down", "right"],
+  group: ["org", "app"],
+  density: ["detailed", "compact"],
+} as const;
+
+const PANEL_MIN = 360;
+const PANEL_MAX = 760;
+
+type Check = { ok: true; value: unknown } | { ok: false; error: string };
+
+function check(key: keyof GraphPrefs, v: unknown): Check {
+  if (key === "panelWidth") {
+    if (typeof v !== "number" || !Number.isFinite(v))
+      return { ok: false, error: panelError() };
+    const w = Math.round(v);
+    if (w < PANEL_MIN || w > PANEL_MAX)
+      return { ok: false, error: panelError() };
+    return { ok: true, value: w };
+  }
+  const allowed: readonly string[] = CHOICES[key];
+  if (typeof v !== "string" || !allowed.includes(v))
+    return {
+      ok: false,
+      error: `graph.${key} must be one of ${allowed.map((a) => `"${a}"`).join(", ")}`,
+    };
+  return { ok: true, value: v };
+}
+
+function panelError(): string {
+  return `graph.panelWidth must be a number from ${PANEL_MIN} to ${PANEL_MAX}`;
+}
+
+const isObject = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null && !Array.isArray(v);
+
+/** The stored block, normalised: a missing or hand-broken field is its default. */
+export function graphPrefs(stored: unknown): GraphPrefs {
+  const out: GraphPrefs = { ...GRAPH_DEFAULTS };
+  if (!isObject(stored)) return out;
+  for (const key of Object.keys(GRAPH_DEFAULTS) as (keyof GraphPrefs)[]) {
+    if (!(key in stored)) continue;
+    const c = check(key, stored[key]);
+    if (c.ok) (out as unknown as Record<string, unknown>)[key] = c.value;
+  }
+  return out;
+}
+
+/** Merge a POSTed (partial) block over the current prefs; any bad field fails it. */
+export function mergeGraphPrefs(
+  current: GraphPrefs,
+  patch: unknown,
+): { ok: true; value: GraphPrefs } | { ok: false; error: string } {
+  if (!isObject(patch)) return { ok: false, error: "graph must be an object" };
+  const out: GraphPrefs = { ...current };
+  for (const [key, v] of Object.entries(patch)) {
+    if (!(key in GRAPH_DEFAULTS))
+      return { ok: false, error: `unknown graph setting "${key}"` };
+    const c = check(key as keyof GraphPrefs, v);
+    if (!c.ok) return c;
+    (out as unknown as Record<string, unknown>)[key] = c.value;
+  }
+  return { ok: true, value: out };
+}

package/src/ui/server/health-row.ts

@@ -0,0 +1,15 @@
+/**
+ * The fields of a /api/health row that say what was checked. `url` is only
+ * ever a URL (or null): a shell check's command (a compose stack's
+ * `<cli> stack health …`, or any declared shell check) goes in `check`.
+ */
+export type HealthCheckType = "shell" | "http" | "none";
+
+export function healthCheckFields(
+  checkType: HealthCheckType,
+  target: string,
+): { url: string | null; check?: string } {
+  if (checkType === "shell") return { url: null, check: target };
+  if (checkType === "http") return { url: target };
+  return { url: null };
+}

package/src/ui/server/index.ts

@@ -11,6 +11,7 @@
  */
 
 import { composeHealthCmd } from "../../shared/stacks/manifest-commands.js";
+import { healthCheckFields } from "./health-row.js";
 import { hasRuntime, repoKind } from "../../shared/repo-kind.js";
 import * as http from "http";
 import * as fs from "fs";
@@ -52,7 +53,7 @@ import {
 } from "../../shared/environment-manager/workspaces.js";
 import { deriveGraph } from "../../shared/environment-manager/derivation/derive-graph.js";
 import { orderForDown } from "../../shared/environment-manager/derivation/derived-up.js";
-import { findConventionalContainer } from "../../shared/environment-manager/opctl.js";
+import { findServiceContainer } from "../../shared/environment-manager/service-container.js";
 import {
   resolveHistorySource,
   ensureSnapshot,
@@ -78,7 +79,10 @@ import {
   shouldDetachServiceCommand,
 } from "../../shared/environment-manager/service-runner.js";
 import { reapDeadDaemons } from "./daemon-reaper.js";
-import { readManifest } from "../../shared/manifest/read-manifest.js";
+import {
+  loadManifest,
+  readManifest,
+} from "../../shared/manifest/read-manifest.js";
 import {
   getServiceLogRoot,
   spawnStreaming,
@@ -86,6 +90,7 @@ import {
 } from "../../shared/process/spawn-streaming.js";
 import {
   readDenConfig,
+  isProductionEnv,
   isLocalEnabled,
   readUserConfig,
   writeUserConfig,
@@ -95,7 +100,7 @@ import {
   type ReleaseConfig,
 } from "../../shared/den-config.js";
 import { readOrg } from "../../shared/org.js";
-import { getDistRoot } from "../../shared/paths.js";
+import { engineVersion, getDistRoot } from "../../shared/paths.js";
 import { enginePath } from "../../shared/engine.js";
 import {
   releaseService,
@@ -106,8 +111,18 @@ import {
 import { deploySessions } from "./release-deploy-session.js";
 import { spawnDetachedWebRestart } from "../cli/web-command.js";
 import { recordInvocation } from "../../shared/dev-metrics/emit.js";
-import { validateManifest } from "../../shared/manifest/validate-manifest.js";
+import {
+  validateManifest,
+  validateManifestLayers,
+} from "../../shared/manifest/validate-manifest.js";
 import { depService } from "../../shared/manifest/deps.js";
+import {
+  placementRefusal,
+  resolveHealthCheck,
+  servicePlacement,
+  type Expect,
+  type Placement,
+} from "../../shared/manifest/placement.js";
 import {
   isOpSignedIn,
   hasSudoInVault,
@@ -115,6 +130,16 @@ import {
   saveSudoToVault,
 } from "../../shared/auth/sudo-vault.js";
 import { DEN_BANNER_LINES, DEN_SUBTITLE } from "../../shared/banner.js";
+import { actorLabel } from "../../shared/agent-actor.js";
+import {
+  actorFromHeaders,
+  actorSuffix,
+  recordAction,
+  setAuditSink,
+} from "./audit.js";
+import { handleReadonlyRoutes } from "./readonly-routes.js";
+import { serveUiAsset } from "./ui-assets.js";
+import { graphPrefs, mergeGraphPrefs } from "./graph-prefs.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -132,7 +157,10 @@ interface HealthResult {
   repo: string;
   service: string;
   label: string;
+  /** The HTTP check's URL, or null (never a command: see `check`). */
   url: string | null;
+  /** A shell check's command (e.g. a compose stack's `stack health`). */
+  check?: string;
   repoPath: string;
   mode: "dev-managed" | "managed";
   isEntrypoint: boolean;
@@ -143,6 +171,9 @@ interface HealthResult {
   openUrl?: string | null;
   /** Extra named links for this env. */
   links?: OpenLink[];
+  /** Where it runs for this env, and where a remote one is (R13). */
+  runs: Placement["runs"];
+  target: Placement["target"];
 }
 
 /**
@@ -267,6 +298,8 @@ interface LogEntry {
   ts: string;
   kind: string;
   text: string;
+  /** Set when an agent (via `<cli> mcp`) asked for this action: its label. */
+  actor?: string;
 }
 
 const LOG_RING_MAX = 500;
@@ -281,11 +314,12 @@ function stripAnsi(s: string): string {
   return s.replace(ANSI_RE, "");
 }
 
-function pushLog(kind: string, text: string): void {
+function pushLog(kind: string, text: string, actor?: string): void {
   const entry: LogEntry = {
     ts: new Date().toISOString(),
     kind,
     text: stripAnsi(text),
+    ...(actor ? { actor } : {}),
   };
   logRing.push(entry);
   if (logRing.length > LOG_RING_MAX) logRing.shift();
@@ -302,11 +336,17 @@ function pushLog(kind: string, text: string): void {
  * Log to stdout unless --silent was passed, AND fan out to the log ring so the
  * /logs page and any connected SSE subscribers see the same stream.
  */
-function serverLog(msg: string, kind: string = "info"): void {
-  pushLog(kind, msg);
+function serverLog(msg: string, kind: string = "info", actor?: string): void {
+  pushLog(kind, msg, actor);
   if (!SILENT) process.stdout.write(msg + "\n");
 }
 
+// Every audited action (exec, run, sync) lands in the log as a lifecycle
+// line; an agent's carries its label so the /logs page can mark it.
+setAuditSink((line, actor) =>
+  serverLog(line, "lifecycle", actor ? actorLabel(actor) : undefined),
+);
+
 /** ANSI helpers (no chalk dependency in the server) */
 const dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
 const green = (s: string) => `\x1b[32m${s}\x1b[0m`;
@@ -552,6 +592,9 @@ async function handleRequest(
     return serveFile(res, path.join(PUBLIC_DIR, "header.js"));
   }
 
+  // The graph's modules (graph.js, panel.js, …) and vendored libraries (ELK).
+  if (serveUiAsset(res, pathname, PUBLIC_DIR)) return;
+
   if (pathname === "/perf-report.js") {
     return serveFile(res, path.join(PUBLIC_DIR, "perf-report.js"));
   }
@@ -687,6 +730,9 @@ async function handleRequest(
     }
   }
 
+  // ── API: stacks, edge, security plan (read-only; see readonly-routes.ts) ──
+  if (await handleReadonlyRoutes(req, res, pathname, url)) return;
+
   // ── API: test sources ─────────────────────────────────────────────────────
   // Returns the repos that contribute tests for a given pillar, with their
   // current branch + short SHA. Lets the Tests UI show "you are testing
@@ -827,6 +873,9 @@ async function handleRequest(
       links: OpenLink[];
       /** The GitHub org that owns the repo. */
       org: string;
+      /** Codes that count as up for a remote target.url probe. */
+      expect?: Expect;
+      meta: Pick<HealthResult, "runs" | "target">;
     }> = [];
     let edgeDomain: string | null = null;
     try {
@@ -858,6 +907,7 @@ async function handleRequest(
           openUrl: null,
           links: [],
           org: orgOf(resolved.repoName, catalog),
+          meta: { runs: "none", target: null },
         });
         continue;
       }
@@ -873,11 +923,16 @@ async function handleRequest(
               ws.name,
             )
           : null;
-      const healthCfg =
-        svcCfg?.health?.[env] ??
-        (composeHealth
-          ? { type: "shell" as const, cmd: composeHealth }
-          : undefined);
+      // One resolution path with `<cli> status` (placement.ts): a remote
+      // service is checked by target.env's declaration, else target.url.
+      const plan = resolveHealthCheck(
+        manifest,
+        resolved.subsystem,
+        env,
+        composeHealth,
+      );
+      const healthCfg = plan.check;
+      const remote = plan.placement.runs === "remote";
       // Keep services with no health check (checkType "none") so systems like
       // jobs-runtime still appear — as an "unknown" (muted) dot, matching
       // `den status`, rather than vanishing from the health row.
@@ -896,7 +951,7 @@ async function handleRequest(
         deps,
         repo: resolved.repoName,
         service: resolved.subsystem,
-        label: healthCfg?.label ?? resolved.subsystem,
+        label: plan.label ?? healthCfg?.label ?? resolved.subsystem,
         checkType: healthCfg
           ? healthCfg.type === "shell"
             ? "shell"
@@ -914,7 +969,7 @@ async function handleRequest(
         // service with no declared local health check may still serve the stack
         // convention at http://<repo>/healthz via opctl DNS.
         conventional: (() => {
-          if (healthCfg || env !== "local") return null;
+          if (healthCfg || env !== "local" || remote) return null;
           const keys = Object.keys(manifest.services ?? {});
           const isPrimary = manifest.entrypoint
             ? resolved.subsystem === manifest.entrypoint
@@ -932,6 +987,8 @@ async function handleRequest(
         }),
         links: linksFor(manifest, resolved.subsystem, env),
         org: orgOf(resolved.repoName, catalog),
+        ...(plan.expect ? { expect: plan.expect } : {}),
+        meta: { runs: plan.placement.runs, target: plan.placement.target },
       });
     }
 
@@ -961,6 +1018,7 @@ async function handleRequest(
       isEntrypoint,
       conventional,
       meta,
+      expect,
     }) => {
       if (checkType !== "none") {
         const started = Date.now();
@@ -969,15 +1027,16 @@ async function handleRequest(
             ? await pingShell(target, awsProfileEnv(env), repoPath)
             : await pingHttp(
                 target,
-                env === "local"
+                env === "local" && meta.runs !== "remote"
                   ? HEALTH_CHECK_TIMEOUT_MS
                   : HOSTED_HEALTH_CHECK_TIMEOUT_MS,
+                expect,
               );
         return {
           repo,
           service,
           label,
-          url: target,
+          ...healthCheckFields(checkType, target),
           repoPath,
           mode,
           isEntrypoint,
@@ -1131,23 +1190,28 @@ async function handleRequest(
 
     // Legacy: discovered repos from .den/ symlinks / registered-repos.json
     const legacyRepos = discoverRepos();
-    const legacyEntries = legacyRepos.flatMap((repo) =>
-      Object.entries(repo.manifest.services ?? {}).map(([svcName, svc]) => ({
-        repo: repo.repoName,
-        service: svcName,
-        address: `${repo.repoName}/${svcName}`,
-        repoPath: repo.repoPath,
-        commands: withDown(Object.keys(svc.commands?.[env] ?? {})),
-        logs: svc.logs?.[env] ?? null,
-        mode: "dev-managed" as const,
-        branch: null as string | null,
-        fromCatalog: false,
-        isEntrypoint: repo.manifest.entrypoint === svcName,
-        autostart: true, // legacy discovery has no workspace entry to toggle
-        deps: (svc.depends_on ?? []).map(depService),
-        cloned: true, // legacy discovery only ever finds on-disk repos
-      })),
-    );
+    const legacyEntries = legacyRepos.flatMap((repo) => {
+      const manifestLayers = loadManifest(repo.repoPath).layers;
+      return Object.entries(repo.manifest.services ?? {}).map(
+        ([svcName, svc]) => ({
+          repo: repo.repoName,
+          service: svcName,
+          address: `${repo.repoName}/${svcName}`,
+          repoPath: repo.repoPath,
+          commands: withDown(Object.keys(svc.commands?.[env] ?? {})),
+          logs: svc.logs?.[env] ?? null,
+          mode: "dev-managed" as const,
+          branch: null as string | null,
+          fromCatalog: false,
+          isEntrypoint: repo.manifest.entrypoint === svcName,
+          autostart: true, // legacy discovery has no workspace entry to toggle
+          deps: (svc.depends_on ?? []).map(depService),
+          cloned: true, // legacy discovery only ever finds on-disk repos
+          manifestLayers,
+          ...servicePlacement(repo.manifest, svcName, env),
+        }),
+      );
+    });
 
     // Catalog entries (workspace-aware)
     const catalog = readCatalog();
@@ -1182,7 +1246,11 @@ async function handleRequest(
       ? listWorkspaceServices(ws.config, catalog, ws.name)
           .filter((r) => hasRuntime(repoKind(r.repoPath)))
           .flatMap((resolved) => {
-            const manifest = readManifest(resolved.repoPath);
+            // The manifest and the layers it was built from: repo or held,
+            // plus override when manifests/<repo>.override.yml applied.
+            const { manifest, layers: manifestLayers } = loadManifest(
+              resolved.repoPath,
+            );
             const svc = manifest?.services?.[resolved.subsystem];
             if (!manifest || !svc) {
               // Workspace membership is config-driven: a managed entry
@@ -1207,6 +1275,8 @@ async function handleRequest(
                   owners: daemonOwners.get(resolved.address) ?? [],
                   deps: [] as string[],
                   cloned: fs.existsSync(resolved.repoPath),
+                  manifestLayers,
+                  ...servicePlacement(null, resolved.subsystem, env),
                 },
               ];
             }
@@ -1228,6 +1298,8 @@ async function handleRequest(
                   resolveDepAddress(depService(d), catalog, ws.config, ws.name),
                 ),
                 cloned: true,
+                manifestLayers,
+                ...servicePlacement(manifest, resolved.subsystem, env),
               },
             ];
           })
@@ -1316,6 +1388,14 @@ async function handleRequest(
     if (resolved) {
       repoPath = resolved.repoPath;
       const manifest = readManifest(repoPath);
+      // R13: nothing runs a command on a remote service.
+      const refusal = placementRefusal(
+        `${repoName}/${svcName}`,
+        servicePlacement(manifest, resolved.subsystem, env),
+        (e) => isProductionEnv(e),
+        cmdName === "down" ? "stop" : "start",
+      );
+      if (refusal) return fail(refusal);
       if (manifest) {
         cmdDef =
           manifest.services?.[resolved.subsystem]?.commands?.[env]?.[cmdName];
@@ -1327,6 +1407,15 @@ async function handleRequest(
       const repos = discoverRepos();
       const repo = repos.find((r) => r.repoName === repoName);
       repoPath = repo?.repoPath;
+      const refusal = repo
+        ? placementRefusal(
+            `${repoName}/${svcName}`,
+            servicePlacement(repo.manifest, svcName, env),
+            (e) => isProductionEnv(e),
+            cmdName === "down" ? "stop" : "start",
+          )
+        : null;
+      if (refusal) return fail(refusal);
       cmdDef = repo?.manifest.services?.[svcName]?.commands?.[env]?.[cmdName];
     }
 
@@ -1373,7 +1462,11 @@ async function handleRequest(
 
     const execId = shortRunId();
     const execDesc = `${repoName}/${svcName} ${cmdName} (${env})`;
-    serverLog(`▶ exec ${execDesc} [${execId}]`, "lifecycle");
+    const execActor = actorFromHeaders(req.headers);
+    recordAction(execActor, {
+      verb: "exec",
+      detail: `${execDesc} [${execId}]`,
+    });
 
     // For detachable commands (up/restart), the service is spawned as a daemon
     // writing to a log file so it survives den restarts.  The tail proc
@@ -1397,8 +1490,9 @@ async function handleRequest(
         if (!active) return; // client already closed — don't write to dead response
         const duration = Date.now() - startTime;
         serverLog(
-          `■ exec ${execDesc} · exit=${exitCode} · ${formatDuration(duration)} [${execId}]`,
+          `■ exec ${execDesc} · exit=${exitCode} · ${formatDuration(duration)} [${execId}]${actorSuffix(execActor)}`,
           "lifecycle",
+          execActor ? actorLabel(execActor) : undefined,
         );
         // Dev-tooling telemetry: one invocation per service command run. The
         // action is whitelisted to common lifecycle verbs (low cardinality);
@@ -1675,9 +1769,10 @@ async function handleRequest(
   //
   // Source resolution, in order:
   //   1. The service's manifest `logs.local` shell command (e.g. `docker logs -f`)
-  //   2. Conventional container derivation: a running `opctl_<base>_<hash>`
-  //      container matched from the repo's op manifest / repo name →
-  //      `docker logs -f` — real runtime logs with zero manifest config
+  //   2. The service's running container → `docker logs -f`: a compose
+  //      stack's `<stack>-<workspace>-<service>-1`, else an
+  //      `opctl_<base>_<hash>` one matched from the repo's op manifest / repo
+  //      name — real runtime logs with zero manifest config
   //   3. The den daemon startup log (~/.den/logs/<repo>/<service>.log) —
   //      last resort, covers host-run processes with no container
   // A manifest command that exits within the quick-exit window (container not
@@ -1818,13 +1913,13 @@ async function handleRequest(
     let retryCount = 0;
     let retryTimer: ReturnType<typeof setTimeout> | null = null;
 
-    // Fallback tier 1: resolve the service's running container by opctl
-    // naming convention (`opctl_<base>_<hash>`) and stream `docker logs -f`.
-    // This gives REAL runtime logs for services with no (or broken)
-    // manifest `logs.local` — no den daemon file needed. Returns false
-    // when no conventional container is running.
+    // Fallback tier 1: resolve the service's running container (its compose
+    // stack's, else opctl's `opctl_<base>_<hash>`) and stream
+    // `docker logs -f`. This gives REAL runtime logs for services with no (or
+    // broken) manifest `logs.local` — no den daemon file needed. Returns
+    // false when no such container is running.
     const startDockerFallback = (): boolean => {
-      const container = findConventionalContainer(
+      const container = findServiceContainer(
         repoName,
         tailResolved?.repoPath,
         tailSubsystem,
@@ -2084,7 +2179,8 @@ async function handleRequest(
     const runId = shortRunId();
     const modDesc = modules.length ? modules.join(",") : "all";
     const runDesc = `${pillar}/${env} · modules=${modDesc}`;
-    serverLog(`▶ run ${runDesc} [${runId}]`, "lifecycle");
+    const runActor = actorFromHeaders(req.headers);
+    recordAction(runActor, { verb: "run", detail: `${runDesc} [${runId}]` });
     if (
       pillar === "synthetic" ||
       pillar === "smoke" ||
@@ -2108,8 +2204,9 @@ async function handleRequest(
       const dur = formatDuration(Date.now() - startTime);
       const extra = note ? ` · ${note}` : "";
       serverLog(
-        `■ run ${runDesc} · exit=${exitCode} · ${dur}${extra} [${runId}]`,
+        `■ run ${runDesc} · exit=${exitCode} · ${dur}${extra} [${runId}]${actorSuffix(runActor)}`,
         "lifecycle",
+        runActor ? actorLabel(runActor) : undefined,
       );
       // Dev-tooling telemetry: one invocation per test run (pillar/env are
       // low-cardinality enums; module count only — never module names/args).
@@ -2254,6 +2351,8 @@ async function handleRequest(
     return sendJson(res, {
       pid: process.pid,
       port: PORT,
+      // Den's version: the MCP server compares it with the routes it needs.
+      version: engineVersion() ?? null,
       startedAt: new Date(SERVER_STARTED_AT).toISOString(),
       uptimeMs: Date.now() - SERVER_STARTED_AT,
       stale,
@@ -2584,10 +2683,24 @@ async function handleRequest(
       const filePath = url.searchParams.get("path");
       if (!filePath) return send400(res, '"path" query param required');
       try {
-        const denYml = fs.existsSync(filePath)
-          ? fs.lstatSync(filePath).isDirectory()
-            ? path.join(filePath, `${product().manifestYml}`)
-            : filePath
+        const isDir =
+          fs.existsSync(filePath) && fs.lstatSync(filePath).isDirectory();
+        // A repo folder: every layer that applies (repo or held, override,
+        // merged), flattened into the usual shape; each error names its file.
+        if (isDir) {
+          const layered = validateManifestLayers(filePath);
+          if (layered.layers.length > 0)
+            return sendJson(res, {
+              valid: layered.valid,
+              version: layered.layers[0].result.version,
+              errors: layered.layers.flatMap((l) => l.result.errors),
+              warnings: layered.layers.flatMap((l) => l.result.warnings),
+              manifestLayers: loadManifest(filePath).layers,
+              layers: layered.layers,
+            });
+        }
+        const denYml = isDir
+          ? path.join(filePath, `${product().manifestYml}`)
           : filePath;
         const content = fs.readFileSync(denYml, "utf-8");
         return sendJson(res, validateManifest(content));
@@ -2726,7 +2839,8 @@ async function handleRequest(
 
   // ── API: user settings ────────────────────────────────────────────────────
   // GET  /api/settings  → { editor, editors, terminal, terminals, editor_overrides, languages }
-  // POST /api/settings  body: { editor?, terminal?, editor_overrides? }
+  // POST /api/settings  body: { editor?, terminal?, editor_overrides?, graph? }
+  //   graph: { direction, group, density, panelWidth } (see graph-prefs.ts)
   if (pathname === "/api/settings") {
     if (req.method === "GET") {
       const user = readUserConfig();
@@ -2740,6 +2854,7 @@ async function handleRequest(
         editor_overrides: user.editor_overrides ?? {},
         languages: SUPPORTED_LANGUAGES,
         log_window_lines: user.log_window_lines ?? 20_000,
+        graph: graphPrefs(user.graph),
       });
     }
     if (req.method === "POST") {
@@ -2748,8 +2863,14 @@ async function handleRequest(
           editor?: string | null;
           terminal?: string | null;
           editor_overrides?: Record<string, string> | null;
+          graph?: unknown;
         };
         const user = readUserConfig();
+        if (body.graph !== undefined) {
+          const g = mergeGraphPrefs(graphPrefs(user.graph), body.graph);
+          if (!g.ok) return send400(res, g.error);
+          user.graph = g.value;
+        }
         if (body.editor === null || body.editor === "") {
           delete user.editor;
         } else if (body.editor !== undefined) {
@@ -2793,6 +2914,7 @@ async function handleRequest(
           editor: user.editor ?? null,
           terminal: user.terminal ?? null,
           editor_overrides: user.editor_overrides ?? {},
+          graph: graphPrefs(user.graph),
         });
       } catch (e) {
         return send400(res, `Invalid request: ${(e as Error).message}`);
@@ -3078,15 +3200,7 @@ server.listen(PORT, BIND_HOST, () => {
     ? `${product().cli}`
     : "localhost";
 
-  let pkgVersion = "?";
-  try {
-    const pkg = JSON.parse(
-      fs.readFileSync(enginePath("package.json"), "utf-8"),
-    ) as { version?: string };
-    if (pkg.version) pkgVersion = pkg.version;
-  } catch (_e) {
-    /* package.json unreadable — version stays "?" */
-  }
+  const pkgVersion = engineVersion() ?? "?";
 
   console.log();
   for (const line of DEN_BANNER_LINES) {

package/src/ui/server/log-history.ts

@@ -20,7 +20,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { execFile, spawnSync } from "child_process";
 
-import { findConventionalContainer } from "../../shared/environment-manager/opctl.js";
+import { findServiceContainer } from "../../shared/environment-manager/service-container.js";
 import {
   resolveService,
   hasRunningOpctlContainers,
@@ -90,8 +90,9 @@ export function resolveHistorySource(
     resolveService(`${repoName}/${svcName}`) ?? resolveService(repoName);
   const repoPath = resolved?.repoPath;
 
-  // 1. Conventional opctl container (opctl_<base>_<hash>).
-  const conventional = findConventionalContainer(repoName, repoPath, svcName);
+  // 1. The service's container: its compose stack's, else opctl's
+  //    conventional one (opctl_<base>_<hash>).
+  const conventional = findServiceContainer(repoName, repoPath, svcName);
   if (conventional) return { kind: "docker", container: conventional };
 
   // 2. Container named by the manifest log command's docker ps filter.