@monster-orange/den 0.4.13 → 0.4.14

package/CHANGELOG.md

@@ -4,6 +4,54 @@ All notable changes to Den are documented here. Each release lists the
 config and manifest changes a distribution must make to move to it under
 **Migrations**.
 
+## [0.4.14] - 2026-11-07
+
+### Added
+
+- **Bring in a conversation (AG-17.1).** A Claude Code conversation you
+  started in a terminal outside Den, in the workspace's folder or in one
+  of its repos' folders (a repo added by path outside it too), can become
+  a Den agent. Agents › Bring in lists them, newest first, and asks for a
+  persona; Bring in runs `claude --resume <id>` in the folder it ran in,
+  with Den's token, MCP, hooks and guards from then on. Den reads only the
+  first and last 64 KB of each transcript. A conversation written in the
+  last minute is refused: "Still open in another terminal. Close it there
+  first". CLI: `agents import -w <ws>` lists, `agents import -w <ws>
+  --session <id> --persona <p>` brings one in. MCP `agent_import` is
+  opt-in through `mcp.actions`. Routes: `GET
+  /api/workspaces/<ws>/conversations`, `POST
+  /api/workspaces/<ws>/conversations/<id>/import`. Only den-claude can
+  bring one in for now. The dialog asks you to close the
+  conversation in any other terminal first.
+- **One persona, several agents (AG-10.10).** Starting a persona that
+  already has an agent in the workspace starts another: `be-dev`, then
+  `be-dev-2`, `be-dev-3`. A stopped agent's id is never reused by a new
+  start, only by its Resume or Start fresh. The Start dialog says the id
+  it will use ("Starts as be-dev-2") and takes an optional Name. An id
+  that is running is refused, and the dialog offers "Open the running
+  one". `--id` stays exact. The start route takes `name`; `GET
+  /api/personas?workspace=<ws>` answers `startsAs`; a 409 for a running
+  agent carries `running: {id, sessionId}`.
+
+### Changed
+
+- Without `--id`, a start of a persona whose agent is stopped in that
+  workspace no longer replaces it: it starts `<persona>-2`. To continue
+  the stopped one, Resume it or Start fresh on it.
+
+### Fixed
+
+- Bring in: a long title no longer cuts off its "Agent …" badge, and each
+  "can't bring in a conversation yet" line is its own sentence.
+  Its intro names the repos' folders too.
+
+- Start › Advanced: the Model select's default reads "Persona default
+  (latest)" for a persona with no model of its own; the longer label was
+  cut off.
+- An `up` whose service exits at once with an error no longer leaves the
+  service listed. The command could exit before Den recorded its process
+  group, and then its record stayed.
+
 ## [0.4.13] - 2026-11-07
 
 ### Added
@@ -56,6 +104,7 @@ config and manifest changes a distribution must make to move to it under
   `sessions.max_concurrent`).
 - **A tester persona** in Den's default pack.
 
+
 ### Changed
 
 - `POST /api/workspaces/<ws>/agents` takes `version`, `permission`,

package/README.md

@@ -10,8 +10,8 @@
 </p>
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="docs/images/0.4.13/hero-dark.png">
-  <img src="docs/images/0.4.13/hero-light.png" width="100%" alt="Den's Graph page: the demo workspace's services grouped by application, all healthy, with the status chip and the left rail">
+  <source media="(prefers-color-scheme: dark)" srcset="docs/images/0.4.14/hero-dark.png">
+  <img src="docs/images/0.4.14/hero-light.png" width="100%" alt="Den's Graph page: the demo workspace's services grouped by application, all healthy, with the status chip and the left rail">
 </picture>
 
 ## Set up by your agent
@@ -38,7 +38,7 @@ It doesn't replace your tools. Your repos, Docker, your test runners, your secre
 yours. Den connects them and turns on good practice from the start.
 
 <p align="center">
-  <img src="docs/images/0.4.13/up.gif" width="100%" alt="make up in the Graph page: every stack down, then demo-api, demo-web and demo-notes come up in dependency order until the status chip reads All 3 healthy">
+  <img src="docs/images/0.4.14/up.gif" width="100%" alt="make up in the Graph page: every stack down, then demo-api, demo-web and demo-notes come up in dependency order until the status chip reads All 3 healthy">
 </p>
 
 ## How it helps
@@ -68,10 +68,10 @@ yours. Den connects them and turns on good practice from the start.
   lives in your own repo.
 
 <p align="center">
-  <img src="docs/images/0.4.13/agents.png" width="49%" alt="The Agents tab: the demo workspace's sessions on the left, and one open in a terminal pane on the right, running demo-api's test and then the service">
-  <img src="docs/images/0.4.13/workspaces.png" width="49%" alt="The Workspaces page: the demo workspace's repos with their health, mode and Start, Stop, Restart and Logs actions">
-  <img src="docs/images/0.4.13/status-drawer.png" width="49%" alt="The status drawer: nothing needs attention, and every service in the demo workspace, by application, with its latency">
-  <img src="docs/images/0.4.13/edge.png" width="49%" alt="The Edge page: the edge container up, its ports and TLS, and every route it serves, Den's own and each stack's, with its upstream">
+  <img src="docs/images/0.4.14/agents.png" width="49%" alt="The Agents tab: the demo workspace's sessions on the left, and one open in a terminal pane on the right, running demo-api's test and then the service">
+  <img src="docs/images/0.4.14/workspaces.png" width="49%" alt="The Workspaces page: the demo workspace's repos with their health, mode and Start, Stop, Restart and Logs actions">
+  <img src="docs/images/0.4.14/status-drawer.png" width="49%" alt="The status drawer: nothing needs attention, and every service in the demo workspace, by application, with its latency">
+  <img src="docs/images/0.4.14/edge.png" width="49%" alt="The Edge page: the edge container up, its ports and TLS, and every route it serves, Den's own and each stack's, with its upstream">
 </p>
 
 ## Get started

package/docs/distributions.md

@@ -1932,6 +1932,13 @@ orchestrator. It is off unless `mcp.actions` names it. A scoped server
 itself. The web server checks the same rule, and the resume route is the
 only agent route an agent's token reaches.
 
+`agent_import` (AG-17.1) brings in a conversation started outside Den as an
+agent: with no `session` it lists them, with `session` and `persona` it
+brings one in (see [Bring in a conversation](#bring-in-a-conversation)). It
+is off unless `mcp.actions` names it, and a scoped server reaches its own
+workspace or a granted one. Without it, an agent's token gets 403 on both
+the list and the import.
+
 ### Guards
 
 - **Lifecycle only, local only.** The service tools run a manifest's `up`,
@@ -2042,6 +2049,8 @@ server scoped to its workspace.
 <cli> agents list -w <ws> [--json]
 <cli> agents stop <id> [-w <ws>]
 <cli> agents resume <id> [-w <ws>]
+<cli> agents import -w <ws> [--runtime <r>] [--json]          # conversations to bring in
+<cli> agents import -w <ws> --session <id> --persona <p>      # bring one in
 <cli> agents personas [--json]
 <cli> agents doctor [-w <ws>] [--json]  # can each runtime run here, and why not
 <cli> agents handback-check <file|->    # is a hand-back complete and plain (see Guardrails)
@@ -2052,7 +2061,10 @@ server scoped to its workspace.
   checkout dir (its `directory`, else `den-workspaces/<ws>`), capped by
   `agents.max_concurrent` (agents only: plain sessions never count). The id defaults to the persona's id; an id is
   unique in the distribution, so a second workspace's planner gets
-  `planner-<ws>` unless you give `--id`.
+  `planner-<ws>` unless you give `--id`. A persona that already has an
+  agent there, running or stopped, starts another: `planner-2`,
+  `planner-3`. A stopped agent is continued by Resume or Start fresh,
+  never by a new start. `--id` is exact: a running id is refused.
 - The **agent record**, `<stateDir>/agents/<id>.json` (0600), holds its id,
   persona, runtime, model, workspace, cwd, session and times, and what it was
   started with from the Start dialog: `version` (the model's, "latest" or
@@ -2085,6 +2097,36 @@ server scoped to its workspace.
   exits non-zero, Den prints the exit code and its last lines (at most 10,
   secret-shaped values redacted) and exits 1.
 
+#### Bring in a conversation
+
+A conversation you started in a terminal outside Den (Claude Code, in the
+workspace's folder, a folder inside it, or a folder of one of its repos,
+a repo added by path outside it too) can become a Den agent. Agents ›
+**Bring in** lists them, newest first, with the persona list; `agents
+import -w <ws>` lists them too.
+
+- Den reads the runtime's own history: Claude Code's
+  `~/.claude/projects/<folder>/<id>.jsonl` (or under `CLAUDE_CONFIG_DIR`).
+  It reads only the first and last 64 KB of each file, for the folder it
+  ran in, its latest `/rename` and its first prompt. It never reads a whole
+  transcript, and it lists at most 50.
+- Bringing one in runs the runtime's resume (`claude --resume <id>`) in the
+  folder it ran in, as a new agent with the persona you pick. From then on
+  Den's token, MCP config, hooks, guards and audit trail apply. It is an
+  agent like any other: stop, resume, rename. The record notes
+  `broughtInAt`.
+- **One writer only.** A conversation written in the last minute is taken
+  to be still open in another terminal: "Still open in another terminal.
+  Close it there first" (HTTP 409 `open_elsewhere`). A conversation an
+  agent already continues is refused too (409 `already_agent`).
+- The agent's id is the persona's, or `<persona>-2`, `-3`… when that is
+  taken; `--id` sets one. An existing agent is never overwritten.
+- Only den-claude can bring one in for now. Other runtimes say "<runtime>
+  can't bring in a conversation yet".
+- Routes: `GET /api/workspaces/<ws>/conversations[?runtime=<r>]` and `POST
+/api/workspaces/<ws>/conversations/<id>/import` `{ persona, runtime?, id?
+}`. A person's only, unless MCP `agent_import` is opted in.
+
 ### On the Workspaces page
 
 The selected workspace's agents are listed under its repo table, one row

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monster-orange/den",
-  "version": "0.4.13",
+  "version": "0.4.14",
   "description": "Den: a local multi-repo dev orchestrator, HTTPS edge and E2E harness",
   "type": "module",
   "bin": {

package/src/shared/agents/conversations.ts

@@ -0,0 +1,227 @@
+/**
+ * AG-17.1, bring in a conversation: the runtime's own recent conversations
+ * for a folder, read from its history without ever reading a whole
+ * transcript.
+ *
+ * Claude Code keeps one JSON-lines file per conversation,
+ * `<projects>/<slug>/<id>.jsonl`, where <slug> is the cwd with every
+ * character that isn't a letter or digit made "-" (`/w/a.b` → `-w-a-b`).
+ * The slug alone can't tell `/w/north` from `/w/north-2`, so a
+ * conversation is listed only when the `cwd` its own records carry is the
+ * folder or inside it.
+ *
+ * Each file is read at its two ends only (ENDS_BYTES each): the head for
+ * its cwd and its first prompt, the tail for its latest `/rename`
+ * (custom-title). Title: the latest custom-title, else the first prompt a
+ * person typed, else null. lastAt is the file's mtime: a conversation
+ * written in the last OPEN_ELSEWHERE_MS is taken to be open in another
+ * terminal (one writer only).
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { claudeProjectsDir } from "../usage/paths.js";
+import { cleanName } from "./transcript-follow.js";
+
+/** One of a runtime's conversations, as Bring in lists it. */
+export interface RuntimeConversation {
+  /** The runtime's own id for it (Claude Code: the transcript's name). */
+  id: string;
+  /** Its name for people, or null when it has none yet. */
+  title: string | null;
+  /** When it was last written (ISO). */
+  lastAt: string;
+  /** The folder it ran in. */
+  cwd: string;
+}
+
+/** Bytes read at each end of a transcript. */
+export const ENDS_BYTES = 64 * 1024;
+/** Written this recently: still open in another terminal (AG-17.1). */
+export const OPEN_ELSEWHERE_MS = 60_000;
+/** The most conversations listed for one folder (the newest). */
+export const MAX_CONVERSATIONS = 50;
+
+export const OPEN_ELSEWHERE_MESSAGE =
+  "Still open in another terminal. Close it there first";
+
+const ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+
+/** Claude Code's project folder name for `dir`. */
+export function claudeSlug(dir: string): string {
+  return dir.replace(/[^A-Za-z0-9]/g, "-");
+}
+
+/** Whether `p` is `dir` or inside it. */
+function within(p: string, dir: string): boolean {
+  const rel = path.relative(dir, p);
+  return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
+}
+
+/**
+ * The complete lines at the two ends of `file`: at most `bytes` from each.
+ * A line cut at either edge is left out; a short file is all head.
+ */
+export function readEnds(
+  file: string,
+  bytes = ENDS_BYTES,
+): { head: string[]; tail: string[] } {
+  const fd = fs.openSync(file, "r");
+  try {
+    const size = fs.fstatSync(fd).size;
+    const read = (at: number, n: number) => {
+      const buf = Buffer.alloc(n);
+      const got = fs.readSync(fd, buf, 0, n, at);
+      return buf.subarray(0, got).toString("utf-8");
+    };
+    const headText = read(0, Math.min(size, bytes));
+    const head = headText.split("\n");
+    // The whole file: every line. Else the last piece was cut.
+    if (size <= bytes) return { head: head.filter(Boolean), tail: [] };
+    head.pop();
+    const start = Math.max(bytes, size - bytes);
+    const tail = read(start, size - start).split("\n");
+    // The first piece was cut (or is the head's).
+    tail.shift();
+    return { head: head.filter(Boolean), tail: tail.filter(Boolean) };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function parse(line: string): Record<string, unknown> | null {
+  try {
+    const v = JSON.parse(line) as unknown;
+    return v && typeof v === "object" ? (v as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The text a person typed in a user record, or null (tool results, meta). */
+function promptText(rec: Record<string, unknown>): string | null {
+  if (rec.type !== "user" || rec.isMeta === true) return null;
+  const msg = rec.message as { content?: unknown } | undefined;
+  let text: unknown = msg?.content;
+  if (Array.isArray(text)) {
+    const first = text.find(
+      (c) => (c as { type?: unknown })?.type === "text",
+    ) as { text?: unknown } | undefined;
+    text = first?.text;
+  }
+  if (typeof text !== "string") return null;
+  // Slash commands and their output come wrapped in tags: not a prompt.
+  if (text.trimStart().startsWith("<")) return null;
+  return cleanName(text);
+}
+
+/** A transcript's cwd and title, from its two ends. */
+export function transcriptSummary(
+  file: string,
+  bytes = ENDS_BYTES,
+): { cwd: string | null; title: string | null } {
+  const { head, tail } = readEnds(file, bytes);
+  let cwd: string | null = null;
+  let prompt: string | null = null;
+  let title: string | null = null;
+  const titleIn = (line: string) => {
+    if (!line.includes("custom-title")) return;
+    const r = parse(line);
+    if (r?.type === "custom-title") title = cleanName(r.customTitle) ?? title;
+  };
+  for (const line of head) {
+    titleIn(line);
+    if (cwd && prompt) continue;
+    if (!line.includes('"cwd"') && !line.includes('"user"')) continue;
+    const r = parse(line);
+    if (!r) continue;
+    if (!cwd && typeof r.cwd === "string" && path.isAbsolute(r.cwd))
+      cwd = r.cwd;
+    prompt ??= promptText(r);
+  }
+  for (const line of tail) titleIn(line);
+  return { cwd, title: title ?? prompt };
+}
+
+/** A folder's absolute forms: as given and its real path. */
+function forms(dir: string): string[] {
+  const out = [path.resolve(dir)];
+  try {
+    const real = fs.realpathSync(dir);
+    if (!out.includes(real)) out.push(real);
+  } catch {
+    /* gone: as given */
+  }
+  return out;
+}
+
+/**
+ * Claude Code's conversations that ran in `folder` or a folder inside it,
+ * newest first, at most MAX_CONVERSATIONS. Never throws: a history it
+ * can't read is no conversations.
+ */
+export function claudeConversations(
+  folder: string,
+  env: NodeJS.ProcessEnv = process.env,
+): RuntimeConversation[] {
+  const root = claudeProjectsDir(env);
+  const dirs = forms(folder);
+  const slugs = dirs.map(claudeSlug);
+  let projects: string[];
+  try {
+    projects = fs.readdirSync(root);
+  } catch {
+    return [];
+  }
+  const files: { id: string; file: string; mtimeMs: number }[] = [];
+  for (const p of projects) {
+    if (!slugs.some((s) => p === s || p.startsWith(`${s}-`))) continue;
+    let names: string[];
+    try {
+      names = fs.readdirSync(path.join(root, p));
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      if (!n.endsWith(".jsonl")) continue;
+      const id = n.slice(0, -".jsonl".length);
+      if (!ID_RE.test(id)) continue;
+      const file = path.join(root, p, n);
+      try {
+        const st = fs.statSync(file);
+        if (st.isFile() && st.size > 0)
+          files.push({ id, file, mtimeMs: st.mtimeMs });
+      } catch {
+        /* gone */
+      }
+    }
+  }
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const out: RuntimeConversation[] = [];
+  const seen = new Set<string>();
+  for (const f of files) {
+    if (out.length >= MAX_CONVERSATIONS) break;
+    if (seen.has(f.id)) continue;
+    let s: ReturnType<typeof transcriptSummary>;
+    try {
+      s = transcriptSummary(f.file);
+    } catch {
+      continue;
+    }
+    const cwd = s.cwd;
+    if (!cwd || !dirs.some((d) => within(cwd, d))) continue;
+    seen.add(f.id);
+    out.push({
+      id: f.id,
+      title: s.title,
+      lastAt: new Date(f.mtimeMs).toISOString(),
+      cwd,
+    });
+  }
+  return out;
+}
+
+/** Whether a conversation last written at `lastAt` is still open elsewhere. */
+export function openElsewhere(lastAt: string, now = Date.now()): boolean {
+  const t = Date.parse(lastAt);
+  return Number.isFinite(t) && now - t < OPEN_ELSEWHERE_MS;
+}

package/src/shared/agents/den-claude.ts

@@ -70,6 +70,7 @@ import { catalogFind } from "./catalog-runtime.js";
 import { locateRuntime, type RuntimeFind } from "./runtime-search.js";
 import { claudeProjectsDir } from "../usage/paths.js";
 import { cleanName, transcriptTitle } from "./transcript-follow.js";
+import { claudeConversations } from "./conversations.js";
 
 /**
  * `/rename "x"` keeps the quotes in customTitle: one matching pair around
@@ -488,6 +489,14 @@ export const denClaude: Runtime = {
   conversationExists(token, env = process.env) {
     return transcriptFile(token, env) !== null;
   },
+  // AG-17.1: its transcripts for the folder (conversations.ts).
+  listSessions(cwd, env = process.env) {
+    try {
+      return claudeConversations(cwd, env);
+    } catch {
+      return [];
+    }
+  },
   // AG-4b, unofficial (catalog sessionName): `/rename` appends a
   // {"type":"custom-title","customTitle":…} record to the transcript; the
   // latest one, read on from the last ask (never the whole file), less one

package/src/shared/agents/records.ts

@@ -42,6 +42,11 @@ export interface AgentRecord {
   resumedAt?: string;
   /** The runtime's handle for resume (den-claude: the conversation id). */
   resumeToken?: string;
+  /**
+   * AG-17.1: brought in from a conversation started outside Den (when);
+   * Den's token, hooks and guards apply from then on.
+   */
+  broughtInAt?: string;
   /**
    * The runtime was launched on resumeToken at least once (0.4.8). A
    * resume then always tries the runtime's own resume first, never a new

package/src/shared/agents/runtime.ts

@@ -21,6 +21,7 @@ import type { AgentRecord } from "./records.js";
 import type { Persona } from "./personas.js";
 import type { BinSource, RuntimeFind } from "./runtime-search.js";
 import type { PermissionIntent } from "./permissions.js";
+import type { RuntimeConversation } from "./conversations.js";
 
 export const RUNTIME_KIND = "runtime";
 
@@ -193,6 +194,14 @@ export interface Runtime {
    * just mean it isn't written yet.
    */
   conversationExists?(token: string, env?: NodeJS.ProcessEnv): boolean;
+  /**
+   * AG-17.1, bring in a conversation: the runtime's own recent
+   * conversations that ran in `cwd` or a folder inside it, newest first,
+   * read from its history (only the ends of each file, never a whole
+   * transcript). Each id is one `resume` continues. None: this runtime
+   * can't bring one in yet. Must never throw.
+   */
+  listSessions?(cwd: string, env?: NodeJS.ProcessEnv): RuntimeConversation[];
   /**
    * What the runtime prints when it exits at once (0.4.8): `noConversation`
    * when a resume finds nothing to continue, `idInUse` when a new

package/src/shared/den-config.ts

@@ -818,6 +818,8 @@ export const MCP_ACTIONS = [
   "run_tests",
   // AG-14.4: resume another agent of its workspace (or a granted one).
   "agent_resume",
+  // AG-17.1: bring in a conversation started outside Den, as an agent.
+  "agent_import",
 ] as const;
 export type McpAction = (typeof MCP_ACTIONS)[number];
 

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

@@ -2794,18 +2794,13 @@ export function runServiceCommand(
   // later down signalled the dead group while the real listener ran on).
   // A failed start keeps no record at all.
   const serviceExited = (exitCode: number): void => {
-    const rec = recorded;
-    if (rec && processGroupStateSync(rec)?.state === "gone") {
-      const now = findDaemonByAddress(resolved.address);
-      // A non-zero exit is a failed start: nothing of it runs, so no
-      // record (its containers, if any, still run: then only the group
-      // goes). A zero exit handed off (`make up`): its group stays, and
-      // down says it already exited.
-      if (now?.pgid === rec.pgid && exitCode !== 0) {
-        if (!(now.containers?.length ?? 0)) unregisterDaemon(resolved.address);
-        else clearDaemonProcessGroup(resolved.address);
-      }
-    }
+    const rec: RecordedProcessGroup | null = recorded;
+    const state = rec ? (processGroupStateSync(rec)?.state ?? null) : null;
+    const now = findDaemonByAddress(resolved.address);
+    const action = failedStartCleanup(exitCode, rec, state, now);
+    if (action === "unregister") unregisterDaemon(resolved.address);
+    else if (action === "clear-group")
+      clearDaemonProcessGroup(resolved.address);
     onServiceExit?.(exitCode);
   };
   const proc = recordGroup
@@ -2835,6 +2830,30 @@ export function runServiceCommand(
   return { proc, detachable, interactive: false, logPath };
 }
 
+/**
+ * What a detached up does with its record when the service process exits.
+ * A non-zero exit is a failed start: nothing of it runs, so no record (its
+ * containers, if any, still run: then only the group goes). A zero exit
+ * handed off (`make up`): its group stays, and down says it already exited.
+ * The record goes only if it is this run's: its group is the one this run
+ * recorded and that group is gone, or this run could not record a group
+ * (the command exited, a zombie, before `ps` saw it) and the record names
+ * none.
+ */
+export function failedStartCleanup(
+  exitCode: number,
+  rec: RecordedProcessGroup | null,
+  groupState: string | null,
+  now: { pgid?: number; containers?: unknown[] } | undefined,
+): "unregister" | "clear-group" | "keep" {
+  if (exitCode === 0 || !now) return "keep";
+  const ours = rec
+    ? groupState === "gone" && now.pgid === rec.pgid
+    : now.pgid === undefined;
+  if (!ours) return "keep";
+  return (now.containers?.length ?? 0) ? "clear-group" : "unregister";
+}
+
 // ── Health checks ─────────────────────────────────────────────────────────────
 // (implementation lives in health.ts — re-exported above)
 

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

@@ -344,6 +344,17 @@ export function resolveWorkspaceDir(
   return reposRoot;
 }
 
+/**
+ * The folders of a workspace's by-path repos (`repo add <path>`), wherever
+ * they are, outside its own folder too (AG-17.1). Managed clones and a
+ * feature workspace's clones live under Den's or the workspace's folder.
+ */
+export function repoFolders(cfg: WorkspaceConfig | undefined): string[] {
+  return Object.values(cfg?.services ?? {})
+    .map((e) => (e as { path?: string }).path)
+    .filter((p): p is string => typeof p === "string" && path.isAbsolute(p));
+}
+
 export function getWorkspaceByName(name: string): {
   name: string;
   config: WorkspaceConfig;