@dam-agents/cli 0.2.16 → 0.2.17

package/dist/bin.js

@@ -26990,12 +26990,19 @@ var skillSourceSeedSchema = external_exports.object({
   path: skillSourcePathSchema.optional()
 });
 var templateCategorySchema = external_exports.enum(["harness", "preconfigured"]).default("harness");
+var harnessFamilySchema = external_exports.enum([
+  "claude-code",
+  "codex",
+  "pi",
+  "bob"
+]);
 var templateSpecSchema = external_exports.object({
   version: external_exports.string(),
   image: external_exports.string(),
   name: external_exports.string().optional(),
   description: external_exports.string().optional(),
   category: templateCategorySchema,
+  harness: harnessFamilySchema.optional(),
   tags: external_exports.array(external_exports.string()).optional(),
   docsUrl: external_exports.string().optional(),
   releaseNotesUrl: external_exports.string().optional(),
@@ -27098,7 +27105,8 @@ var podSessionTypeSchema = external_exports.enum([
   "channel_slack",
   "channel_telegram",
   "schedule_cron",
-  "experiment_execute"
+  "experiment_execute",
+  "cli_run"
 ]);
 var podSessionSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
@@ -27122,6 +27130,16 @@ var podSessionListSchema = external_exports.object({
 var podSessionNoticeSchema = external_exports.object({
   topic: external_exports.literal("sessions")
 });
+var sessionDirectoryEntrySchema = external_exports.object({
+  sessionId: external_exports.string().min(1),
+  mode: podSessionModeSchema,
+  type: podSessionTypeSchema,
+  createdAt: external_exports.string()
+});
+var sessionDirectoryReportSchema = external_exports.object({
+  protocolVersion: external_exports.literal("v1"),
+  sessions: external_exports.array(sessionDirectoryEntrySchema).max(1e4)
+});
 
 // ../agent-runtime-api/src/modules/skills/schemas.ts
 var skillInstallInputSchema2 = external_exports.object({
@@ -27175,6 +27193,9 @@ var skillWriteLocalInputSchema = external_exports.object({
   ).min(1).max(50)
 });
 
+// ../agent-runtime-api/src/modules/skills/source-roots.ts
+var STAGED_SKILLS_DIR = "/usr/local/share/dam-skills";
+
 // ../agent-runtime-api/src/modules/workspace/paths.ts
 var AGENT_HOME_DIR = "/home/agent";
 var AGENT_WORK_DIR = `${AGENT_HOME_DIR}/work`;
@@ -27841,7 +27862,14 @@ var artifactKindSchema = external_exports.enum([
   "text",
   "binary"
 ]);
-var artifactVisibilitySchema = external_exports.enum(["private", "public"]);
+var artifactVisibilitySchema = external_exports.enum([
+  "private",
+  "restricted",
+  "public"
+]);
+var artifactCreateVisibilitySchema = external_exports.enum(["private", "public"]);
+var VIEWER_ALLOWLIST_MAX = 50;
+var viewerEmailSchema = external_exports.string().trim().toLowerCase().pipe(external_exports.email().max(254));
 var ARTIFACT_TITLE_MAX_LENGTH = 300;
 var titleSchema = external_exports.string().trim().min(1, "title is required").max(ARTIFACT_TITLE_MAX_LENGTH);
 var fileNameSchema = external_exports.string().trim().min(1).max(255);
@@ -27868,7 +27896,7 @@ var artifactCreateInputSchema = external_exports.object({
   kind: artifactKindSchema.optional(),
   contentType: external_exports.string().trim().min(1).max(200).optional(),
   folderId: external_exports.string().min(1).optional(),
-  visibility: artifactVisibilitySchema.optional(),
+  visibility: artifactCreateVisibilitySchema.optional(),
   expiresInHours: expiresInHoursSchema.nullish()
 }).refine((v2) => v2.content == null !== (v2.uploadRef == null), {
   message: "provide exactly one of content or uploadRef",
@@ -27888,7 +27916,10 @@ var artifactUpdateInputSchema = external_exports.object({
 var artifactSharingInputSchema = external_exports.object({
   id: external_exports.string().min(1),
   visibility: artifactVisibilitySchema.optional(),
-  expiresInHours: expiresInHoursSchema.nullish()
+  expiresInHours: expiresInHoursSchema.nullish(),
+  viewers: external_exports.array(viewerEmailSchema).max(VIEWER_ALLOWLIST_MAX).transform((emails) => [...new Set(emails)]).optional().describe(
+    "The whole Viewer Allowlist. Replaces the stored list; omit to leave it as is."
+  )
 });
 var artifactUploadUrlInputSchema = external_exports.object({
   fileName: fileNameSchema
@@ -31122,6 +31153,79 @@ function templateIdForProvider(type, value) {
   return (matched ?? modes.find((mode) => mode.isDefault) ?? modes[0]).templateId;
 }
 
+// ../api-server-api/src/modules/case-studies/constants.ts
+var CASE_STUDY_CONTENT_MAX_CHARS = 262144;
+var CASE_STUDY_SKILL_NAME = "agent-case-study";
+var CASE_STUDY_SKILL_PATH = `${STAGED_SKILLS_DIR}/${CASE_STUDY_SKILL_NAME}/SKILL.md`;
+var CASE_STUDY_SCHEDULE_TASK = `Read ${CASE_STUDY_SKILL_PATH} and follow it to produce this week's edition of your case study. If that file does not exist, reply that this image does not ship the case-study skill and stop \u2014 do not attempt the task without it.`;
+
+// ../api-server-api/src/modules/case-studies/schemas.ts
+var caseStudyStatusSchema = external_exports.enum([
+  "pending",
+  "released",
+  "hidden",
+  "deleted"
+]);
+var caseStudyContentSourceSchema = external_exports.enum(["artifact", "submitted"]);
+var isoDateSchema = external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/, "expected YYYY-MM-DD");
+var caseStudyIdInputSchema = external_exports.object({
+  id: external_exports.string().min(1)
+});
+var caseStudyContentSchema = external_exports.string().min(1).max(CASE_STUDY_CONTENT_MAX_CHARS);
+var caseStudySubmitInputSchema = external_exports.object({
+  content: caseStudyContentSchema,
+  window_start: isoDateSchema,
+  window_end: isoDateSchema,
+  artifact_id: external_exports.string().min(1).optional()
+});
+var calendarDateSchema = isoDateSchema.refine((value) => {
+  const parsed = new Date(value);
+  return !Number.isNaN(parsed.getTime()) && parsed.toISOString().slice(0, 10) === value;
+}, "not a real calendar date");
+var caseStudyInspectionFilterSchema = external_exports.object({
+  since: external_exports.string().datetime().optional().describe("Only editions updated at or after this ISO date-time."),
+  week_of: calendarDateSchema.optional().describe(
+    "Only editions of the week containing this date (YYYY-MM-DD, any day of that week)."
+  ),
+  agent_id: external_exports.string().min(1).optional().describe("Only editions submitted by this agent.")
+});
+
+// ../api-server-api/src/modules/metrics/constants.ts
+var METRICS_MAX_SINCE_HOURS = 720;
+var METRICS_MAX_LIMIT = 1e3;
+var METRICS_DEFAULT_LIMIT = 100;
+var USAGE_SUMMARY_MAX_DAYS = 30;
+var USAGE_SUMMARY_DEFAULT_DAYS = 7;
+
+// ../api-server-api/src/modules/metrics/schemas.ts
+var metricsOverviewInputSchema = external_exports.object({
+  agentId: external_exports.string().min(1).optional(),
+  sessionId: external_exports.string().min(1).optional(),
+  sinceHours: external_exports.coerce.number().int().positive().max(METRICS_MAX_SINCE_HOURS).optional(),
+  limit: external_exports.coerce.number().int().positive().max(METRICS_MAX_LIMIT).default(METRICS_DEFAULT_LIMIT)
+});
+var usageSummaryInputSchema = external_exports.object({
+  days: external_exports.number().int().min(1).max(USAGE_SUMMARY_MAX_DAYS).default(USAGE_SUMMARY_DEFAULT_DAYS).describe(
+    `Window length in days, counted back from now (default ${USAGE_SUMMARY_DEFAULT_DAYS}, max ${USAGE_SUMMARY_MAX_DAYS}).`
+  )
+});
+var metricsSpendInputSchema = external_exports.object({
+  from: external_exports.string().datetime(),
+  to: external_exports.string().datetime()
+});
+var isValidTimeZone = (tz) => {
+  try {
+    Intl.DateTimeFormat(void 0, { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var metricsSpendBreakdownInputSchema = metricsSpendInputSchema.extend({
+  agentId: external_exports.string().min(1).optional(),
+  timeZone: external_exports.string().min(1).refine(isValidTimeZone, { message: "invalid IANA timeZone" })
+});
+
 // ../api-server-api/src/modules/secret-store/types.ts
 var secretRef = external_exports.object({
   storeId: external_exports.string().optional(),
@@ -31407,7 +31511,8 @@ var SessionType = {
   ChannelSlack: "channel_slack",
   ChannelTelegram: "channel_telegram",
   ScheduleCron: "schedule_cron",
-  ExperimentExecute: "experiment_execute"
+  ExperimentExecute: "experiment_execute",
+  CliRun: "cli_run"
 };
 var SessionMode = /* @__PURE__ */ ((SessionMode2) => {
   SessionMode2["Chat"] = "chat";
@@ -31503,6 +31608,11 @@ function describeApprovalPayload(payload) {
   return { title: payload.toolName ?? "tool call", subtitle: "" };
 }
 
+// ../api-server-api/src/modules/approvals/ids.ts
+function acpNativeRowId(agentId, sessionId, rpcId) {
+  return `acpnative:${agentId}:${sessionId}:${rpcId}`;
+}
+
 // ../api-server-api/src/modules/egress-rules/format.ts
 function formatEgressRuleSource(source) {
   if (source === "manual") return "manual";
@@ -31559,8 +31669,11 @@ function gatewayRestartImpact(input) {
 }
 
 // ../api-server-api/src/modules/acp/types.ts
+var PROMPT_QUEUE_FULL_CODE = "PROMPT_QUEUE_FULL";
 var platformTurnEndedParamsSchema = external_exports.object({
-  sessionId: external_exports.string().min(1)
+  sessionId: external_exports.string().min(1),
+  promptId: external_exports.string().min(1).optional(),
+  stopReason: external_exports.string().min(1).optional()
 });
 var platformTurnEndedNotificationSchema = external_exports.object({
   jsonrpc: external_exports.literal("2.0"),
@@ -31570,6 +31683,37 @@ var platformTurnEndedNotificationSchema = external_exports.object({
 var platformClippedReplayMetaSchema = external_exports.object({
   older: external_exports.string().min(1).optional()
 });
+var platformReplayTurnMetaSchema = external_exports.object({
+  inFlight: external_exports.boolean(),
+  interruptedAt: external_exports.string().optional()
+});
+var promptBlockSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("text"), text: external_exports.string() }),
+  external_exports.object({
+    type: external_exports.literal("image"),
+    data: external_exports.string(),
+    mimeType: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("resource_link"),
+    uri: external_exports.string(),
+    name: external_exports.string(),
+    mimeType: external_exports.string().optional(),
+    size: external_exports.number().optional()
+  })
+]);
+var UNDELIVERED_INLINE_IMAGE_BYTES_CAP = 4 * 1024 * 1024;
+var platformUndeliveredPromptSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  recordedAt: external_exports.string(),
+  blocks: external_exports.array(promptBlockSchema).default([]),
+  droppedAttachments: external_exports.array(external_exports.string()).default([]),
+  reason: external_exports.string().optional()
+});
+var platformUndeliveredMetaSchema = external_exports.array(
+  platformUndeliveredPromptSchema
+);
+var platformSupersededMetaSchema = external_exports.array(external_exports.string());
 var platformPromptAcceptedParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
   promptId: external_exports.string().min(1),
@@ -31580,6 +31724,18 @@ var platformPromptAcceptedNotificationSchema = external_exports.object({
   method: external_exports.literal("platform/promptAccepted"),
   params: platformPromptAcceptedParamsSchema
 });
+var platformRunResultSchema = external_exports.object({
+  promptId: external_exports.string().nullable(),
+  stopReason: external_exports.string().nullable(),
+  finalText: external_exports.string(),
+  truncated: external_exports.boolean(),
+  endedAt: external_exports.string()
+});
+var platformRunResultResponseSchema = external_exports.discriminatedUnion("status", [
+  external_exports.object({ status: external_exports.literal("done"), result: platformRunResultSchema }),
+  external_exports.object({ status: external_exports.literal("pending") }),
+  external_exports.object({ status: external_exports.literal("none") })
+]);
 var platformPromptStartedParamsSchema = external_exports.object({
   sessionId: external_exports.string().min(1),
   promptId: external_exports.string().min(1)
@@ -31757,7 +31913,8 @@ var slackOutboundRecordSchema = external_exports.discriminatedUnion("kind", [
   external_exports.object({
     kind: external_exports.literal("upload"),
     channelId: external_exports.string(),
-    filename: external_exports.string()
+    filename: external_exports.string(),
+    threadTs: external_exports.string().optional()
   }).strict(),
   external_exports.object({
     kind: external_exports.literal("stream_start"),
@@ -32155,6 +32312,8 @@ var EXIT_AGENT_NOT_REACHABLE = 7;
 var EXIT_APPROVAL_NOT_ACTIONABLE = 8;
 var EXIT_SCHEDULE_NOT_FOUND = 9;
 var EXIT_TERMS_NOT_ACCEPTED = 10;
+var EXIT_RUN_STOPPED = 11;
+var EXIT_RUN_TIMEOUT = 12;
 var EXIT_SIGINT = 130;
 
 // src/modules/agent/commands/create.ts
@@ -38149,37 +38308,146 @@ function printError(e2) {
   }
 }
 
-// src/modules/chat/commands/session-list.ts
-function buildSessionListCommand(deps) {
-  return new Command("list").description("List sessions for an Agent").argument("<agent>", "agent name or ID").option("--server <url>", "override the configured server URL").option("--json", "emit raw JSON instead of the default table").action(
-    async (agentRef, opts) => {
-      const result = await deps.chatService.listSessions({
-        agentRef,
-        serverFlag: opts.server
-      });
-      if (!result.ok) {
-        printError(result.error);
-        process.exit(exitCodeFor2(result.error));
-      }
-      if (opts.json) {
-        process.stdout.write(`${JSON.stringify(result.value)}
-`);
-        return;
-      }
-      if (result.value.length === 0) {
-        process.stderr.write("No sessions.\n");
+// src/modules/chat/commands/run.ts
+import { readFileSync } from "fs";
+
+// src/modules/chat/services/run-service.ts
+import { randomUUID } from "crypto";
+
+// ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
+var import_stream = __toESM(require_stream(), 1);
+var import_extension = __toESM(require_extension(), 1);
+var import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
+var import_receiver = __toESM(require_receiver(), 1);
+var import_sender = __toESM(require_sender(), 1);
+var import_subprotocol = __toESM(require_subprotocol(), 1);
+var import_websocket = __toESM(require_websocket(), 1);
+var import_websocket_server = __toESM(require_websocket_server(), 1);
+var wrapper_default = import_websocket.default;
+
+// src/modules/shared/ws-proxy.ts
+var import_http_proxy_agent = __toESM(require_dist2(), 1);
+var import_https_proxy_agent = __toESM(require_dist3(), 1);
+function proxyAgentForUrl(url2, env = process.env) {
+  let target;
+  try {
+    target = new URL(url2);
+  } catch {
+    return void 0;
+  }
+  const secure = target.protocol === "wss:" || target.protocol === "https:";
+  const proxy = secure ? env.HTTPS_PROXY ?? env.https_proxy : env.HTTP_PROXY ?? env.http_proxy;
+  if (!proxy) return void 0;
+  if (isNoProxy(target.hostname, env.NO_PROXY ?? env.no_proxy))
+    return void 0;
+  return secure ? new import_https_proxy_agent.HttpsProxyAgent(proxy) : new import_http_proxy_agent.HttpProxyAgent(proxy);
+}
+function isNoProxy(host, noProxy) {
+  if (!noProxy) return false;
+  for (const raw of noProxy.split(",")) {
+    const entry = raw.trim();
+    if (entry === "") continue;
+    if (entry === "*") return true;
+    const bare = (entry.startsWith(".") ? entry.slice(1) : entry).toLowerCase();
+    if (host === bare || host.endsWith(`.${bare}`)) return true;
+  }
+  return false;
+}
+
+// src/modules/chat/infrastructure/acp-run-connection.ts
+var CLIENT_ANSWERED_REQUESTS = {
+  "fs/read_text_file": { content: "" },
+  "fs/write_text_file": {}
+};
+async function connectRun(deps) {
+  const ws = new import_websocket.default(deps.url, { agent: proxyAgentForUrl(deps.url) });
+  await new Promise((resolve4, reject) => {
+    ws.on("open", () => {
+      resolve4();
+    });
+    ws.on("error", reject);
+  });
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const closed = new Promise((resolve4) => {
+    ws.on("close", () => {
+      for (const settle of pending.values())
+        settle({
+          ok: false,
+          error: { code: -32e3, message: "connection closed" }
+        });
+      pending.clear();
+      resolve4();
+    });
+    ws.on("error", () => {
+    });
+  });
+  ws.on("message", (data) => {
+    let frame;
+    try {
+      frame = JSON.parse(String(data));
+    } catch {
+      return;
+    }
+    if (typeof frame !== "object" || frame === null) return;
+    const f = frame;
+    if ("id" in f && !("method" in f)) {
+      const settle = typeof f.id === "number" ? pending.get(f.id) : void 0;
+      if (settle === void 0) return;
+      pending.delete(f.id);
+      settle(
+        "error" in f && f.error !== void 0 ? { ok: false, error: f.error } : { ok: true, result: f.result }
+      );
+      return;
+    }
+    const method = typeof f.method === "string" ? f.method : "";
+    if ("id" in f && f.id !== void 0 && f.id !== null) {
+      if (method === "session/request_permission") {
+        deps.onPermissionRequest({
+          rpcId: f.id,
+          params: f.params
+        });
         return;
       }
-      const sorted = [...result.value].sort(
-        (a, b2) => a.createdAt.localeCompare(b2.createdAt)
+      const answer = CLIENT_ANSWERED_REQUESTS[method];
+      ws.send(
+        JSON.stringify(
+          answer === void 0 ? {
+            jsonrpc: "2.0",
+            id: f.id,
+            error: { code: -32601, message: `unsupported: ${method}` }
+          } : { jsonrpc: "2.0", id: f.id, result: answer }
+        )
       );
-      const rows = [
-        ["SESSION ID", "MODE", "TYPE", "CREATED"],
-        ...sorted.map((s) => [s.sessionId, s.mode, s.type, s.createdAt])
-      ];
-      process.stdout.write(renderTable(rows));
+      return;
     }
-  );
+    deps.onNotification(method, f.params);
+  });
+  return {
+    request(method, params) {
+      return new Promise((resolve4) => {
+        if (ws.readyState !== import_websocket.default.OPEN) {
+          resolve4({
+            ok: false,
+            error: { code: -32e3, message: "connection closed" }
+          });
+          return;
+        }
+        const id = nextId++;
+        pending.set(id, resolve4);
+        ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+      });
+    },
+    notify(method, params) {
+      if (ws.readyState !== import_websocket.default.OPEN) return;
+      ws.send(JSON.stringify({ jsonrpc: "2.0", method, params }));
+    },
+    closed,
+    close() {
+      if (ws.readyState === import_websocket.default.OPEN || ws.readyState === import_websocket.default.CONNECTING)
+        ws.close();
+    }
+  };
 }
 
 // ../../node_modules/.pnpm/@agentclientprotocol+sdk@0.17.1_zod@4.4.3/node_modules/@agentclientprotocol/sdk/dist/schema/index.js
@@ -39853,46 +40121,6 @@ var RequestError = class _RequestError extends Error {
   }
 };
 
-// ../../node_modules/.pnpm/ws@8.21.0/node_modules/ws/wrapper.mjs
-var import_stream = __toESM(require_stream(), 1);
-var import_extension = __toESM(require_extension(), 1);
-var import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
-var import_receiver = __toESM(require_receiver(), 1);
-var import_sender = __toESM(require_sender(), 1);
-var import_subprotocol = __toESM(require_subprotocol(), 1);
-var import_websocket = __toESM(require_websocket(), 1);
-var import_websocket_server = __toESM(require_websocket_server(), 1);
-var wrapper_default = import_websocket.default;
-
-// src/modules/shared/ws-proxy.ts
-var import_http_proxy_agent = __toESM(require_dist2(), 1);
-var import_https_proxy_agent = __toESM(require_dist3(), 1);
-function proxyAgentForUrl(url2, env = process.env) {
-  let target;
-  try {
-    target = new URL(url2);
-  } catch {
-    return void 0;
-  }
-  const secure = target.protocol === "wss:" || target.protocol === "https:";
-  const proxy = secure ? env.HTTPS_PROXY ?? env.https_proxy : env.HTTP_PROXY ?? env.http_proxy;
-  if (!proxy) return void 0;
-  if (isNoProxy(target.hostname, env.NO_PROXY ?? env.no_proxy))
-    return void 0;
-  return secure ? new import_https_proxy_agent.HttpsProxyAgent(proxy) : new import_http_proxy_agent.HttpProxyAgent(proxy);
-}
-function isNoProxy(host, noProxy) {
-  if (!noProxy) return false;
-  for (const raw of noProxy.split(",")) {
-    const entry = raw.trim();
-    if (entry === "") continue;
-    if (entry === "*") return true;
-    const bare = (entry.startsWith(".") ? entry.slice(1) : entry).toLowerCase();
-    if (host === bare || host.endsWith(`.${bare}`)) return true;
-  }
-  return false;
-}
-
 // src/modules/chat/infrastructure/acp-session-client.ts
 var TIMEOUT_MS = 12e4;
 function wsStream(url2) {
@@ -40000,13 +40228,13 @@ async function withConnection(url2, fn) {
     return await Promise.race([
       fn(connection2),
       new Promise((_, reject) => {
-        const fail = () => reject(
+        const fail2 = () => reject(
           new Error(
             `ACP connection timed out after ${TIMEOUT_MS / 1e3}s of inactivity`
           )
         );
-        if (ac.signal.aborted) fail();
-        else ac.signal.addEventListener("abort", fail, { once: true });
+        if (ac.signal.aborted) fail2();
+        else ac.signal.addEventListener("abort", fail2, { once: true });
       })
     ]);
   } finally {
@@ -40041,6 +40269,701 @@ function createAcpSessionClient(opts) {
   };
 }
 
+// src/modules/chat/services/run-service.ts
+var DEFAULT_RUN_TIMEOUT_SECONDS = 3600;
+var RECONNECT_BACKOFF_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
+function createWaiter() {
+  const buffered = [];
+  let wake = null;
+  return {
+    push(event2) {
+      buffered.push(event2);
+      wake?.();
+    },
+    async next(deadlineAt, closed) {
+      for (; ; ) {
+        const head = buffered.shift();
+        if (head !== void 0) return head;
+        const remaining = deadlineAt - Date.now();
+        if (remaining <= 0) return "timed-out";
+        let timer;
+        let onClosed = false;
+        await Promise.race([
+          new Promise((resolve4) => {
+            wake = resolve4;
+            timer = setTimeout(resolve4, remaining);
+          }),
+          closed.then(() => {
+            onClosed = true;
+          })
+        ]);
+        wake = null;
+        clearTimeout(timer);
+        if (buffered.length > 0) continue;
+        if (onClosed) return "closed";
+        if (Date.now() >= deadlineAt) return "timed-out";
+      }
+    }
+  };
+}
+function extractText(params) {
+  if (typeof params !== "object" || params === null) return null;
+  const update = params.update;
+  if (typeof update !== "object" || update === null) return null;
+  const u = update;
+  if (u.sessionUpdate !== "agent_message_chunk") return null;
+  const content = u.content;
+  if (typeof content !== "object" || content === null) return null;
+  const c2 = content;
+  return c2.type === "text" && typeof c2.text === "string" ? c2.text : null;
+}
+function sessionIdOf(params) {
+  if (typeof params !== "object" || params === null) return null;
+  const sid = params.sessionId;
+  return typeof sid === "string" ? sid : null;
+}
+function stallLine(agentId, request) {
+  const params = request.params ?? {};
+  const title = typeof params.toolCall?.title === "string" ? params.toolCall.title : "tool call";
+  const egressId = params.toolCall?.rawInput?.approvalId;
+  const approvalId = typeof egressId === "string" ? egressId : typeof params.sessionId === "string" ? acpNativeRowId(agentId, params.sessionId, request.rpcId) : null;
+  return approvalId === null ? `run stalled on a permission request (${title}) \u2014 see: dam approval list` : `run stalled on a permission request (${title}) \u2014 resolve with: dam approval approve ${approvalId}`;
+}
+function matchesPrompt(result, promptId) {
+  return result.promptId === promptId || result.promptId === null;
+}
+function resultSessionId(result) {
+  if (typeof result !== "object" || result === null) return null;
+  const sid = result.sessionId;
+  return typeof sid === "string" && sid.length > 0 ? sid : null;
+}
+function createRunService(deps) {
+  async function connect(ctx, waiter, sessionFilter, onText, onPromptStarted) {
+    let conn;
+    try {
+      conn = await connectRun({
+        url: acpUrl(ctx.host, ctx.agentId, ctx.token),
+        onPermissionRequest: (request) => {
+          deps.errOut(stallLine(ctx.agentId, request));
+        },
+        onNotification: (method, params) => {
+          const sid = sessionIdOf(params);
+          if (sid === null || sid !== sessionFilter()) return;
+          if (method === "session/update") {
+            const text = extractText(params);
+            if (text !== null) onText(text);
+            return;
+          }
+          if (method === "platform/promptStarted") {
+            const parsed = platformPromptStartedParamsSchema.safeParse(params);
+            if (parsed.success) {
+              onPromptStarted?.();
+              waiter.push({ kind: "prompt-started" });
+            }
+            return;
+          }
+          if (method === "platform/promptAccepted") {
+            const parsed = platformPromptAcceptedParamsSchema.safeParse(params);
+            if (parsed.success && parsed.data.queued)
+              waiter.push({ kind: "prompt-queued" });
+            return;
+          }
+          if (method === "platform/turnEnded") {
+            const parsed = platformTurnEndedParamsSchema.safeParse(params);
+            waiter.push({
+              kind: "turn-ended",
+              promptId: parsed.success ? parsed.data.promptId ?? null : null,
+              stopReason: parsed.success ? parsed.data.stopReason ?? null : null
+            });
+          }
+        }
+      });
+    } catch {
+      return null;
+    }
+    const init = await conn.request("initialize", {
+      protocolVersion: 1,
+      clientCapabilities: {},
+      clientInfo: { name: "platform-cli-run", version: "1.0.0" }
+    });
+    if (!init.ok) {
+      conn.close();
+      return null;
+    }
+    return conn;
+  }
+  async function loadSession(conn, sessionId) {
+    const loaded = await conn.request("session/load", {
+      sessionId,
+      cwd: ".",
+      mcpServers: [],
+      _meta: { platform: { tail: true } }
+    });
+    if (!loaded.ok) {
+      return err2({
+        kind: "run-failed",
+        reason: `session '${sessionId}' could not be loaded: ${loaded.error.message}`,
+        sessionId
+      });
+    }
+    return ok2(loaded.result);
+  }
+  async function fetchRunResult(conn, sessionId) {
+    const res = await conn.request("platform/runResult", { sessionId });
+    if (!res.ok) return null;
+    const parsed = platformRunResultResponseSchema.safeParse(res.result);
+    return parsed.success ? parsed.data : null;
+  }
+  async function reconnectAndFinish(opts) {
+    const { ctx, sessionId, promptId, deadlineAt } = opts;
+    let backoffStep = 0;
+    const finish = (result) => {
+      const remainder = result.finalText.slice(opts.printedChars);
+      if (remainder.length > 0) deps.out(remainder);
+      if (result.truncated)
+        deps.errOut("note: the recorded run output was truncated");
+      return ok2({
+        kind: "completed",
+        sessionId,
+        stopReason: result.stopReason
+      });
+    };
+    for (; ; ) {
+      if (Date.now() >= deadlineAt)
+        return ok2({ kind: "timed-out", sessionId });
+      const delay = RECONNECT_BACKOFF_MS[Math.min(backoffStep, RECONNECT_BACKOFF_MS.length - 1)];
+      backoffStep += 1;
+      await new Promise((resolve4) => setTimeout(resolve4, delay));
+      const waiter = createWaiter();
+      const conn = await connect(
+        ctx,
+        waiter,
+        () => sessionId,
+        () => {
+        }
+      );
+      if (conn === null) continue;
+      deps.errOut("reconnected; waiting for the turn to finish");
+      try {
+        const loaded = await loadSession(conn, sessionId);
+        if (!loaded.ok) return loaded;
+        for (; ; ) {
+          const record2 = await fetchRunResult(conn, sessionId);
+          if (record2?.status === "done" && matchesPrompt(record2.result, promptId))
+            return finish(record2.result);
+          const event2 = await waiter.next(deadlineAt, conn.closed);
+          if (event2 === "timed-out")
+            return ok2({ kind: "timed-out", sessionId });
+          if (event2 === "closed") break;
+          if (event2.kind !== "turn-ended") continue;
+          if (event2.promptId !== null && event2.promptId !== promptId) continue;
+          const after = await fetchRunResult(conn, sessionId);
+          if (after?.status === "done" && matchesPrompt(after.result, promptId))
+            return finish(after.result);
+          if (event2.promptId === promptId) {
+            deps.errOut(
+              "note: the turn ended but no run record was found; output may be incomplete"
+            );
+            return ok2({
+              kind: "completed",
+              sessionId,
+              stopReason: event2.stopReason
+            });
+          }
+        }
+      } finally {
+        conn.close();
+      }
+    }
+  }
+  return {
+    async run(input) {
+      const ctx = await deps.bootstrap(input.agentRef, input.serverFlag);
+      if (!ctx.ok) return ctx;
+      const deadlineAt = Date.now() + input.timeoutSeconds * 1e3;
+      const promptId = randomUUID();
+      let sessionId = input.sessionId ?? null;
+      const streaming = input.async !== true;
+      let started = input.sessionId === void 0;
+      let printedChars = 0;
+      const waiter = createWaiter();
+      const conn = await connect(
+        ctx.value,
+        waiter,
+        () => sessionId,
+        (text) => {
+          if (!started || !streaming) return;
+          deps.out(text);
+          printedChars += text.length;
+        },
+        () => {
+          started = true;
+        }
+      );
+      if (conn === null)
+        return err2({
+          kind: "run-failed",
+          reason: "could not connect to the agent"
+        });
+      let releaseInterrupt = () => {
+      };
+      try {
+        if (sessionId === null) {
+          const created = await conn.request("session/new", {
+            cwd: ".",
+            mcpServers: [],
+            _meta: {
+              platform: { mode: "chat" /* Chat */, type: SessionType.CliRun }
+            }
+          });
+          if (!created.ok)
+            return err2({
+              kind: "run-failed",
+              reason: `session could not be created: ${created.error.message}`
+            });
+          sessionId = resultSessionId(created.result);
+          if (sessionId === null)
+            return err2({
+              kind: "run-failed",
+              reason: "the agent returned no session id"
+            });
+        } else {
+          const loaded = await loadSession(conn, sessionId);
+          if (!loaded.ok) return loaded;
+        }
+        const sid = sessionId;
+        releaseInterrupt = deps.onInterrupt?.(() => {
+          deps.errOut("cancelling the run");
+          conn.notify("session/cancel", { sessionId: sid });
+        }) ?? (() => {
+        });
+        void conn.request("session/prompt", {
+          sessionId: sid,
+          prompt: [{ type: "text", text: input.prompt }],
+          _meta: { platform: { promptId, surface: "cli" } }
+        }).then((outcome) => {
+          waiter.push({ kind: "prompt-response", outcome });
+        });
+        for (; ; ) {
+          const event2 = await waiter.next(deadlineAt, conn.closed);
+          if (event2 === "timed-out")
+            return ok2({ kind: "timed-out", sessionId: sid });
+          if (event2 === "closed") {
+            deps.errOut(
+              `connection lost mid-turn; the run continues on the agent (session ${sid})`
+            );
+            return reconnectAndFinish({
+              ctx: ctx.value,
+              sessionId: sid,
+              promptId,
+              deadlineAt,
+              printedChars
+            });
+          }
+          if (event2.kind === "prompt-response") {
+            const outcome = event2.outcome;
+            if (outcome.ok) {
+              const stopReason = typeof outcome.result?.stopReason === "string" ? outcome.result.stopReason : null;
+              return ok2({
+                kind: "completed",
+                sessionId: sid,
+                stopReason
+              });
+            }
+            if (outcome.error.message === "connection closed") {
+              deps.errOut(
+                `connection lost mid-turn; the run continues on the agent (session ${sid})`
+              );
+              return reconnectAndFinish({
+                ctx: ctx.value,
+                sessionId: sid,
+                promptId,
+                deadlineAt,
+                printedChars
+              });
+            }
+            const queueFull = typeof outcome.error.data === "object" && outcome.error.data !== null && outcome.error.data.code === PROMPT_QUEUE_FULL_CODE;
+            return err2({
+              kind: "run-failed",
+              reason: queueFull ? "the session's prompt queue is full \u2014 try again later" : `prompt failed: ${outcome.error.message}`,
+              sessionId: sid
+            });
+          }
+          if (event2.kind === "prompt-queued" && !started)
+            deps.errOut("prompt queued behind a running turn; waiting");
+          if (event2.kind === "prompt-started") {
+            started = true;
+            if (input.async)
+              return ok2({ kind: "async-started", sessionId: sid });
+          }
+        }
+      } finally {
+        releaseInterrupt();
+        conn.close();
+      }
+    },
+    async get(input) {
+      const ctx = await deps.bootstrap(input.agentRef, input.serverFlag);
+      if (!ctx.ok) return ctx;
+      const deadlineAt = Date.now() + input.timeoutSeconds * 1e3;
+      const sessionId = input.sessionId;
+      let firstAttempt = true;
+      for (; ; ) {
+        if (!firstAttempt) {
+          if (Date.now() >= deadlineAt)
+            return ok2({ kind: "timed-out", sessionId });
+          await new Promise((resolve4) => setTimeout(resolve4, 2e3));
+        }
+        firstAttempt = false;
+        const waiter = createWaiter();
+        const conn = await connect(
+          ctx.value,
+          waiter,
+          () => sessionId,
+          () => {
+          }
+        );
+        if (conn === null) {
+          if (input.wait) continue;
+          return err2({
+            kind: "run-failed",
+            reason: "could not connect to the agent",
+            sessionId
+          });
+        }
+        try {
+          const record2 = await fetchRunResult(conn, sessionId);
+          if (record2 === null)
+            return err2({
+              kind: "run-failed",
+              reason: "the agent does not support run results \u2014 update its image",
+              sessionId
+            });
+          if (record2.status === "done")
+            return ok2({ kind: "done", result: record2.result });
+          if (record2.status === "none" && !input.wait)
+            return ok2({ kind: "none", sessionId });
+          if (!input.wait) return ok2({ kind: "pending", sessionId });
+          const loaded = await loadSession(conn, sessionId);
+          if (!loaded.ok) return loaded;
+          for (; ; ) {
+            const event2 = await waiter.next(deadlineAt, conn.closed);
+            if (event2 === "timed-out")
+              return ok2({ kind: "timed-out", sessionId });
+            if (event2 === "closed") break;
+            if (event2.kind !== "turn-ended") continue;
+            const after = await fetchRunResult(conn, sessionId);
+            if (after?.status === "done")
+              return ok2({ kind: "done", result: after.result });
+          }
+        } finally {
+          conn.close();
+        }
+      }
+    },
+    async cancel(input) {
+      const ctx = await deps.bootstrap(input.agentRef, input.serverFlag);
+      if (!ctx.ok) return ctx;
+      const sessionId = input.sessionId;
+      const conn = await connect(
+        ctx.value,
+        createWaiter(),
+        () => sessionId,
+        () => {
+        }
+      );
+      if (conn === null)
+        return err2({
+          kind: "run-failed",
+          reason: "could not connect to the agent",
+          sessionId
+        });
+      try {
+        const record2 = await fetchRunResult(conn, sessionId);
+        if (record2 === null)
+          return err2({
+            kind: "run-failed",
+            reason: "could not read the run state \u2014 the agent may not support run results; update its image, or cancel from the UI",
+            sessionId
+          });
+        if (record2.status !== "pending")
+          return ok2({ kind: "not-running", sessionId });
+        conn.notify("session/cancel", { sessionId });
+        return ok2({ kind: "cancelled", sessionId });
+      } finally {
+        conn.close();
+      }
+    }
+  };
+}
+
+// src/modules/chat/commands/run.ts
+var END_TURN = "end_turn";
+function resolvePrompt(opts) {
+  if (opts.prompt !== void 0 && opts.promptFile !== void 0)
+    return err2("pass exactly one of --prompt and --prompt-file");
+  if (opts.prompt !== void 0) return ok2(opts.prompt);
+  if (opts.promptFile === void 0)
+    return err2("a prompt is required: pass --prompt or --prompt-file");
+  try {
+    return ok2(opts.readFile(opts.promptFile));
+  } catch (e2) {
+    return err2(
+      `could not read prompt file '${opts.promptFile}': ${e2 instanceof Error ? e2.message : String(e2)}`
+    );
+  }
+}
+function readPromptFile(path2) {
+  return readFileSync(path2 === "-" ? 0 : path2, "utf8");
+}
+function fail(e2) {
+  if (e2.kind === "run-failed") {
+    process.stderr.write(`error: ${e2.reason}
+`);
+    if (e2.sessionId !== void 0)
+      process.stderr.write(`session: ${e2.sessionId}
+`);
+    process.exitCode = EXIT_RUNTIME_FAILURE;
+    return;
+  }
+  printError(e2);
+  process.exitCode = exitCodeFor2(e2);
+}
+function stopExitCode(stopReason) {
+  return stopReason === END_TURN ? 0 : EXIT_RUN_STOPPED;
+}
+function timeoutOrInvalid(raw) {
+  const seconds = parseTimeout(raw, DEFAULT_RUN_TIMEOUT_SECONDS);
+  if (seconds === null) {
+    process.stderr.write("error: --timeout must be a positive number\n");
+    process.exit(EXIT_INVALID_INPUT);
+  }
+  return seconds;
+}
+function buildRunCommand(deps) {
+  const run2 = new Command("run").description(
+    "Run an agent headlessly: submit a prompt and stream the answer"
+  ).argument("<agent>", "agent name or ID").option("--server <url>", "override the configured server URL").option("-p, --prompt <text>", "the prompt text").option("--prompt-file <path>", "read the prompt from a file ('-' = stdin)").option("--session <id>", "continue an existing session").option("--async", "exit once the prompt has started; poll with 'run get'").option(
+    "--timeout <seconds>",
+    `give up waiting after this many seconds (default ${String(DEFAULT_RUN_TIMEOUT_SECONDS)})`
+  ).action(
+    async (agentRef, opts) => {
+      const prompt = resolvePrompt({
+        prompt: opts.prompt,
+        promptFile: opts.promptFile,
+        readFile: readPromptFile
+      });
+      if (!prompt.ok) {
+        process.stderr.write(`error: ${prompt.error}
+`);
+        process.exitCode = EXIT_INVALID_INPUT;
+        return;
+      }
+      const result = await deps.runService.run({
+        agentRef,
+        serverFlag: opts.server,
+        prompt: prompt.value,
+        sessionId: opts.session,
+        async: opts.async,
+        timeoutSeconds: timeoutOrInvalid(opts.timeout)
+      });
+      if (!result.ok) {
+        fail(result.error);
+        return;
+      }
+      const outcome = result.value;
+      if (outcome.kind === "async-started") {
+        process.stdout.write(`${outcome.sessionId}
+`);
+        process.stderr.write(
+          `run started; poll it with: dam run get ${agentRef} ${outcome.sessionId}
+`
+        );
+        return;
+      }
+      if (outcome.kind === "timed-out") {
+        process.stderr.write(
+          `timed out waiting; the run continues on the agent
+check it with: dam run get ${agentRef} ${outcome.sessionId}
+`
+        );
+        process.exitCode = EXIT_RUN_TIMEOUT;
+        return;
+      }
+      endStdoutLine();
+      process.stderr.write(
+        `stopReason: ${outcome.stopReason ?? "unknown"}
+`
+      );
+      process.exitCode = stopExitCode(outcome.stopReason);
+    }
+  );
+  run2.command("get").description("Read a headless run's recorded result").argument("<agent>", "agent name or ID").argument("<session-id>", "the run's session id").option("--server <url>", "override the configured server URL").option("-w, --wait", "wait for the running turn to finish").option(
+    "--timeout <seconds>",
+    `with --wait, give up after this many seconds (default ${String(DEFAULT_RUN_TIMEOUT_SECONDS)})`
+  ).option("--json", "emit the raw run-result payload instead of plain text").action(
+    async (agentRef, sessionId, opts) => {
+      const result = await deps.runService.get({
+        agentRef,
+        serverFlag: opts.server,
+        sessionId,
+        wait: opts.wait,
+        timeoutSeconds: timeoutOrInvalid(opts.timeout)
+      });
+      if (!result.ok) {
+        fail(result.error);
+        return;
+      }
+      const outcome = result.value;
+      if (outcome.kind === "pending") {
+        if (opts.json)
+          process.stdout.write(`${JSON.stringify({ status: "pending" })}
+`);
+        else process.stderr.write("still running\n");
+        return;
+      }
+      if (outcome.kind === "none") {
+        if (opts.json)
+          process.stdout.write(`${JSON.stringify({ status: "none" })}
+`);
+        else
+          process.stderr.write(
+            "no recorded result for this session \u2014 it never finished a headless run here, or the record was evicted\n"
+          );
+        process.exitCode = EXIT_INVALID_INPUT;
+        return;
+      }
+      if (outcome.kind === "timed-out") {
+        if (opts.json)
+          process.stdout.write(`${JSON.stringify({ status: "pending" })}
+`);
+        process.stderr.write("timed out waiting; the run continues\n");
+        process.exitCode = EXIT_RUN_TIMEOUT;
+        return;
+      }
+      if (opts.json) {
+        process.stdout.write(
+          `${JSON.stringify({ status: "done", result: outcome.result })}
+`
+        );
+        process.exitCode = stopExitCode(outcome.result.stopReason);
+        return;
+      }
+      if (outcome.result.finalText.length > 0) {
+        process.stdout.write(outcome.result.finalText);
+        if (!outcome.result.finalText.endsWith("\n"))
+          process.stdout.write("\n");
+      }
+      if (outcome.result.truncated)
+        process.stderr.write("note: the recorded run output was truncated\n");
+      process.stderr.write(
+        `stopReason: ${outcome.result.stopReason ?? "unknown"}
+`
+      );
+      process.exitCode = stopExitCode(outcome.result.stopReason);
+    }
+  );
+  run2.command("cancel").description("Cancel a running headless run").argument("<agent>", "agent name or ID").argument("<session-id>", "the run's session id").option("--server <url>", "override the configured server URL").action(
+    async (agentRef, sessionId, opts) => {
+      const result = await deps.runService.cancel({
+        agentRef,
+        serverFlag: opts.server,
+        sessionId
+      });
+      if (!result.ok) {
+        fail(result.error);
+        return;
+      }
+      if (result.value.kind === "not-running") {
+        process.stderr.write(
+          "nothing to cancel: the session is not running\n"
+        );
+        process.exitCode = EXIT_INVALID_INPUT;
+        return;
+      }
+      process.stderr.write("cancel sent\n");
+    }
+  );
+  return run2;
+}
+var stdoutEndedWithNewline = true;
+function trackStdout(text) {
+  process.stdout.write(text);
+  if (text.length > 0) stdoutEndedWithNewline = text.endsWith("\n");
+}
+function endStdoutLine() {
+  if (!stdoutEndedWithNewline) process.stdout.write("\n");
+}
+
+// src/modules/chat/commands/session-list.ts
+function buildSessionListCommand(deps) {
+  return new Command("list").description("List sessions for an Agent").argument("<agent>", "agent name or ID").option("--server <url>", "override the configured server URL").option("--json", "emit raw JSON instead of the default table").action(
+    async (agentRef, opts) => {
+      const result = await deps.chatService.listSessions({
+        agentRef,
+        serverFlag: opts.server
+      });
+      if (!result.ok) {
+        printError(result.error);
+        process.exit(exitCodeFor2(result.error));
+      }
+      if (opts.json) {
+        process.stdout.write(`${JSON.stringify(result.value)}
+`);
+        return;
+      }
+      if (result.value.length === 0) {
+        process.stderr.write("No sessions.\n");
+        return;
+      }
+      const sorted = [...result.value].sort(
+        (a, b2) => a.createdAt.localeCompare(b2.createdAt)
+      );
+      const rows = [
+        ["SESSION ID", "MODE", "TYPE", "CREATED"],
+        ...sorted.map((s) => [s.sessionId, s.mode, s.type, s.createdAt])
+      ];
+      process.stdout.write(renderTable(rows));
+    }
+  );
+}
+
+// src/modules/chat/services/bootstrap.ts
+function createBootstrap(deps) {
+  return async function bootstrap(agentRef, serverFlag) {
+    const flag = serverFlag ? { server: serverFlag } : void 0;
+    const config2 = await deps.configService.getResolved({ flag });
+    if (!config2.ok) {
+      return config2.error.kind === "malformed-config" ? err2({
+        kind: "malformed-config",
+        reason: config2.error.reason
+      }) : err2({ kind: "no-server" });
+    }
+    const host = config2.value.server;
+    const compat = await deps.compatService.check({ flag });
+    if (!compat.ok)
+      return err2({
+        kind: "transport",
+        reason: compat.error.kind === "probe-error" ? compat.error.message : compat.error.kind
+      });
+    if (compat.value.kind === "below-floor") {
+      return err2({
+        kind: "below-floor",
+        localCli: compat.value.localCli,
+        serverMinClient: compat.value.serverMinClient
+      });
+    }
+    const resolved = await createAgentResolver({
+      agentService: deps.createAgentService(host)
+    }).resolve(agentRef);
+    if (!resolved.ok) return resolved;
+    const tok = await deps.tokenProvider.getValidAccessToken(host);
+    if (!tok.ok)
+      return err2({ kind: "auth-required", reason: tok.error.kind });
+    return ok2({ host, token: tok.value, agentId: resolved.value.id });
+  };
+}
+
 // src/modules/chat/infrastructure/terminal-bridge.ts
 var TERMINAL_MODE_RESET = "\x1B[<u\x1B[?1049l\x1B[?1000;1002;1003;1005;1006;1015;1016l\x1B[?1004l\x1B[?2004l\x1B[?25h\x1B[0m";
 function connectTerminalBridge({
@@ -40112,41 +41035,13 @@ function connectTerminalBridge({
 
 // src/modules/chat/services/chat-service.ts
 function createChatService(deps) {
+  const bare = createBootstrap(deps);
   async function bootstrap(agentRef, serverFlag) {
-    const flag = serverFlag ? { server: serverFlag } : void 0;
-    const config2 = await deps.configService.getResolved({ flag });
-    if (!config2.ok) {
-      return config2.error.kind === "malformed-config" ? err2({
-        kind: "malformed-config",
-        reason: config2.error.reason
-      }) : err2({ kind: "no-server" });
-    }
-    const host = config2.value.server;
-    const compat = await deps.compatService.check({ flag });
-    if (!compat.ok)
-      return err2({
-        kind: "transport",
-        reason: compat.error.kind === "probe-error" ? compat.error.message : compat.error.kind
-      });
-    if (compat.value.kind === "below-floor") {
-      return err2({
-        kind: "below-floor",
-        localCli: compat.value.localCli,
-        serverMinClient: compat.value.serverMinClient
-      });
-    }
-    const resolved = await createAgentResolver({
-      agentService: deps.createAgentService(host)
-    }).resolve(agentRef);
-    if (!resolved.ok) return resolved;
-    const tok = await deps.tokenProvider.getValidAccessToken(host);
-    if (!tok.ok)
-      return err2({ kind: "auth-required", reason: tok.error.kind });
+    const ctx = await bare(agentRef, serverFlag);
+    if (!ctx.ok) return ctx;
     return ok2({
-      host,
-      token: tok.value,
-      agentId: resolved.value.id,
-      sessions: deps.createSessionsPort(host, tok.value)
+      ...ctx.value,
+      sessions: deps.createSessionsPort(ctx.value.host, ctx.value.token)
     });
   }
   return {
@@ -40208,7 +41103,7 @@ function createChatService(deps) {
 }
 
 // src/modules/chat/services/sessions-service.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function transportError(e2) {
   return {
     kind: "transport",
@@ -40232,7 +41127,7 @@ function createSessionsPort(deps) {
         terminalPath: terminalPath(sid)
       });
       try {
-        if (strategy.kind === "new") return ok2(ready(randomUUID()));
+        if (strategy.kind === "new") return ok2(ready(randomUUID2()));
         const regular = (await deps.acp.list(agentId)).filter(
           (s) => s.type === SessionType.Regular
         );
@@ -40305,6 +41200,21 @@ function composeChatModule({
     }),
     isTty: Boolean(process.stdin.isTTY)
   });
+  const runService = createRunService({
+    bootstrap: createBootstrap({
+      compatService,
+      configService,
+      tokenProvider,
+      createAgentService: createAgentService2
+    }),
+    out: trackStdout,
+    errOut: (line) => process.stderr.write(`${line}
+`),
+    onInterrupt: (handler) => {
+      process.once("SIGINT", handler);
+      return () => process.removeListener("SIGINT", handler);
+    }
+  });
   const sessionParent = new Command("session").description(
     "Manage sessions for an Agent"
   );
@@ -40312,7 +41222,11 @@ function composeChatModule({
     isDefault: true
   });
   return {
-    commands: [buildChatCommand({ chatService }), sessionParent]
+    commands: [
+      buildChatCommand({ chatService }),
+      buildRunCommand({ runService }),
+      sessionParent
+    ]
   };
 }
 
@@ -40571,7 +41485,7 @@ function createProcessEnvReader() {
 
 // src/modules/cli/infrastructure/package-version.ts
 function readPackageVersion() {
-  return true ? "0.2.16" : DEV_VERSION;
+  return true ? "0.2.17" : DEV_VERSION;
 }
 
 // src/modules/cli/infrastructure/version-probe.ts

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dam-agents/cli",
   "author": "IBM Corp.",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "type": "module",
   "license": "Apache-2.0",
   "homepage": "https://github.com/dam-agents/dam/tree/main/packages/cli#readme",
@@ -32,7 +32,10 @@
     "@types/node": "^24.0.0",
     "@types/tar-stream": "^3.1.4",
     "@types/ws": "^8.18.1",
+    "agent-runtime-api": "0.0.1",
+    "api-server-api": "0.0.1",
     "commander": "^14.0.3",
+    "dev-config": "0.0.1",
     "http-proxy-agent": "^7.0.2",
     "https-proxy-agent": "^7.0.6",
     "open": "^11.0.0",
@@ -42,9 +45,6 @@
     "typescript": "^6.0.2",
     "vitest": "^4.1.3",
     "ws": "^8.20.0",
-    "zod": "^4.4.3",
-    "agent-runtime-api": "0.0.1",
-    "api-server-api": "0.0.1",
-    "dev-config": "0.0.1"
+    "zod": "^4.4.3"
   }
 }