@monster-orange/den 0.3.0 → 0.4.1

package/src/shared/agents/runtime.ts

@@ -0,0 +1,199 @@
+/**
+ * The runtime contract (strategy kind `runtime`, AG spec §4): which CLI an
+ * agent runs. A runtime turns a persona and a workspace into argv, env and
+ * files (a per-agent MCP config), and says how to resume. It knows nothing
+ * about sessions, tmux or the browser; Den joins it to a session backend.
+ *
+ * Built-ins register here exactly as a runtime plugin would (AG-8a):
+ * den-claude and generic.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import {
+  getStrategy,
+  registerStrategy,
+  strategyIds,
+  type StrategyEntry,
+} from "../strategies/registry.js";
+import type { Persona } from "./personas.js";
+
+export const RUNTIME_KIND = "runtime";
+
+/** The runtime an agent gets when neither it nor its persona names one. */
+export const DEFAULT_RUNTIME_ID = "den-claude";
+
+export interface RuntimeDetect {
+  available: boolean;
+  version?: string;
+  /** Why it is unavailable. */
+  why?: string;
+}
+
+/** The MCP server an agent acts through: Den's, scoped to its workspace. */
+export interface AgentMcp {
+  /** The server's name in an MCP config (the distribution's CLI). */
+  name: string;
+  /** `<cli> mcp --workspace <ws> --actor agent:<id> [--grant <ws>…]`. */
+  command: string[];
+  /** The server's own environment (PATH pinned), never a secret. */
+  env: Record<string, string>;
+  /** The workspace it is pinned to. */
+  scope: string;
+}
+
+export interface LaunchInput {
+  persona: Persona;
+  workspace: { name: string; dir: string };
+  agentId: string;
+  /** Where the agent works: the workspace's dir (a worktree from AG-9a). */
+  worktree: string;
+  model?: string;
+  mcp: AgentMcp;
+  /** A directory of this agent's own (0700) for the files a runtime writes. */
+  filesDir: string;
+  /**
+   * Den's own state dir (web.secret, the session records). A runtime adds
+   * deny rules for it to the agent's own permission config (SEC-1 §6c.1):
+   * that binds a cooperating agent only, since an agent runs as the same OS
+   * user and could read the files itself.
+   */
+  stateDir?: string;
+  /**
+   * The caller's environment, for finding the runtime's CLI on PATH. The
+   * agent does not get it: it starts from an allowlist (sessions/env.ts),
+   * plus envPassthrough and LaunchOutput.env.
+   */
+  env: NodeJS.ProcessEnv;
+  /**
+   * A conversation id to start under instead of a new one: a resume of a
+   * run that was never prompted starts afresh with the id it had.
+   */
+  resumeToken?: string;
+}
+
+export interface LaunchOutput {
+  argv: string[];
+  /** Added to the session's environment (after the allowlist). */
+  env: Record<string, string>;
+  /** Absolute path (inside filesDir) → content; Den writes each 0600. */
+  files?: Record<string, string>;
+  /** What resume needs to continue this run (kept in the agent record). */
+  resumeToken?: string;
+  /** One line each, printed when the agent starts (never secret). */
+  warnings?: string[];
+}
+
+export type ResumeInput = LaunchInput;
+
+export interface Runtime {
+  /** "den-claude", "generic". */
+  id: string;
+  detect(env?: NodeJS.ProcessEnv): RuntimeDetect;
+  /** Throws LaunchError when this persona or this machine can't run it. */
+  launch(input: LaunchInput): LaunchOutput;
+  /** A new run that continues the last one; null when there is nothing to resume. */
+  resume?(input: ResumeInput): Omit<LaunchOutput, "resumeToken"> | null;
+  /** Where permission prompts surface (Q-AG-2). */
+  approvals?: "terminal" | "hook";
+  /**
+   * Caller variables this runtime needs beyond the allowlist (PATH, HOME,
+   * USER, LOGNAME, SHELL, TERM, COLORTERM, LANG, LC_*, TZ, TMPDIR). Named
+   * one by one; Claude Code's session plumbing never passes.
+   */
+  envPassthrough?: readonly string[];
+  /**
+   * Names this runtime owns that must never reach a session Den starts
+   * (an exact name, or a prefix ending in `*`): den-claude's CLAUDECODE and
+   * CLAUDE_CODE_*. Den removes them after building any session's env,
+   * whatever put them there (sessions/env.ts).
+   */
+  scrubEnv: readonly string[];
+}
+
+/** A runtime cannot launch this agent here: a refusal, not a crash. */
+export class LaunchError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "LaunchError";
+  }
+}
+
+/** Register a runtime as strategy kind `runtime` (doctor lists it). */
+export function registerRuntime(rt: Runtime): void {
+  const entry: StrategyEntry<typeof RUNTIME_KIND, Runtime> = {
+    id: rt.id,
+    kind: RUNTIME_KIND,
+    detect(env) {
+      const d = rt.detect(env);
+      if (!d.available)
+        return { available: false, reason: d.why ?? "unavailable" };
+      return d.version
+        ? { available: true, reason: `version ${d.version}` }
+        : { available: true };
+    },
+    capabilities: rt,
+  };
+  registerStrategy(entry);
+}
+
+export function getRuntime(id: string): Runtime | undefined {
+  return getStrategy<typeof RUNTIME_KIND, Runtime>(RUNTIME_KIND, id)
+    ?.capabilities;
+}
+
+export function runtimeIds(): string[] {
+  return strategyIds(RUNTIME_KIND);
+}
+
+/** Every registered runtime's scrubEnv: applied to every session Den starts. */
+export function allScrubEnv(): string[] {
+  return [
+    ...new Set(runtimeIds().flatMap((id) => getRuntime(id)?.scrubEnv ?? [])),
+  ];
+}
+
+/** The first executable `bin` on `env.PATH`, or null. Runs nothing. */
+export function whichBin(
+  bin: string,
+  env: NodeJS.ProcessEnv = process.env,
+): string | null {
+  for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    const file = path.join(dir, bin);
+    try {
+      fs.accessSync(file, fs.constants.X_OK);
+      if (fs.statSync(file).isFile()) return file;
+    } catch {
+      /* not here */
+    }
+  }
+  return null;
+}
+
+/**
+ * A standard MCP config (`mcpServers`, the shape most MCP clients read)
+ * with Den's server as the only entry.
+ */
+export function mcpConfigJson(mcp: AgentMcp): string {
+  const [command, ...args] = mcp.command;
+  return (
+    JSON.stringify(
+      {
+        mcpServers: {
+          [mcp.name]: {
+            command,
+            args,
+            ...(Object.keys(mcp.env).length ? { env: mcp.env } : {}),
+          },
+        },
+      },
+      null,
+      2,
+    ) + "\n"
+  );
+}
+
+/** Where a runtime puts an agent's MCP config. */
+export function mcpConfigPath(input: Pick<LaunchInput, "filesDir">): string {
+  return path.join(input.filesDir, "mcp.json");
+}

package/src/shared/agents/runtimes.ts

@@ -0,0 +1,54 @@
+/**
+ * Den's built-in runtimes, registered as strategy kind `runtime`: import
+ * this module to have them. den-claude first: it is the default.
+ */
+import { denClaude } from "./den-claude.js";
+import { generic } from "./generic.js";
+import { allScrubEnv, registerRuntime, type Runtime } from "./runtime.js";
+import { ACTOR_TOKEN_ENV } from "../actor-token.js";
+import { AGENT_ACTOR_ENV, buildSessionEnv } from "../sessions/env.js";
+
+registerRuntime(denClaude);
+registerRuntime(generic);
+
+export {
+  allScrubEnv,
+  DEFAULT_RUNTIME_ID,
+  getRuntime,
+  LaunchError,
+  RUNTIME_KIND,
+  runtimeIds,
+  type AgentMcp,
+  type LaunchInput,
+  type LaunchOutput,
+  type ResumeInput,
+  type Runtime,
+} from "./runtime.js";
+
+/**
+ * An agent's session env, as `agents start` builds it and `doctor --probe`
+ * checks it: the allowlist, the runtime's passthrough and launch env, Den's
+ * markers (DEN_AGENT=agent:<id>, and SEC-1c's DEN_ACTOR_TOKEN when one was
+ * minted), then every runtime's scrubEnv and any person credential.
+ */
+export function agentSessionEnv(
+  caller: NodeJS.ProcessEnv,
+  rt: Pick<Runtime, "envPassthrough">,
+  launch: Record<string, string>,
+  agentId: string,
+  /** SEC-1c: the agent's actor token (`agents start` mints it; the probe has none). */
+  actorToken?: string,
+): Record<string, string> {
+  return buildSessionEnv({
+    caller,
+    passthrough: rt.envPassthrough,
+    launch,
+    // The seam for a persona's or runtime's declared env: none yet.
+    extra: {},
+    den: {
+      [AGENT_ACTOR_ENV]: `agent:${agentId}`,
+      ...(actorToken ? { [ACTOR_TOKEN_ENV]: actorToken } : {}),
+    },
+    scrub: allScrubEnv(),
+  });
+}

package/src/shared/den-config.ts

@@ -243,6 +243,11 @@ export interface DenConfig {
    * only; `actions` opts in to named actions. See readMcpConfig.
    */
   mcp?: McpConfig;
+  /**
+   * Agents: `max_concurrent` caps the sessions running at once in this
+   * distribution (default 4). See readAgentsConfig.
+   */
+  agents?: AgentsConfig;
   /**
    * The web UI: `port` (read by edge/config.ts readWebPort) and `service`,
    * the launchd service `<cli> service` installs. See readWebServiceConfig.
@@ -552,6 +557,7 @@ export function readDenConfig(): DenConfig {
       env_health_urls: parsed?.env_health_urls,
       security: parsed?.security,
       mcp: parsed?.mcp,
+      agents: parsed?.agents,
       web: parsed?.web,
       test_accounts: parsed?.test_accounts,
       defaults: parsed?.defaults,
@@ -729,6 +735,116 @@ export function readMcpConfig(
   };
 }
 
+// ── Agents (`<cli> sessions`, `<cli> agents`) ─────────────────────────────────
+
+/** `agents:` in the org config. */
+export interface AgentsConfig {
+  /** Sessions that may run at once (default 4). */
+  max_concurrent?: number;
+  /**
+   * Persona packs (AG-2a): directories of persona files, relative to the
+   * distribution root. Den's default pack is always read first; a pack's
+   * persona replaces one of the same id.
+   */
+  persona_packs?: string[];
+  /**
+   * Any other key is an agent id: `agents.<id>.grants` widens that agent's
+   * MCP scope to other workspaces (AG spec §5b). Config only: an agent
+   * never grants itself one.
+   */
+  [agentId: string]: unknown;
+}
+
+export const DEFAULT_AGENTS_MAX_CONCURRENT = 4;
+
+/** The keys of `agents:` that are not an agent id. */
+export const AGENTS_RESERVED_KEYS = ["max_concurrent", "persona_packs"];
+
+/** One agent's own block, `agents.<id>`. */
+export interface AgentGrantsConfig {
+  /** Workspaces beyond its own that its MCP serves. */
+  grants: string[];
+}
+
+/** `agents:` with its defaults applied. */
+export interface ResolvedAgentsConfig {
+  maxConcurrent: number;
+  /** As configured (relative to the distribution root). */
+  personaPacks: string[];
+  /** `agents.<id>` blocks, by agent id. */
+  agents: Record<string, AgentGrantsConfig>;
+}
+
+/** An agent id or workspace name: what WORKSPACE_NAME_RE accepts. */
+const AGENT_KEY_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+
+const isMapping = (v: unknown): v is Record<string, unknown> =>
+  v !== null && typeof v === "object" && !Array.isArray(v);
+
+/**
+ * The effective agents config. Anything malformed throws, naming the key:
+ * a typo must not lift the cap, drop a pack or widen a grant.
+ */
+export function readAgentsConfig(
+  config: DenConfig = readDenConfig(),
+): ResolvedAgentsConfig {
+  const raw = (config.agents ?? {}) as unknown;
+  if (!isMapping(raw))
+    throw new Error(`agents: must be a mapping (got ${JSON.stringify(raw)})`);
+  const out: ResolvedAgentsConfig = {
+    maxConcurrent: DEFAULT_AGENTS_MAX_CONCURRENT,
+    personaPacks: [],
+    agents: {},
+  };
+  const max = raw.max_concurrent;
+  if (max !== undefined) {
+    if (typeof max !== "number" || !Number.isInteger(max) || max < 1)
+      throw new Error(
+        `agents.max_concurrent: must be a whole number of at least 1 (got ${JSON.stringify(max)})`,
+      );
+    out.maxConcurrent = max;
+  }
+  const packs = raw.persona_packs;
+  if (packs !== undefined && packs !== null) {
+    if (!Array.isArray(packs))
+      throw new Error(
+        `agents.persona_packs: must be a list of paths (got ${JSON.stringify(packs)})`,
+      );
+    packs.forEach((p, i) => {
+      if (typeof p !== "string" || !p.trim())
+        throw new Error(
+          `agents.persona_packs[${i}]: must be a non-empty path (got ${JSON.stringify(p)})`,
+        );
+    });
+    out.personaPacks = packs as string[];
+  }
+  for (const [id, block] of Object.entries(raw)) {
+    if (AGENTS_RESERVED_KEYS.includes(id)) continue;
+    const where = `agents.${id}`;
+    if (!AGENT_KEY_RE.test(id) || !isMapping(block))
+      throw new Error(
+        `${where}: unknown key (agents: takes max_concurrent, persona_packs, ` +
+          `or an agent id mapping to { grants: [...] })`,
+      );
+    for (const k of Object.keys(block))
+      if (k !== "grants")
+        throw new Error(`${where}.${k}: unknown key (an agent takes grants)`);
+    const grants = block.grants ?? [];
+    if (!Array.isArray(grants))
+      throw new Error(
+        `${where}.grants: must be a list of workspace names (got ${JSON.stringify(grants)})`,
+      );
+    grants.forEach((g, i) => {
+      if (typeof g !== "string" || !AGENT_KEY_RE.test(g))
+        throw new Error(
+          `${where}.grants[${i}]: ${JSON.stringify(g)} is not a workspace name`,
+        );
+    });
+    out.agents[id] = { grants: [...new Set(grants as string[])] };
+  }
+  return out;
+}
+
 // ── Web UI service (`<cli> service`) ──────────────────────────────────────────
 
 /** `web:` in the org config. */

package/src/shared/engine.ts

@@ -13,6 +13,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { pathToFileURL } from "node:url";
 import { getDistRoot, getEngineRoot } from "./paths.js";
 
 /** An absolute path inside Den's own package. */
@@ -83,3 +84,25 @@ export function distPath(...parts: string[]): string {
 export function playwrightCommand(...args: string[]): EngineCommand {
   return { command: engineBin("playwright"), args };
 }
+
+/**
+ * How to run Den's CLI as a background process of its own, whatever process
+ * asks (the CLI, the web server): one node process, never the tsx CLI (a
+ * parent that relays signals). Live TypeScript source with tsx's loader in
+ * a checkout or a package install; the compiled build when tsx is absent,
+ * or with DEN_USE_DIST=1. Mirrors the web server's resolveServerEntrypoint.
+ */
+export function cliEntrypoint(engine: string = getEngineRoot()): EngineCommand {
+  const built = path.join(engine, "dist/src/ui/cli/index.js");
+  if (process.env.DEN_USE_DIST === "1" && fs.existsSync(built))
+    return { command: process.execPath, args: [built] };
+  const loader = engineModuleFile("tsx/dist/loader.mjs", engine);
+  const src = path.join(engine, "src/ui/cli/index.ts");
+  if (loader && fs.existsSync(src))
+    return {
+      command: process.execPath,
+      args: ["--import", pathToFileURL(loader).href, src],
+    };
+  if (fs.existsSync(built)) return { command: process.execPath, args: [built] };
+  return { command: engineBin("tsx", engine), args: [src] };
+}

package/src/shared/environment-manager/scope.ts

@@ -82,6 +82,28 @@ export function scopeView(scope?: ViewScope): ScopeView {
   };
 }
 
+/**
+ * WS-6.4: what health covers, whatever is in view: every active workspace,
+ * focused first. Scope only filters what is displayed (inViewMarker); it
+ * never narrows what is polled, so a workspace outside it still shows its
+ * real health on the Workspaces page.
+ */
+export function pollView(): ScopeView {
+  return scopeView(ALL_ACTIVE);
+}
+
+/**
+ * Whether a health row is in view: one of the workspaces that define it
+ * (`workspaces`, its owners) is in `view`. A row without owners counts as
+ * in view.
+ */
+export function inViewMarker(
+  view: ScopeView,
+): (owners: readonly string[] | undefined) => boolean {
+  const names = new Set(view.workspaces.map((w) => w.name));
+  return (owners) => !owners?.length || owners.some((o) => names.has(o));
+}
+
 /** A cache key for what is in view (the scope's workspaces, in order). */
 export function scopeKey(view: ScopeView): string {
   return view.workspaces.map((w) => w.name).join(",");

package/src/shared/environment-manager/service-runner.ts

@@ -400,6 +400,70 @@ export function findDaemonByAddress(address: string): DaemonRecord | undefined {
   return _daemonRegistry.get(address);
 }
 
+/**
+ * The other spelling of a single-service repo's daemon: "<repo>" and
+ * "<repo>/<svc>" name the same process (0.4.1-dev.5, a consumer's dev.4
+ * finding: `up <repo>` recorded "<repo>", `restart <repo>/<svc>` found no
+ * record, adopted the running process instead of restarting it, and left
+ * two records on one process group). Null for a repo with several
+ * services: each of its services is its own daemon.
+ */
+function singleServiceAlias(
+  resolved: Pick<ResolvedService, "address" | "repoName" | "subsystem"> & {
+    repoPath: string;
+  },
+): string | null {
+  const keys = Object.keys(readManifest(resolved.repoPath)?.services ?? {});
+  if (keys.length !== 1 || keys[0] !== resolved.subsystem) return null;
+  const full = `${resolved.repoName}/${resolved.subsystem}`;
+  if (resolved.address === resolved.repoName) return full;
+  if (resolved.address === full) return resolved.repoName;
+  return null;
+}
+
+/**
+ * Bring a single-service repo's record to the address this command uses,
+ * so every lookup by `resolved.address` finds it whichever spelling wrote
+ * it. A record only under the other spelling moves; a duplicate (two
+ * records on one process group, the dev.4 bug's leftover, or one of them
+ * dead or without a group) is merged into one, owners and containers
+ * unioned. Two records on two different live groups are left alone.
+ */
+export function reconcileDaemonAddress(resolved: ResolvedService): void {
+  const alias = singleServiceAlias(resolved);
+  if (!alias) return;
+  loadDaemonsFromFile();
+  const other = _daemonRegistry.get(alias);
+  if (!other || other.repoPath !== resolved.repoPath) return;
+  const own = _daemonRegistry.get(resolved.address);
+  if (own) {
+    const sameGroup =
+      own.pgid === undefined ||
+      other.pgid === undefined ||
+      own.pgid === other.pgid ||
+      isDaemonVerifiablyDead(other);
+    if (!sameGroup) return;
+  }
+  // The record carrying a process group is the one `down` can stop.
+  const keep =
+    own && (own.pgid !== undefined || other.pgid === undefined) ? own : other;
+  const drop = keep === own ? other : own;
+  const merged: DaemonRecord = {
+    ...keep,
+    address: resolved.address,
+    workspaces: [
+      ...new Set([...(keep.workspaces ?? []), ...(drop?.workspaces ?? [])]),
+    ],
+  };
+  const containers = [
+    ...new Set([...(keep.containers ?? []), ...(drop?.containers ?? [])]),
+  ];
+  if (containers.length > 0) merged.containers = containers;
+  _daemonRegistry.delete(alias);
+  _daemonRegistry.set(resolved.address, merged);
+  saveDaemonsFile(getDaemonsFile());
+}
+
 /** Add a workspace owner to a running daemon (share / attach). */
 export function attachDaemonOwner(address: string, workspace: string): void {
   loadDaemonsFromFile();
@@ -1344,6 +1408,12 @@ export interface RunCommandOptions {
   explicit?: boolean;
   /** For `down`: what it found to stop (see DownOutcome). */
   onDownOutcome?: (outcome: DownOutcome) => void;
+  /**
+   * Internal: this `up` is a restart's up step ("up"), or the up step of
+   * the restart a restart ran after adopting a process ("after-adopt").
+   * A restart never ends on an adoption: what it adopts it restarts.
+   */
+  restartStep?: "up" | "after-adopt";
 }
 
 /**
@@ -1506,6 +1576,7 @@ function settleDaemonRecord(
   record: DaemonRecord | undefined;
   outcome: "adopted" | "dropped" | "busy" | null;
 } {
+  reconcileDaemonAddress(resolved);
   const record = findDaemonByAddress(resolved.address);
   if (!record || !isLegacyRecord(record)) return { record, outcome: null };
   const outcome = settleLegacyRecord(record, resolved, workspace, onLine);
@@ -1674,7 +1745,12 @@ function restartAsDownThenUp(
         options.onClose(code);
         return;
       }
-      const up = runServiceCommand({ ...options, command: "up" });
+      const up = runServiceCommand({
+        ...options,
+        command: "up",
+        restartStep:
+          options.restartStep === "after-adopt" ? "after-adopt" : "up",
+      });
       tail = up.proc;
       if (stopTail) {
         try {
@@ -2052,6 +2128,9 @@ export function runServiceCommand(
   }
 
   const { repoPath, subsystem } = resolved;
+  // A single-service repo's record answers to "<repo>" and "<repo>/<svc>":
+  // every decision below reads it under this command's spelling.
+  reconcileDaemonAddress(resolved);
 
   const explicit = options.explicit ?? true;
   const reportDown = (outcome: DownOutcome): void =>
@@ -2217,6 +2296,16 @@ export function runServiceCommand(
           `${resolved.address} not started`,
         );
         if (holder === "adopted") {
+          // A restart's up step (its down found nothing recorded): the
+          // adopted process is the old instance, so it is restarted now,
+          // never left running as if restarted (0.4.1-dev.5).
+          if (options.restartStep === "up") {
+            onLine(`restarting the adopted process for ${resolved.address}`);
+            return restartAsDownThenUp(
+              { ...options, restartStep: "after-adopt" },
+              getServiceLogPath(resolved.repoName, resolved.subsystem),
+            );
+          }
           closeAsync(0);
           return dummy();
         }
@@ -2355,7 +2444,10 @@ export function runServiceCommand(
     resolved.repoName,
     workspace,
   );
-  let cmdDef = svcCommands[command];
+  // Own properties only (SEC-1 §6b.2): `constructor` is no command.
+  let cmdDef = Object.prototype.hasOwnProperty.call(svcCommands, command)
+    ? svcCommands[command]
+    : undefined;
   const requestedCmdDef = cmdDef;
 
   // `restart` fallback: synthesise `make down && make up` when no explicit

package/src/shared/environment-manager/workspaces.ts

@@ -325,6 +325,25 @@ export function writeWorkspacesFile(file: WorkspacesFile): void {
   }
 }
 
+/**
+ * A workspace's checkout directory: its `directory` (relative to the
+ * distribution root), else den-workspaces/<name>, else the legacy
+ * <reposRoot>/<name>, else the repos root itself. What /api/workspaces
+ * reports as resolvedDirs, and where an agent of the workspace runs.
+ */
+export function resolveWorkspaceDir(
+  name: string,
+  ws: Pick<WorkspaceConfig, "directory">,
+  reposRoot: string,
+): string {
+  if (ws.directory) return path.resolve(ROOT, ws.directory);
+  const gwDir = path.join(DEN_WORKSPACES_DIR, name);
+  if (fs.existsSync(gwDir)) return gwDir;
+  const legacyDir = path.join(reposRoot, name);
+  if (fs.existsSync(legacyDir)) return legacyDir;
+  return reposRoot;
+}
+
 export function getWorkspaceByName(name: string): {
   name: string;
   config: WorkspaceConfig;

package/src/shared/profile.ts

@@ -70,8 +70,16 @@ const expandHome = (p: string): string =>
       ? path.join(os.homedir(), p.slice(2))
       : p;
 
-/** A profile from a `product:` block; unset fields derive from the name. */
-export function profileFrom(raw: RawProduct = {}): ProductProfile {
+/**
+ * A profile from a `product:` block; unset fields derive from the name. A
+ * relative `state_dir` resolves against `baseDir`: the directory holding
+ * den.yml (the distribution root), never the cwd, so an agent's CLI or MCP
+ * server started elsewhere reads the same state.
+ */
+export function profileFrom(
+  raw: RawProduct = {},
+  baseDir: string = process.cwd(),
+): ProductProfile {
   const name = str(raw.name) ?? "den";
   if (!SLUG.test(name))
     throw new Error(
@@ -91,7 +99,10 @@ export function profileFrom(raw: RawProduct = {}): ProductProfile {
     envPrefix,
     configFile: str(raw.config) ?? `config/${name}.yml`,
     manifestFiles: json === manifest ? [manifest] : [manifest, json],
-    stateDir: path.resolve(expandHome(str(raw.state_dir) ?? `~/.${name}`)),
+    stateDir: path.resolve(
+      baseDir,
+      expandHome(str(raw.state_dir) ?? `~/.${name}`),
+    ),
     servicesDir: str(raw.services_dir) ?? `.${name}-services`,
     workspacesDir: str(raw.workspaces_dir) ?? `${name}-workspaces`,
   };
@@ -106,7 +117,7 @@ export function readProfileFile(file: string): ProductProfile {
     if ((e as NodeJS.ErrnoException).code === "ENOENT") return profileFrom();
     throw new Error(`${file}: ${(e as Error).message}`);
   }
-  return profileFrom(raw?.product ?? {});
+  return profileFrom(raw?.product ?? {}, path.dirname(path.resolve(file)));
 }
 
 let cached: { key: string; profile: ProductProfile } | null = null;