npm - replicas-mcp - Versions diffs - 0.2.10 → 0.2.12 - Mend

replicas-mcp 0.2.10 → 0.2.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/index.js CHANGED Viewed

@@ -3,16 +3,38 @@
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
+import { z as z2 } from "zod";
 // ../shared/src/agent.ts
-var VALID_AGENT_PROVIDERS = ["claude", "codex", "cursor", "opencode", "relay"];
+var AGENT = {
+  CLAUDE: "claude",
+  CODEX: "codex",
+  CURSOR: "cursor",
+  OPENCODE: "opencode",
+  PI: "pi",
+  RELAY: "relay"
+};
+var VALID_AGENT_PROVIDERS = Object.values(AGENT);
+var VALID_RELAY_SUBAGENT_PROVIDERS = VALID_AGENT_PROVIDERS;
 var VALID_CODING_AGENT_PROVIDERS = VALID_AGENT_PROVIDERS.filter(
-  (provider) => provider !== "relay"
+  (provider) => provider !== AGENT.RELAY
 );
 function isValidCodingAgentProvider(value) {
   return VALID_CODING_AGENT_PROVIDERS.some((provider) => provider === value);
 }
+var VALID_THINKING_LEVELS = ["low", "medium", "high", "xhigh", "max", "ultra", "ultracode"];
+var STANDARD_THINKING_LEVELS = ["low", "medium", "high", "xhigh", "max"];
+var THINKING_LEVELS_BY_AGENT = {
+  claude: [...STANDARD_THINKING_LEVELS, "ultracode"],
+  codex: [...STANDARD_THINKING_LEVELS, "ultra"],
+  cursor: STANDARD_THINKING_LEVELS,
+  opencode: STANDARD_THINKING_LEVELS,
+  pi: STANDARD_THINKING_LEVELS,
+  relay: [...STANDARD_THINKING_LEVELS, "ultracode"]
+};
+function isValidThinkingLevel(value) {
+  return VALID_THINKING_LEVELS.some((l) => l === value);
+}
 function getProviderDisplayName(provider, variant = "short") {
   switch (provider) {
     case "codex":
@@ -21,6 +43,8 @@ function getProviderDisplayName(provider, variant = "short") {
       return "Cursor";
     case "opencode":
       return "Opencode";
+    case "pi":
+      return "Pi";
     case "relay":
       return "Relay";
     case "claude":
@@ -31,9 +55,92 @@ function getCodingAgentDisplayNames() {
   return VALID_CODING_AGENT_PROVIDERS.map((provider) => getProviderDisplayName(provider)).join(", ");
 }
+// ../shared/src/credentials/types.ts
+var CREDENTIAL_SCOPE = {
+  USER: "user",
+  ORG: "org"
+};
+var CREDENTIAL_SCOPES = Object.values(CREDENTIAL_SCOPE);
+var CREDENTIAL_SCOPE_PRIORITY = [CREDENTIAL_SCOPE.USER, CREDENTIAL_SCOPE.ORG];
+// ../shared/src/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// ../shared/src/credentials/agents.ts
+var CREDENTIAL_METHOD = {
+  OAUTH: "oauth",
+  API_KEY: "api_key",
+  FOUNDRY: "foundry",
+  BEDROCK: "bedrock",
+  OPENCODE_GO: "opencode-go",
+  ASTER: "aster",
+  OPENROUTER: "openrouter"
+};
+var CREDENTIAL_TYPE = {
+  CLAUDE_OAUTH: "claude",
+  ANTHROPIC_API_KEY: "claude_anthropic_api_key",
+  CLAUDE_FOUNDRY: "claude_foundry",
+  CLAUDE_BEDROCK: "claude_bedrock",
+  CODEX_OAUTH: "codex",
+  OPENAI_API_KEY: "openai_api_key",
+  CODEX_FOUNDRY: "codex_foundry",
+  CURSOR_API_KEY: "cursor_api_key",
+  OPENCODE_GO_API_KEY: "opencode_go_api_key",
+  ASTER_API_KEY: "aster_api_key",
+  OPENROUTER_API_KEY: "openrouter_api_key"
+};
+var AGENT_CREDENTIAL_METHODS_IN_ORDER = {
+  [AGENT.CLAUDE]: [
+    { method: CREDENTIAL_METHOD.OAUTH, credentialType: CREDENTIAL_TYPE.CLAUDE_OAUTH },
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.ANTHROPIC_API_KEY },
+    { method: CREDENTIAL_METHOD.FOUNDRY, credentialType: CREDENTIAL_TYPE.CLAUDE_FOUNDRY },
+    { method: CREDENTIAL_METHOD.BEDROCK, credentialType: CREDENTIAL_TYPE.CLAUDE_BEDROCK }
+  ],
+  [AGENT.CODEX]: [
+    { method: CREDENTIAL_METHOD.OAUTH, credentialType: CREDENTIAL_TYPE.CODEX_OAUTH },
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.OPENAI_API_KEY },
+    { method: CREDENTIAL_METHOD.FOUNDRY, credentialType: CREDENTIAL_TYPE.CODEX_FOUNDRY }
+  ],
+  [AGENT.CURSOR]: [
+    { method: CREDENTIAL_METHOD.API_KEY, credentialType: CREDENTIAL_TYPE.CURSOR_API_KEY }
+  ],
+  [AGENT.OPENCODE]: [
+    { method: CREDENTIAL_METHOD.OPENCODE_GO, credentialType: CREDENTIAL_TYPE.OPENCODE_GO_API_KEY },
+    { method: CREDENTIAL_METHOD.ASTER, credentialType: CREDENTIAL_TYPE.ASTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY }
+  ],
+  [AGENT.PI]: [
+    { method: CREDENTIAL_METHOD.ASTER, credentialType: CREDENTIAL_TYPE.ASTER_API_KEY },
+    { method: CREDENTIAL_METHOD.OPENROUTER, credentialType: CREDENTIAL_TYPE.OPENROUTER_API_KEY }
+  ]
+};
+// ../shared/src/event.ts
+var CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE = "claude-partial-message";
+function coerceClaudePartialMessagePayload(payload) {
+  const streamId = payload.streamId;
+  if (typeof streamId !== "string" || !streamId) return null;
+  const parentToolUseId = payload.parent_tool_use_id;
+  const text = typeof payload.text === "string" && payload.text ? payload.text : void 0;
+  const thinking = typeof payload.thinking === "string" && payload.thinking ? payload.thinking : void 0;
+  if (!text && !thinking) return null;
+  return {
+    streamId,
+    parent_tool_use_id: typeof parentToolUseId === "string" ? parentToolUseId : null,
+    ...text ? { text } : {},
+    ...thinking ? { thinking } : {},
+    status: payload.status === "completed" ? "completed" : "in_progress"
+  };
+}
+var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
+var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
+var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
 // ../shared/src/default-skills/replicas-agent/abilities/computer.ts
 var SECTION = `### Computer use (Linux desktop control)
-Drive the workspace's Linux desktop - open a browser, click, type, scroll, screenshot, record - via the \`replicas computer\` CLI. Every Replicas workspace boots with Xvfb / openbox / x11vnc / noVNC pre-installed and the live noVNC viewer is automatically published as an authenticated preview, so a \`Desktop\` tab is always available in the dashboard. Use \`replicas computer info\` to get the viewer URL when you want to share it (e.g. point a user on Slack at the live stream).
+Drive the workspace's Linux desktop - open a browser, click, type, scroll, screenshot, record - via the \`replicas computer\` CLI. Every Replicas workspace boots with a live H.264 and Opus stream published as an authenticated preview, so a \`Desktop\` tab is always available in the dashboard. Use \`replicas computer info\` to get the viewer URL when you want to share it (e.g. point a user on Slack at the live stream).
 **Reference:** \`references/COMPUTER-USE.md\`
@@ -44,7 +151,7 @@ Use this when:
 - You want to record a screen capture of a task as proof to share back`;
 var REFERENCE = `# Computer use (Linux desktop control)
-Every Replicas workspace boots with a full Linux desktop stack - Xvfb (1920\xD71080), openbox, tint2, x11vnc, noVNC, ffmpeg, and Google Chrome. The engine also auto-registers the noVNC viewer (port 6080) as an authenticated preview at startup, so the dashboard \`Desktop\` tab is live the moment the workspace is up. You drive the desktop through the \`replicas computer\` CLI.
+Every Replicas workspace boots with a full Linux desktop stack - Xvfb (1920\xD71080), openbox, tint2, PulseAudio, ffmpeg, and Google Chrome. The engine auto-registers the H.264 and Opus viewer (port 6080) as an authenticated preview at startup, so the dashboard \`Desktop\` tab is live the moment the workspace is up. You drive the desktop through the \`replicas computer\` CLI.
 Use this for anything the user can't reasonably do via an API - clicking around web apps, filling forms, testing UI changes, dragging files between desktop apps, recording a walkthrough.
@@ -79,25 +186,24 @@ replicas computer info
 # 2) Launch a browser on the workspace display.
 replicas computer launch chrome https://news.ycombinator.com
-# 3) Observe the settled screen and browser tab state before clicking.
-replicas computer observe /tmp/state.png
-replicas computer browser --snapshot
+# 3) Capture the settled viewport and native accessibility tree together.
+replicas computer browser-state /tmp/state.png --full
-# 4) Drive the UI.
-replicas computer click 521 700                    # click coordinates from the screenshot
-replicas computer scroll down --amount 5
+# 4) Batch actions that use refs from the same state, then capture the semantic diff.
+replicas computer browser-batch '[{"action":"fill","ref":17,"value":"hello"},{"action":"click","ref":42}]'
+replicas computer browser-state /tmp/after-click.png
 # 5) (Optional) Record a screencap to share back.
 replicas computer record start /tmp/demo.mp4 --fps 60
 # ... do stuff ...
 replicas computer record stop
-replicas media upload /tmp/demo.mp4
+replicas media upload /tmp/demo.mp4 --name "Demo recording"
 \`\`\`
 ## Command reference
 ### \`replicas computer info\`
-Prints the live noVNC viewer URL (\`https://6080-<hash>.tryreplicas.com/\`) for the workspace desktop. The engine auto-registers this authenticated preview on startup; \`info\` just looks it up. Use it when you want to share the live stream URL with the user out-of-band (e.g. in a Slack reply) - the dashboard \`Desktop\` tab already points at the same URL automatically.
+Prints the live desktop viewer URL (\`https://6080-<hash>.tryreplicas.com/\`). The engine auto-registers this authenticated preview on startup; \`info\` just looks it up. Use it when you want to share the live stream URL with the user out-of-band (e.g. in a Slack reply) - the dashboard \`Desktop\` tab already points at the same URL automatically.
 If invoked very early in the workspace lifecycle, \`info\` will poll briefly while the engine finishes registering the preview, then error if it's still not available.
@@ -114,21 +220,33 @@ Waits briefly for the screen to stop changing, saves a 1:1 screenshot, and print
 Use this instead of hand-written \`sleep && screenshot\` loops after clicks, navigation, typing, or page loads. By default it saves a 100px coordinate-grid screenshot and waits up to 3s for 600ms of visual stability. Pass \`--raw\` if you need an unannotated 1:1 screenshot.
-### \`replicas computer browser\`
-Prints JSON for Chrome tabs launched through Replicas, including page titles and URLs. Pass \`--snapshot\` to include visible page text and interactive controls with DOM viewport bounding boxes.
+### \`replicas computer browser-state <path> [--full] [--timeout MS] [--stable-ms MS]\`
+Waits for the selected Chrome page to settle, saves its viewport screenshot, and prints a compact native Chrome accessibility tree in the same coordinate space. Actionable nodes have DOM-backed refs such as \`[ref=42] button "Save"\`; the tree includes accessible roles, names, values, states, visible bounds, and iframe content.
+The first call returns a full tree. Later calls for the same target and document return semantic changes; navigation or reload forces a new full tree. Pass \`--full\` to reset the baseline. Refs are valid for the current document.
+### \`replicas computer browser [--snapshot]\`
+Lists Chrome tabs. \`--snapshot\` returns the compatibility accessibility snapshot. Use \`browser-state\` for the primary action/observe loop.
+### \`replicas computer browser-batch '<actions-json>'\`
+Runs up to 100 ordered browser actions through one Chrome session and stops at the first failure. Supported actions are \`click\`, \`fill\`, \`key\`, \`type\`, \`scroll\`, and \`wait\`. Prefer this when several actions use refs from the same \`browser-state\`; it avoids repeated process, tab-selection, and connection setup. Do not carry refs across navigation\u2014capture fresh state and start a new batch.
-Use this alongside \`observe\` when testing web apps so you do not infer navigation, page state, or click targets from pixels alone. Snapshot coordinates are DOM viewport coordinates, not desktop click coordinates.
+### \`replicas computer browser-click --ref ID [--button left|middle|right] [--double]\`
+Scrolls the referenced node into view and sends trusted Chrome mouse input at its current visible bounds. Prefer refs from \`browser-state\`. \`browser-click <text> [--exact] [--index N]\` remains a fallback when no fresh ref is available.
-### \`replicas computer browser-click <text> [--exact] [--index N]\`
-Clicks the first visible Chrome control whose text, label, placeholder, or href matches \`<text>\`. Use this for web buttons and links found via \`browser --snapshot\`; it is faster and less error-prone than converting DOM coordinates to desktop pixels.
+### \`replicas computer browser-fill --ref ID <value>\`
+Focuses the referenced field, fills it with trusted Chrome input, and verifies the resulting value. Select controls use their semantic option value. \`browser-fill <field> <value> [--exact] [--index N]\` remains a text-matching fallback.
-### \`replicas computer browser-fill <field> <value> [--exact] [--index N]\`
-Fills the first visible Chrome field whose label, placeholder, name, or text matches \`<field>\`, then dispatches input/change events. Use this for web forms instead of clicking a field and typing through the desktop.
+### \`replicas computer browser-scroll <up|down|left|right> [--ref ID] [--amount PX]\`
+Sends trusted wheel input at a referenced element or the center of the viewport.
+### \`replicas computer browser-key <combo>\` / \`browser-type <text>\`
+Sends trusted keyboard input to the focused element in the selected Chrome target. Prefer \`browser-fill\` when setting a known field value.
 ### \`replicas computer browser-wait <text> [--mode any|text|title|url|control] [--exact] [--timeout MS]\`
 Waits until the active Chrome page matches text in the title, URL, body text, or visible controls. Use this after \`browser-click\` / \`browser-fill\` when you need web app state to settle without screenshot polling.
-For \`browser-click\`, \`browser-fill\`, and \`browser-wait\`, pass \`--id <id>\`, \`--title <text>\`, \`--url <text>\`, or \`--page <n>\` when multiple Chrome tabs are open. Run \`replicas computer browser\` first to list tabs. Prefer \`--id\` when a click may change the page title or URL.
+For browser state and actions, pass \`--target-id <id>\`, \`--title <text>\`, \`--url <text>\`, or \`--page <n>\` when multiple Chrome tabs are open. Prefer \`--target-id\` because titles and URLs can change after an action. The matched tab is brought to the foreground before each action, so driving multiple tabs or recording the screen switches which tab is visible.
 ### \`replicas computer click <x> <y> [--button N] [--double] [--modifiers ctrl+shift]\`
 Move to (x, y) and click. Coordinates can be absolute pixels or percentages such as \`50%\` \`50%\`. Default is left-click (button 1); pass \`--button 3\` for right-click. \`--modifiers\` holds keys during the click (e.g. ctrl-click a link to open in a new tab).
@@ -161,26 +279,29 @@ Spawns an app on the workspace display. Built-in aliases:
 Anything else gets \`exec\`'d verbatim, so \`replicas computer launch xeyes\` works if xeyes is installed.
 When opening a known page, prefer passing the URL directly: \`replicas computer launch chrome http://localhost:3000/\`.
+Chrome launches do not return until the requested page is controllable. The output includes its page ID; carry that ID with \`--target-id\` into \`browser-state\` and browser actions so unrelated tabs cannot steal task context.
 ### \`replicas computer record start <path> [--fps N]\`
-Starts an ffmpeg screen recorder. Output is a fragmented MP4 (still playable if the workspace dies mid-record). Default 60fps; drop to 30 if the workspace is CPU-constrained.
+Starts an ffmpeg screen recorder and returns only after ffmpeg has written the first bytes. Output is post-processed when stopped: action windows stay at normal speed, idle gaps accelerate, click moments get eased camera zoom, and a synthetic cursor animates between logged mouse positions. The raw capture is fragmented MP4 while active (still playable if the workspace dies mid-record). Default 60fps; drop to 30 if the workspace is CPU-constrained.
 Only one recording at a time. Re-running \`start\` while one is active fails - call \`stop\` first.
 ### \`replicas computer record stop\`
-SIGINTs ffmpeg, waits for it to finalize the MP4, prints the output path. Upload it with \`replicas media upload <path>\` to share it.
+SIGINTs ffmpeg, verifies that the process has finalized the MP4, then prints the output path. A finalization timeout preserves the recording state so \`stop\` can be retried safely. Upload it with \`replicas media upload <path> --name "<name>"\` to share it.
 ## Patterns
-### Action / observe loop
-You are blind between tool calls. After any action that changes the screen, observe before deciding the next coordinate:
+### Browser action / state loop
+For Chrome, use the native accessibility state before interpreting pixels or guessing coordinates:
 \`\`\`bash
-replicas computer click 521 700
-replicas computer observe /tmp/after-click.png
-# read /tmp/after-click.png and the JSON output, decide next click
+replicas computer launch chrome https://example.com
+replicas computer browser-state /tmp/before.png --full --target-id <page-id>
+replicas computer browser-batch '[{"action":"fill","ref":17,"value":"hello"},{"action":"click","ref":23}]' --target-id <page-id>
+replicas computer browser-state /tmp/after.png --target-id <page-id>
 \`\`\`
-The JSON \`stable\`, \`frames\`, and \`changes\` fields tell you whether something changed while you were waiting. If \`stable\` is false, observe again or increase \`--timeout\` before acting on coordinates.
+Read the screenshot and tree as one state. Batch ordered actions whose refs all come from that state, then inspect the next semantic diff. A batch is fail-fast and validates each ref against the cached document. Split at navigation or whenever a later action depends on newly rendered refs. Fall back to \`observe\` plus desktop coordinates for canvas content, browser chrome, non-Chrome apps, or controls missing from the accessibility tree.
 ### Typing into an address bar
 \`\`\`bash
@@ -189,10 +310,9 @@ replicas computer observe /tmp/browser-open.png
 replicas computer key ctrl+l
 replicas computer type "https://example.com"
 replicas computer key Return
-replicas computer observe /tmp/loaded.png
-replicas computer browser --snapshot
-replicas computer browser-fill "Search" "replicas"
-replicas computer browser-click "More information" --title "Example"
+replicas computer browser-state /tmp/loaded.png --full
+replicas computer browser-fill --ref 17 "replicas"
+replicas computer browser-click --ref 23 --title "Example"
 replicas computer browser-wait "Example Domain" --mode title --title "Example"
 \`\`\`
@@ -212,12 +332,13 @@ For tasks the user wants proof of:
 replicas computer record start /tmp/walkthrough.mp4
 # ... your work ...
 replicas computer record stop
-replicas media upload /tmp/walkthrough.mp4
+replicas media upload /tmp/walkthrough.mp4 --name "Walkthrough recording"
 \`\`\`
 Then embed the printed \`![\u2026](\u2026)\` line in your chat reply. See \`MEDIA.md\`.
 ## Failure modes
+- **"Computer-use daemon is unavailable"**: the package-managed systemd service did not start. Check \`systemctl status replicas-computer.service\` and its journal.
 - **"Desktop services script missing"**: workspace image is older than this skill. Tell the user - nothing you can do from the CLI side.
 - **\`xdotool ... failed: Can't open display\`**: Xvfb didn't come up. \`replicas computer status\` will show which service is dead and auto-repair the desktop bridge.
 - **Browser doesn't appear after \`launch chrome\`**: run \`replicas computer observe /tmp/state.png\`. Chrome cold-start on the virtual display takes ~500ms but bigger pages take longer.
@@ -228,17 +349,18 @@ Then embed the printed \`![\u2026](\u2026)\` line in your chat reply. See \`MEDI
 | Component | Where |
 |---|---|
-| \`xvfb\`, \`openbox\`, \`tint2\`, \`x11vnc\`, \`websockify\`, \`xdotool\`, \`scrot\`, \`ffmpeg\`, \`google-chrome\` | Baked into the workspace image |
-| Xvfb / openbox / tint2 / x11vnc / websockify processes | Started at workspace boot (\`replicas-start-desktop-services\`) |
-| noVNC preview URL (port 6080) | Registered by the engine on startup (authenticated) |
+| \`xvfb\`, \`openbox\`, \`tint2\`, \`pulseaudio\`, \`xautomation\`, \`xdotool\`, \`scrot\`, \`ffmpeg\`, \`google-chrome\` | Baked into the workspace image |
+| \`replicas-computer\`, desktop assets, and service unit | Installed by \`replicas-computer setup\` during the image build |
+| Xvfb / openbox / tint2 / PulseAudio / stream processes | Managed by \`replicas-computer.service\` |
+| Desktop stream URL (port 6080) | Registered by the engine on startup (authenticated) |
 | Dashboard \`Desktop\` tab | Always available once the engine has registered the preview |
 You can call any of the input tools (\`click\`, \`type\`, \`screenshot\`, etc.) immediately - the daemons are already running.
 `;
 var COMPUTER_ABILITY = {
   label: "Computer use",
-  description: "Drive the workspace's Linux desktop and stream a live noVNC viewer.",
-  bullet: "- Driving the workspace Linux desktop (open a browser, click, type, scroll, screenshot, record) and exposing a live noVNC viewer in the dashboard",
+  description: "Drive the workspace's Linux desktop and stream a live H.264 and Opus viewer.",
+  bullet: "- Driving the workspace Linux desktop (open a browser, click, type, scroll, screenshot, record) and exposing a live audio and video stream in the dashboard",
   section: SECTION,
   referenceFile: { name: "COMPUTER-USE.md", content: REFERENCE }
 };
@@ -285,7 +407,7 @@ var DOCKER_ABILITY = {
 // ../shared/src/default-skills/replicas-agent/abilities/github.ts
 var SECTION3 = `### GitHub
-Use the pre-authenticated \`gh\` CLI for pull requests, issues, actions, and API calls.
+Use the pre-authenticated \`gh\` CLI for repository workflows and the workspace-scoped TypeScript SDK for GitHub API calls.
 **Reference:** \`references/GITHUB.md\`
@@ -296,7 +418,7 @@ Use this when:
 - You need to include images in PR descriptions`;
 var REFERENCE3 = `# GitHub Integration
-This guide covers how to interact with GitHub from within your Replicas workspace.
+This guide covers how to interact with GitHub from within your Replicas workspace. Prefer \`@replicas/sdk\` for API calls so batching and data processing stay in one TypeScript program. The \`gh\` CLI remains useful for ergonomic pull request and git-adjacent workflows.
 ## Prerequisites
@@ -381,17 +503,21 @@ gh run rerun RUN_ID --failed
 ### GitHub API (Advanced)
-For operations not covered by \`gh\` subcommands, use the API directly:
+For operations not covered by \`gh\` subcommands, use the scoped SDK. Pass only a relative GitHub API path:
-\`\`\`bash
-# GET request
-gh api repos/owner/repo/pulls/123/comments
+\`\`\`ts
+import { replicas } from '@replicas/sdk';
-# POST request
-gh api repos/owner/repo/issues/123/comments -f body="Comment text"
+const comments = await replicas.github.request('/repos/owner/repo/pulls/123/comments');
+await replicas.github.request('/repos/owner/repo/issues/123/comments', {
+  method: 'POST',
+  body: { body: 'Comment text' },
+});
-# GraphQL query
-gh api graphql -f query='{ repository(owner: "owner", name: "repo") { issues(first: 10) { nodes { title number } } } }'
+const result = await replicas.github.request('/graphql', {
+  method: 'POST',
+  body: { query: '{ viewer { login } }' },
+});
 \`\`\`
 ### Working with PR Reviews
@@ -413,12 +539,15 @@ gh pr review 123 --request-changes --body "Changes needed"
 GitHub does NOT have a public API for uploading images to PRs/issues. When you need to include images:
 - Do NOT use placeholder image URLs
 - Do NOT commit screenshots as files to the repository
-- Use the \`replicas-agent\` skill to share the image
+- Run \`replicas media upload <image> --name "<display name>" --share\` and put the printed \`Forge embed\` Markdown in the PR body or comment
+- For a self-contained HTML report, run \`replicas media upload <page.html> --name "<display name>" --access organization\` and put the printed \`Forge link\` Markdown in the PR body or comment. Organization members who are already signed in open it directly; others sign in and return to the page
+- For video, embed a shared poster image linked to the recording's **View in Replicas** URL; GitHub does not reliably render externally hosted video inline
+- Treat the public URL as an opt-in bearer capability; revoke it with \`replicas media revoke <media-id>\` only when the user asks or the media should stop rendering \u2014 revoking breaks embeds already posted on the PR
 - If you were triggered from Slack, also upload the image to the Slack thread so the user can see it directly
 `;
 var GITHUB_ABILITY = {
   label: "GitHub",
-  description: "Pre-authenticated `gh` CLI for PRs, issues, releases, and GraphQL.",
+  description: "GitHub workflows through gh and API calls through @replicas/sdk.",
   bullet: "- Interacting with GitHub (creating PRs, managing issues, using the API, etc.)",
   section: SECTION3,
   referenceFile: { name: "GITHUB.md", content: REFERENCE3 }
@@ -426,435 +555,152 @@ var GITHUB_ABILITY = {
 // ../shared/src/default-skills/replicas-agent/abilities/gitlab.ts
 var SECTION4 = `### GitLab
-Workspace repos hosted on GitLab use pre-configured git credentials \u2014 push, pull, and open merge requests with plain \`git\`.
+Use plain git for repository traffic and the workspace-scoped TypeScript SDK for GitLab API operations.
 **Reference:** \`references/GITLAB.md\`
 Use this when:
-- A repo's remote is on gitlab.com or a self-managed GitLab instance
-- You need to open or update a merge request`;
+- A repository remote is on gitlab.com or a self-managed GitLab instance
+- You need to open or update a merge request
+- You need GitLab issues, pipelines, comments, or other API data`;
 var REFERENCE4 = `# GitLab Integration
-This guide covers how to work with GitLab-hosted repositories from within your Replicas workspace.
-## Prerequisites
-Git credentials for the workspace's GitLab hosts are pre-configured in \`~/.git-credentials\` and refreshed automatically. Plain \`git fetch\` / \`git pull\` / \`git push\` over HTTPS work with no additional setup.
+Git credentials are preconfigured for fetch, pull, and push. Use \`@replicas/sdk\` for API traffic; never inspect \`~/.git-credentials\`, request a token, or send a credential with curl.
-- Never ask the user for a GitLab token or PAT \u2014 credentials are already wired. If a push fails with an authentication error, report it to the user instead of working around it.
-- There is no \`glab\` CLI in the workspace, and \`gh\` only works for GitHub remotes. Check a repo's host with \`git remote get-url origin\` before choosing the GitHub or GitLab workflow.
+## Merge requests
-## Merge Requests
-Create a merge request directly from a push using push options:
+Create a merge request directly from a push:
 \`\`\`bash
-git push -o merge_request.create -o merge_request.target=<default-branch> origin HEAD
+git push -o merge_request.create -o merge_request.target=<default-branch> -o merge_request.title="Title" origin HEAD
 \`\`\`
-Useful options:
+Useful options are \`-o merge_request.draft\` and \`-o merge_request.remove_source_branch\`. GitLab prints the merge request URL.
-\`\`\`bash
--o merge_request.title="Title"
--o merge_request.description="Description"
--o merge_request.draft                  # open as draft
--o merge_request.remove_source_branch   # delete branch on merge
-\`\`\`
+## API requests
-GitLab prints the MR URL in the push output \u2014 include it in your reply to the user.
+Pass a relative path below \`/api/v4\`. Replicas selects the credential only from GitLab hosts attached to the workspace repositories.
-## GitLab API (advanced)
+\`\`\`ts
+import { replicas } from '@replicas/sdk';
-For operations with no git equivalent (commenting on MRs, reading pipelines), call the REST API with the workspace credential:
+const project = encodeURIComponent('group/project');
+const mergeRequests = await replicas.gitlab.request(
+  \`/projects/\${project}/merge_requests?state=opened\`,
+);
-\`\`\`bash
-TOKEN=$(grep -m1 '://oauth2:' ~/.git-credentials | sed -E 's#https://oauth2:([^@]+)@.*#\\1#')
-curl -s -H "Authorization: Bearer $TOKEN" "https://gitlab.com/api/v4/projects/<url-encoded-path>/merge_requests"
+await replicas.gitlab.request(\`/projects/\${project}/issues/42/notes\`, {
+  method: 'POST',
+  body: { body: 'Update from Replicas' },
+});
+\`\`\`
+When a workspace contains repositories from more than one GitLab host, pass the exact repository host:
+\`\`\`ts
+await replicas.gitlab.request('/projects/group%2Frepo/pipelines', {
+  host: 'gitlab.example.com',
+});
 \`\`\`
-Use the repo's own host in the API base URL for self-managed instances.
+## Descriptions and media
+API updates replace the entire merge request description, so always preserve the required Replicas footer and co-author trailers. For media, first run \`replicas media upload\` as documented in \`MEDIA.md\`; use GitLab's project uploads endpoint only when a native repository-protected embed is required.
 `;
 var GITLAB_ABILITY = {
   label: "GitLab",
-  description: "Pre-configured git credentials for GitLab repos; merge requests via push options.",
+  description: "Git for repository traffic and @replicas/sdk for the GitLab API.",
   bullet: "- Interacting with GitLab (pushing to GitLab repos, opening merge requests)",
   section: SECTION4,
   referenceFile: { name: "GITLAB.md", content: REFERENCE4 }
 };
-// ../shared/src/default-skills/replicas-agent/abilities/google.ts
-var SECTION5 = `### Google Workspace (Docs, Sheets, Forms, Drive)
-Create and edit Google Docs, Sheets, and Forms via the Replicas gateway. Files are owned by Replicas \u2014 the integration cannot access pre-existing Google content created outside of it.
-**Reference:** \`references/GOOGLE.md\`
-Use this when:
-- You need to create or edit a Google Doc, Sheet, or Form
-- You need to share, rename, move, or delete a Replicas-created Google file
-- You need to read responses from a Replicas-created Google Form`;
-var REFERENCE5 = `# Google Workspace (Docs, Sheets, Forms, Drive)
-This guide covers how to create and edit Google Docs, Sheets, and Forms \u2014 plus do basic Drive file operations \u2014 from inside a Replicas workspace, using the monolith as a gateway to Google's APIs.
-## Prerequisites
-The integration is configured at the org or user level by the Replicas admin. From inside a workspace you don't have a Google access token directly; instead you call the monolith's \`/v1/gdrive/*\` endpoints, authenticated with your workspace's engine secret. The monolith refreshes the org's (or user's) Google access token and proxies the call.
-Quick check that the integration is connected:
-\`\`\`bash
-curl -s -X GET "$MONOLITH_URL/v1/gdrive/credentials" \\
-  -H "Authorization: Bearer $REPLICAS_ENGINE_SECRET" \\
-  -H "X-Workspace-Id: $WORKSPACE_ID"
-\`\`\`
-- If \`hasCredentials\` is \`true\`: you're good to go.
-- If \`hasCredentials\` is \`false\`: Google has not been connected for this org. Ask the user to go to **Settings \u2192 Integrations \u2192 Google** in the [Replicas dashboard](https://replicas.dev) and connect a Google account. Do not attempt Google operations until it's connected.
-Standard auth headers used by every call below:
-\`\`\`
-Authorization: Bearer $REPLICAS_ENGINE_SECRET
-X-Workspace-Id: $WORKSPACE_ID
-\`\`\`
-For brevity the examples below use a shell variable:
-\`\`\`bash
-GDRIVE_AUTH=(-H "Authorization: Bearer $REPLICAS_ENGINE_SECRET" -H "X-Workspace-Id: $WORKSPACE_ID")
-\`\`\`
-## Important constraint: drive.file scope
-The integration uses the **sensitive-tier \`drive.file\` scope**. That means Replicas can only read and edit Google files **it created itself**. It **cannot**:
-- Read or edit a user's pre-existing Google Docs, Sheets, or Forms \u2014 even ones that were shared with the connected Google account.
-- List or search the user's broader Drive.
-- Touch any file that was not created via these gateway endpoints.
-If the user asks you to edit an existing doc that Replicas didn't create, tell them this constraint and offer to create a new doc that mirrors what they want.
-## Google Docs
-### Create a new doc
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/docs" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{"title":"Meeting notes 2026-05-14"}'
-\`\`\`
-Returns the full Doc object; grab \`.documentId\` for follow-up calls.
-### Read a doc
-\`\`\`bash
-curl -s "$MONOLITH_URL/v1/gdrive/docs/$DOC_ID" "\${GDRIVE_AUTH[@]}"
-\`\`\`
-Returns the full document structure \u2014 \`body.content\` is an ordered list of structural elements (paragraphs, tables, etc.) with character indexes you can target for edits.
-### Edit a doc (batchUpdate)
-The Docs API edits use a list of [structural requests](https://developers.google.com/workspace/docs/api/reference/rest/v1/documents/request). Insert text, then style it; or insert tables, images, page breaks, etc.
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/docs/$DOC_ID/batchUpdate" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{
-    "requests": [
-      { "insertText": { "location": { "index": 1 }, "text": "Hello, world!\\n" } }
-    ]
-  }'
-\`\`\`
-Common request types:
-- \`insertText\` \u2014 insert plain text at a given index
-- \`deleteContentRange\` \u2014 delete a range
-- \`replaceAllText\` \u2014 find-and-replace
-- \`updateTextStyle\` \u2014 bold/italic/colors/fonts/sizes for a range
-- \`updateParagraphStyle\` \u2014 headings (\`HEADING_1\`..\`HEADING_6\`), alignment, spacing
-- \`createParagraphBullets\` \u2014 turn paragraphs into bulleted/numbered lists
-- \`insertTable\` \u2014 insert a table
-- \`insertInlineImage\` \u2014 insert an image from a URL
-Edits are verbose but powerful. Prefer batching many requests into a single \`batchUpdate\` call rather than making many round trips \u2014 it's faster and keeps the doc state consistent.
-## Google Sheets
-### Create a new spreadsheet
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/sheets" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{"title":"Q2 metrics"}'
-\`\`\`
-Returns the full Spreadsheet object; grab \`.spreadsheetId\`.
-### Read a range of cells
-\`\`\`bash
-# Range is in A1 notation, e.g. "Sheet1!A1:C10"
-curl -s "$MONOLITH_URL/v1/gdrive/sheets/$SHEET_ID/values/$(printf %s 'Sheet1!A1:C10' | jq -sRr @uri)" \\
-  "\${GDRIVE_AUTH[@]}"
-\`\`\`
-### Write a range of cells
-\`\`\`bash
-curl -s -X PUT \\
-  "$MONOLITH_URL/v1/gdrive/sheets/$SHEET_ID/values/$(printf %s 'Sheet1!A1:B2' | jq -sRr @uri)?valueInputOption=USER_ENTERED" \\
-  "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{
-    "range": "Sheet1!A1:B2",
-    "majorDimension": "ROWS",
-    "values": [
-      ["Name", "Revenue"],
-      ["Q1",   "=SUM(B3:B100)"]
-    ]
-  }'
-\`\`\`
-\`valueInputOption=USER_ENTERED\` makes formulas evaluate as if a human typed them. Use \`RAW\` to write literal strings.
-### Bulk operations (formatting, charts, new tabs, etc.)
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/sheets/$SHEET_ID/batchUpdate" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{ "requests": [ { "addSheet": { "properties": { "title": "Raw data" } } } ] }'
-\`\`\`
-\`batchUpdate\` accepts an array of [Sheets API requests](https://developers.google.com/workspace/sheets/api/reference/rest/v4/spreadsheets/request) \u2014 addSheet, updateSheetProperties, repeatCell, addChart, autoResizeDimensions, etc.
-## Google Forms
-### Create a new form
+// ../shared/src/default-skills/replicas-agent/abilities/learnings.ts
+var SECTION5 = `### Learnings
+Propose additions, updates, or deletions to curated organization knowledge.
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/forms" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{"title":"Customer feedback"}'
-\`\`\`
-Returns the form. Grab \`.formId\`.
-### Add questions / edit form structure
-The Forms API uses its own \`batchUpdate\`:
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/forms/$FORM_ID/batchUpdate" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{
-    "requests": [
-      {
-        "createItem": {
-          "item": {
-            "title": "How likely are you to recommend us?",
-            "questionItem": {
-              "question": {
-                "required": true,
-                "scaleQuestion": { "low": 0, "high": 10, "lowLabel": "Not at all", "highLabel": "Very likely" }
-              }
-            }
-          },
-          "location": { "index": 0 }
-        }
-      }
-    ]
-  }'
-\`\`\`
-See the [Forms API Request reference](https://developers.google.com/workspace/forms/api/reference/rest/v1/forms/request) for all supported request types \u2014 text questions, multiple choice, checkboxes, scale, grid, date, time, file upload, section breaks, branching logic, quiz settings, etc.
-### Read responses
-\`\`\`bash
-curl -s "$MONOLITH_URL/v1/gdrive/forms/$FORM_ID/responses" "\${GDRIVE_AUTH[@]}"
-\`\`\`
-Pagination: pass \`?pageToken=...&pageSize=...\` to walk through responses.
-## Drive operations (only on Replicas-created files)
-### Share a file with a person
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/files/$FILE_ID/permissions" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{
-    "type": "user",
-    "role": "writer",
-    "emailAddress": "alice@example.com",
-    "sendNotificationEmail": true
-  }'
-\`\`\`
-Roles: \`reader\`, \`commenter\`, \`writer\`. Types: \`user\`, \`group\`, \`domain\`, \`anyone\`.
-### Make a file viewable by anyone with the link
-\`\`\`bash
-curl -s -X POST "$MONOLITH_URL/v1/gdrive/files/$FILE_ID/permissions" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{ "type": "anyone", "role": "reader" }'
-\`\`\`
-### List existing permissions
-\`\`\`bash
-curl -s "$MONOLITH_URL/v1/gdrive/files/$FILE_ID/permissions" "\${GDRIVE_AUTH[@]}"
-\`\`\`
-### Rename / move a file
+**Reference:** \`references/LEARNINGS.md\``;
+var REFERENCE5 = `# Learnings
-\`\`\`bash
-curl -s -X PATCH "$MONOLITH_URL/v1/gdrive/files/$FILE_ID" "\${GDRIVE_AUTH[@]}" \\
-  -H "Content-Type: application/json" \\
-  -d '{"name":"Final report.docx"}'
-\`\`\`
-To move into a folder, also pass \`addParents\` and \`removeParents\` as query parameters per [Drive API docs](https://developers.google.com/workspace/drive/api/reference/rest/v3/files/update).
-### Get file metadata
-\`\`\`bash
-curl -s "$MONOLITH_URL/v1/gdrive/files/$FILE_ID?fields=id,name,mimeType,webViewLink,parents,modifiedTime" \\
-  "\${GDRIVE_AUTH[@]}"
-\`\`\`
-\`webViewLink\` is the human-shareable URL that opens in Google Docs/Sheets/Forms.
+Learnings are curated, human-approved knowledge entries your organization maintains: conventions, gotchas, environment facts, and process rules.
-### Delete a file
+All writes are proposals: a human reviews them in the dashboard, and nothing takes effect until approved.
-\`\`\`bash
-curl -s -X DELETE "$MONOLITH_URL/v1/gdrive/files/$FILE_ID" "\${GDRIVE_AUTH[@]}"
-\`\`\`
-### List Replicas-created files
-\`\`\`bash
-curl -s "$MONOLITH_URL/v1/gdrive/files?pageSize=50" "\${GDRIVE_AUTH[@]}"
-\`\`\`
+Use \`replicas learnings --help\` and subcommand help such as \`replicas learnings add --help\`, \`replicas learnings update --help\`, or \`replicas learnings delete --help\` for current command syntax.
-Pass \`?q=...\` to filter using [Drive API search syntax](https://developers.google.com/workspace/drive/api/guides/search-files). Only files the app created or was granted access to will appear.
+A human approves every proposal before it takes effect, so don't agonize over borderline calls \u2014 but keep proposals genuinely useful rather than reflexive.
-## Tips
-- **Always return the \`webViewLink\`** to the user when you create or edit a file so they can open it. Get it from \`/v1/gdrive/files/$FILE_ID?fields=webViewLink\` or from \`documents.documentId\` \u2192 \`https://docs.google.com/document/d/$ID/edit\`.
-- **Batch your edits.** A single \`batchUpdate\` with 20 requests beats 20 round-trips.
-- **Watch error responses.** A 412 from the gateway means the org has no Google credentials connected \u2014 tell the user to connect Google in the dashboard. Other 4xx responses come straight from Google and usually explain the issue clearly.
-`;
-var GOOGLE_ABILITY = {
-  label: "Google Workspace",
-  description: "Create / edit Docs, Sheets, Forms, and Drive files via the Replicas gateway.",
-  bullet: "- Interacting with Google Workspace (creating and editing Docs, Sheets, and Forms, sharing files, reading form responses, etc.)",
+- Propose \`add\` for anything repeatable and org-useful: user corrections and preferences, hard-won environment or process knowledge, conventions and decisions worth following, and gotchas that would waste time again. If you learned it the hard way this task, capture it.
+- Never store task-specific details that won't recur, facts trivially derivable by reading the repo, or secrets/credentials.
+- Propose \`update\` or \`delete\` when a learning is contradicted by the current code or docs, especially if the outdated guidance would affect future repeated work.
+- Write narrow triggers describing when the entry should surface (e.g. "UI/UX work on the admin panel"), not vague topics.`;
+var LEARNINGS_ABILITY = {
+  label: "Learnings",
+  description: "Propose changes to curated org knowledge for human review.",
+  bullet: "- Proposing changes to organization Learnings (curated, human-approved knowledge)",
   section: SECTION5,
-  referenceFile: { name: "GOOGLE.md", content: REFERENCE5 }
+  referenceFile: { name: "LEARNINGS.md", content: REFERENCE5 }
 };
 // ../shared/src/default-skills/replicas-agent/abilities/linear.ts
 var SECTION6 = `### Linear
-Fetch issues, update state, add comments, and search via the Linear GraphQL API.
+Fetch issues, update state, add comments, and search through the workspace-scoped TypeScript SDK.
 **Reference:** \`references/LINEAR.md\`
 Use this when:
 - You encounter a Linear issue link and need to understand the task
-- You need to update an issue's state (e.g. mark as done)
-- You need to comment on or search for Linear issues`;
+- You need to update an issue's state or add a comment
+- You need to search Linear issues`;
 var REFERENCE6 = `# Linear Integration
-This guide covers how to interact with Linear from within your Replicas workspace.
-## Prerequisites
-Check that the workspace has the Replicas engine credentials needed to proxy Linear requests:
-\`\`\`bash
-test -n "$MONOLITH_URL" && test -n "$REPLICAS_ENGINE_SECRET" && test -n "$WORKSPACE_ID" && echo set
-\`\`\`
-- If **set**: Use the Replicas Linear proxy below. It refreshes Linear OAuth tokens for you.
-- If **not set**: The workspace cannot authenticate to Replicas. Let the user know and do not attempt Linear operations.
-Then verify Linear is connected:
-\`\`\`bash
-curl -fsS -X POST "$MONOLITH_URL/v1/engine/linear/refresh-token" \\
-  -H "Authorization: Bearer $REPLICAS_ENGINE_SECRET" \\
-  -H "X-Workspace-Id: $WORKSPACE_ID" \\
-  -H "Content-Type: application/json" \\
-  -d '{}' >/dev/null
-\`\`\`
-If this fails because no Linear credential is connected, the user needs to connect Linear in the [Replicas dashboard](https://replicas.dev) under their organization's integration settings.
-## Using the Linear API
-Linear uses a GraphQL API. Always call it through Replicas so the access token stays fresh:
-\`\`\`bash
-linear_graphql() {
-  curl -sS -X POST "$MONOLITH_URL/v1/engine/linear/graphql" \\
-    -H "Authorization: Bearer $REPLICAS_ENGINE_SECRET" \\
-    -H "X-Workspace-Id: $WORKSPACE_ID" \\
-    -H "Content-Type: application/json" \\
-    --data-binary @-
-}
-\`\`\`
-### Fetching an Issue
-If you encounter a Linear issue link (e.g. \`https://linear.app/team/issue/ENG-123\`), the identifier is the last path segment (\`ENG-123\`).
+Use \`@replicas/sdk\`; never request or handle a Linear OAuth token. Replicas refreshes the organization credential behind the gateway.
-\`\`\`bash
-jq -n --arg identifier "ENG-123" '{
-  query: "query($identifier: String!) { issue(id: $identifier) { id identifier title description state { name } assignee { name } parent { identifier title description } } }",
-  variables: { identifier: $identifier }
-}' | linear_graphql
-\`\`\`
+## Check access
-### Updating Issue State
+\`\`\`ts
+import { replicas } from '@replicas/sdk';
-\`\`\`bash
-jq -n --arg issueId "ISSUE_UUID" --arg stateId "STATE_UUID" '{
-  query: "mutation($issueId: String!, $stateId: String!) { issueUpdate(id: $issueId, input: { stateId: $stateId }) { success issue { identifier state { name } } } }",
-  variables: { issueId: $issueId, stateId: $stateId }
-}' | linear_graphql
+const { native } = await replicas.integrations.list();
+if (!native.linear) throw new Error('Connect Linear in Replicas organization integrations first.');
 \`\`\`
-To find available states, query: \`query { workflowStates { nodes { id name } } }\`
+## Fetch an issue
-### Adding a Comment
-\`\`\`bash
-jq -n --arg issueId "ISSUE_UUID" --arg body "Your comment here" '{
-  query: "mutation($issueId: String!, $body: String!) { commentCreate(input: { issueId: $issueId, body: $body }) { success comment { id } } }",
-  variables: { issueId: $issueId, body: $body }
-}' | linear_graphql
+\`\`\`ts
+const issue = await replicas.linear.graphql({
+  query: \`query($identifier: String!) {
+    issue(id: $identifier) {
+      id identifier title description state { id name } assignee { name }
+      parent { identifier title description }
+    }
+  }\`,
+  variables: { identifier: 'ENG-123' },
+});
 \`\`\`
-### Searching Issues
+## Update and comment in one script
-\`\`\`bash
-jq -n --arg query "search terms" '{
-  query: "query($query: String!) { issues(filter: { or: [{ title: { containsIgnoreCase: $query } }, { description: { containsIgnoreCase: $query } }] }, first: 10) { nodes { identifier title state { name } } } }",
-  variables: { query: $query }
-}' | linear_graphql
+\`\`\`ts
+await replicas.linear.graphql({
+  query: \`mutation($issueId: String!, $stateId: String!) {
+    issueUpdate(id: $issueId, input: { stateId: $stateId }) { success }
+  }\`,
+  variables: { issueId, stateId },
+});
+await replicas.linear.graphql({
+  query: \`mutation($issueId: String!, $body: String!) {
+    commentCreate(input: { issueId: $issueId, body: $body }) { success comment { id } }
+  }\`,
+  variables: { issueId, body: 'Implemented in PR #123.' },
+});
 \`\`\`
-### Other Operations
-The Linear GraphQL API supports creating issues, managing projects, labels, cycles, and more. For the full schema and documentation, see: https://developers.linear.app/docs/graphql/working-with-the-graphql-api
+Search with \`containsIgnoreCase: $query\` filters, for example on both \`title\` and \`description\`. Batch independent queries with \`Promise.all\` to save round trips.
 `;
 var LINEAR_ABILITY = {
   label: "Linear",
-  description: "Fetch issues, post comments, update states via the Linear GraphQL API.",
+  description: "Fetch issues, comment, and update state through @replicas/sdk.",
   bullet: "- Interacting with Linear (fetching issues, updating state, commenting, etc.)",
   section: SECTION6,
   referenceFile: { name: "LINEAR.md", content: REFERENCE6 }
@@ -862,17 +708,18 @@ var LINEAR_ABILITY = {
 // ../shared/src/default-skills/replicas-agent/abilities/media.ts
 var SECTION7 = `### Media
-Share screenshots, screen recordings, generated diagrams, and audio clips inline in the Replicas chat and natively embedded in external messages.
+Share screenshots, screen recordings, generated diagrams, audio clips, and self-contained HTML pages through Replicas and external messages.
 **Reference:** \`references/MEDIA.md\`
 Use this when:
 - You produce a screenshot, recording, generated image, or audio clip the user should see
+- You produce a self-contained HTML report that should be linked from a pull request
 - You record video output (browser automation, screen capture) \u2014 including the recommended aspect ratio and FPS
 - You need to embed media in a Slack/Linear/GitHub message AND keep a referenceable copy in the Replicas dashboard`;
-var REFERENCE7 = `# Media (Screenshots, Recordings, Audio)
+var REFERENCE7 = `# Media (Screenshots, Recordings, Audio, HTML)
-This guide covers how to share screenshots, screen recordings, generated diagrams, and audio clips \u2014 both inline in the Replicas chat and natively embedded in external surfaces (Slack, Linear, GitHub).
+This guide covers how to share screenshots, screen recordings, generated diagrams, audio clips, and self-contained HTML pages through Replicas and external surfaces (Slack, Linear, GitHub).
 ## Prerequisites
@@ -883,7 +730,7 @@ The \`replicas\` CLI is pre-installed and authenticated in your workspace. No ad
 Upload to Replicas in these cases \u2014 and **only** these cases:
 1. **Media you produce.** Any screenshot, screen recording, generated diagram, or audio clip you create that the user might want to see. Upload before doing anything else with the file (analyzing, deleting, sending elsewhere). This applies even when you're also sending the file to Slack, Linear, GitHub, etc.
-2. **Files the user explicitly asks you to upload.** If the user sends or points at a file (image, video, audio) and asks you to upload it, run \`replicas media upload\`. Otherwise leave it alone \u2014 files in the workspace the user did not ask about should not be auto-uploaded as media.
+2. **Files the user explicitly asks you to upload.** If the user sends or points at a file (image, video, audio, HTML) and asks you to upload it, run \`replicas media upload\`. Otherwise leave it alone \u2014 files in the workspace the user did not ask about should not be auto-uploaded as media.
 3. **Anything you plan to share externally (Slack, Linear, GitHub, etc.).** Upload to Replicas *in addition to* the platform's native upload. Never as a replacement.
 If none of these apply, don't upload.
@@ -891,24 +738,60 @@ If none of these apply, don't upload.
 ## Uploading to Replicas
 \`\`\`bash
-replicas media upload <path-to-file> [<path-to-file> ...]
+replicas media upload <path-to-file> --name "<display name>" [<path-to-file> --name "<display name>" ...]
+\`\`\`
+Pass one or more file paths, each with a required \`--name\` (see below). Uploading several files in a single invocation is preferred over running the command repeatedly: it's faster and keeps the output grouped.
+### Name each upload
+\`--name\` is **required** and sets the short, human-readable display name shown in the Replicas dashboard (the backend still tracks the asset by UUID). Make it descriptive of the content, e.g. \`login-page\`, \`checkout-error\`, or \`db-latency-chart\`. Never use a generic value like \`screenshot\` or \`image\`.
+\`\`\`bash
+replicas media upload /tmp/shot.png --name "Login page after fix"
+\`\`\`
+Pass one \`--name\` per file, in the same order as the file paths:
+\`\`\`bash
+replicas media upload /tmp/before.png /tmp/after.png --name "Before fix" --name "After fix"
 \`\`\`
-Pass one or more file paths. Uploading several files in a single invocation is preferred over running the command repeatedly \u2014 it's faster and keeps the output grouped.
+Names are normalized to hyphen-case (spaces become hyphens, e.g. \`Login page\` is stored as \`login-page\`). Give every asset a **distinct** name \u2014 duplicates are not rejected, but Replicas keeps the first as-is and adds a \`-1\`, \`-2\` suffix to later collisions, which produces confusing lists, so pick unique names yourself.
-For each file, the CLI prints two lines:
+For each media file, the CLI prints two lines:
 1. \`![filename](<api-url>)\` \u2014 the chat embed (renders inline in Replicas chat **only** \u2014 see below).
-2. \`View in Replicas: <deep-link>\` \u2014 a per-file dashboard URL of the form \`https://tryreplicas.com/workspaces/<workspace-id>?mode=media&media=<media-id>\` that opens directly to that specific file.
+2. \`View in Replicas: <deep-link>\` \u2014 a per-file dashboard URL of the form \`https://tryreplicas.com/workspaces/<workspace-id>?media=<media-id>\` that opens directly to that specific file.
 Match each "View in Replicas" line to the embed line directly above it \u2014 that's the deep link for that file.
-## The two URLs the CLI gives you \u2014 and where each one is allowed
+HTML uploads print an \`HTML page\` Markdown link instead of an image embed.
+For an HTML page that should stay inside the Replicas organization, create an authenticated link:
+\`\`\`bash
+replicas media upload recap.html --name "Visual recap" --access organization
+\`\`\`
+The printed \`Forge link (organization only)\` opens a dedicated page. Signed-in organization members go straight to it; signed-out members sign in and return to the page.
+Use public access only when the media must render without Replicas authentication:
+\`\`\`bash
+replicas media upload screenshot.png --name "Login page" --access public
+\`\`\`
+\`--share\` remains an alias for \`--access public\`. Public access prints an additional \`Forge embed\` for image, video, or audio media, backed by an opt-in bearer URL. Anyone with that unguessable URL can view the asset until it is rotated or revoked. HTML pages only support organization access. Use \`replicas media share <media-id>\` to rotate a public media URL and \`replicas media revoke <media-id>\` to revoke it.
+## The URLs the CLI gives you \u2014 and where each one is allowed
 | URL | What it is | Where it's allowed |
 |---|---|---|
 | \`https://api.tryreplicas.com/v1/media/<id>\` (inside \`![\u2026](\u2026)\`) | Authenticated API redirect to a presigned blob \u2014 requires the Replicas chat session | **Only** in the Replicas chat reply. Nowhere else. |
-| \`https://tryreplicas.com/workspaces/<workspace-id>?mode=media&media=<media-id>\` | Public dashboard deep link to the media tab, scrolled to that specific file | Everywhere external \u2014 Slack, GitHub, Linear, PR bodies, comments, emails. |
+| \`https://tryreplicas.com/organizations/<organization-id>/media/<media-id>\` | Organization-only page printed by \`--access organization\` | Pull requests and other places where every viewer belongs to the Replicas organization. |
+| \`https://api.tryreplicas.com/v1/media/public/<id>/<token>\` | Opt-in public bearer URL printed by \`--access public\` or \`--share\` | GitHub embeds for image, video, or audio media. |
+| \`https://tryreplicas.com/workspaces/<workspace-id>?media=<media-id>\` | Authenticated dashboard deep link that opens the media file in the workspace | Everywhere external \u2014 Slack, GitHub, Linear, PR bodies, comments, emails. |
 ### NEVER link the API redirect URL outside the Replicas chat reply
@@ -921,38 +804,36 @@ This rule has no exceptions:
 - \u274C Never link to it from any external doc, email, or external chat.
 - \u274C Never include it as a "backup link" in case the dashboard link breaks \u2014 it will always break externally.
-### ALWAYS link the dashboard URL \u2014 never the API URL \u2014 when referencing media externally
+### ALWAYS link a Replicas web URL \u2014 never the authenticated API URL \u2014 when referencing media externally
-When you reference an uploaded file from anywhere outside the Replicas chat reply, the link must be the dashboard form:
+For an organization-only HTML page, use the \`Forge link\` printed by \`--access organization\`. For other authenticated media references, use the dashboard form:
 \`\`\`
-https://tryreplicas.com/workspaces/<workspace-id>?mode=media&media=<media-id>
+https://tryreplicas.com/workspaces/<workspace-id>?media=<media-id>
 \`\`\`
-Both query params are required:
-- \`mode=media\` opens the media tab in the dashboard.
-- \`media=<media-id>\` scrolls to and opens that specific file.
+The \`media=<media-id>\` query param opens that specific file in the workspace.
-Never link \`tryreplicas.com/workspaces/<id>?mode=media\` without the \`media=<id>\` param when you have a specific file in mind \u2014 that lands on the gallery, not the file. Never link the bare workspace URL.
+When you have a specific file in mind, never link the bare workspace URL without the \`media=<id>\` param.
 Always render as a markdown / mrkdwn hyperlink labeled **View in Replicas** \u2014 never paste a raw URL.
 ## In your Replicas chat reply
-Include each markdown embed line **verbatim** where you want that file to render inline. The chat substitutes each one with an embedded image, video, or audio player. Multiple embeds can appear in a single reply.
+Include each markdown embed line **verbatim** where you want that file to render inline. The chat substitutes each one with an embedded image, video, or audio player. For HTML, use the \`HTML page\` or \`View in Replicas\` link instead. Multiple embeds can appear in a single reply.
-After (or alongside) the embeds, include a \`[View in Replicas](<deep-link>)\` hyperlink for each file using the per-file dashboard URL from the CLI. This lets the user jump to the specific item in the media tab.
+After (or alongside) the embeds, include a \`[View in Replicas](<deep-link>)\` hyperlink for each file using the per-file dashboard URL from the CLI. This lets the user open the specific item in the workspace.
 ## On external platforms \u2014 upload natively AND link the dashboard
 Sharing media externally is a **two-step requirement** for every file:
 1. **Upload the raw bytes natively to that platform** so the recipient sees the media embedded inline in the message itself.
-2. **Link the Replicas dashboard deep link** (\`?mode=media&media=<id>\` form) so the user can jump straight to the workspace.
+2. **Link the Replicas dashboard deep link** (\`?media=<id>\` form) so the user can jump straight to the file in the workspace.
 A link alone is not enough. A native upload alone is not enough. Do both.
-The one exception is GitHub, which has no public image upload API \u2014 there, the dashboard link is the only option (see below).
+GitHub has no native upload API, so use an explicit Replicas public share for screenshots and recording previews. GitLab has a native upload API and should receive the original bytes.
 ### Slack \u2014 embed natively via the 3-step external file upload flow
@@ -967,7 +848,7 @@ LENGTH=$(stat -c%s "$FILE" 2>/dev/null || stat -f%z "$FILE")
 # 1. Reserve an upload URL + file ID.
 RESERVE=$(curl -s -G "https://slack.com/api/files.getUploadURLExternal" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \\
+  -H "Authorization: Bearer \${REPLICAS_SLACK_BOT_TOKEN:-$SLACK_BOT_TOKEN}" \\
   --data-urlencode "filename=$FILENAME" \\
   --data-urlencode "length=$LENGTH")
 UPLOAD_URL=$(echo "$RESERVE" | jq -r '.upload_url')
@@ -982,13 +863,13 @@ curl -s -X POST "$UPLOAD_URL" \\
 # 3. Complete the upload, sharing it into the channel/thread with the dashboard link.
 curl -s -X POST "https://slack.com/api/files.completeUploadExternal" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \\
+  -H "Authorization: Bearer \${REPLICAS_SLACK_BOT_TOKEN:-$SLACK_BOT_TOKEN}" \\
   -H "Content-Type: application/json; charset=utf-8" \\
   -d "{
     \\"files\\": [{\\"id\\": \\"$FILE_ID\\", \\"title\\": \\"Screenshot\\"}],
     \\"channel_id\\": \\"CHANNEL_ID\\",
     \\"thread_ts\\": \\"THREAD_TS\\",
-    \\"initial_comment\\": \\"<https://tryreplicas.com/workspaces/<workspace-id>?mode=media&media=<media-id>|View in Replicas>\\"
+    \\"initial_comment\\": \\"<https://tryreplicas.com/workspaces/<workspace-id>?media=<media-id>|View in Replicas>\\"
   }"
 \`\`\`
@@ -1016,9 +897,9 @@ ISSUE_UUID=...           # the Linear issue's UUID
 MEDIA_ID=...             # the media ID printed by \`replicas media upload\`
 linear_graphql() {
-  curl -sS -X POST "$MONOLITH_URL/v1/engine/linear/graphql" \\
+  curl -sS -X POST "$REPLICAS_MONOLITH_URL/v1/engine/linear/graphql" \\
     -H "Authorization: Bearer $REPLICAS_ENGINE_SECRET" \\
-    -H "X-Workspace-Id: $WORKSPACE_ID" \\
+    -H "X-Workspace-Id: $REPLICAS_WORKSPACE_ID" \\
     -H "Content-Type: application/json" \\
     --data-binary @-
 }
@@ -1048,8 +929,8 @@ curl -s -X PUT "$UPLOAD_URL" \\
   --data-binary @"$FILE"
 # 3. Reference assetUrl inline in the comment body, alongside the dashboard link.
-BODY=$(printf '![screenshot](%s)\\n\\n[View in Replicas](https://tryreplicas.com/workspaces/%s?mode=media&media=%s)' \\
-  "$ASSET_URL" "$WORKSPACE_ID" "$MEDIA_ID")
+BODY=$(printf '![screenshot](%s)\\n\\n[View in Replicas](https://tryreplicas.com/workspaces/%s?media=%s)' \\
+  "$ASSET_URL" "$REPLICAS_WORKSPACE_ID" "$MEDIA_ID")
 jq -n \\
     --arg issueId "$ISSUE_UUID" \\
@@ -1064,20 +945,36 @@ The same flow works for issue bodies (use \`issueCreate\` / \`issueUpdate\` with
 Never paste the \`api.tryreplicas.com/v1/media/<id>\` URL into a Linear body or comment \u2014 it will render as a broken image to anyone outside your Replicas chat.
-### GitHub \u2014 link the dashboard deep link (no public upload API exists)
+### GitHub: inline screenshots and recording previews
+GitHub has **no public API** for uploading attachments to PRs or issues. Its web UI uses an undocumented internal endpoint that API clients must not emulate. For screenshots, explicitly create a forge share and put the printed \`Forge embed\` Markdown directly in the PR body or comment, followed by the dashboard link:
+\`\`\`bash
+replicas media upload /tmp/screenshot.png --name "PR screenshot" --share
+\`\`\`
+GitHub does not reliably render arbitrary external videos as inline players. For a recording:
-GitHub has **no public API** for uploading images to PRs or issues. Their web UI uses an undocumented internal endpoint that's not available to API clients. So for GitHub specifically, the only correct way to share media is the dashboard deep link, rendered as a markdown hyperlink:
+1. Upload the MP4 normally so it remains available in Replicas.
+2. Generate a poster image from the recording: \`ffmpeg -i /tmp/demo.mp4 -frames:v 1 /tmp/demo-poster.png\`.
+3. Upload the poster with \`--share\`.
+4. Wrap the poster embed in a link to the recording's **View in Replicas** URL.
 \`\`\`markdown
-[View in Replicas](https://tryreplicas.com/workspaces/<workspace-id>?mode=media&media=<media-id>)
+[![Demo recording](<public-poster-url>)](<recording-dashboard-url>)
 \`\`\`
-Do **not**:
-- Commit screenshots as files to the repo as a workaround.
-- Use placeholder image URLs.
-- Embed the \`api.tryreplicas.com/v1/media/<id>\` URL in markdown \u2014 it renders as a broken image for every viewer.
+Public forge shares are bearer capabilities. For private repositories, create one only when the user asked for inline PR media. Revoke with \`replicas media revoke <media-id>\` **only** when the user asks or the media should intentionally stop rendering \u2014 never as routine post-task cleanup, since revoking breaks every embed already posted on the PR.
-This applies to PR descriptions, PR review comments, issue bodies, issue comments, and commit messages.
+For a self-contained HTML report, upload it with \`--access organization\` and put the printed \`Forge link\` Markdown in the PR body or comment. GitHub cannot render the page inline, so use the normal link rather than image syntax. HTML pages cannot be shared publicly.
+Do **not** commit screenshots to the repo, use placeholder URLs, expose the authenticated \`/v1/media/<id>\` URL, or automate GitHub's undocumented browser upload flow.
+### GitLab: native inline screenshots and videos
+GitLab supports native project Markdown uploads. Always upload the media to Replicas first, then POST the same original file to the repository's \`/projects/:id/uploads\` API using the workspace GitLab credential. Insert the returned \`markdown\` value into the merge request body or comment and include the Replicas dashboard link. Image uploads render inline; MP4, MOV, and WebM uploads render as inline video players.
+Do not use a Replicas public forge share for GitLab when the native project upload succeeds; native uploads preserve project access controls.
 ## Recording defaults
@@ -1105,23 +1002,27 @@ Auto-detected from the filename extension:
 | \`png\`, \`jpg\`, \`jpeg\`, \`webp\` | image |
 | \`mp4\`, \`webm\` | video |
 | \`mp3\`, \`wav\` | audio |
+| \`html\`, \`htm\` | html |
-For other extensions, pass \`--kind image|video|audio\` explicitly. The kind applies to every file in that invocation, so group files of the same kind together:
+For other extensions, pass \`--kind image|video|audio|html\` explicitly. The kind applies to every file in that invocation, so group files of the same kind together:
 \`\`\`bash
-replicas media upload diagram.svg --kind image
-replicas media upload chart-a.svg chart-b.svg --kind image
+replicas media upload diagram.svg --name "Architecture diagram" --kind image
+replicas media upload chart-a.svg chart-b.svg --name "Latency chart" --name "Error rate chart" --kind image
 \`\`\`
 ## Options
-- \`--kind <image|video|audio>\` \u2014 override auto-detection
+- \`--kind <image|video|audio|html>\` \u2014 override auto-detection
+- \`--name <name>\`: required display name shown in the dashboard, one per file in order
 - \`--session-id <id>\` \u2014 associate the upload with a specific session
+- \`--access organization|public\`: create an organization-only link, or a public bearer URL for non-HTML media
+- \`--share\`: alias for \`--access public\`; not supported for HTML
 `;
 var MEDIA_ABILITY = {
   label: "Media",
-  description: "Share screenshots, recordings, generated images, and audio clips.",
-  bullet: "- Producing or showing the user any media \u2014 screenshots, screen recordings, generated images or diagrams, audio clips \u2014 including in your Replicas chat reply, PR descriptions/comments, and other external platforms",
+  description: "Share screenshots, recordings, generated images, audio clips, and HTML pages.",
+  bullet: "- Producing or showing the user any media \u2014 screenshots, screen recordings, generated images or diagrams, audio clips, or HTML recap pages \u2014 including in your Replicas chat reply, PR descriptions/comments, and other external platforms",
   section: SECTION7,
   referenceFile: { name: "MEDIA.md", content: REFERENCE7 }
 };
@@ -1142,24 +1043,18 @@ When you run services on ports \u2014 such as a web app, API server, or database
 ## Running Services for Preview
-Services must run as detached background processes so they survive after your command session ends. Do not leave them attached to a foreground terminal.
+Always start services with \`replicas service start\` (see \`REPLICAS.md\`, "Long-running services"). It daemonizes the process so it survives your turn ending and workspace sleep/wake \u2014 a service left attached to your shell or backgrounded with \`&\`/\`nohup\` dies when the workspace sleeps, leaving the preview broken for the user.
-Some potential methods:
 \`\`\`bash
-# Start a detached service with logging
-setsid -f bash -lc 'cd /path/to/app && exec yarn dev >> /tmp/app.log 2>&1'
-# For daemons like Docker
-nohup dockerd > /tmp/dockerd.log 2>&1 &
+replicas service start web "yarn dev" --cwd /path/to/app
 \`\`\`
 After starting a service:
-1. Verify the process is running: \`pgrep -af 'yarn dev'\`
-2. Check logs for readiness: \`tail -f /tmp/app.log\`
-3. Confirm it's actually serving: \`curl -s http://localhost:3000\` (or appropriate health check)
-4. Only create the preview after the service is healthy
+1. Check logs for readiness: \`replicas service logs web\`
+2. Confirm it's actually serving: \`curl -s http://localhost:3000\` (or appropriate health check)
+3. Only create the preview after the service is healthy
-If a prior detached process exists on the same port, stop it before restarting.
+\`replicas service start\` on the same name restarts the service, so you never need to hunt down stale processes on the port.
 ## Creating Previews
@@ -1222,26 +1117,100 @@ var PREVIEWS_ABILITY = {
   referenceFile: { name: "PREVIEWS.md", content: REFERENCE8 }
 };
-// ../shared/src/default-skills/replicas-agent/abilities/replicas.ts
-var SECTION9 = `### Replicas (in-workspace CLI)
-Take action *with* Replicas itself \u2014 manage automations, environments (variables, files), repos, and \`replicas.json\` config \u2014 using the pre-installed, pre-authenticated \`replicas\` CLI.
+// ../shared/src/default-skills/replicas-agent/abilities/plugins.ts
+var SECTION9 = `### Plugins
+Discover and execute installed marketplace tools through the workspace-scoped TypeScript SDK.
-**Reference:** \`references/REPLICAS.md\`
+**Reference:** \`references/PLUGINS.md\`
 Use this when:
-- The user asks you to create, edit, run, or delete an automation
-- The user asks you to manage environments, environment variables, or environment files
-- The user asks "what envs / repos / automations do I have?"
-- The user asks you to scaffold a \`replicas.json\` / \`replicas.yaml\` in a repo`;
-var REFERENCE9 = `# Replicas (in-workspace CLI)
+- The user asks for CRM data from Attio
+- The user asks to manage Calendly events, invitees, or scheduling links
+- The user asks to read or change Google Ads, Docs, Drive, Search Console, or Sheets data
+- The user asks for ClickHouse analytics or PostHog product data
+- The user asks for Stripe customers, payments, invoices, subscriptions, or balances`;
+var REFERENCE9 = `# Plugins
-This guide covers how to take action *with* Replicas itself from inside a Replicas workspace \u2014 managing automations, environments (and their variables/files), repos, previews, and the user's \`replicas.json\` config \u2014 using the pre-installed \`replicas\` CLI.
+Plugins are TypeScript libraries, not MCP servers. Import \`@replicas/sdk\`; Replicas authenticates the workspace and selects only the owner\u2019s personal connection or the organization fallback. Composio credentials, sessions, and project keys are never exposed.
-When the user asks _about_ Replicas (concepts, pricing, how a feature works), check https://docs.replicas.dev first. When the user asks you to _do_ something in their Replicas org, this is the file to use.
+Plugin tools may read or write provider data according to the connected account's permissions. Only execute write or destructive tools when they match the user's request.
-## Prerequisites
+## Discover installed plugins
-The CLI is pre-installed in every workspace and pre-authenticated using the workspace's engine secret. You do **not** need to log in or set an API key. Verify:
+\`\`\`ts
+import { replicas } from '@replicas/sdk';
+const plugins = await replicas.plugins.list();
+const installed = plugins.filter((plugin) => plugin.connected);
+\`\`\`
+If a plugin is not connected, ask the user to install it under personal or organization Integrations in the Replicas dashboard.
+## Search, inspect, execute
+\`\`\`ts
+const search = await replicas.plugins.search({
+  plugin: 'stripe',
+  query: 'list recent successful payments with customer details',
+});
+const [tool] = search.tools;
+if (!tool) throw new Error('No matching tool found');
+const { data } = await replicas.plugins.execute({
+  plugin: 'stripe',
+  tool: tool.slug,
+  arguments: { limit: 25 },
+});
+\`\`\`
+Use \`replicas.plugins.describe({ plugin, tools: [slug] })\` when search returned a partial schema or before constructing unfamiliar arguments.
+## Batch work
+Keep dependent operations in one TypeScript file and batch independent calls:
+\`\`\`ts
+const results = await Promise.all(customerIds.map((customer) =>
+  replicas.plugins.execute({
+    plugin: 'stripe',
+    tool: 'STRIPE_RETRIEVE_CUSTOMER',
+    arguments: { customer },
+  }),
+));
+\`\`\`
+Never attempt to import Composio, create a session, manage a connection, or call a provider with raw credentials. Those operations are intentionally unavailable inside the workspace.
+`;
+var PLUGINS_ABILITY = {
+  label: "Plugins",
+  description: "Use installed marketplace tools through @replicas/sdk.",
+  bullet: "- Interacting with installed marketplace plugins through TypeScript",
+  section: SECTION9,
+  referenceFile: { name: "PLUGINS.md", content: REFERENCE9 }
+};
+// ../shared/src/default-skills/replicas-agent/abilities/replicas.ts
+var SECTION10 = `### Replicas (in-workspace CLI)
+Take action *with* Replicas itself \u2014 manage automations, environments (variables, files), repos, and \`replicas.json\` config \u2014 using the pre-installed, pre-authenticated \`replicas\` CLI.
+**Reference:** \`references/REPLICAS.md\`
+Use this when:
+- The user asks you to create, edit, run, or delete an automation
+- The user asks you to manage environments, environment variables, or environment files
+- The user asks "what envs / repos / automations do I have?"
+- The user asks you to scaffold a \`replicas.json\` / \`replicas.yaml\` in a repo
+- You need to run a long-lived service (dev server, daemon) \u2014 always use \`replicas service start\` so it survives workspace sleep/wake`;
+var REFERENCE10 = `# Replicas (in-workspace CLI)
+This guide covers how to take action *with* Replicas itself from inside a Replicas workspace \u2014 managing automations, environments (and their variables/files), repos, previews, and the user's \`replicas.json\` config \u2014 using the pre-installed \`replicas\` CLI.
+When the user asks _about_ Replicas (concepts, pricing, how a feature works), check https://docs.replicas.dev first. When the user asks you to _do_ something in their Replicas org, this is the file to use.
+## Prerequisites
+The CLI is pre-installed in every workspace and pre-authenticated using the workspace's engine secret. You do **not** need to log in or set an API key. Verify:
 \`\`\`bash
 replicas whoami
@@ -1268,7 +1237,9 @@ In agent mode the CLI hides commands that don't make sense for in-workspace agen
 | \`replicas environment ...\` | Manage environments, env vars, env files |
 | \`replicas automation ...\` | Manage automations (cron + GitHub/GitLab event triggers) |
 | \`replicas preview ...\` | Register / list preview URLs (covered in \`PREVIEWS.md\`) |
+| \`replicas service ...\` | Run long-lived services detached so they survive workspace sleep/wake (see below) |
 | \`replicas media ...\` | Upload screenshots, videos, audio (covered in \`MEDIA.md\`) |
+| \`replicas slack thread ...\` | Attach or switch Slack thread routing (covered in \`SLACK.md\`) |
 \`replicas <command> --help\` is always the source of truth for flags.
@@ -1285,6 +1256,7 @@ In agent mode the CLI hides commands that don't make sense for in-workspace agen
 | "Make an automation that runs every weekday at 9am" | \`replicas automation create\` (interactive) or \`--trigger-cron "0 9 * * 1-5"\` |
 | "Make an automation that runs when a PR opens on \`acme/web\`" | \`replicas automation create ... --trigger-github pull_request.opened --trigger-github-repos acme/web\` |
 | "Make an automation that runs when an MR opens on \`acme/web\`" | \`replicas automation create ... --trigger-gitlab merge_request.opened --trigger-gitlab-repos acme/web\` |
+| "Ignore Dependabot for this PR automation" | \`replicas automation edit <id> --trigger-github-exclude-users 'dependabot[bot]'\` |
 | "What repos are connected?" | \`replicas repos\` |
 | "Set up a \`replicas.json\` in this repo" | \`replicas init\` (\`-y\` for YAML) |
@@ -1371,21 +1343,23 @@ replicas automation create "Review my PRs" \\
   --prompt "Leave a code review on this PR" \\
   --environment <env-name-or-id> \\
   --trigger-github pull_request.opened \\
-  --trigger-github-repos acme/web,acme/api
+  --trigger-github-repos acme/web,acme/api \\
+  --trigger-github-exclude-users 'dependabot[bot],renovate[bot]'
 replicas automation create "Review my MRs" \\
   --prompt "Leave a code review on this MR" \\
   --environment <env-name-or-id> \\
   --trigger-gitlab merge_request.opened \\
-  --trigger-gitlab-repos acme/web,acme/api
+  --trigger-gitlab-repos acme/web,acme/api \\
+  --trigger-gitlab-exclude-users 'bot-user'
 # Disable on creation
 replicas automation create ... --disabled
 # Workspace lifecycle
-replicas automation create ... --lifecycle delete_when_done
+replicas automation create ... --lifecycle archive_when_done
 replicas automation create ... --lifecycle sleep_when_done
-replicas automation create ... --lifecycle delete_after_inactivity --auto-stop-minutes 30
+replicas automation create ... --lifecycle default --auto-stop-minutes 30
 \`\`\`
 When the user says "make me an automation that...", default to **picking the environment for them by listing the available envs** and asking only when the user hasn't already pinned one. Same for repos in GitHub triggers. Don't pepper the user with questions you can answer by reading the existing config.
@@ -1401,8 +1375,28 @@ replicas automation edit <id> \\
   --trigger-cron "0 4 * * *"   # replaces existing triggers
 \`\`\`
+\`replicas automation edit <id> --trigger-github-exclude-users "dependabot[bot],renovate[bot]"\` updates existing GitHub triggers without replacing the rest of the trigger list. The GitLab equivalent is \`--trigger-gitlab-exclude-users\`. Passing an empty string (for example, \`--trigger-github-exclude-users ""\`) clears existing exclusions for that code host. Passing \`--trigger-github\` or \`--trigger-gitlab\` still replaces triggers, and the matching exclude flag is applied to the replacement trigger.
 \`replicas automation edit <id>\` with no flags drops into interactive mode.
+## Long-running services
+**Always use \`replicas service start\` to run anything that should keep running after your current command or turn ends** \u2014 dev servers, backend APIs, databases, daemons, watchers. Never leave them attached to your shell, and never rely on plain \`&\`, \`nohup\`, or your own backgrounding: processes started inside your session are torn down when your turn ends and the workspace goes to sleep, so the user finds them dead after waking the workspace. \`replicas service start\` daemonizes the process into its own session, which survives workspace sleep/wake.
+\`\`\`bash
+replicas service start <name> "<command>"        # start (or restart) a named service
+replicas service start web "bun run dev" --cwd ~/workspaces/app
+replicas service list                            # names, pids, running/stopped
+replicas service logs <name> [-n 100]            # tail the service log
+replicas service stop <name>                     # stop the whole process group
+\`\`\`
+Notes:
+- Quote the command if it contains shell operators: \`replicas service start web "cd app && bun dev"\`.
+- \`start\` on an existing name restarts it (the old process group is stopped first). It fails fast and prints the log tail if the service dies within the first second.
+- Logs stream to \`~/.replicas/services/<name>.log\`.
+- After starting, verify the service is actually healthy (check \`logs\`, then \`curl\` its port) before telling the user it's up or creating a preview for it.
 ## Repositories
 Read-only listing of repos connected to the org. Use when the user asks "what repos can I use?", or to validate a \`--repository\` value before passing it to \`environment create\` / \`automation create\`:
@@ -1435,125 +1429,128 @@ var REPLICAS_ABILITY = {
   description: "Teach the agent about Replicas itself \u2014 automations, environments, the in-workspace CLI.",
   // No bullet — help_instructions covers the `replicas` CLI surface in detail.
   bullet: "",
-  section: SECTION9,
-  referenceFile: { name: "REPLICAS.md", content: REFERENCE9 },
+  section: SECTION10,
+  referenceFile: { name: "REPLICAS.md", content: REFERENCE10 },
   locked: true
 };
-// ../shared/src/default-skills/replicas-agent/abilities/slack.ts
-var SECTION10 = `### Slack
-Send messages, read threads, search conversations, and upload files via the Slack Web API.
+// ../shared/src/default-skills/replicas-agent/abilities/sentry.ts
+var SECTION11 = `### Sentry
+Read issues and project data through the workspace-scoped TypeScript SDK.
-**Reference:** \`references/SLACK.md\`
+**Reference:** \`references/SENTRY.md\`
 Use this when:
-- You need to send a message to a Slack channel or thread
-- You need to read or fetch a Slack conversation
-- You encounter a Slack message link and need to retrieve its content
-- The task asks you to notify, update, or communicate via Slack`;
-var REFERENCE10 = `# Slack Integration
+- You need to inspect Sentry projects or issues
+- A user asks for error-monitoring context outside a webhook-triggered task`;
+var REFERENCE11 = `# Sentry Integration
-This guide covers how to interact with Slack from within your Replicas workspace.
+Use \`@replicas/sdk\`; never request or read a Sentry token. Sentry access is organization-scoped and read-only.
-## Prerequisites
+\`\`\`ts
+import { replicas } from '@replicas/sdk';
-Check if the \`SLACK_BOT_TOKEN\` environment variable is set:
+const { native } = await replicas.integrations.list();
+if (!native.sentry) throw new Error('Connect Sentry in Replicas organization integrations first.');
-\`\`\`bash
-echo "\${SLACK_BOT_TOKEN:+set}"
+const issues = await replicas.sentry.request('/organizations/acme/issues/?query=is:unresolved');
 \`\`\`
-- If **set**: Your workspace has Slack access. You can use the Slack Web API as described below.
-- If **not set**: Slack has not been configured for this workspace. The user needs to connect Slack in the [Replicas dashboard](https://replicas.dev) under their organization's integration settings. Let the user know and do not attempt Slack operations.
-## Using the Slack API
+Pass only a relative Sentry API path. The Replicas gateway selects the connected organization credential and rejects writes, absolute URLs, oversized responses, and long-running requests.
+`;
+var SENTRY_ABILITY = {
+  label: "Sentry",
+  description: "Read Sentry projects and issues through @replicas/sdk.",
+  bullet: "- Interacting with Sentry (reading projects, issues, and error context)",
+  section: SECTION11,
+  referenceFile: { name: "SENTRY.md", content: REFERENCE11 }
+};
-All requests use the \`$SLACK_BOT_TOKEN\` for authentication via the Slack Web API.
+// ../shared/src/default-skills/replicas-agent/abilities/slack.ts
+var SECTION12 = `### Slack
+Send messages, read threads, search conversations, and upload files through the workspace-scoped TypeScript SDK.
-### Fetching a Thread from a Slack Link
+**Reference:** \`references/SLACK.md\`
-If you encounter a Slack message link (e.g. \`https://team.slack.com/archives/C0123ABC/p1234567890123456\`), extract the channel ID and thread timestamp:
+Use this when:
+- You need to send a message to a Slack channel or thread
+- You need to read or search Slack conversations
+- You encounter a Slack message link and need its full thread`;
+var REFERENCE12 = `# Slack Integration
-- **Channel ID**: The segment after \`/archives/\` (e.g. \`C0123ABC\`)
-- **Thread TS**: The \`p\` value with a dot inserted before the last 6 digits (e.g. \`p1234567890123456\` -> \`1234567890.123456\`)
+Use \`@replicas/sdk\`; never read or send a Slack token directly. The SDK calls Replicas, which selects only this workspace's organization connection.
-\`\`\`bash
-curl -s "https://slack.com/api/conversations.replies?channel=CHANNEL_ID&ts=THREAD_TS" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN"
-\`\`\`
+## Check access
-### Sending a Message
+\`\`\`ts
+import { replicas } from '@replicas/sdk';
-\`\`\`bash
-curl -s -X POST "https://slack.com/api/chat.postMessage" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \\
-  -H "Content-Type: application/json" \\
-  -d '{
-    "channel": "CHANNEL_ID",
-    "text": "Your message here",
-    "thread_ts": "OPTIONAL_THREAD_TS"
-  }'
+const { native } = await replicas.integrations.list();
+if (!native.slack) throw new Error('Connect Slack in Replicas organization integrations first.');
 \`\`\`
-Omit \`thread_ts\` to post a new message to the channel. Include it to reply in a thread.
+## Read a thread
-### Searching Messages
+For a link such as \`https://team.slack.com/archives/C0123ABC/p1234567890123456\`, the channel is \`C0123ABC\` and the timestamp is \`1234567890.123456\`.
-\`\`\`bash
-curl -s "https://slack.com/api/search.messages?query=YOUR_SEARCH_QUERY" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN"
+\`\`\`ts
+const thread = await replicas.slack.call('conversations.replies', {
+  channel: 'C0123ABC',
+  ts: '1234567890.123456',
+  limit: 200,
+});
 \`\`\`
-### Uploading Files
+## Send and attach a message
-Slack deprecated \`files.upload\`; the raw HTTP replacement is a 3-step flow. (\`files.uploadV2\` is **only** an SDK convenience wrapper and is NOT a real Web API HTTP endpoint \u2014 \`POST https://slack.com/api/files.uploadV2\` returns \`unknown_method\`.)
-\`\`\`bash
-FILE=/path/to/file
-FILENAME=$(basename "$FILE")
-LENGTH=$(stat -c%s "$FILE" 2>/dev/null || stat -f%z "$FILE")
+\`\`\`ts
+const message = await replicas.slack.call<{ channel: string; ts: string }>('chat.postMessage', {
+  channel: 'C0123ABC',
+  text: 'Update from Replicas',
+});
+await replicas.slack.attachThread({ channel: message.channel, threadTs: message.ts });
+\`\`\`
-# 1. Reserve an upload URL + file ID.
-RESERVE=$(curl -s -G "https://slack.com/api/files.getUploadURLExternal" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \\
-  --data-urlencode "filename=$FILENAME" \\
-  --data-urlencode "length=$LENGTH")
-UPLOAD_URL=$(echo "$RESERVE" | jq -r '.upload_url')
-FILE_ID=$(echo "$RESERVE" | jq -r '.file_id')
+A link in the message text stays plain text, so when the message carries a pull request or merge request link, pass \`blocks\` alongside \`text\` to render a button for it. Keep \`text\` set to the same message \u2014 Slack uses it for notifications and fallback.
-# 2. POST the raw bytes to the reserved URL.
-#    Do not use -F / multipart here \u2014 the presigned URL expects the bytes
-#    directly in the request body.
-curl -s -X POST "$UPLOAD_URL" \\
-  -H "Content-Type: application/octet-stream" \\
-  --data-binary @"$FILE"
-# 3. Complete the upload and share into a channel (and optionally a thread).
-curl -s -X POST "https://slack.com/api/files.completeUploadExternal" \\
-  -H "Authorization: Bearer $SLACK_BOT_TOKEN" \\
-  -H "Content-Type: application/json; charset=utf-8" \\
-  -d "{
-    \\"files\\": [{\\"id\\": \\"$FILE_ID\\", \\"title\\": \\"File title\\"}],
-    \\"channel_id\\": \\"CHANNEL_ID\\",
-    \\"thread_ts\\": \\"OPTIONAL_THREAD_TS\\",
-    \\"initial_comment\\": \\"Optional message body\\"
-  }"
+\`\`\`ts
+await replicas.slack.call('chat.postMessage', {
+  channel: 'C0123ABC',
+  thread_ts: '1234567890.123456',
+  text: summary,
+  blocks: [
+    { type: 'section', text: { type: 'mrkdwn', text: summary } },
+    {
+      type: 'actions',
+      elements: [
+        { type: 'button', text: { type: 'plain_text', text: 'View PR' }, url: prUrl, action_id: 'view_pr' },
+      ],
+    },
+  ],
+});
 \`\`\`
-Omit \`thread_ts\` and/or \`initial_comment\` if you don't need them.
+Use "View MR" for GitLab. With several links, give each button a unique \`action_id\` and name its repository in the label ("View PR \xB7 web").
+Attach every new top-level conversation so future replies route to this workspace. For a reply in another thread, attach its root \`thread_ts\`, not the reply timestamp. Do not attach the originating thread again.
-### Other Operations
+## Search and batch
-You can list channels, read channel history, add reactions, and perform any other operation supported by the Slack Web API using the same authentication pattern.
+\`\`\`ts
+const [messages, users] = await Promise.all([
+  replicas.slack.call('search.messages', { query: 'launch status' }),
+  replicas.slack.call('users.list', { limit: 200 }),
+]);
+\`\`\`
-For full API documentation, see: https://docs.slack.dev/apis/web-api/
+Supported methods cover conversations, messages, search, users, reactions, and Slack's external file-upload flow. An unsupported method is rejected by Replicas before Slack is called.
 `;
 var SLACK_ABILITY = {
   label: "Slack",
-  description: "Send messages, read threads, search conversations, upload files.",
+  description: "Send messages, read threads, and search through @replicas/sdk.",
   bullet: "- Interacting with Slack (sending messages, reading threads, etc.)",
-  section: SECTION10,
-  referenceFile: { name: "SLACK.md", content: REFERENCE10 }
+  section: SECTION12,
+  referenceFile: { name: "SLACK.md", content: REFERENCE12 }
 };
 // ../shared/src/default-skills/replicas-agent/registry.ts
@@ -1563,10 +1560,12 @@ var REPLICAS_AGENT_ABILITY_REGISTRY = {
   docker: DOCKER_ABILITY,
   github: GITHUB_ABILITY,
   gitlab: GITLAB_ABILITY,
-  google: GOOGLE_ABILITY,
+  learnings: LEARNINGS_ABILITY,
   linear: LINEAR_ABILITY,
   media: MEDIA_ABILITY,
+  plugins: PLUGINS_ABILITY,
   previews: PREVIEWS_ABILITY,
+  sentry: SENTRY_ABILITY,
   slack: SLACK_ABILITY
 };
 var REPLICAS_AGENT_ABILITIES = Object.keys(
@@ -1574,36 +1573,306 @@ var REPLICAS_AGENT_ABILITIES = Object.keys(
 );
 // ../shared/src/routes/preferences.ts
-var DEFAULT_REPLICAS_AGENT_ABILITIES = Object.fromEntries(
-  REPLICAS_AGENT_ABILITIES.map((key) => [key, true])
-);
+var EMPTY_AGENT_DEFAULT_SETTINGS = {
+  agent_provider: null,
+  model: null,
+  thinking_level: null,
+  goal_mode: null,
+  fast_mode: null
+};
+var DEFAULT_RELAY_SUBAGENT_PROVIDERS = [...VALID_RELAY_SUBAGENT_PROVIDERS];
+var DEFAULT_USER_PREFERENCES = {
+  default_agent: "codex",
+  default_model: null,
+  claude_models: null,
+  codex_models: null,
+  cursor_models: null,
+  openrouter_models: null,
+  relay_models: null,
+  close_workspace_on_pr_close: true,
+  close_workspace_on_pr_merge: true,
+  default_environment_id: null,
+  respond_to_ci_workflows: true,
+  respond_to_ci_checks: true,
+  respond_to_human_pr_reviews: false,
+  pr_user_attribution: false,
+  auto_draft_prs: false,
+  open_prs_in_graphite: false,
+  open_links_in_desktop_app: false,
+  default_fast_mode: false,
+  agent_defaults: { ...EMPTY_AGENT_DEFAULT_SETTINGS },
+  credential_priority: null
+};
+function defaultReplicasAgentAbilities() {
+  const abilities = {};
+  for (const key of REPLICAS_AGENT_ABILITIES) {
+    abilities[key] = true;
+  }
+  if (hasAllReplicasAgentAbilities(abilities)) return abilities;
+  throw new Error("Default Replicas agent ability flags are incomplete");
+}
+function hasAllReplicasAgentAbilities(abilities) {
+  return REPLICAS_AGENT_ABILITIES.every((key) => typeof abilities[key] === "boolean");
+}
 var DEFAULT_DEFAULT_SKILLS = {
   replicas_agent: {
     enabled: true,
-    abilities: { ...DEFAULT_REPLICAS_AGENT_ABILITIES }
+    abilities: defaultReplicasAgentAbilities()
   }
 };
-// ../shared/src/event.ts
-var CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE = "claude-partial-message";
-function coerceClaudePartialMessagePayload(payload) {
-  const streamId = payload.streamId;
-  if (typeof streamId !== "string" || !streamId) return null;
-  const parentToolUseId = payload.parent_tool_use_id;
-  const text = typeof payload.text === "string" && payload.text ? payload.text : void 0;
-  const thinking = typeof payload.thinking === "string" && payload.thinking ? payload.thinking : void 0;
-  if (!text && !thinking) return null;
+// ../shared/src/aster.ts
+var ASTER_MODELS = [
+  "kimi-k3",
+  "glm-5.2",
+  "gpt-oss-120b-fast",
+  "gpt-oss-120b"
+];
+var DEFAULT_ASTER_MODEL = ASTER_MODELS[0];
+var ASTER_MODEL_LABELS = {
+  "kimi-k3": "Kimi K3",
+  "glm-5.2": "GLM 5.2",
+  "gpt-oss-120b-fast": "GPT-OSS 120B Fast",
+  "gpt-oss-120b": "GPT-OSS 120B"
+};
+// ../shared/src/engine/types.ts
+var CLAUDE_OPUS_1M_MODEL = "opus[1m]";
+var LEGACY_CLAUDE_OPUS_1M_MODEL = "opus-1m";
+var CLAUDE_FABLE_5_MODEL = "claude-fable-5";
+var CLAUDE_OPUS_5_MODEL = "claude-opus-5";
+var CLAUDE_OPUS_4_8_MODEL = "claude-opus-4-8";
+var CLAUDE_SONNET_5_MODEL = "claude-sonnet-5";
+var CLAUDE_HAIKU_4_5_MODEL = "claude-haiku-4-5";
+var CLAUDE_FABLE_5_BEDROCK_MODEL = "anthropic.claude-fable-5";
+var CLAUDE_OPUS_5_BEDROCK_MODEL = "anthropic.claude-opus-5";
+var CLAUDE_OPUS_4_8_BEDROCK_MODEL = "us.anthropic.claude-opus-4-8";
+var CLAUDE_SONNET_5_BEDROCK_MODEL = "anthropic.claude-sonnet-5";
+var CLAUDE_HAIKU_4_5_BEDROCK_MODEL = "us.anthropic.claude-haiku-4-5-20251001-v1:0";
+var GPT_5_6_SOL_MODEL = "gpt-5.6-sol";
+var GPT_5_6_TERRA_MODEL = "gpt-5.6-terra";
+var GPT_5_6_LUNA_MODEL = "gpt-5.6-luna";
+var DEFAULT_CODEX_MODEL = GPT_5_6_SOL_MODEL;
+var DEFAULT_OPENCODE_MODEL = "z-ai/glm-5.2";
+var OPENROUTER_MODELS = [
+  DEFAULT_OPENCODE_MODEL,
+  "minimax/minimax-m3",
+  "xiaomi/mimo-v2.5-pro",
+  "moonshotai/kimi-k2.6"
+];
+var CLAUDE_MODEL_CONTEXT_WINDOWS = {
+  [CLAUDE_FABLE_5_MODEL]: 1e6,
+  [CLAUDE_OPUS_5_MODEL]: 1e6,
+  [CLAUDE_OPUS_4_8_MODEL]: 1e6,
+  [CLAUDE_SONNET_5_MODEL]: 1e6,
+  [CLAUDE_HAIKU_4_5_MODEL]: 2e5,
+  [CLAUDE_FABLE_5_BEDROCK_MODEL]: 1e6,
+  [CLAUDE_OPUS_5_BEDROCK_MODEL]: 1e6,
+  [CLAUDE_OPUS_4_8_BEDROCK_MODEL]: 1e6,
+  [CLAUDE_SONNET_5_BEDROCK_MODEL]: 1e6,
+  [CLAUDE_HAIKU_4_5_BEDROCK_MODEL]: 2e5,
+  "anthropic.claude-opus-4-8": 1e6,
+  "us.anthropic.claude-sonnet-5": 1e6,
+  "anthropic.claude-haiku-4-5": 2e5,
+  "claude-haiku-4-5-20251001": 2e5,
+  "claude-haiku-4-5@20251001": 2e5
+};
+var AGENT_MODELS = {
+  claude: [
+    CLAUDE_FABLE_5_MODEL,
+    CLAUDE_OPUS_5_MODEL,
+    CLAUDE_OPUS_4_8_MODEL,
+    CLAUDE_SONNET_5_MODEL,
+    CLAUDE_HAIKU_4_5_MODEL
+  ],
+  codex: [DEFAULT_CODEX_MODEL, GPT_5_6_TERRA_MODEL, GPT_5_6_LUNA_MODEL, "gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.2"],
+  cursor: [
+    CLAUDE_FABLE_5_MODEL,
+    CLAUDE_OPUS_5_MODEL,
+    CLAUDE_OPUS_4_8_MODEL,
+    GPT_5_6_SOL_MODEL,
+    GPT_5_6_TERRA_MODEL,
+    GPT_5_6_LUNA_MODEL,
+    "gpt-5.5",
+    "composer-2.5",
+    CLAUDE_SONNET_5_MODEL,
+    "claude-opus-4-7",
+    "gpt-5.4",
+    "gpt-5.4-mini",
+    "gpt-5.4-nano",
+    "gpt-5.3-codex",
+    "gpt-5.2",
+    "gpt-5.2-codex",
+    "gpt-5.1",
+    "gpt-5.1-codex-max",
+    "gpt-5.1-codex-mini",
+    "gpt-5-mini",
+    "gemini-3.1-pro",
+    "gemini-3-flash",
+    "grok-4.5",
+    "grok-4.3",
+    CLAUDE_HAIKU_4_5_MODEL,
+    "kimi-k2.5"
+  ],
+  opencode: [...OPENROUTER_MODELS, ...ASTER_MODELS],
+  pi: [...OPENROUTER_MODELS, ...ASTER_MODELS],
+  relay: [CLAUDE_FABLE_5_MODEL, CLAUDE_OPUS_5_MODEL, CLAUDE_OPUS_4_8_MODEL, CLAUDE_SONNET_5_MODEL]
+};
+var MODEL_LABELS = {
+  fable: "Fable 5",
+  [CLAUDE_FABLE_5_MODEL]: "Fable 5",
+  sonnet: "Sonnet 5",
+  "claude-sonnet-5": "Sonnet 5",
+  opus: "Opus 5",
+  [CLAUDE_OPUS_5_MODEL]: "Opus 5",
+  [CLAUDE_OPUS_1M_MODEL]: "Opus (1M)",
+  [LEGACY_CLAUDE_OPUS_1M_MODEL]: "Opus (1M)",
+  haiku: "Haiku 4.5",
+  [GPT_5_6_SOL_MODEL]: "GPT-5.6 Sol",
+  [GPT_5_6_TERRA_MODEL]: "GPT-5.6 Terra",
+  [GPT_5_6_LUNA_MODEL]: "GPT-5.6 Luna",
+  "gpt-5.5": "GPT-5.5",
+  [DEFAULT_OPENCODE_MODEL]: "GLM 5.2 via OpenRouter",
+  "minimax/minimax-m3": "MiniMax M3 via OpenRouter",
+  "xiaomi/mimo-v2.5-pro": "MiMo V2.5 Pro via OpenRouter",
+  "moonshotai/kimi-k2.6": "Kimi K2.6 via OpenRouter",
+  ...ASTER_MODEL_LABELS,
+  "gpt-5.4": "GPT-5.4",
+  "gpt-5.4-mini": "GPT-5.4 Mini",
+  "gpt-5.4-nano": "GPT-5.4 Nano",
+  "gpt-5.3-codex": "GPT-5.3 Codex",
+  "gpt-5.2": "GPT-5.2",
+  "gpt-5.2-codex": "GPT-5.2 Codex",
+  "gpt-5.1": "GPT-5.1",
+  "gpt-5.1-codex-max": "GPT-5.1 Codex Max",
+  "gpt-5.1-codex-mini": "GPT-5.1 Codex Mini",
+  "gpt-5-mini": "GPT-5 Mini",
+  "composer-2.5": "Composer 2.5",
+  [CLAUDE_OPUS_4_8_MODEL]: "Opus 4.8",
+  "claude-opus-4-7": "Opus 4.7",
+  [CLAUDE_HAIKU_4_5_MODEL]: "Haiku 4.5",
+  "gemini-3.1-pro": "Gemini 3.1 Pro",
+  "gemini-3-flash": "Gemini 3 Flash",
+  "grok-4.5": "Grok 4.5",
+  "grok-4.3": "Grok 4.3",
+  "kimi-k2.5": "Kimi K2.5"
+};
+var IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
+var MAX_CANVAS_FILE_BYTES = 25 * 1024 * 1024;
+var MAX_CANVAS_PREVIEW_BYTES = 5 * 1024 * 1024;
+// ../shared/src/engine/v1.ts
+import { z } from "zod";
+var createChatRequestSchema = z.object({
+  id: z.string().uuid().optional(),
+  createdAt: z.string().datetime().optional(),
+  provider: z.enum(VALID_AGENT_PROVIDERS),
+  title: z.string().min(1).optional(),
+  parentChatId: z.string().uuid().optional(),
+  clientRequestId: z.string().min(1).max(128).optional()
+});
+var sendChatMessageRequestSchema = z.object({
+  messageId: z.string().optional(),
+  submittedAt: z.string().optional(),
+  message: z.string(),
+  model: z.string().optional(),
+  customInstructions: z.string().optional(),
+  planMode: z.boolean().optional(),
+  images: z.array(z.object({
+    type: z.literal("image"),
+    source: z.discriminatedUnion("type", [
+      z.object({ type: z.literal("base64"), media_type: z.enum(IMAGE_MEDIA_TYPES), data: z.string() }),
+      z.object({ type: z.literal("url"), url: z.string() })
+    ])
+  })).optional(),
+  thinkingLevel: z.enum(VALID_THINKING_LEVELS).optional(),
+  goalMode: z.boolean().optional(),
+  fastMode: z.boolean().optional(),
+  enableInteractiveTools: z.boolean().optional(),
+  type: z.string().optional(),
+  merge: z.boolean().optional(),
+  idempotencyKey: z.string().optional(),
+  senderUserId: z.string().optional(),
+  senderEmail: z.string().optional(),
+  senderDisplayName: z.string().optional(),
+  senderAvatarUrl: z.string().optional(),
+  errorNotificationTarget: z.discriminatedUnion("type", [
+    z.object({ type: z.literal("slack") }),
+    z.object({ type: z.literal("linear"), sessionId: z.string() }),
+    z.object({
+      type: z.literal("code_host"),
+      provider: z.enum(["github", "gitlab"]),
+      resource: z.enum(["issue", "pull_request"]),
+      repositoryId: z.string(),
+      resourceNumber: z.number()
+    }),
+    z.object({ type: z.literal("automation"), executionId: z.string() })
+  ]).optional()
+}).passthrough();
+// ../shared/src/display-message/types.ts
+var BACKGROUND_TASK_SUBTYPES = /* @__PURE__ */ new Set([
+  "task_started",
+  "task_progress",
+  "task_updated",
+  "task_notification"
+]);
+function isBackgroundTaskSubtype(subtype) {
+  return typeof subtype === "string" && BACKGROUND_TASK_SUBTYPES.has(subtype);
+}
+function optionalString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function coerceBackgroundTaskPayload(payload) {
+  if (!isRecord(payload)) return null;
+  const subtype = payload.subtype;
+  if (!isBackgroundTaskSubtype(subtype)) return null;
+  const taskId = payload.task_id;
+  if (typeof taskId !== "string" || !taskId) return null;
+  const patch = isRecord(payload.patch) ? {
+    status: optionalString(payload.patch.status),
+    description: optionalString(payload.patch.description),
+    error: optionalString(payload.patch.error),
+    isBackgrounded: optionalBoolean(payload.patch.is_backgrounded)
+  } : void 0;
+  const usage = isRecord(payload.usage) ? {
+    totalTokens: optionalNumber(payload.usage.total_tokens),
+    toolUses: optionalNumber(payload.usage.tool_uses),
+    durationMs: optionalNumber(payload.usage.duration_ms)
+  } : void 0;
   return {
-    streamId,
-    parent_tool_use_id: typeof parentToolUseId === "string" ? parentToolUseId : null,
-    ...text ? { text } : {},
-    ...thinking ? { thinking } : {},
-    status: payload.status === "completed" ? "completed" : "in_progress"
+    subtype,
+    taskId,
+    description: optionalString(payload.description),
+    summary: optionalString(payload.summary),
+    outputFile: optionalString(payload.output_file),
+    status: optionalString(payload.status),
+    taskType: optionalString(payload.task_type),
+    workflowName: optionalString(payload.workflow_name),
+    prompt: optionalString(payload.prompt),
+    lastToolName: optionalString(payload.last_tool_name),
+    usage,
+    patch
   };
 }
-var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
-var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
-var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
+function optionalNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function optionalBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function normalizeBackgroundTaskStatus(status) {
+  if (status === "completed" || status === "failed" || status === "stopped") {
+    return status;
+  }
+  if (status === "killed") {
+    return "stopped";
+  }
+  return "in_progress";
+}
+// ../shared/src/display-message/constants.ts
+var USER_MESSAGE_MATCH_GRACE_PERIOD_MS = 3e4;
 // ../shared/src/json.ts
 function safeJsonParse(str, fallback) {
@@ -1614,9 +1883,277 @@ function safeJsonParse(str, fallback) {
   }
 }
-// ../shared/src/type-guards.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// ../shared/src/display-message/parsers/utils.ts
+function userMessageImages(value) {
+  if (!Array.isArray(value)) return void 0;
+  const images = value.filter((item) => isRecord(item) && item.type === "image" && typeof item.mediaType === "string" && typeof item.data === "string");
+  return images.length > 0 ? images : void 0;
+}
+function stringifyDisplayValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function upsertDisplayMessage(messages, message) {
+  const index = messages.findIndex((candidate) => candidate.id === message.id);
+  if (index === -1) messages.push(message);
+  else messages[index] = message;
+}
+function parseSkillName(tool, input) {
+  if (typeof tool !== "string") return null;
+  const normalizedTool = tool.toLowerCase();
+  if (normalizedTool.startsWith("skill.")) return tool.slice("skill.".length) || null;
+  if (normalizedTool !== "skill") return null;
+  const parsedInput = typeof input === "string" ? safeJsonParse(input, null) : input;
+  if (!isRecord(parsedInput)) return null;
+  const skillName = parsedInput.skill ?? parsedInput.name;
+  return typeof skillName === "string" && skillName ? skillName : null;
+}
+function skillNameFromFilePath(path) {
+  const skillName = skillNameFromSkillRootPath(path);
+  if (skillName) return skillName;
+  const parts = path.split(/[\\/]+/).filter(Boolean);
+  if (parts.length < 2 || parts[parts.length - 1].toLowerCase() !== "skill.md") return null;
+  const fallbackSkillName = parts[parts.length - 2];
+  return fallbackSkillName && fallbackSkillName.toLowerCase() !== "skills" ? fallbackSkillName : null;
+}
+function skillNameFromSkillRootPath(path) {
+  const parts = path.split(/[\\/]+/).filter(Boolean);
+  const skillsIndex = parts.findLastIndex((part) => part.toLowerCase() === "skills");
+  if (skillsIndex === -1) return null;
+  const firstSkillPart = parts[skillsIndex + 1];
+  const skillName = firstSkillPart?.toLowerCase() === ".system" ? parts[skillsIndex + 2] : firstSkillPart;
+  return skillName && skillName.toLowerCase() !== "skill.md" ? skillName : null;
+}
+function parseSkillFilePath(input) {
+  const parsedInput = typeof input === "string" ? safeJsonParse(input, null) : input;
+  if (!isRecord(parsedInput)) return null;
+  const path = [parsedInput.path, parsedInput.filePath, parsedInput.file_path].find((value) => typeof value === "string" && value.length > 0);
+  if (!path) return null;
+  return skillNameFromFilePath(path);
+}
+function skillNameFromToolCall(tool, input) {
+  const directSkillName = parseSkillName(tool, input);
+  if (directSkillName) return directSkillName;
+  if (typeof tool !== "string" || !["read", "read_file", "readfile"].includes(tool.toLowerCase())) return null;
+  return parseSkillFilePath(input);
+}
+function createCallDisplayMessage(message) {
+  const skillName = message.server.toLowerCase() === "skills" ? message.tool : skillNameFromToolCall(message.tool, message.input);
+  if (skillName === null) return { ...message, type: "tool_call" };
+  return {
+    id: message.id,
+    type: "skill",
+    skillName,
+    status: message.status,
+    timestamp: message.timestamp
+  };
+}
+// ../shared/src/display-message/format.ts
+function unquoteShellArg(value) {
+  const trimmed = value.trim();
+  if (trimmed.length < 2) return trimmed;
+  if (trimmed[0] === "'" && trimmed[trimmed.length - 1] === "'") {
+    return trimmed.slice(1, -1).replace(/'\\''/g, "'");
+  }
+  if (trimmed[0] === '"' && trimmed[trimmed.length - 1] === '"') {
+    return trimmed.slice(1, -1).replace(/\\(["\\$`])/g, "$1");
+  }
+  return trimmed;
+}
+function shellPayload(command) {
+  const match = command.trim().match(/^(?:\S*\/)?(?:ba|z|c|fi)?sh\s+-(?:[a-zA-Z]*c[a-zA-Z]*|c)\s+([\s\S]+)$/);
+  return match ? unquoteShellArg(match[1]) : command.trim();
+}
+function splitShellWords(command) {
+  const words = [];
+  let word = "";
+  let quote = null;
+  let escaped = false;
+  for (const char of command) {
+    if (escaped) {
+      word += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = null;
+      else word += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (word) {
+        words.push(word);
+        word = "";
+      }
+      continue;
+    }
+    word += char;
+  }
+  if (word) words.push(word);
+  return words;
+}
+function commandWords(command) {
+  const payload = shellPayload(command);
+  if (!payload || /[;|<>]|&&/.test(payload)) return null;
+  return splitShellWords(payload);
+}
+function skillNamesFromCommand(command) {
+  const words = commandWords(command);
+  if (!words) return [];
+  return Array.from(new Set(words.flatMap((word) => {
+    const skillName = skillNameFromSkillRootPath(word);
+    return skillName ? [skillName] : [];
+  })));
+}
+// ../shared/src/display-message/task-accumulator.ts
+function mapTaskStatus(status) {
+  if (status === "in_progress" || status === "completed") return status;
+  return "pending";
+}
+function toAccumulatorInput(input) {
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      return isRecord(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return isRecord(input) ? input : {};
+}
+function extractToolResultText(content, separator = "\n") {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const texts = [];
+  for (const part of content) {
+    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
+      texts.push(part.text);
+    }
+  }
+  return texts.join(separator);
+}
+function normalizeContentBlocks(content) {
+  if (typeof content === "string") {
+    return content ? [{ type: "text", text: content }] : [];
+  }
+  return Array.isArray(content) ? content.filter((block) => isRecord(block) && typeof block.type === "string") : [];
+}
+function parseStringField(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function parseCreateResultTaskId(resultText) {
+  try {
+    const parsed = JSON.parse(resultText);
+    if (isRecord(parsed) && isRecord(parsed.task)) {
+      return parseStringField(parsed.task.id);
+    }
+  } catch {
+  }
+  return resultText.match(/\bTask\s+#?([A-Za-z0-9_-]+)\s+created\b/i)?.[1] ?? null;
+}
+var TaskAccumulator = class {
+  tasksByTaskId = /* @__PURE__ */ new Map();
+  tasksByCreateToolUseId = /* @__PURE__ */ new Map();
+  orderedKeys = [];
+  processToolUse(toolName, toolUseId, input) {
+    if (toolName === "TaskCreate") {
+      const subject = parseStringField(input.subject);
+      if (!subject) return false;
+      this.tasksByCreateToolUseId.set(toolUseId, { subject, status: "pending" });
+      this.orderedKeys.push(toolUseId);
+      return true;
+    }
+    if (toolName === "TaskUpdate") {
+      const taskId = parseStringField(input.taskId);
+      if (!taskId) return false;
+      if (input.status === "deleted") {
+        if (!this.tasksByTaskId.delete(taskId)) return false;
+        const idx = this.orderedKeys.indexOf(taskId);
+        if (idx !== -1) this.orderedKeys.splice(idx, 1);
+        return true;
+      }
+      const existing = this.tasksByTaskId.get(taskId);
+      const subject = parseStringField(input.subject) ?? existing?.subject;
+      if (!subject) return false;
+      const status = input.status !== void 0 ? mapTaskStatus(input.status) : existing?.status ?? "pending";
+      this.tasksByTaskId.set(taskId, { subject, status });
+      if (!existing) this.orderedKeys.push(taskId);
+      return true;
+    }
+    if (toolName === "TaskList") {
+      if (!Array.isArray(input.tasks)) return false;
+      let changed = false;
+      for (const raw of input.tasks) {
+        if (!isRecord(raw)) continue;
+        const id = parseStringField(raw.id);
+        const subject = parseStringField(raw.subject);
+        if (!id || !subject) continue;
+        const existing = this.tasksByTaskId.get(id);
+        const next = { subject, status: mapTaskStatus(raw.status) };
+        if (existing && existing.subject === next.subject && existing.status === next.status) continue;
+        this.tasksByTaskId.set(id, next);
+        if (!existing) this.orderedKeys.push(id);
+        changed = true;
+      }
+      return changed;
+    }
+    return false;
+  }
+  processCreateResult(toolUseId, resultText) {
+    const pending = this.tasksByCreateToolUseId.get(toolUseId);
+    if (!pending) return false;
+    const taskId = parseCreateResultTaskId(resultText);
+    if (!taskId) return false;
+    this.tasksByTaskId.set(taskId, pending);
+    this.tasksByCreateToolUseId.delete(toolUseId);
+    const idx = this.orderedKeys.indexOf(toolUseId);
+    if (idx !== -1) this.orderedKeys.splice(idx, 1, taskId);
+    return true;
+  }
+  getTasks() {
+    const out = [];
+    for (const key of this.orderedKeys) {
+      const task = this.tasksByTaskId.get(key) ?? this.tasksByCreateToolUseId.get(key);
+      if (task && task.subject) out.push(task);
+    }
+    return out;
+  }
+  processContentBlock(block) {
+    if (!isRecord(block)) return false;
+    if (block.type === "tool_use" && typeof block.name === "string" && typeof block.id === "string") {
+      return this.processToolUse(block.name, block.id, toAccumulatorInput(block.input));
+    }
+    if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+      return this.processCreateResult(block.tool_use_id, extractToolResultText(block.content, ""));
+    }
+    return false;
+  }
+};
+// ../shared/src/user-message-matching.ts
+function parseTimestampMs(timestamp) {
+  const value = Date.parse(timestamp);
+  return Number.isFinite(value) ? value : 0;
+}
+function areUserMessagesWithinMatchWindow(a, b) {
+  return a.content === b.content && Math.abs(parseTimestampMs(a.timestamp) - parseTimestampMs(b.timestamp)) <= USER_MESSAGE_MATCH_GRACE_PERIOD_MS;
 }
 // ../shared/src/display-message/parsers/codex-parser.ts
@@ -1628,16 +2165,8 @@ function getPayloadString(event, key) {
   return typeof value === "string" ? value : null;
 }
 function displayId(event, eventIndex, prefix) {
-  const stableId = getPayloadString(event, USER_MESSAGE_ID_PAYLOAD_KEY) ?? getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY);
-  return stableId ? `${prefix}-${stableId}` : `${prefix}-${event.timestamp}-${eventIndex}`;
-}
-function userMessageImages(value) {
-  if (!Array.isArray(value)) return void 0;
-  const images = value.filter((item) => {
-    if (!isRecord(item)) return false;
-    return item.type === "image" && typeof item.mediaType === "string" && typeof item.data === "string";
-  });
-  return images.length > 0 ? images : void 0;
+  const stableId = getPayloadString(event, USER_MESSAGE_ID_PAYLOAD_KEY) ?? getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY);
+  return stableId ? `${prefix}-${stableId}` : `${prefix}-${event.timestamp}-${eventIndex}`;
 }
 function parseShellOutput(raw) {
   const exitCodeMatch = raw.match(/^Exit code: (\d+)/m) || raw.match(/Process exited with code (\d+)/);
@@ -1758,10 +2287,12 @@ function parseCodexEvents(events) {
         const callId = event.payload.call_id;
         const args = safeJsonParse(event.payload.arguments || "{}", {});
         const command = args.cmd || (Array.isArray(args.command) ? args.command.join(" ") : args.command) || "";
+        const skillNames = skillNamesFromCommand(command);
         const msg = {
           id: `command-${callId || "no-call-id"}-${eventIndex}`,
           type: "command",
           command,
+          ...skillNames.length > 0 ? { skillNames } : {},
           output: "",
           status: "in_progress",
           timestamp: event.timestamp
@@ -1793,17 +2324,17 @@ function parseCodexEvents(events) {
           const operations = parsePatch(input);
           pendingPatches.set(callId, { input, status, timestamp: event.timestamp, operations });
         } else {
-          const msg = {
-            id: `toolcall-${callId || getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY) || `${event.timestamp}-${eventIndex}`}`,
-            type: "tool_call",
+          const id = `toolcall-${callId || getPayloadString(event, CODEX_ASP_ITEM_ID_PAYLOAD_KEY) || `${event.timestamp}-${eventIndex}`}`;
+          const msg = createCallDisplayMessage({
+            id,
             server: server2,
             tool: name,
             input,
             status,
             timestamp: event.timestamp
-          };
+          });
           messages.push(msg);
-          if (callId) {
+          if (callId && msg.type === "tool_call") {
             pendingToolCalls.set(callId, msg);
           }
         }
@@ -1862,17 +2393,6 @@ function parseCodexEvents(events) {
   return messages;
 }
-// ../shared/src/display-message/parsers/utils.ts
-function stringifyDisplayValue(value) {
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return String(value);
-  }
-}
 // ../shared/src/display-message/parsers/cursor-parser.ts
 function getTextContent(value) {
   if (!Array.isArray(value)) return "";
@@ -1898,10 +2418,10 @@ function getCursorThinkingText(event) {
 function isTerminalStatus(status) {
   return status === "FINISHED" || status === "ERROR" || status === "CANCELLED" || status === "EXPIRED";
 }
-function finalizeOpenTools(messages, toolIndexes, status) {
-  for (const index of toolIndexes.values()) {
+function finalizeOpenCalls(messages, callIndexes, status) {
+  for (const index of callIndexes.values()) {
     const message = messages[index];
-    if (message?.type === "tool_call" && message.status === "in_progress") {
+    if ((message?.type === "tool_call" || message?.type === "skill") && message.status === "in_progress") {
       messages[index] = {
         ...message,
         status
@@ -1911,7 +2431,7 @@ function finalizeOpenTools(messages, toolIndexes, status) {
 }
 function parseCursorEvents(events) {
   const messages = [];
-  const toolIndexes = /* @__PURE__ */ new Map();
+  const callIndexes = /* @__PURE__ */ new Map();
   const runAssistantSegments = /* @__PURE__ */ new Map();
   const runThinkingSegments = /* @__PURE__ */ new Map();
   let activeAssistant = null;
@@ -2003,21 +2523,20 @@ function parseCursorEvents(events) {
       const tool = typeof event.payload.name === "string" ? event.payload.name : "tool";
       const status = cursorStatusToDisplayStatus(event.payload.status);
       const input = isRecord(event.payload.args) ? event.payload.args : typeof event.payload.args === "string" ? event.payload.args : void 0;
-      const existing = toolIndexes.get(callId);
-      const next = {
+      const existing = callIndexes.get(callId);
+      const next = createCallDisplayMessage({
         id: callId,
-        type: "tool_call",
         server: "cursor",
         tool,
         ...input !== void 0 ? { input } : {},
         output: stringifyDisplayValue(event.payload.result),
         status,
         timestamp: event.timestamp
-      };
+      });
       if (existing === void 0) {
-        toolIndexes.set(callId, messages.push(next) - 1);
+        callIndexes.set(callId, messages.push(next) - 1);
       } else {
-        messages[existing] = { ...messages[existing], ...next };
+        messages[existing] = next;
       }
       continue;
     }
@@ -2039,7 +2558,7 @@ function parseCursorEvents(events) {
       if (isTerminalStatus(status)) {
         const displayStatus = cursorStatusToDisplayStatus(status);
         finalizeActiveThinking(displayStatus);
-        finalizeOpenTools(messages, toolIndexes, displayStatus);
+        finalizeOpenCalls(messages, callIndexes, displayStatus);
         activeThinking = null;
         activeAssistant = null;
       }
@@ -2047,7 +2566,7 @@ function parseCursorEvents(events) {
     }
     if (event.type === "cursor-error") {
       finalizeActiveThinking("failed");
-      finalizeOpenTools(messages, toolIndexes, "failed");
+      finalizeOpenCalls(messages, callIndexes, "failed");
       activeAssistant = null;
       activeThinking = null;
       const message = typeof event.payload.message === "string" ? event.payload.message : "Cursor run failed";
@@ -2072,14 +2591,6 @@ function partFromEvent(event) {
 function toolStatus(status) {
   return status === "completed" ? "completed" : status === "error" ? "failed" : "in_progress";
 }
-function setById(messages, id, next) {
-  const index = messages.findIndex((message) => message.id === id);
-  if (index === -1) {
-    messages.push(next);
-  } else {
-    messages[index] = next;
-  }
-}
 function assistantError(info) {
   if (!isRecord(info) || !isRecord(info.error)) return null;
   const data = isRecord(info.error.data) ? info.error.data : null;
@@ -2093,8 +2604,9 @@ function parseOpencodeEvents(events) {
     if (event.type === "event_msg" && event.payload.type === "user_message") {
       const message = event.payload.message;
       if (typeof message === "string" && message.trim()) {
+        const messageId = event.payload[USER_MESSAGE_ID_PAYLOAD_KEY];
         messages.push({
-          id: `opencode-user-${event.timestamp}-${messages.length}`,
+          id: typeof messageId === "string" ? messageId : `opencode-user-${event.timestamp}`,
           type: "user",
           content: message,
           timestamp: event.timestamp
@@ -2106,7 +2618,7 @@ function parseOpencodeEvents(events) {
       const error = assistantError(event.payload.info);
       if (error) {
         messages.push({
-          id: `opencode-error-${event.timestamp}-${messages.length}`,
+          id: `opencode-${event.type}-${event.timestamp}`,
           type: "error",
           message: error,
           timestamp: event.timestamp
@@ -2117,22 +2629,39 @@ function parseOpencodeEvents(events) {
     if (event.type === "opencode-error") {
       const message = typeof event.payload.message === "string" ? event.payload.message : "Opencode run failed";
       messages.push({
-        id: `opencode-error-${event.timestamp}-${messages.length}`,
+        id: `opencode-${event.type}-${event.timestamp}`,
         type: "error",
         message,
         timestamp: event.timestamp
       });
       continue;
     }
+    if (event.type === "opencode-session.next.tool.called") {
+      const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
+      const input = event.payload.input ?? event.payload.arguments;
+      const callId = typeof event.payload.callID === "string" ? event.payload.callID : null;
+      const id2 = callId ? `opencode-${callId}` : `opencode-${event.type}-${event.timestamp}`;
+      upsertDisplayMessage(messages, createCallDisplayMessage({
+        id: id2,
+        server: "opencode",
+        tool,
+        input: isRecord(input) ? input : stringifyDisplayValue(input),
+        status: "in_progress",
+        timestamp: event.timestamp
+      }));
+      continue;
+    }
     const part = partFromEvent(event);
     if (!part) continue;
-    const id = typeof part.id === "string" ? `opencode-${part.id}` : `opencode-${event.timestamp}-${messages.length}`;
+    let id = `opencode-${event.type}-${event.timestamp}`;
+    if (typeof part.callID === "string") id = `opencode-${part.callID}`;
+    else if (typeof part.id === "string") id = `opencode-${part.id}`;
     const time = isRecord(part.time) ? part.time : null;
     const timestamp = timestampFromMs(time?.start, event.timestamp);
     if (part.type === "text") {
       const text = typeof part.text === "string" ? part.text : "";
       if (text.trim()) {
-        setById(messages, id, {
+        upsertDisplayMessage(messages, {
           id,
           type: "agent",
           content: text,
@@ -2144,7 +2673,7 @@ function parseOpencodeEvents(events) {
     if (part.type === "reasoning") {
       const text = typeof part.text === "string" ? part.text : "";
       if (text.trim()) {
-        setById(messages, id, {
+        upsertDisplayMessage(messages, {
           id,
           type: "reasoning",
           content: text,
@@ -2157,23 +2686,24 @@ function parseOpencodeEvents(events) {
     if (part.type === "tool" && isRecord(part.state)) {
       const state = part.state;
       const status = toolStatus(state.status);
+      const tool = typeof part.tool === "string" ? part.tool : "tool";
+      const input = state.input;
       const output = state.status === "completed" ? stringifyDisplayValue(state.output) : state.status === "error" ? stringifyDisplayValue(state.error) : void 0;
-      setById(messages, id, {
+      upsertDisplayMessage(messages, createCallDisplayMessage({
         id,
-        type: "tool_call",
         server: "opencode",
-        tool: typeof part.tool === "string" ? part.tool : "tool",
-        input: isRecord(state.input) ? state.input : stringifyDisplayValue(state.input),
+        tool,
+        input: isRecord(input) ? input : stringifyDisplayValue(input),
         output,
         status,
         timestamp
-      });
+      }));
       continue;
     }
     if (part.type === "patch") {
       const files = Array.isArray(part.files) ? part.files.filter((file) => typeof file === "string") : [];
       if (files.length > 0) {
-        setById(messages, id, {
+        upsertDisplayMessage(messages, {
           id,
           type: "file_change",
           changes: files.map((path) => ({ path, kind: "update" })),
@@ -2186,193 +2716,83 @@ function parseOpencodeEvents(events) {
   return messages;
 }
-// ../shared/src/display-message/types.ts
-var BACKGROUND_TASK_SUBTYPES = /* @__PURE__ */ new Set([
-  "task_started",
-  "task_progress",
-  "task_updated",
-  "task_notification"
-]);
-function isBackgroundTaskSubtype(subtype) {
-  return typeof subtype === "string" && BACKGROUND_TASK_SUBTYPES.has(subtype);
-}
-function optionalString(value) {
-  return typeof value === "string" ? value : void 0;
-}
-function coerceBackgroundTaskPayload(payload) {
-  if (!isRecord(payload)) return null;
-  const subtype = payload.subtype;
-  if (!isBackgroundTaskSubtype(subtype)) return null;
-  const taskId = payload.task_id;
-  if (typeof taskId !== "string" || !taskId) return null;
-  const patch = isRecord(payload.patch) ? {
-    status: optionalString(payload.patch.status),
-    description: optionalString(payload.patch.description),
-    error: optionalString(payload.patch.error),
-    isBackgrounded: optionalBoolean(payload.patch.is_backgrounded)
-  } : void 0;
-  const usage = isRecord(payload.usage) ? {
-    totalTokens: optionalNumber(payload.usage.total_tokens),
-    toolUses: optionalNumber(payload.usage.tool_uses),
-    durationMs: optionalNumber(payload.usage.duration_ms)
-  } : void 0;
-  return {
-    subtype,
-    taskId,
-    description: optionalString(payload.description),
-    summary: optionalString(payload.summary),
-    outputFile: optionalString(payload.output_file),
-    status: optionalString(payload.status),
-    taskType: optionalString(payload.task_type),
-    workflowName: optionalString(payload.workflow_name),
-    prompt: optionalString(payload.prompt),
-    lastToolName: optionalString(payload.last_tool_name),
-    usage,
-    patch
-  };
-}
-function optionalNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function optionalBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function normalizeBackgroundTaskStatus(status) {
-  if (status === "completed" || status === "failed" || status === "stopped") {
-    return status;
-  }
-  if (status === "killed") {
-    return "stopped";
-  }
-  return "in_progress";
-}
-// ../shared/src/display-message/task-accumulator.ts
-function mapTaskStatus(status) {
-  if (status === "in_progress" || status === "completed") return status;
-  return "pending";
-}
-function toAccumulatorInput(input) {
-  if (typeof input === "string") {
-    try {
-      const parsed = JSON.parse(input);
-      return isRecord(parsed) ? parsed : {};
-    } catch {
-      return {};
-    }
-  }
-  return isRecord(input) ? input : {};
-}
-function extractToolResultText(content, separator = "\n") {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  const texts = [];
-  for (const part of content) {
-    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
-      texts.push(part.text);
-    }
-  }
-  return texts.join(separator);
-}
-function normalizeContentBlocks(content) {
-  if (typeof content === "string") {
-    return content ? [{ type: "text", text: content }] : [];
-  }
-  return content ?? [];
+// ../shared/src/display-message/parsers/pi-parser.ts
+function nestedPayload(event) {
+  return isRecord(event.payload.assistantMessageEvent) ? event.payload.assistantMessageEvent : event.payload;
 }
-function parseStringField(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : null;
+function toolStatus2(value) {
+  return value === "completed" || value === "success" ? "completed" : value === "error" ? "failed" : "in_progress";
 }
-function parseCreateResultTaskId(resultText) {
-  try {
-    const parsed = JSON.parse(resultText);
-    if (isRecord(parsed) && isRecord(parsed.task)) {
-      return parseStringField(parsed.task.id);
-    }
-  } catch {
-  }
-  return resultText.match(/\bTask\s+#?([A-Za-z0-9_-]+)\s+created\b/i)?.[1] ?? null;
+function assistantErrorMessage(value) {
+  if (!isRecord(value) || value.role !== "assistant" || value.stopReason !== "error") return null;
+  return typeof value.errorMessage === "string" && value.errorMessage ? value.errorMessage : "Pi run failed";
 }
-var TaskAccumulator = class {
-  tasksByTaskId = /* @__PURE__ */ new Map();
-  tasksByCreateToolUseId = /* @__PURE__ */ new Map();
-  orderedKeys = [];
-  processToolUse(toolName, toolUseId, input) {
-    if (toolName === "TaskCreate") {
-      const subject = parseStringField(input.subject);
-      if (!subject) return false;
-      this.tasksByCreateToolUseId.set(toolUseId, { subject, status: "pending" });
-      this.orderedKeys.push(toolUseId);
-      return true;
-    }
-    if (toolName === "TaskUpdate") {
-      const taskId = parseStringField(input.taskId);
-      if (!taskId) return false;
-      if (input.status === "deleted") {
-        if (!this.tasksByTaskId.delete(taskId)) return false;
-        const idx = this.orderedKeys.indexOf(taskId);
-        if (idx !== -1) this.orderedKeys.splice(idx, 1);
-        return true;
+function parsePiEvents(events) {
+  const messages = [];
+  const text = /* @__PURE__ */ new Map();
+  const thinking = /* @__PURE__ */ new Map();
+  let activeMessageId = "assistant";
+  for (const event of events) {
+    if (event.type === "event_msg" && event.payload.type === "user_message" && typeof event.payload.message === "string") {
+      messages.push({ id: `pi-user-${event.timestamp}-${messages.length}`, type: "user", content: event.payload.message, timestamp: event.timestamp });
+      if (typeof event.payload.skillName === "string" && event.payload.skillName) {
+        messages.push({
+          id: `pi-skill-${event.timestamp}-${messages.length}`,
+          type: "skill",
+          skillName: event.payload.skillName,
+          status: "completed",
+          timestamp: event.timestamp
+        });
       }
-      const existing = this.tasksByTaskId.get(taskId);
-      const subject = parseStringField(input.subject) ?? existing?.subject;
-      if (!subject) return false;
-      const status = input.status !== void 0 ? mapTaskStatus(input.status) : existing?.status ?? "pending";
-      this.tasksByTaskId.set(taskId, { subject, status });
-      if (!existing) this.orderedKeys.push(taskId);
-      return true;
+      continue;
     }
-    if (toolName === "TaskList") {
-      if (!Array.isArray(input.tasks)) return false;
-      let changed = false;
-      for (const raw of input.tasks) {
-        if (!isRecord(raw)) continue;
-        const id = parseStringField(raw.id);
-        const subject = parseStringField(raw.subject);
-        if (!id || !subject) continue;
-        const existing = this.tasksByTaskId.get(id);
-        const next = { subject, status: mapTaskStatus(raw.status) };
-        if (existing && existing.subject === next.subject && existing.status === next.status) continue;
-        this.tasksByTaskId.set(id, next);
-        if (!existing) this.orderedKeys.push(id);
-        changed = true;
+    if (event.type === "pi-error") {
+      messages.push({ id: `pi-error-${event.timestamp}-${messages.length}`, type: "error", message: String(event.payload.message ?? "Pi run failed"), timestamp: event.timestamp });
+      continue;
+    }
+    if (event.type === "pi-message_end") {
+      const error = assistantErrorMessage(event.payload.message);
+      if (error) {
+        messages.push({ id: `pi-error-${event.timestamp}-${messages.length}`, type: "error", message: error, timestamp: event.timestamp });
       }
-      return changed;
+      continue;
     }
-    return false;
-  }
-  processCreateResult(toolUseId, resultText) {
-    const pending = this.tasksByCreateToolUseId.get(toolUseId);
-    if (!pending) return false;
-    const taskId = parseCreateResultTaskId(resultText);
-    if (!taskId) return false;
-    this.tasksByTaskId.set(taskId, pending);
-    this.tasksByCreateToolUseId.delete(toolUseId);
-    const idx = this.orderedKeys.indexOf(toolUseId);
-    if (idx !== -1) this.orderedKeys.splice(idx, 1, taskId);
-    return true;
-  }
-  getTasks() {
-    const out = [];
-    for (const key of this.orderedKeys) {
-      const task = this.tasksByTaskId.get(key) ?? this.tasksByCreateToolUseId.get(key);
-      if (task && task.subject) out.push(task);
+    if (event.type === "pi-message_update") {
+      const payload = nestedPayload(event);
+      const id = typeof payload.id === "string" ? payload.id : activeMessageId;
+      if (payload.type === "text_delta" && typeof payload.delta === "string") text.set(id, `${text.get(id) ?? ""}${payload.delta}`);
+      if (payload.type === "thinking_delta" && typeof payload.delta === "string") thinking.set(id, `${thinking.get(id) ?? ""}${payload.delta}`);
+      const textContent = text.get(id);
+      const thinkingContent = thinking.get(id);
+      if (textContent !== void 0) upsertDisplayMessage(messages, { id: `pi-${id}`, type: "agent", content: textContent, timestamp: event.timestamp });
+      if (thinkingContent !== void 0) upsertDisplayMessage(messages, { id: `pi-thinking-${id}`, type: "reasoning", content: thinkingContent, status: "in_progress", timestamp: event.timestamp });
+      continue;
     }
-    return out;
-  }
-  processContentBlock(block) {
-    if (!isRecord(block)) return false;
-    if (block.type === "tool_use" && typeof block.name === "string" && typeof block.id === "string") {
-      return this.processToolUse(block.name, block.id, toAccumulatorInput(block.input));
+    if (event.type === "pi-message_start") {
+      const message = isRecord(event.payload.message) ? event.payload.message : null;
+      activeMessageId = typeof message?.id === "string" ? message.id : `assistant-${event.timestamp}`;
+      continue;
     }
-    if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
-      return this.processCreateResult(block.tool_use_id, extractToolResultText(block.content, ""));
+    if (event.type === "pi-tool_execution_start" || event.type === "pi-tool_execution_update" || event.type === "pi-tool_execution_end") {
+      const payload = event.payload;
+      const input = payload.args ?? payload.input;
+      const id = typeof payload.toolCallId === "string" ? payload.toolCallId : typeof payload.id === "string" ? payload.id : `tool-${event.timestamp}`;
+      const tool = typeof payload.toolName === "string" ? payload.toolName : "tool";
+      const messageId = `pi-tool-${id}`;
+      const status = event.type === "pi-tool_execution_end" ? toolStatus2(payload.isError ? "error" : "completed") : "in_progress";
+      upsertDisplayMessage(messages, createCallDisplayMessage({
+        id: messageId,
+        server: "pi",
+        tool,
+        input: isRecord(input) ? input : stringifyDisplayValue(input),
+        output: event.type === "pi-tool_execution_end" ? stringifyDisplayValue(payload.result ?? payload.error) : void 0,
+        status,
+        timestamp: event.timestamp
+      }));
     }
-    return false;
   }
-};
+  return messages;
+}
 // ../shared/src/display-message/parsers/mcp.ts
 function parseMcpToolName(name) {
@@ -2388,13 +2808,22 @@ function parseMcpToolName(name) {
 }
 // ../shared/src/display-message/parsers/claude-parser.ts
-function upsertDisplayMessage(messages, message) {
-  const index = messages.findIndex((existing) => existing.id === message.id);
-  if (index === -1) {
-    messages.push(message);
-  } else {
-    messages[index] = message;
-  }
+var ABORTED_TERMINAL_REASONS = /* @__PURE__ */ new Set(["aborted_streaming", "aborted_tools"]);
+function coerceClaudeResultPayload(payload) {
+  return {
+    is_error: typeof payload.is_error === "boolean" ? payload.is_error : void 0,
+    subtype: typeof payload.subtype === "string" ? payload.subtype : void 0,
+    errors: Array.isArray(payload.errors) ? payload.errors.filter((e) => typeof e === "string") : void 0,
+    terminal_reason: typeof payload.terminal_reason === "string" ? payload.terminal_reason : void 0
+  };
+}
+function stripAgentDiagnosticErrors(errors) {
+  return errors.filter((error) => !error.startsWith("[ede_diagnostic]"));
+}
+function isClaudeResultError(payload) {
+  if (payload.terminal_reason && ABORTED_TERMINAL_REASONS.has(payload.terminal_reason)) return false;
+  if (payload.errors?.length && stripAgentDiagnosticErrors(payload.errors).length === 0) return false;
+  return Boolean(payload.is_error) || payload.subtype !== "success";
 }
 var LOCAL_COMMAND_ECHO_REGEX = /^<(?:command-name|command-message|local-command-stdout|local-command-stderr)>/;
 function parseClaudeEvents(events, parentToolUseId) {
@@ -2412,6 +2841,14 @@ function parseClaudeEvents(events, parentToolUseId) {
   let liveStreamId = null;
   const assistantThinking = /* @__PURE__ */ new Map();
   const assistantTextCounts = /* @__PURE__ */ new Map();
+  const acceptedUserMessageIndexes = /* @__PURE__ */ new Set();
+  const canonicalUserMessageIndexes = /* @__PURE__ */ new Set();
+  const findMatchingUserMessageIndex = (indexes, content, timestamp) => {
+    return [...indexes].find((index) => {
+      const message = messages[index];
+      return message?.type === "user" && areUserMessagesWithinMatchWindow(message, { content, timestamp });
+    });
+  };
   const taskAccumulator = new TaskAccumulator();
   const taskSnapshot = () => taskAccumulator.getTasks().map((task) => ({
     text: task.subject,
@@ -2419,6 +2856,29 @@ function parseClaudeEvents(events, parentToolUseId) {
     itemStatus: task.status
   }));
   filteredEvents.forEach((event) => {
+    if (event.type === "event_msg" && event.payload.type === "user_message") {
+      const content = typeof event.payload.message === "string" ? event.payload.message : "";
+      const images = userMessageImages(event.payload.images);
+      if (content || images) {
+        const messageId = event.payload[USER_MESSAGE_ID_PAYLOAD_KEY];
+        const canonicalIndex = findMatchingUserMessageIndex(canonicalUserMessageIndexes, content, event.timestamp);
+        const canonical = canonicalIndex === void 0 ? void 0 : messages[canonicalIndex];
+        const message = {
+          id: typeof messageId === "string" ? messageId : `user-${event.timestamp}`,
+          type: "user",
+          content,
+          images: images?.length ? images : canonical?.type === "user" ? canonical.images : void 0,
+          timestamp: event.timestamp
+        };
+        if (canonicalIndex === void 0) {
+          acceptedUserMessageIndexes.add(messages.push(message) - 1);
+        } else {
+          messages[canonicalIndex] = message;
+          canonicalUserMessageIndexes.delete(canonicalIndex);
+        }
+      }
+      return;
+    }
     if (event.type === CLAUDE_PARTIAL_MESSAGE_EVENT_TYPE) {
       const payload = coerceClaudePartialMessagePayload(event.payload);
       if (!payload) return;
@@ -2476,13 +2936,25 @@ function parseClaudeEvents(events, parentToolUseId) {
         };
       }).filter((img) => img.data);
       if (textContent || images.length > 0) {
-        messages.push({
-          id: `user-${event.timestamp}`,
+        const acceptedIndex = findMatchingUserMessageIndex(
+          acceptedUserMessageIndexes,
+          textContent,
+          event.timestamp
+        );
+        const accepted = acceptedIndex === void 0 ? void 0 : messages[acceptedIndex];
+        const message = {
+          id: accepted?.id ?? `user-${event.timestamp}`,
           type: "user",
           content: textContent || (images.length > 0 ? `[${images.length} image${images.length > 1 ? "s" : ""} attached]` : ""),
-          images: images.length > 0 ? images : void 0,
+          images: images.length > 0 ? images : accepted?.type === "user" ? accepted.images : void 0,
           timestamp: event.timestamp
-        });
+        };
+        if (acceptedIndex === void 0) {
+          canonicalUserMessageIndexes.add(messages.push(message) - 1);
+        } else {
+          messages[acceptedIndex] = message;
+          acceptedUserMessageIndexes.delete(acceptedIndex);
+        }
       }
     }
     if (event.type === "claude-assistant") {
@@ -2565,10 +3037,12 @@ function parseClaudeEvents(events, parentToolUseId) {
           } else if (toolName === "Bash" || toolName === "bash" || toolName === "shell") {
             const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
             const command = inputObj.command || "";
+            const skillNames = skillNamesFromCommand(command);
             messages.push({
               id: `command-${event.timestamp}-${messages.length}`,
               type: "command",
               command,
+              ...skillNames.length > 0 ? { skillNames } : {},
               output: "",
               status: "in_progress",
               timestamp: event.timestamp
@@ -2635,7 +3109,7 @@ function parseClaudeEvents(events, parentToolUseId) {
           } else if (toolName === "Skill") {
             const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
             messages.push({
-              id: `skill-${event.timestamp}-${messages.length}`,
+              id: `skill-${toolUseId}`,
               type: "skill",
               skillName: inputObj.skill || "unknown",
               args: inputObj.args,
@@ -2644,19 +3118,37 @@ function parseClaudeEvents(events, parentToolUseId) {
             });
           } else if (toolName === "mcp__relay-subagent-tools__spawn_agent") {
             const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            const provider = typeof inputObj.provider === "string" ? inputObj.provider : "unknown";
+            const prompt = typeof inputObj.prompt === "string" ? inputObj.prompt : "";
+            const model = typeof inputObj.model === "string" ? inputObj.model : void 0;
+            const title = typeof inputObj.title === "string" ? inputObj.title : void 0;
             messages.push({
               id: `subagent-${event.timestamp}-${messages.length}`,
               type: "subagent",
               toolUseId,
-              description: inputObj.title || `Relay subagent (${inputObj.provider || "unknown"})`,
-              prompt: inputObj.prompt || "",
-              subagentType: inputObj.provider || "unknown",
-              model: inputObj.model,
+              description: title || `Relay subagent (${provider})`,
+              prompt,
+              subagentType: provider,
+              model,
+              thinkingLevel: isValidThinkingLevel(inputObj.thinking_level) ? inputObj.thinking_level : void 0,
               status: "in_progress",
               nestedEvents: [],
               isChatBased: true,
               timestamp: event.timestamp
             });
+          } else if (toolName === "mcp__relay-subagent-tools__message_agent") {
+            const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
+            messages.push({
+              id: `subagent-followup-${event.timestamp}-${messages.length}`,
+              type: "subagent_followup",
+              toolUseId,
+              chatId: typeof inputObj.chatId === "string" ? inputObj.chatId : "",
+              message: typeof inputObj.message === "string" ? inputObj.message : "",
+              model: typeof inputObj.model === "string" ? inputObj.model : void 0,
+              thinkingLevel: isValidThinkingLevel(inputObj.thinking_level) ? inputObj.thinking_level : void 0,
+              status: "in_progress",
+              timestamp: event.timestamp
+            });
           } else if (toolName === "mcp__relay-subagent-tools__delete_agent") {
             const inputObj = typeof toolInput === "string" ? safeJsonParse(toolInput, {}) : toolInput;
             const mcp = parseMcpToolName(toolName);
@@ -2684,14 +3176,13 @@ function parseClaudeEvents(events, parentToolUseId) {
       });
     }
     if (event.type === "claude-result") {
-      const payload = event.payload;
-      if (payload.is_error || payload.subtype !== "success") {
-        const errorList = payload.errors || [];
-        const errorMessage = errorList.length > 0 ? errorList.join("\n") : "Claude session encountered an unexpected error.";
+      const payload = coerceClaudeResultPayload(event.payload);
+      if (isClaudeResultError(payload)) {
+        const genuineErrors = stripAgentDiagnosticErrors(payload.errors ?? []);
         messages.push({
           id: `error-${event.timestamp}`,
           type: "error",
-          message: errorMessage,
+          message: genuineErrors.length > 0 ? genuineErrors.join("\n") : "Claude session encountered an unexpected error.",
           timestamp: event.timestamp
         });
       }
@@ -2800,10 +3291,21 @@ function parseClaudeEvents(events, parentToolUseId) {
               message.chatId = parsed.chatId;
             }
           }
+        } else if (message.type === "subagent_followup") {
+          message.output = resultContent;
+          message.status = status;
         }
       }
     }
   });
+  for (const message of messages) {
+    if (message.type !== "subagent_followup") continue;
+    const target = messages.find((candidate) => candidate.type === "subagent" && candidate.chatId === message.chatId);
+    if (target?.type === "subagent") {
+      message.targetTitle = target.description;
+      message.targetProvider = target.subagentType;
+    }
+  }
   const staleIndexes = /* @__PURE__ */ new Set();
   for (const streamId of [...completedStreamIds, ...supersededStreamIds]) {
     const refs = partialIndexes.get(streamId);
@@ -2828,16 +3330,18 @@ function parseAgentEvents(events, agentType) {
   if (agentType === "opencode") {
     return parseOpencodeEvents(events);
   }
+  if (agentType === "pi") {
+    return parsePiEvents(events);
+  }
   return parseClaudeEvents(events);
 }
 // ../shared/src/routes/workspaces.ts
 var WORKSPACE_STATUSES = ["active", "sleeping", "archived", "preparing", "error"];
-var VALID_LIFECYCLE_POLICIES = ["default", "delete_when_done", "sleep_when_done", "delete_after_inactivity"];
-var WORKSPACE_FILE_UPLOAD_MAX_SIZE_BYTES = 20 * 1024 * 1024;
-var WORKSPACE_FILE_CONTENT_MAX_SIZE_BYTES = 1 * 1024 * 1024;
+var VALID_LIFECYCLE_POLICIES = ["default", "archive_when_done", "sleep_when_done", "delete_after_inactivity"];
 var WORKSPACE_STATUS_FILTERS = WORKSPACE_STATUSES.map((status) => status === "error" ? "failed" : status);
 var WORKSPACE_SORT_CHOICES = [
+  ["manual", "Custom"],
   ["activity", "Last activity"],
   ["created", "Created date"],
   ["status", "Status"]
@@ -2892,24 +3396,24 @@ function result(data, isError = false) {
 }
 var server = new McpServer({
   name: "replicas-mcp",
-  version: "0.2.10"
+  version: "0.2.12"
 });
 var registerTool = server.registerTool.bind(server);
-var codingAgentSchema = z.string().refine(isValidCodingAgentProvider, {
+var codingAgentSchema = z2.string().refine(isValidCodingAgentProvider, {
   message: `Coding agent must be ${getCodingAgentDisplayNames()}`
 });
-var lifecyclePolicySchema = z.enum(VALID_LIFECYCLE_POLICIES);
+var lifecyclePolicySchema = z2.enum(VALID_LIFECYCLE_POLICIES);
 registerTool(
   "create_replica",
   {
     description: "Create a new replica workspace and send initial message",
     inputSchema: {
-      name: z.string().regex(/^\S+$/, "Name cannot contain spaces"),
-      message: z.string(),
-      repository_ids: z.array(z.string()).min(1).optional().describe("Repository IDs to include. Mutually exclusive with repository_set_id."),
-      repository_set_id: z.string().optional().describe("Repository set ID to use. Mutually exclusive with repository_ids."),
+      name: z2.string().regex(/^\S+$/, "Name cannot contain spaces"),
+      message: z2.string(),
+      repository_ids: z2.array(z2.string()).min(1).optional().describe("Repository IDs to include. Mutually exclusive with repository_set_id."),
+      repository_set_id: z2.string().optional().describe("Repository set ID to use. Mutually exclusive with repository_ids."),
       coding_agent: codingAgentSchema.optional().describe("Coding agent to use (default: claude)"),
-      model: z.string().optional().describe("Model to use for the coding agent"),
+      model: z2.string().optional().describe("Model to use for the coding agent"),
       lifecycle_policy: lifecyclePolicySchema.optional().describe("Lifecycle policy for the workspace")
     }
   },
@@ -2935,11 +3439,11 @@ registerTool(
   {
     description: "List all replicas with pagination and optional filters",
     inputSchema: {
-      page: z.number().optional(),
-      limit: z.number().optional(),
-      user_id: z.string().optional().describe("Filter by creator user ID"),
-      source: z.enum(["api", "dashboard", "slack", "linear", "github", "gitlab", "automation"]).optional().describe("Filter by creation source"),
-      status: z.enum(["active", "sleeping", "preparing"]).optional().describe("Filter by workspace status")
+      page: z2.number().optional(),
+      limit: z2.number().optional(),
+      user_id: z2.string().optional().describe("Filter by creator user ID"),
+      source: z2.enum(["api", "dashboard", "slack", "linear", "github", "gitlab", "automation"]).optional().describe("Filter by creation source"),
+      status: z2.enum(["active", "sleeping", "preparing"]).optional().describe("Filter by workspace status")
     }
   },
   async (args) => {
@@ -2962,8 +3466,8 @@ registerTool(
   {
     description: "Get replica details by ID, including current status, chats, and repository statuses",
     inputSchema: {
-      id: z.string(),
-      include: z.array(z.enum(["environment", "diffs"])).optional().describe("Extra data to include in response")
+      id: z2.string(),
+      include: z2.array(z2.enum(["environment", "diffs"])).optional().describe("Extra data to include in response")
     }
   },
   async (args) => {
@@ -2982,12 +3486,12 @@ registerTool(
   {
     description: "Send a message to an existing replica. Automatically handles waking sleeping replicas.",
     inputSchema: {
-      id: z.string(),
-      message: z.string(),
+      id: z2.string(),
+      message: z2.string(),
       coding_agent: codingAgentSchema.optional().describe("Coding agent to use"),
-      chat_id: z.string().optional().describe("Chat ID to send the message to (uses default chat if omitted)"),
-      model: z.string().optional().describe("Model to use"),
-      plan_mode: z.boolean().optional().describe("Whether to use plan mode")
+      chat_id: z2.string().optional().describe("Chat ID to send the message to (uses default chat if omitted)"),
+      model: z2.string().optional().describe("Model to use"),
+      plan_mode: z2.boolean().optional().describe("Whether to use plan mode")
     }
   },
   async (args) => {
@@ -3008,7 +3512,7 @@ registerTool(
   {
     description: "Delete a replica. This terminates the workspace and cannot be undone.",
     inputSchema: {
-      id: z.string()
+      id: z2.string()
     }
   },
   async (args) => {
@@ -3050,7 +3554,7 @@ registerTool(
   {
     description: "List chats in a replica workspace",
     inputSchema: {
-      id: z.string().describe("Replica ID")
+      id: z2.string().describe("Replica ID")
     }
   },
   async (args) => {
@@ -3066,9 +3570,9 @@ registerTool(
   {
     description: "Create a new chat in a replica workspace",
     inputSchema: {
-      id: z.string().describe("Replica ID"),
+      id: z2.string().describe("Replica ID"),
       provider: codingAgentSchema.describe("Coding agent provider for the chat"),
-      title: z.string().optional().describe("Optional title for the chat")
+      title: z2.string().optional().describe("Optional title for the chat")
     }
   },
   async (args) => {
@@ -3086,8 +3590,8 @@ registerTool(
   {
     description: "Delete a chat from a replica workspace",
     inputSchema: {
-      id: z.string().describe("Replica ID"),
-      chat_id: z.string().describe("Chat ID to delete")
+      id: z2.string().describe("Replica ID"),
+      chat_id: z2.string().describe("Chat ID to delete")
     }
   },
   async (args) => {
@@ -3103,8 +3607,8 @@ registerTool(
   {
     description: "Read conversation history of a replica. Returns parsed DisplayMessage objects (user messages, agent responses, commands, file changes, tool calls, etc). If the workspace is sleeping, it will be woken and you should retry in 30-90 seconds.",
     inputSchema: {
-      id: z.string(),
-      chat_id: z.string().optional().describe("Read history for a specific chat (uses default chat if omitted)")
+      id: z2.string(),
+      chat_id: z2.string().optional().describe("Read history for a specific chat (uses default chat if omitted)")
     }
   },
   async (args) => {
@@ -3138,7 +3642,7 @@ registerTool(
   {
     description: "Get warm and start hook logs for a replica workspace",
     inputSchema: {
-      id: z.string().describe("Replica ID")
+      id: z2.string().describe("Replica ID")
     }
   },
   async (args) => {