@monster-orange/den 0.4.12 → 0.4.14

package/src/ui/cli/agents-command.ts

@@ -28,6 +28,13 @@
  *           same conversation id (there is nothing to continue).
  *           --all-interrupted (AG-14.3): every agent interrupted when Den or
  *           the machine restarted that can resume.
+ *   import  (AG-17.1) bring in a conversation started outside Den: with
+ *           no --session, the runtime's own conversations in the
+ *           workspace's folder (newest first); with --session <id> and
+ *           --persona <p>, the runtime's resume of it (den-claude:
+ *           --resume <id>) in the folder it ran in, as a new agent under
+ *           Den's token, hooks and guards. Refused while it is still open
+ *           in another terminal (written in the last minute).
  *   rm      (AG-14.1b) forgets a stopped, interrupted or exited agent (never
  *           a running one); --stopped forgets every one of -w <ws> (or of
  *           every workspace). The runtime's own history stays.
@@ -69,7 +76,9 @@ import {
 } from "../../shared/agents/records.js";
 import {
   AgentError,
+  importAgent,
   listAgents,
+  listConversations,
   listPersonas as personaList,
   listRuntimes,
   loadAgentWorkspaces,
@@ -107,7 +116,7 @@ export {
 
 export const AGENTS_HELP = {
   usage:
-    "agents <list|start|stop|resume|relaunch|rm|personas|doctor|handback-check|handoff-check> ...",
+    "agents <list|start|stop|resume|relaunch|import|rm|personas|doctor|handback-check|handoff-check> ...",
   lines: [
     "Agents: a persona and a workspace, run by a runtime in a session that",
     "outlives the web server (see `{cli} sessions`).",
@@ -132,6 +141,12 @@ export const AGENTS_HELP = {
     "    compactions (default 3) or its pull request merged, and its handoff.md",
     "    passes the check, a fresh conversation (same persona, workspace, folder,",
     "    grants) whose first prompt is the handoff",
+    "{cli} agents import -w <ws> [--runtime <r>] [--json]",
+    "{cli} agents import -w <ws> --session <id> --persona <p> [--runtime <r>] [--id <id>]",
+    "    bring in a conversation started outside Den: the first lists the runtime's",
+    "    own (default den-claude) in the workspace's folder; the second continues",
+    "    one as a Den agent (its resume, in the folder it ran in). Refused while it",
+    "    is still open in another terminal: close it there first",
     "{cli} agents rm <id> [-w <ws>]",
     "{cli} agents rm --stopped [-w <ws>]",
     "    forget a stopped, interrupted or exited agent (never a running one);",
@@ -279,6 +294,72 @@ async function start(args: string[], d: AgentsResolved): Promise<number> {
   );
 }
 
+/** `agents import` (AG-17.1): list, or bring one in. */
+async function bringIn(args: string[], d: AgentsResolved): Promise<number> {
+  const where = "agents import";
+  const p = parseArgs(where, args, {
+    "--workspace": true,
+    "--runtime": true,
+    "--session": true,
+    "--persona": true,
+    "--id": true,
+    "--json": false,
+  });
+  noExtra(where, p);
+  const ws = workspaceFlag(where, p);
+  if (!ws) throw new UsageError(`${where} needs -w <workspace>`);
+  const runtime = str(p, "--runtime");
+  const session = str(p, "--session");
+  if (!session) {
+    if (str(p, "--persona") || str(p, "--id"))
+      throw new UsageError(`${where}: --persona and --id need --session <id>`);
+    const { runtimes, conversations } = listConversations(d, ws, runtime);
+    if (p.flags["--json"]) {
+      d.out(
+        JSON.stringify({ workspace: ws, runtimes, conversations }, null, 2),
+      );
+      return 0;
+    }
+    for (const r of runtimes)
+      if (!r.bringIn && (!runtime || runtime === r.id)) d.err(`${r.why}`);
+    if (!conversations.length) {
+      d.out(`no conversations to bring in for workspace ${ws}`);
+      return 0;
+    }
+    d.out(
+      columns([
+        ["ID", "RUNTIME", "LAST", "TITLE", "FOLDER", "NOTE"],
+        ...conversations.map((c) => [
+          c.id,
+          c.runtime,
+          c.lastAt.slice(0, 16).replace("T", " "),
+          c.title ?? "(untitled)",
+          c.cwd,
+          c.agent ? `agent ${c.agent}` : c.open ? "open elsewhere" : "",
+        ]),
+      ]).join("\n"),
+    );
+    d.out(
+      `bring one in: ${d.cli} agents import -w ${ws} --session <id> --persona <p>`,
+    );
+    return 0;
+  }
+  const persona = str(p, "--persona");
+  if (!persona) throw new UsageError(`${where} needs --persona <p>`);
+  const s = await importAgent(d, {
+    workspace: ws,
+    session,
+    persona,
+    runtime,
+    id: str(p, "--id"),
+  });
+  return report(
+    d,
+    s,
+    `brought in ${session} as agent ${s.rec.id} (${s.rec.persona}, ${s.rec.runtime}) as ${s.rec.sessionName} in ${s.rec.cwd}`,
+  );
+}
+
 /** `<id> [-w <ws>]`. */
 function idAndWorkspace(
   where: string,
@@ -410,13 +491,23 @@ async function listPersonas(
     return 0;
   }
   for (const l of columns([
-    ["PERSONA", "STANDING", "RUNTIME", "MODEL", "ROLE"],
+    [
+      "PERSONA",
+      "SOURCE",
+      "STANDING",
+      "RUNTIME",
+      "MODEL",
+      "ROLE",
+      "DESCRIPTION",
+    ],
     ...all.map((x) => [
       x.id,
+      x.origin,
       x.standing ? "yes" : "-",
       x.runtime ?? DEFAULT_RUNTIME_ID,
       x.model ?? "-",
-      x.role,
+      x.role ?? "-",
+      x.description,
     ]),
   ]))
     d.out(l);
@@ -606,6 +697,9 @@ export async function cmdAgents(
         case "relaunch":
           await loadAgentWorkspaces(deps);
           return await relaunch(rest, d);
+        case "import":
+          await loadAgentWorkspaces(deps);
+          return await bringIn(rest, d);
         case "rm":
           await loadAgentWorkspaces(deps);
           return await rm(rest, d);

package/src/ui/cli/env-probe.ts

@@ -112,7 +112,10 @@ function probeInput(d: ProbeDeps, dir: string): LaunchInput {
   return {
     persona: {
       id: PROBE_ID,
-      role: "",
+      description: "",
+      category: "engineering",
+      allowedCommands: [],
+      origin: "builtin",
       prompt: "",
       standing: false,
       tools: [],

package/src/ui/mcp/api.ts

@@ -140,12 +140,23 @@ const ACTION_ROUTES: Record<string, string> = {
   "/api/workspace/sync": "POST",
 };
 
-/** Action routes with a parameter: an agent's resume (MCP agent_resume). */
+/**
+ * Action routes with a parameter: an agent's resume (MCP agent_resume),
+ * and Bring in's list and import (MCP agent_import, AG-17.1).
+ */
 const ACTION_ROUTE_PATTERNS: { re: RegExp; method: string }[] = [
   {
     re: /^\/api\/workspaces\/[A-Za-z0-9._-]{1,64}\/agents\/[A-Za-z0-9._-]{1,64}\/resume$/,
     method: "POST",
   },
+  {
+    re: /^\/api\/workspaces\/[A-Za-z0-9._-]{1,64}\/conversations$/,
+    method: "GET",
+  },
+  {
+    re: /^\/api\/workspaces\/[A-Za-z0-9._-]{1,64}\/conversations\/[A-Za-z0-9][A-Za-z0-9_-]{0,127}\/import$/,
+    method: "POST",
+  },
 ];
 
 /**

package/src/ui/mcp/tools.ts

@@ -740,7 +740,7 @@ const agentResumeTool: DenTool = {
   name: "agent_resume",
   title: "Resume an agent",
   description:
-    "Resume a stopped or interrupted agent in the same conversation, persona, workspace and folder. Never starts a new conversation: an agent whose runtime can't resume is refused. Never the caller itself.",
+    "Resume a stopped or interrupted agent in the same conversation, persona, workspace and folder. Never starts a new conversation: an agent whose runtime can't resume is refused. Never the caller itself. Answers with agent: its id, persona, runtime, workspace, cwd, session (the session handle, <dist>-<ws>:<id>), sessionId, displayName (a person's name for it) and sessionTitle (the name its session shows: Den's rename or the runtime's, the later), when set.",
   action: true,
   shape: {
     agent: z.string().describe("The agent's id"),
@@ -776,6 +776,63 @@ const agentResumeTool: DenTool = {
   },
 };
 
+/** A runtime's conversation id (Claude Code: a uuid). */
+const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+
+/**
+ * MCP agent_import (AG-17.1): bring in a conversation started outside Den
+ * as an agent of this workspace (or a granted one). No session: the list.
+ * Opt-in through mcp.actions; the web server checks the scope again.
+ */
+const agentImportTool: DenTool = {
+  name: "agent_import",
+  title: "Bring in a conversation",
+  description:
+    "Bring in a conversation started outside Den (in the workspace's folder) as a Den agent: its runtime's own resume, in the folder it ran in, under Den's token, hooks and guards. Without session: lists the conversations there are (id, title, lastAt, cwd, runtime, open, agent). With session and persona: brings that one in and answers with the agent. Refused while it is still open in another terminal (written in the last minute), or when an agent already continues it.",
+  action: true,
+  shape: {
+    session: z
+      .string()
+      .optional()
+      .describe("The runtime's conversation id (omit to list them)"),
+    persona: z.string().optional().describe("The persona to run it as"),
+    runtime: z.string().optional().describe("The runtime (default den-claude)"),
+    workspace: workspaceArg,
+  },
+  async run(a, { api, scope }) {
+    let ws = str(a.workspace) ?? scope?.workspace;
+    if (!ws) {
+      const focused = (await api.get("/api/workspaces")) as {
+        focus?: unknown;
+      };
+      ws = typeof focused?.focus === "string" ? focused.focus : undefined;
+    }
+    if (!ws || !NAME_RE.test(ws))
+      throw new Refusal("agent_import: name the workspace");
+    if (scope && ws !== scope.workspace && !(scope.grants ?? []).includes(ws))
+      throw new ScopeRefusal(
+        `agent_import: workspace "${ws}" is outside this agent's scope ("${scope.workspace}")`,
+      );
+    const runtime = str(a.runtime);
+    if (runtime && !NAME_RE.test(runtime))
+      throw new Refusal("agent_import: runtime must be a runtime id");
+    const session = str(a.session);
+    const base = `/api/workspaces/${encodeURIComponent(ws)}/conversations`;
+    if (!session) return api.get(base, runtime ? { runtime } : {}, "GET");
+    if (!SESSION_RE.test(session))
+      throw new Refusal("agent_import: session must be a conversation id");
+    const persona = str(a.persona);
+    if (!persona || !NAME_RE.test(persona))
+      throw new Refusal("agent_import: name the persona to run it as");
+    return api.get(
+      `${base}/${encodeURIComponent(session)}/import`,
+      {},
+      "POST",
+      { persona, ...(runtime ? { runtime } : {}) },
+    );
+  },
+};
+
 const ACTION_TOOLS: Record<McpAction, DenTool> = {
   service_up: lifecycleTool("up"),
   service_down: lifecycleTool("down"),
@@ -865,6 +922,7 @@ const ACTION_TOOLS: Record<McpAction, DenTool> = {
     },
   },
   agent_resume: agentResumeTool,
+  agent_import: agentImportTool,
 };
 
 export const READ_TOOL_NAMES: readonly string[] = READ_TOOLS.map((t) => t.name);
@@ -903,6 +961,7 @@ const WORKSPACE_TOOLS = new Set([
   "workspace_sync",
   "run_tests",
   "agent_resume",
+  "agent_import",
 ]);
 
 /**

package/src/ui/server/agent-resume-grant.ts

@@ -51,3 +51,38 @@ export function agentResumeTarget(
     return null;
   }
 }
+
+/**
+ * MCP `agent_import` (AG-17.1): bring a conversation in as an agent, and
+ * list the ones there are. Off unless `mcp.actions` lists it; only in the
+ * caller's workspace or one its grants give it. A person's otherwise.
+ */
+export const AGENT_IMPORT_ACTION = "agent_import";
+
+/** GET /api/workspaces/<ws>/conversations, POST …/<id>/import. */
+export const AGENT_IMPORT_ROUTE =
+  /^\/api\/workspaces\/([^/]+)\/conversations(?:\/([^/]+)\/import)?$/;
+
+/** Why this agent may not bring in a conversation of `ws`, or null. */
+export function agentImportRefusal(
+  p: ResumingAgent,
+  ws: string,
+  actions: readonly string[],
+): string | null {
+  if (!actions.includes(AGENT_IMPORT_ACTION))
+    return `${p.actor} can't bring in conversations: the org config's mcp.actions doesn't list ${AGENT_IMPORT_ACTION}.`;
+  if (ws !== p.workspace && !p.grants.includes(ws))
+    return `${p.actor} can bring in conversations of workspace ${p.workspace} only${p.grants.length ? ` (or ${p.grants.join(", ")}, its grants)` : ""}, not ${ws}.`;
+  return null;
+}
+
+/** The import route's workspace, decoded; null when it isn't it. */
+export function agentImportTarget(pathname: string): { ws: string } | null {
+  const m = AGENT_IMPORT_ROUTE.exec(pathname);
+  if (!m) return null;
+  try {
+    return { ws: decodeURIComponent(m[1]) };
+  } catch {
+    return null;
+  }
+}