@impulselab/hepha 0.2.384 → 0.2.386

package/dist/index.js

@@ -544,9 +544,9 @@ var ArgsParser = class {
     if (raw === void 0) {
       return void 0;
     }
-    const trimmed = raw.trim();
-    const value = Number(trimmed);
-    if (trimmed === "" || !Number.isFinite(value)) {
+    const trimmed2 = raw.trim();
+    const value = Number(trimmed2);
+    if (trimmed2 === "" || !Number.isFinite(value)) {
       throw new CliError(`--${name} expects a number, got "${raw}".`, 2);
     }
     if (!Number.isInteger(value)) {
@@ -975,9 +975,9 @@ async function approvalsCommand(parsed) {
 async function listCatalogBranches(parsed, asJson) {
   args.expect(parsed, { positional: 1 });
   const repoFullName = args.required(parsed, 0, "owner/repo");
-  const segments = repoFullName.split("/");
-  const [owner, repo] = segments;
-  if (segments.length !== 2 || !owner || !repo) {
+  const segments2 = repoFullName.split("/");
+  const [owner, repo] = segments2;
+  if (segments2.length !== 2 || !owner || !repo) {
     throw new CliError(
       `Expected a repository as "owner/repo", got "${repoFullName}".`,
       2
@@ -1713,8 +1713,8 @@ var ADVISOR_NOTE_STATUS = {
 
 // src/lib/truncate/truncate.ts
 function truncate(text, max = 2e3) {
-  const trimmed = out.safe(text).trim();
-  return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
+  const trimmed2 = out.safe(text).trim();
+  return trimmed2.length > max ? `${trimmed2.slice(0, max)}\u2026` : trimmed2;
 }
 
 // src/lib/event/format-advisor-part.ts
@@ -1735,8 +1735,1004 @@ function formatAdvisorPart(part) {
   }
 }
 
+// ../../packages/realtime/src/events/deliverable/deliverable-download-path.ts
+function deliverableDownloadPath(sessionId, pathname, options) {
+  const query = new URLSearchParams({ pathname });
+  if (options?.inline) {
+    query.set("disposition", "inline");
+  }
+  return `/api/sessions/${sessionId}/deliverables?${query.toString()}`;
+}
+
+// ../../packages/realtime/src/events/attachment/format-attachment-size.ts
+function formatAttachmentSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  const kb = bytes / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(0)} KB`;
+  }
+  return `${(kb / 1024).toFixed(1)} MB`;
+}
+
+// src/lib/event/format-deliverable-part.ts
+function formatDeliverablePart(part, sessionId, baseUrl) {
+  const entries = part.archive ? `, ${part.archive.entryCount} entries` : "";
+  const size = `${formatAttachmentSize(part.sizeBytes)}${entries}`;
+  const caption = part.caption ? ` - ${out.cell(part.caption)}` : "";
+  const link = `${baseUrl}${deliverableDownloadPath(sessionId, part.pathname)}`;
+  return `${out.paint("attach", "dim")} ${out.cell(part.name)} ${out.paint(`(${size})`, "dim")}${caption}
+       ${out.cell(link)}`;
+}
+
+// ../../packages/agents/src/turns/turn-constants.ts
+var SESSION_TERMINATION_MODES = {
+  DESTROY: "destroy",
+  DETACH: "detach",
+  STOP: "stop",
+  SUSPEND_TURN: "suspend-turn"
+};
+var ALL_SESSION_TERMINATION_MODES = Object.values(
+  SESSION_TERMINATION_MODES
+);
+var HOST_TOOL_NAMES = {
+  ADVISE: "advise",
+  ASK_USER: "ask_user",
+  SAVE_DEV_ENV_MANIFEST: "save_dev_env_manifest",
+  REQUEST_DEV_ENV_CREDENTIALS: "request_dev_env_credentials",
+  GENERATE_DEV_ENV_SECRET: "generate_dev_env_secret",
+  SET_DEV_ENV_SIZING: "set_dev_env_sizing",
+  BAKE_DEV_ENV: "bake_dev_env",
+  PROPOSE_PLAN: "propose_plan",
+  REPORT_CONFIDENCE: "report_confidence",
+  REQUEST_GUARDRAIL_APPROVAL: "request_guardrail_approval",
+  // Somnium, mid-run: the automatic recall only fires on a session's FIRST
+  // prompt, so the agent reads on demand and writes what it learns.
+  MEMORY_SEARCH: "memory_search",
+  MEMORY_WRITE: "memory_write",
+  SKILL_SEARCH: "skill_search",
+  SKILL_LOAD: "skill_load",
+  SAVE_SKILL: "save_skill",
+  RECORD_REVIEW_LESSON: "record_review_lesson",
+  // Proposes an EDIT to a skill already in the registry: a version above the
+  // skill's current one, invisible to sessions until a human approves it
+  // (docs/08-skills/01-registry.md).
+  PROPOSE_SKILL_EDIT: "propose_skill_edit",
+  DELIVERABLE_PUBLISH: "deliverable_publish",
+  // Design mode: pull a round of static bundles out of the sandbox, store them
+  // as immutable versions, and hand back the public link the panel mirrors.
+  PUBLISH_DESIGN: "publish_design",
+  SET_LIVE_DESIGN: "set_live_design",
+  // Advisory dynamic playbook (WS6): the agent defines its own ordered steps
+  // (set_steps) and fills each step's todo checklist (set_todos). Replaces the
+  // fixed 5-phase set_phase pointer; neither parks the turn, the runner park
+  // logic is untouched. A step's status is derived from its todos.
+  SET_STEPS: "set_steps",
+  SET_TODOS: "set_todos",
+  // The chat's title is generated from the FIRST prompt by the platform's
+  // small model. This lets the agent correct it mid-run when the real scope
+  // turns out to be something else, and only then (see the pipeline
+  // templates). Refused once a human has renamed the chat; never parks.
+  RENAME_SESSION: "rename_session",
+  // Files an issue in Hephaistos' own Linear tracker; never parks the turn.
+  REPORT_HARNESS_ISSUE: "report_harness_issue",
+  RUN_VALIDATION: "run_validation",
+  // Media tool (Stage 1): generate images host-side via the AI Gateway; the
+  // result renders inline in the thread. Always available, never parks the
+  // turn.
+  GENERATE_IMAGE: "generate_image",
+  // In-sandbox annotation (#43): renders the source image + an SVG overlay in
+  // the sandbox's chromium and screenshots it. NEVER host-side, the previous
+  // @napi-rs/canvas implementation broke the glibc Trigger.dev worker deploy.
+  ANNOTATE_IMAGE: "annotate_image",
+  // WS8: the admin-configured image_generator registry, the agent reads the
+  // enabled {model, description} rows to pick a model for generate_image.
+  GET_IMAGE_GENERATORS: "get_image_generators",
+  // Capture tools (Stage 2): drive a headless chromium INSIDE the session's
+  // sandbox to screenshot / record a running app URL (or a file:// the agent
+  // rendered), then attach the result inline. Provision the sandbox on demand
+  // (WS7), always exposed.
+  TAKE_SCREENSHOT: "take_screenshot",
+  RECORD_VIDEO: "record_video",
+  // Interactive browser control: ONE persistent chromium per sandbox, one
+  // context per session, driven by the in-sandbox daemon (packages/tasks
+  // lib/browser). The snapshot is an accessibility tree with `ref=eN` handles
+  // the act tool targets, no coordinates, no throwaway playwright script.
+  BROWSER_NAVIGATE: "browser_navigate",
+  BROWSER_SNAPSHOT: "browser_snapshot",
+  BROWSER_ACT: "browser_act",
+  BROWSER_WAIT: "browser_wait",
+  BROWSER_INSPECT: "browser_inspect",
+  BROWSER_SCREENSHOT: "browser_screenshot",
+  // A recording is a PAIR: playwright only films a context it created with
+  // recording on, so start recycles the context and stop hands back the clip.
+  BROWSER_RECORD_START: "browser_record_start",
+  BROWSER_RECORD_STOP: "browser_record_stop",
+  BROWSER_CLOSE: "browser_close",
+  // The escape hatch: JS evaluated in a Node context that SURVIVES between
+  // calls, with the live page bound into it.
+  REPL_EVAL: "repl_eval",
+  REPL_RESET: "repl_reset",
+  // WS5: upload a PNG the agent produced in the sandbox (script/python/write)
+  // as a media reference, silent for ask_user option images, inline otherwise.
+  ATTACH_IMAGE: "attach_image",
+  // Browser-session vault: sites a human captured with the Hephaistos
+  // extension, applied to the live browser one domain at a time, on demand.
+  BROWSER_SESSIONS_LIST: "browser_sessions_list",
+  BROWSER_USE_SESSION: "browser_use_session",
+  BROWSER_FORGET_SESSION: "browser_forget_session",
+  // Outbound files: any format the human should keep, uploaded from the sandbox
+  // to durable storage and downloadable once the sandbox is gone.
+  ATTACH_FILE: "attach_file",
+  // Delegation: a task is the work, a session is one attempt at it. The agent
+  // describes the task and the PLATFORM dispatches it; these address the task,
+  // never a runner. Fire-and-forget, none of them park the turn.
+  CREATE_TASK: "create_task",
+  LIST_TASKS: "list_tasks",
+  UPDATE_TASK: "update_task",
+  PEEK_TASK: "peek_task",
+  SEND_TO_TASK: "send_to_task",
+  STOP_TASK: "stop_task",
+  PICKUP_TASK: "pickup_task",
+  // docs/integrations/database-access.md; detect is environment-setup only.
+  DATABASE_QUERY: "database_query",
+  DATABASE_WRITE: "database_write",
+  DETECT_PROJECT_DATABASE: "detect_project_database",
+  BIND_PROJECT_DATABASE: "bind_project_database",
+  // Historical: the agent-addressed family the tools above replaced. No agent
+  // can call them, but old transcripts still render rows named after them.
+  SPAWN_AGENT: "spawn_agent",
+  LIST_AGENTS: "list_agents",
+  PEEK_AGENT: "peek_agent",
+  SEND_TO_AGENT: "send_to_agent",
+  STOP_AGENT: "stop_agent"
+};
+var ALL_HOST_TOOL_NAMES = Object.values(HOST_TOOL_NAMES);
+var TURN_CLOSING_TOOL_NAMES = [
+  HOST_TOOL_NAMES.UPDATE_TASK,
+  HOST_TOOL_NAMES.CREATE_TASK
+];
+var WORKSPACE_TOOL_NAMES = {
+  BASH: "workspace_bash",
+  READ: "workspace_read",
+  WRITE: "workspace_write",
+  EDIT: "workspace_edit",
+  GLOB: "workspace_glob",
+  GREP: "workspace_grep",
+  TASK_OUTPUT: "workspace_task_output",
+  TASK_STOP: "workspace_task_stop"
+};
+var AGENT_MESSAGE_DELIVERY_MODES = {
+  INTERRUPT: "interrupt",
+  AFTER_TOOL: "after_tool",
+  QUEUE: "queue"
+};
+var ALL_AGENT_MESSAGE_DELIVERY_MODES = Object.values(
+  AGENT_MESSAGE_DELIVERY_MODES
+);
+var DEFAULT_AGENT_MESSAGE_DELIVERY_MODE = AGENT_MESSAGE_DELIVERY_MODES.AFTER_TOOL;
+
+// ../../packages/agents/src/tool-activity/canonical/canonical-tool-name-constants.ts
+var NATIVE_EQUIVALENT = {
+  [WORKSPACE_TOOL_NAMES.BASH]: "bash",
+  [WORKSPACE_TOOL_NAMES.READ]: "read",
+  [WORKSPACE_TOOL_NAMES.WRITE]: "write",
+  [WORKSPACE_TOOL_NAMES.EDIT]: "edit",
+  [WORKSPACE_TOOL_NAMES.GLOB]: "glob",
+  [WORKSPACE_TOOL_NAMES.GREP]: "grep"
+};
+
+// ../../packages/agents/src/tool-activity/tool-input/is-record.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../../packages/agents/src/tool-activity/tool-input/str.ts
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// ../../packages/agents/src/tool-activity/tool-input/trimmed.ts
+function trimmed(value) {
+  const text = str(value)?.trim();
+  return text ? text : null;
+}
+
+// ../../packages/agents/src/tool-activity/tool-input/truncate.ts
+function truncate2(value, max) {
+  const text = value.trim();
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+
+// ../../packages/agents/src/tool-activity/tool-input/verbatim.ts
+function verbatim(value) {
+  const text = str(value);
+  return text && text.trim().length > 0 ? text : null;
+}
+
+// ../../packages/agents/src/tool-activity/tool-input.ts
+var toolInput = { isRecord, str, trimmed, truncate: truncate2, verbatim };
+
+// ../../packages/agents/src/tool-activity/label-only.ts
+function labelOnly(text) {
+  return { text, command: null };
+}
+
+// ../../packages/agents/src/tool-activity/tool-activity-basename.ts
+function toolActivityBasename(path2) {
+  if (!path2) {
+    return void 0;
+  }
+  const segments2 = path2.split(/[/\\]/).filter(Boolean);
+  return segments2.at(-1) ?? path2;
+}
+
+// ../../packages/agents/src/tool-activity/tool-activity-hostname.ts
+function toolActivityHostname(url) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url.replace(/^https?:\/\//, "").split("/")[0] || void 0;
+  }
+}
+
+// ../../packages/agents/src/tool-activity/browser/browser-label.ts
+function browserLabel(state, labels) {
+  if (state.hasFailed) return labelOnly(labels.failed);
+  return labelOnly(state.isRunning ? labels.running : labels.done);
+}
+
+// ../../packages/agents/src/tool-activity/browser/browser-activity-constants.ts
+var BROWSER_ACT_VERBS = Object.assign(/* @__PURE__ */ Object.create(null), {
+  click: { done: "Clicked", gerund: "Clicking", bare: "click" },
+  dblclick: {
+    done: "Double-clicked",
+    gerund: "Double-clicking",
+    bare: "double-click"
+  },
+  fill: { done: "Filled", gerund: "Filling", bare: "fill" },
+  type: { done: "Typed into", gerund: "Typing into", bare: "type into" },
+  select: { done: "Selected in", gerund: "Selecting in", bare: "select in" },
+  check: { done: "Checked", gerund: "Checking", bare: "check" },
+  uncheck: { done: "Unchecked", gerund: "Unchecking", bare: "uncheck" },
+  hover: { done: "Hovered", gerund: "Hovering", bare: "hover" },
+  press: {
+    done: "Pressed a key on",
+    gerund: "Pressing a key on",
+    bare: "press a key on"
+  },
+  scroll: { done: "Scrolled", gerund: "Scrolling", bare: "scroll" },
+  upload: {
+    done: "Uploaded a file to",
+    gerund: "Uploading a file to",
+    bare: "upload a file to"
+  }
+});
+var BROWSER_HISTORY_LABELS = Object.assign(/* @__PURE__ */ Object.create(null), {
+  back: { done: "Went back", gerund: "Going back", bare: "go back" },
+  forward: {
+    done: "Went forward",
+    gerund: "Going forward",
+    bare: "go forward"
+  },
+  reload: {
+    done: "Reloaded the page",
+    gerund: "Reloading the page",
+    bare: "reload the page"
+  }
+});
+
+// ../../packages/agents/src/tool-activity/browser/describe-browser-act.ts
+function describeBrowserAct(record, state) {
+  const action = toolInput.str(record.action) ?? "click";
+  const verb = (Object.hasOwn(BROWSER_ACT_VERBS, action) ? BROWSER_ACT_VERBS[action] : void 0) ?? {
+    done: "Acted on",
+    gerund: "Acting on",
+    bare: "act on"
+  };
+  const target = toolInput.trimmed(record.name) ?? toolInput.trimmed(record.selector) ?? toolInput.trimmed(record.ref) ?? toolInput.trimmed(record.role);
+  const subject = target ? toolInput.truncate(target, 60) : "an element";
+  return browserLabel(state, {
+    failed: `Could not ${verb.bare} ${subject}`,
+    running: `${verb.gerund} ${subject}`,
+    done: `${verb.done} ${subject}`
+  });
+}
+
+// ../../packages/agents/src/tool-activity/browser/describe-browser-navigate.ts
+function describeBrowserNavigate(record, state) {
+  const action = toolInput.str(record.action);
+  if (action && action !== "goto") {
+    const move = Object.hasOwn(BROWSER_HISTORY_LABELS, action) ? BROWSER_HISTORY_LABELS[action] : void 0;
+    return move ? browserLabel(state, {
+      failed: `Could not ${move.bare}`,
+      running: move.gerund,
+      done: move.done
+    }) : browserLabel(state, {
+      failed: "Could not move in the browser",
+      running: "Moving in the browser",
+      done: "Moved in the browser"
+    });
+  }
+  const host = toolActivityHostname(toolInput.str(record.url));
+  const subject = host ?? "a page";
+  return browserLabel(state, {
+    failed: `Could not open ${subject}`,
+    running: `Opening ${subject}`,
+    done: `Opened ${subject}`
+  });
+}
+
+// ../../packages/agents/src/tool-activity/capture/capture-label.ts
+function captureLabel(labels, state, options) {
+  if (options.isOption) {
+    if (state.hasFailed) {
+      return labelOnly(labels.optionFailed);
+    }
+    return labelOnly(
+      state.isRunning ? labels.optionRunning : labels.optionDone
+    );
+  }
+  if (state.hasFailed) {
+    return labelOnly(labels.failed(options.subject));
+  }
+  return labelOnly(
+    state.isRunning ? labels.running(options.subject) : labels.done(options.subject)
+  );
+}
+
+// ../../packages/agents/src/tool-activity/capture/capture-target.ts
+function captureTarget(url) {
+  if (!url) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "file:") {
+      return toolActivityBasename(parsed.pathname) ?? url;
+    }
+    return parsed.host || parsed.hostname;
+  } catch {
+    return toolActivityBasename(url) ?? url;
+  }
+}
+
+// ../../packages/agents/src/tool-activity/capture/capture-label-constants.ts
+var CAPTURE_LABEL_MAX = 60;
+
+// ../../packages/agents/src/tool-activity/capture/describe-take-screenshot.ts
+function describeTakeScreenshot(record, state) {
+  const target = captureTarget(toolInput.str(record.url));
+  return captureLabel(
+    {
+      optionFailed: "Failed to take an option screenshot",
+      optionRunning: "Taking an option screenshot",
+      optionDone: "Took an option screenshot",
+      failed: (subject) => subject ? `Failed to screenshot ${subject}` : "Failed to take a screenshot",
+      running: (subject) => subject ? `Taking a screenshot of ${subject}` : "Taking a screenshot",
+      done: (subject) => subject ? `Took a screenshot of ${subject}` : "Took a screenshot"
+    },
+    state,
+    {
+      isOption: record.silent === true,
+      subject: target ? toolInput.truncate(target, CAPTURE_LABEL_MAX) : null
+    }
+  );
+}
+
+// ../../packages/agents/src/tool-activity/browser/browser-tool-activity-describers.ts
+var browserToolActivityDescribers = [
+  [HOST_TOOL_NAMES.BROWSER_NAVIGATE, describeBrowserNavigate],
+  [HOST_TOOL_NAMES.BROWSER_ACT, describeBrowserAct],
+  [
+    HOST_TOOL_NAMES.BROWSER_SNAPSHOT,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not read the page",
+      running: "Reading the page",
+      done: "Read the page"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_WAIT,
+    (_record, state) => browserLabel(state, {
+      failed: "Gave up waiting for the page",
+      running: "Waiting for the page",
+      done: "Waited for the page"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_INSPECT,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not read the console and network",
+      running: "Reading the console and network",
+      done: "Read the console and network"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_SCREENSHOT,
+    (record, state) => describeTakeScreenshot(record, state)
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_RECORD_START,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not start recording",
+      running: "Starting a recording",
+      done: "Started recording the browser"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_RECORD_STOP,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not finish the recording",
+      running: "Finishing the recording",
+      done: "Recorded the browser"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_CLOSE,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not close the browser",
+      running: "Closing the browser",
+      done: "Closed the browser"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_SESSIONS_LIST,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not read your captured logins",
+      running: "Listing your captured logins",
+      done: "Listed your captured logins"
+    })
+  ],
+  [
+    // The site, never what the vault holds for it.
+    HOST_TOOL_NAMES.BROWSER_USE_SESSION,
+    (record, state) => {
+      const domain = toolInput.str(record.domain);
+      return browserLabel(state, {
+        failed: domain ? `Could not sign in to ${domain} as you` : "Could not load a captured login",
+        running: domain ? `Signing in to ${domain} as you` : "Loading a captured login",
+        done: domain ? `Signed in to ${domain} as you` : "Loaded a captured login"
+      });
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.BROWSER_FORGET_SESSION,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not forget the captured logins",
+      running: "Forgetting the captured logins",
+      done: "Forgot the captured logins"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.REPL_EVAL,
+    (_record, state) => browserLabel(state, {
+      failed: "JavaScript in the REPL failed",
+      running: "Running JavaScript in the REPL",
+      done: "Ran JavaScript in the REPL"
+    })
+  ],
+  [
+    HOST_TOOL_NAMES.REPL_RESET,
+    (_record, state) => browserLabel(state, {
+      failed: "Could not reset the REPL",
+      running: "Resetting the REPL",
+      done: "Reset the REPL"
+    })
+  ]
+];
+
+// ../../packages/agents/src/tool-activity/capture/describe-annotate-image.ts
+function describeAnnotateImage(record, state) {
+  return captureLabel(
+    {
+      optionFailed: "Failed to annotate an option image",
+      optionRunning: "Annotating an option image",
+      optionDone: "Annotated an option image",
+      failed: () => "Failed to annotate an image",
+      running: () => "Annotating an image",
+      done: () => "Annotated an image"
+    },
+    state,
+    { isOption: record.silent === true, subject: null }
+  );
+}
+
+// ../../packages/agents/src/tool-activity/capture/describe-attach-image.ts
+function describeAttachImage(record, state) {
+  const file = toolActivityBasename(toolInput.str(record.path));
+  return captureLabel(
+    {
+      optionFailed: "Failed to attach an option image",
+      optionRunning: "Attaching an option image",
+      optionDone: "Attached an option image",
+      failed: (subject) => subject ? `Failed to attach ${subject}` : "Failed to attach an image",
+      running: (subject) => subject ? `Attaching ${subject}` : "Attaching an image",
+      done: (subject) => subject ? `Attached ${subject}` : "Attached an image"
+    },
+    state,
+    {
+      isOption: record.silent === true,
+      subject: file ? toolInput.truncate(file, CAPTURE_LABEL_MAX) : null
+    }
+  );
+}
+
+// ../../packages/agents/src/tool-activity/capture/describe-generate-image.ts
+function describeGenerateImage(_record, state) {
+  return captureLabel(
+    {
+      optionFailed: "Failed to generate an image",
+      optionRunning: "Generating an image",
+      optionDone: "Generated an image",
+      failed: () => "Failed to generate an image",
+      running: () => "Generating an image",
+      done: () => "Generated an image"
+    },
+    state,
+    { isOption: false, subject: null }
+  );
+}
+
+// ../../packages/agents/src/tool-activity/capture/describe-record-video.ts
+function describeRecordVideo(record, state) {
+  const target = captureTarget(toolInput.str(record.url));
+  return captureLabel(
+    {
+      // record_video has no option variant: a strip thumb is a still image.
+      optionFailed: "Failed to record a video",
+      optionRunning: "Recording a video",
+      optionDone: "Recorded a video",
+      failed: (subject) => subject ? `Failed to record a video of ${subject}` : "Failed to record a video",
+      running: (subject) => subject ? `Recording a video of ${subject}` : "Recording a video",
+      done: (subject) => subject ? `Recorded a video of ${subject}` : "Recorded a video"
+    },
+    state,
+    {
+      isOption: false,
+      subject: target ? toolInput.truncate(target, CAPTURE_LABEL_MAX) : null
+    }
+  );
+}
+
+// ../../packages/agents/src/tool-activity/canonical/describe-memory-search.ts
+function describeMemorySearch(record) {
+  const query = toolInput.str(record.query);
+  return labelOnly(
+    query ? `Searched its memory: ${toolInput.truncate(query, 60)}` : "Searched its memory"
+  );
+}
+
+// ../../packages/agents/src/tool-activity/deliverable/describe-attach-file.ts
+function describeAttachFile(record, state) {
+  const file = toolActivityBasename(toolInput.str(record.path));
+  const subject = file ?? "a file";
+  if (state.hasFailed) {
+    return labelOnly(`Failed to deliver ${subject}`);
+  }
+  return labelOnly(
+    state.isRunning ? `Delivering ${subject}` : `Delivered ${subject}`
+  );
+}
+
+// ../../packages/agents/src/teams/agent-task-update-constants.ts
+var AGENT_TASK_UPDATE_ACTIONS = {
+  BLOCK: "block",
+  COMPLETE: "complete",
+  FAIL: "fail",
+  HEARTBEAT: "heartbeat",
+  PROGRESS: "progress",
+  RELEASE: "release"
+};
+var OPEN_AGENT_TASK_UPDATE_ACTIONS = [
+  AGENT_TASK_UPDATE_ACTIONS.HEARTBEAT,
+  AGENT_TASK_UPDATE_ACTIONS.PROGRESS,
+  AGENT_TASK_UPDATE_ACTIONS.RELEASE
+];
+
+// ../../packages/agents/src/tool-activity/canonical/update-task-labels.ts
+var updateTaskLabels = new Map(
+  Object.entries({
+    [AGENT_TASK_UPDATE_ACTIONS.BLOCK]: "Blocked a task",
+    [AGENT_TASK_UPDATE_ACTIONS.COMPLETE]: "Completed a task",
+    [AGENT_TASK_UPDATE_ACTIONS.FAIL]: "Marked a task failed",
+    [AGENT_TASK_UPDATE_ACTIONS.HEARTBEAT]: "Kept a task alive",
+    [AGENT_TASK_UPDATE_ACTIONS.PROGRESS]: "Reported progress on a task",
+    [AGENT_TASK_UPDATE_ACTIONS.RELEASE]: "Released a blocked task"
+  })
+);
+
+// ../../packages/agents/src/tool-activity/canonical/canonical-tool-activity-describers.ts
+var canonicalToolActivityDescribers = new Map([
+  [HOST_TOOL_NAMES.ADVISE, () => labelOnly("Advised the watched session")],
+  [
+    "read",
+    (record) => labelOnly(
+      `Read ${toolActivityBasename(toolInput.str(record.file_path) ?? toolInput.str(record.path)) ?? "a file"}`
+    )
+  ],
+  [
+    "write",
+    (record) => labelOnly(
+      `Wrote ${toolActivityBasename(toolInput.str(record.file_path) ?? toolInput.str(record.path)) ?? "a file"}`
+    )
+  ],
+  [
+    "edit",
+    (record) => labelOnly(
+      `Edited ${toolActivityBasename(toolInput.str(record.file_path) ?? toolInput.str(record.path)) ?? "a file"}`
+    )
+  ],
+  [
+    "bash",
+    (record) => {
+      const command = toolInput.verbatim(record.command) ?? toolInput.verbatim(record.cmd);
+      const intent = toolInput.trimmed(record.description);
+      if (!command && !intent) {
+        return labelOnly("Ran a command");
+      }
+      return { text: intent, command };
+    }
+  ],
+  [
+    WORKSPACE_TOOL_NAMES.TASK_OUTPUT,
+    () => labelOnly("Read a background command's output")
+  ],
+  [
+    WORKSPACE_TOOL_NAMES.TASK_STOP,
+    () => labelOnly("Stopped a background command")
+  ],
+  [
+    "grep",
+    (record) => {
+      const pattern = toolInput.str(record.pattern) ?? toolInput.str(record.query);
+      return labelOnly(
+        pattern ? `Searched "${toolInput.truncate(pattern, 60)}"` : "Searched"
+      );
+    }
+  ],
+  [
+    "glob",
+    (record) => {
+      const pattern = toolInput.str(record.pattern) ?? toolInput.str(record.glob);
+      return labelOnly(
+        pattern ? `Matched ${toolInput.truncate(pattern, 60)}` : "Matched files"
+      );
+    }
+  ],
+  [
+    "ls",
+    (record) => {
+      const path2 = toolInput.str(record.path) ?? toolInput.str(record.dir);
+      return labelOnly(path2 ? `Listed ${path2}` : "Listed a directory");
+    }
+  ],
+  [
+    "webfetch",
+    (record) => {
+      const host = toolActivityHostname(toolInput.str(record.url));
+      return labelOnly(host ? `Fetched ${host}` : "Fetched a page");
+    }
+  ],
+  [
+    "websearch",
+    (record) => {
+      const query = toolInput.str(record.query) ?? toolInput.str(record.q);
+      return labelOnly(
+        query ? `Searched the web for "${toolInput.truncate(query, 60)}"` : "Searched the web"
+      );
+    }
+  ],
+  ["task", () => labelOnly("Ran a subagent")],
+  [
+    HOST_TOOL_NAMES.SET_STEPS,
+    (record) => {
+      const steps = Array.isArray(record.steps) ? record.steps.length : null;
+      return labelOnly(
+        steps ? `Planned ${steps} step${steps === 1 ? "" : "s"}` : "Planned the work"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.SET_TODOS,
+    (record) => {
+      const step = toolInput.trimmed(record.step);
+      return labelOnly(step ? `Updated the plan: ${step}` : "Updated the plan");
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.SAVE_DEV_ENV_MANIFEST,
+    () => labelOnly("Saved the dev environment manifest")
+  ],
+  [
+    HOST_TOOL_NAMES.REQUEST_DEV_ENV_CREDENTIALS,
+    (record) => {
+      const asked = Array.isArray(record.credentials) ? record.credentials.length : null;
+      return labelOnly(
+        asked ? `Requested ${asked} credential${asked === 1 ? "" : "s"}` : "Requested credentials"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.GENERATE_DEV_ENV_SECRET,
+    (record) => labelOnly(
+      typeof record.name === "string" ? `Generated ${record.name}` : "Generated a dev environment secret"
+    )
+  ],
+  [
+    HOST_TOOL_NAMES.SET_DEV_ENV_SIZING,
+    () => labelOnly("Recorded the dev environment sizing")
+  ],
+  [HOST_TOOL_NAMES.BAKE_DEV_ENV, () => labelOnly("Baked the dev environment")],
+  [
+    HOST_TOOL_NAMES.DETECT_PROJECT_DATABASE,
+    () => labelOnly("Recorded the project database")
+  ],
+  [
+    HOST_TOOL_NAMES.BIND_PROJECT_DATABASE,
+    () => labelOnly("Requested approval to bind the project database")
+  ],
+  [
+    HOST_TOOL_NAMES.DATABASE_QUERY,
+    (record) => {
+      const branch = toolInput.trimmed(record.branch) ?? "production";
+      const sql = toolInput.verbatim(record.sql);
+      return sql ? { text: `Read the database (${branch})`, command: sql } : labelOnly(`Read the database (${branch})`);
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.DATABASE_WRITE,
+    (record) => {
+      const branch = toolInput.trimmed(record.branch) ?? "production";
+      const sql = toolInput.verbatim(record.sql);
+      return sql ? {
+        text: `Requested approval to write to the database (${branch})`,
+        command: sql
+      } : labelOnly(`Requested approval to write to the database (${branch})`);
+    }
+  ],
+  [HOST_TOOL_NAMES.TAKE_SCREENSHOT, describeTakeScreenshot],
+  [HOST_TOOL_NAMES.RECORD_VIDEO, describeRecordVideo],
+  [HOST_TOOL_NAMES.ATTACH_IMAGE, describeAttachImage],
+  [HOST_TOOL_NAMES.ATTACH_FILE, describeAttachFile],
+  [
+    HOST_TOOL_NAMES.GET_IMAGE_GENERATORS,
+    () => labelOnly("Listed the image models")
+  ],
+  [
+    HOST_TOOL_NAMES.ASK_USER,
+    (record) => {
+      const asked = Array.isArray(record.questions) ? record.questions.length : null;
+      return labelOnly(
+        asked ? `Asked ${asked} question${asked === 1 ? "" : "s"}` : "Asked a question"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.PROPOSE_PLAN,
+    (record) => {
+      const title = toolInput.trimmed(record.title);
+      return labelOnly(
+        title ? `Proposed a plan: ${toolInput.truncate(title, 60)}` : "Proposed a plan"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.REQUEST_GUARDRAIL_APPROVAL,
+    () => labelOnly("Asked for an approval")
+  ],
+  [
+    HOST_TOOL_NAMES.REPORT_CONFIDENCE,
+    () => labelOnly("Reported its confidence")
+  ],
+  [
+    HOST_TOOL_NAMES.REPORT_HARNESS_ISSUE,
+    (record) => {
+      const title = toolInput.trimmed(record.title);
+      return labelOnly(
+        title ? `Reported a harness issue: ${toolInput.truncate(title, 60)}` : "Reported a harness issue"
+      );
+    }
+  ],
+  [HOST_TOOL_NAMES.MEMORY_SEARCH, describeMemorySearch],
+  [HOST_TOOL_NAMES.MEMORY_WRITE, () => labelOnly("Wrote to its memory")],
+  [
+    HOST_TOOL_NAMES.RUN_VALIDATION,
+    (record) => {
+      const command = toolInput.verbatim(record.command);
+      return command ? { text: "Ran a validation command", command } : labelOnly("Ran a validation command");
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.CREATE_TASK,
+    (record) => {
+      const title = toolInput.trimmed(record.title);
+      return labelOnly(
+        title ? `Created task "${toolInput.truncate(title, 60)}"` : "Created a team task"
+      );
+    }
+  ],
+  [HOST_TOOL_NAMES.LIST_TASKS, () => labelOnly("Listed the team tasks")],
+  [HOST_TOOL_NAMES.PICKUP_TASK, () => labelOnly("Picked up a team task")],
+  [
+    HOST_TOOL_NAMES.UPDATE_TASK,
+    (record) => {
+      const action = toolInput.str(record.action);
+      return labelOnly(
+        (action ? updateTaskLabels.get(action) : null) ?? "Updated a team task"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.DELIVERABLE_PUBLISH,
+    () => labelOnly("Published a deliverable")
+  ],
+  [
+    HOST_TOOL_NAMES.PUBLISH_DESIGN,
+    (record) => {
+      const count = Array.isArray(record.directions) ? record.directions.length : 0;
+      return labelOnly(
+        count > 1 ? `Published ${count} design directions` : "Published a design"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.SET_LIVE_DESIGN,
+    (record) => {
+      const version = toolInput.trimmed(record.version);
+      return labelOnly(
+        version ? `Pointed the design link at v${version}` : "Moved the design link"
+      );
+    }
+  ],
+  [
+    HOST_TOOL_NAMES.RENAME_SESSION,
+    (record) => {
+      const title = toolInput.trimmed(record.title);
+      return labelOnly(
+        title ? `Renamed the chat "${toolInput.truncate(title, 60)}"` : "Renamed the chat"
+      );
+    }
+  ],
+  [
+    "tool_search",
+    (record) => {
+      const query = toolInput.str(record.query);
+      return labelOnly(
+        query ? `Searched integrations for "${toolInput.truncate(query, 60)}"` : "Searched the connected integrations"
+      );
+    }
+  ],
+  [
+    "tool_execute",
+    (record) => {
+      const target = toolInput.str(record.tool);
+      return labelOnly(
+        target ? `Ran ${toolInput.truncate(target, 60)}` : "Ran an integration tool"
+      );
+    }
+  ],
+  [HOST_TOOL_NAMES.GENERATE_IMAGE, describeGenerateImage],
+  [HOST_TOOL_NAMES.ANNOTATE_IMAGE, describeAnnotateImage],
+  ...browserToolActivityDescribers
+]);
+
+// ../../packages/agents/src/tool-activity/browser/soft-fail-browser-tools-constants.ts
+var SOFT_FAIL_BROWSER_TOOLS = /* @__PURE__ */ new Set([
+  HOST_TOOL_NAMES.BROWSER_NAVIGATE,
+  HOST_TOOL_NAMES.BROWSER_SNAPSHOT,
+  HOST_TOOL_NAMES.BROWSER_ACT,
+  HOST_TOOL_NAMES.BROWSER_WAIT,
+  HOST_TOOL_NAMES.BROWSER_INSPECT,
+  HOST_TOOL_NAMES.BROWSER_SCREENSHOT,
+  HOST_TOOL_NAMES.BROWSER_RECORD_START,
+  HOST_TOOL_NAMES.BROWSER_RECORD_STOP,
+  HOST_TOOL_NAMES.BROWSER_CLOSE,
+  HOST_TOOL_NAMES.REPL_EVAL,
+  HOST_TOOL_NAMES.REPL_RESET
+]);
+
+// ../../packages/agents/src/tool-activity/browser/soft-failed-browser.ts
+function softFailedBrowser(toolName, output) {
+  return SOFT_FAIL_BROWSER_TOOLS.has(toolName) && typeof output === "string" && /^(?:browser|repl)_[a-z_]+ failed:/.test(output.trimStart());
+}
+
+// ../../packages/agents/src/tool-activity/capture/soft-fail-capture-tools-constants.ts
+var SOFT_FAIL_CAPTURE_TOOLS = /* @__PURE__ */ new Set([
+  HOST_TOOL_NAMES.TAKE_SCREENSHOT,
+  HOST_TOOL_NAMES.RECORD_VIDEO,
+  HOST_TOOL_NAMES.ATTACH_IMAGE,
+  HOST_TOOL_NAMES.ATTACH_FILE,
+  HOST_TOOL_NAMES.GENERATE_IMAGE,
+  HOST_TOOL_NAMES.ANNOTATE_IMAGE
+]);
+
+// ../../packages/agents/src/tool-activity/capture/soft-failed-capture.ts
+function softFailedCapture(toolName, output) {
+  if (!SOFT_FAIL_CAPTURE_TOOLS.has(toolName) || typeof output !== "string") {
+    return false;
+  }
+  return output.trimStart().startsWith(`${toolName} failed`);
+}
+
+// ../../packages/agents/src/tool-activity/tool-activity-state-for.ts
+function toolActivityStateFor(toolName, options) {
+  const isRunning = options?.status === "running";
+  return {
+    isRunning,
+    hasFailed: options?.status === "failed" || !isRunning && (softFailedCapture(toolName, options?.output) || softFailedBrowser(toolName, options?.output))
+  };
+}
+
+// ../../packages/agents/src/tool-activity/skill/skill-call-constants.ts
+var SKILL_NAME_KEYS = [
+  "skill",
+  "skill_name",
+  "skillName",
+  "name",
+  "command"
+];
+
+// ../../packages/agents/src/tool-activity/skill/skill-name-from-input.ts
+function skillNameFromInput(input) {
+  if (!toolInput.isRecord(input)) {
+    return null;
+  }
+  for (const key of SKILL_NAME_KEYS) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim().split(/\s+/u)[0] ?? null;
+    }
+  }
+  return null;
+}
+
+// ../../packages/agents/src/tool-activity/skill/string-field.ts
+function stringField(input, key) {
+  return toolInput.isRecord(input) ? toolInput.trimmed(input[key]) : null;
+}
+
+// ../../packages/agents/src/tool-activity/skill/registry-calls.ts
+var registryCalls = {
+  [HOST_TOOL_NAMES.SKILL_SEARCH]: (input) => ({
+    kind: "search",
+    query: stringField(input, "query")
+  }),
+  [HOST_TOOL_NAMES.SKILL_LOAD]: (input) => ({
+    kind: "load",
+    name: skillNameFromInput(input),
+    via: "tool"
+  }),
+  [HOST_TOOL_NAMES.SAVE_SKILL]: (input) => ({
+    kind: "save",
+    name: stringField(input, "name")
+  }),
+  [HOST_TOOL_NAMES.PROPOSE_SKILL_EDIT]: (input) => ({
+    kind: "edit",
+    name: stringField(input, "name")
+  }),
+  [HOST_TOOL_NAMES.RECORD_REVIEW_LESSON]: (input) => ({
+    kind: "lesson",
+    scope: stringField(input, "scope")
+  })
+};
+
+// src/lib/event/format-tool-part.ts
+function formatToolPart(part) {
+  const { hasFailed } = toolActivityStateFor(part.toolName, {
+    status: part.status,
+    output: part.output
+  });
+  const status = hasFailed ? "failed" : part.status;
+  return `${out.paint("tool", "dim")}   ${out.cell(part.toolName)} ${out.paint(`(${status})`, "dim")}`;
+}
+
 // src/lib/event/format-event.ts
-function formatEvent(event) {
+function formatEvent(event, baseUrl) {
   const part = event.part;
   switch (part.kind) {
     case "text":
@@ -1750,7 +2746,7 @@ function formatEvent(event) {
     case "reasoning":
       return out.paint(`think  ${truncate(part.text, 400)}`, "dim");
     case "tool":
-      return `${out.paint("tool", "dim")}   ${out.cell(part.toolName)} ${out.paint(`(${part.status})`, "dim")}`;
+      return formatToolPart(part);
     case "file_change":
       return `${out.paint("file", "dim")}   ${part.changeType.padEnd(8)} ${out.cell(part.path)}`;
     case "question":
@@ -1776,6 +2772,8 @@ function formatEvent(event) {
     }
     case "advisor":
       return formatAdvisorPart(part);
+    case "deliverable":
+      return formatDeliverablePart(part, event.sessionId, baseUrl);
     case "error":
       return out.paint(`error  ${truncate(part.message)}`, "red");
     case "external_event":
@@ -1797,13 +2795,13 @@ function formatEvent(event) {
 }
 
 // src/lib/session/consume-session-events.ts
-function consumeSessionEvents(events, cursor, quiet) {
+function consumeSessionEvents(events, cursor, quiet, baseUrl) {
   for (const event of events) {
     cursor = Math.max(cursor, event.sequence);
     if (quiet) {
       continue;
     }
-    const line = formatEvent(event);
+    const line = formatEvent(event, baseUrl);
     if (line) {
       out.line(line);
     }
@@ -2004,6 +3002,7 @@ async function followSession(sessionId, options = {}, dependencies = defaultFoll
     outageStartedAt: null
   };
   const maxOutageMs = resolveFollowOutageBudget();
+  const { baseUrl } = config.load();
   for (; ; ) {
     const page = await requestWithFollowRetry({
       retry,
@@ -2029,7 +3028,7 @@ async function followSession(sessionId, options = {}, dependencies = defaultFoll
         }
       )
     });
-    cursor = consumeSessionEvents(page.items, cursor, options.quiet);
+    cursor = consumeSessionEvents(page.items, cursor, options.quiet, baseUrl);
     if (page.nextCursor !== null) {
       cursor = Math.max(cursor, page.nextCursor);
     }
@@ -2378,8 +3377,9 @@ async function showLogs(parsed) {
     out.json(page);
     return;
   }
+  const { baseUrl } = config.load();
   for (const event of page.items) {
-    const line = formatEvent(event);
+    const line = formatEvent(event, baseUrl);
     if (line) {
       out.line(line);
     }