From d9cfd7c68ed6498f2aaf1c30dd7151713025228f Mon Sep 17 00:00:00 2001
From: Siddharth Ganesan <33737564+Sg312@users.noreply.github.com>
Date: Thu, 20 Aug 2026 14:05:46 -0700
Subject: [PATCH] improvement(mothership): v0.9 (#6815)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* checkpoint

* Checkpoint

* dot fixes

* Make async tool resume delivery recoverable

* Support split table tools and option recovery

* Harden VFS mutation handling

* feat(platform): platform subagent support — docs corpus VFS, search_docs, account context

Squash of the feat/platform-agent branch (sim side): mounts the Sim docs
corpus in the copilot VFS, wires search_docs and retires the legacy docs
search tools, and syncs the generated tool catalog and trace contracts for
the platform subagent.

* Align Copilot tools and resource handling

* Expand workflow log query support

* checkpoint

* Port desktop-improvements-0 desktop and browser-agent work

* fix(desktop): keep browser-agent input alive through live-SPA re-renders

* Harden workflow sanitization and Slack setup

* feat(desktop): coordinate clicks, caret insertion, and drag for the browser agent

* Revert subagent group eager auto-collapse

* fix(chat): keep sends FIFO across the streaming-to-idle drain gap

* Add the steering backend surface for mid-turn sends

* Sync generated contracts for async subagent orchestration

Pulls the mothership tool catalog (wait_agents / tail_agent / steer_agent /
interrupt_agent), trace spans (chat.async_subagent.*, chat.orchestrate.*), and
trace attributes (copilot.async_subagent.*) into the generated TS contracts.

* Add display titles for the async subagent orchestration tools

wait_agents / tail_agent / steer_agent / interrupt_agent get natural-language
running titles (naming the agent id being waited on, tailed, steered, or
stopped) and a Steering→Steered completed-verb rewrite.

* Show orchestrator-chosen subagent names on agent groups

A subagent_start whose payload data carries a name (the orchestrator's new
name trigger parameter) now labels the agent group with that mission name —
the agent-type icon stays. The name flows through the live stream path, the
turn model (AgentNode.displayName) and its serialize/rebuild round-trip, and
persisted transcripts (PersistedContentBlock.name), so reloads keep the label.

* Improve Copilot error handling and logging

* Backfill the subagent display name from the second start event

The dispatch-time subagent_start fires before the trigger args (and therefore
the name parameter) have streamed; the phase-3 start re-announces the lane with
the name. The block builder was dropping that duplicate wholesale, losing the
name on streaming providers — now it backfills subagentName onto the existing
block instead. (The home turn-model path already reconciled this case.)

* Support Slack bot connection flow

* Harden Copilot error and VFS handling

* Harden VFS resource operations

* Show 'Waiting for the first of N agents' for mode-any waits

The wait_agents title ignored the mode argument, so an any-mode wait over
three agents read 'Waiting for 3 agents' while the model narrated waiting for
the first — contradicting the transcript.

* Collapsed-by-default agent cards with live intent status lines

Subagents now narrate their work through <intent>3-5 words</intent> tags (a
fleet-wide prompt protocol on the mothership side). The turn model streams
each subagent's text through a split-safe tag parser: complete tags update the
agent's currentIntent and disappear from the prose, tags split across deltas
are carried until their close arrives, and a tag that never closes flushes
back as plain text.

The agent card renders as one line — display name (or agent label) plus the
latest intent, replaced inline as the agent shifts gears — and never
auto-expands; expanding to the full tool log is a deliberate click. Only an
outstanding permission prompt or a browser hand-back forces a group open.
Intents persist on the subagent block (and through the legacy persisted-
message paths) so reloads keep the last status, and a renamed reinvocation
now takes the latest name instead of pinning the first.

* Add the internal in-band tool execution route for live mothership turns

POST /api/copilot/tools/execute (INTERNAL_API_SECRET, Go→Sim) runs one
sim-server tool through the same server tool router the resume driver uses
and returns the result synchronously — no checkpoint. This is what lets
background (async) subagents write files/tables/knowledge, and lets the main
lane keep streaming (instead of checkpoint-pausing and killing every
background run) while async agents are live.

* Persist resource side effects for in-band tool execution

Files/tables created through the internal execute route now register on the
chat's resources exactly like the resume driver's executions — the route runs
the same handleResourceSideEffects pass (persistence only; an out-of-band
route has no live event sink, so mid-turn chip pushes are a follow-up).

* Extract intents from group text on every path, sync and async

The turn-model intent filter only fires for span-scoped subagent lanes, but
this surface also delivers subagent text through the legacy block path — so
<intent> tags flowed through unparsed and rendered as prose rows. Groups now
extract intents from their accumulated text at append time: the last complete
tag becomes the card's status line and every complete tag is stripped from
the rendered prose. Covers span-scoped, legacy, and persisted-reload paths
for both synchronous and background delegations.

* Fall back to the live tool title for the agent card status line

Persisted data proved tool-first subagents (grok search agents) emit zero
prose, so intent tags never stream no matter what the prompt says. The
collapsed card now always narrates: the agent's own <intent> tag when present,
else the latest tool's display title while the lane is live.

* Catch subagent <intent> tags in the server relay

The relay's subagent text handler now runs the split-safe intent extraction
as chunks stream: the latest complete tag is stamped onto the lane's persisted
subagent block (subagentIntent) and stripped from the stored prose, so live,
persisted, and replayed views all agree. Per-lane carry handles tags split
across chunks; a never-closing tag flushes back as plain text.

* Drop the tool-title fallback: the status line is the agent's intent

With the intent protocol now injected into every spawn's task message, agents
open with an <intent> tag; the card shows that narration or nothing.

* Replace intents with live tool-title status lines on agent cards

Intent parsing is fully removed (turn model, relay handler, persistence
fields, group extraction). The collapsed card's status is the latest tool
call in its RUNNING phrasing — never the completed rewrite, which stays in
the expanded log. Parallel tools show the most recently started still-running
title with a +N for concurrent siblings; between rounds the last title stays
frozen; a closed lane shows the bare name. Nested agent cards compute their
own status recursively from their own items.

* Keep the main Sim lane live-expanded; collapse only real subagent cards

The mothership group is the turn's own narration, not a delegation card —
collapsing it hid main-lane text and tools until manual expand, which read as
mis-ordered streaming while async subagents interleaved. It keeps the
original live-expand behavior and no status suffix.

* Persist subagent lane lifecycle blocks from the span handler

Lane-scoped span events route to the span handler, which only recorded trace
side effects — no subagent start block was ever persisted (verified: a
seven-agent run stored 104 blocks with zero starts). Grouping then fell back
to keying lane content by agent NAME, so a respawned agent of the same type
merged invisibly into the first one's card until it resolved. The handler now
persists the start block (spanId-keyed and deduped, carrying the display
name) and stamps endedAt on close, giving every invocation its own card.

* Name agents in orchestration titles; '+ n more' overflow format

wait/tail/steer/interrupt titles humanize the slugified agent ids back to
their display names ('Waiting for the first of Digest Workflow Build + 4
more'), and the agent card's parallel-tool suffix uses the same '+ n more'
format.

* Harden in-band tool execution and resources

* Route in-band execution through the comprehensive tool dispatcher

The internal execute route used the bare server-tool router, which rejects
VFS tools with 'Unknown server tool: read/glob/grep' — so nearly every
background agent's first discovery call failed (102 in-band calls in one run,
dozens rejected). It now uses the relay's executeTool dispatcher: registered
handlers (VFS, function execute) with permission checks and param
normalization, falling back to the app tool router — the same surface
foreground execution gets.

* Harden chat stream transition handling

* Harden VFS provenance and resource writes

* Standardize tool environment references

* Harden browser panel and chat cleanup

* Descriptive, user-language tool titles across the board

House rules applied everywhere: use every argument the call carries, never
name internal machinery, and never lead with Getting (the Got rewrite is
deleted so it cannot return).

- Deployments name the workflow: Deploying {workflow} as API/chat app/MCP tool
- Workflow reads name the part: Reading {workflow} meta/state/deployment/notes;
  generic reads always name the file (Reading {leaf}), never bare Reading file
- Block runs name block and workflow: Running {block} in {workflow}, Running
  from {block} in {workflow}, Running {workflow} until {block}, and
  Enabling/Disabling {block} in {workflow}
- The six split-table tools get per-operation verbs (Adding column {name},
  Updating rows, Wiring automation, Creating view {name}) instead of a wall
  of Querying table
- The manage quartet drops X-action system-speak for gerunds
- get_* internal names become user language (Checking run settings, Tracing
  block inputs, Reading the deployed version); web_fetch says Fetching
- Scheduled-task titles removed entirely (feature deleted from the Go catalog)
- New verb rewrites: Fetched, Traced, Wired, Configured, Looked, Rotated

* Deploying {workflow} as chat, not as chat app

* Loader gerunds; mv names both ends; mkdir names the folder

search_integration_tools -> Finding the right integration;
load_integration_tool -> Loading {integration} tools; load_skill ->
Loading skill {name}; run_enrichment -> Looking up {subject}. mv prefers the
model's phrasing, else reads 'Moving {files} to {destination}'; mkdir reads
'Creating folder {name}' from the path.

* Overflow counts read '+ n', dropping 'more'

* Unify workspace find and search

* Scale desktop title bar with page zoom

* Serialize account and organization truth into the copilot VFS

Workspace standing, membership, billing, org role, access-control
restrictions, published-block provenance, and fork topology were reachable
only through three parameterless tools (or not at all). They are ambient
read-only facts, so they belong in the VFS where they are greppable, cost no
tool round-trip, and every agent that can read gets them — the same move that
retired get_blocks_and_tools and list_user_workflows.

Adds account/{workspace,workspaces,members,billing}.json (always mounted) and
organization/{organization,access-control,custom-blocks,forks}.json (only when
the workspace is org-hosted). Every file projects an existing use case or util
after getOrMaterializeVFS's access assert — no new queries, no new
authorization. One relation per file, cross-referenced by id-and-name stub, so
overlapping facts cannot disagree. Volatile content (billing, access control,
forks) is lazy, so numbers are read-time fresh and unasked-for reads cost
nothing.

Projection follows the viewer: member emails are admin-only, fork detail
requires workspace admin on a forking-enabled org, and the whole organization/
namespace is absent for a personal workspace — which is itself the answer.

Retires get_account_billing, get_enterprise_context, and list_user_workspaces
along with their handlers; display titles stay for transcript replay.

* Fix insert_text refusing an editable field focused inside a frame

describeFocusedEditable descended shadow roots but not frames, while
activeElementReadback descends both. Focus inside a same-origin frame therefore
surfaced to the first as the FRAME element — not an input, not contentEditable,
not a canvas, no textbox role — so it fell through to 'not-editable' and
insert_text refused a field that press_key had just typed a character into.

Two functions answering 'what is focused' with different answers is the bug;
the descent loops now match exactly.

The refusal also names what actually held focus (tag, role, contenteditable).
A bare 'not-editable' gave the agent nothing to act on, so it guessed at the
cause — a real run spent twenty rounds on the wrong theory and had to be
stopped by the user.

* Keep retired browser takeover renderable in history

The tool is gone from the catalog, so its generated constant went with it and
every path that referenced it stopped compiling. Deleting those paths instead
would have silently downgraded every past transcript containing a takeover card
to a generic tool row, and dropped the no-timeout budget that an in-flight
takeover still needs while a rolling deploy finishes.

retired-tools.ts gives the literal a documented home that says what it is and
why it survives its tool.

* Follow the agent into a tab it opened to work in

browser_open_tab created the page with activate: false, so the agent worked in
a tab the user could not see while the panel sat on a page where nothing was
happening. The panel now follows a tab the agent deliberately opened.

Scoped to that tool only. A page spawning its own tab (popup, target=_blank) is
the site grabbing the view rather than the agent choosing a workspace, and
stays in the background as before — two existing tests pin that and caught the
first version of this change, which moved both.

A tab the user claimed still wins over both: the work starts in the background
instead of pulling the page out from under them mid-read.

* Make the browser tools agree with each other

An audit of the module found the frame-descent bug was one instance of a
pattern: six independent definitions of 'is this editable' and seven of 'what
is focused', disagreeing with each other. A tool refusing what its sibling
accepts on identical page state is invisible at runtime — the agent follows a
snapshot that says one thing into a tool that says another.

- browser_type now accepts role="textbox" like browser_insert_text does. The
  snapshot advertises those elements as [textbox] with a ref, so refusing them
  meant rejecting exactly what the outline told the model to type into. Both
  the native and synthetic paths, and their descendant scans.
- pressKeyOnPage descends shadow roots and frames like every other focus
  reader. It was dispatching synthetic keys at the shadow host or <iframe>
  element, where they bubble but never reach the editor, while reporting
  success — and contradicting the activeElement reported beside it.
- not-editable and ambiguous-editable name what was found: the element's tag
  and role, and the candidate fields. Both had the data and discarded it, which
  is what turns one blocked step into twenty rounds of guessing.
- obstructedAfterNavigation requires a dialog that ARRIVED with the
  navigation. It compared against nothing, so every SPA route change under a
  persistent role=dialog reported a successful click as obstructed. The test
  that covered this asserted the false positive; it now pins both directions.
- browser_insert_text observes the top document when typing inside a frame,
  like every other input tool. A submit that navigates the top page was
  invisible to its frame-scoped observation.

* Let hover actually see what it mounted

Four independent defects made browser_hover blind to the most common thing a
hover produces — a row's action bar — so it reported no effect on a hover that
worked, and the agent fell back to clicking pixels off screenshots.

- The popup scan matched only role=tooltip/menu/listbox. Slack's message
  shortcuts bar is a labelled toolbar/group, so it registered as nothing at
  all. Added toolbar, menubar, labelled group, and [popover].
- The baseline was captured BEFORE prepareElementSurface scrolled the target
  into view, so scrollChanged was always set by the tool's own probe. That
  pinned every unproductive hover to 'background DOM churn' instead of the
  honest 'nothing happened', and hid scrolling the hover really caused.
  Re-baselined once the scroll settles and before the pointer moves.
- The MutationObserver attached only on the first observation, while the roots
  list is rebuilt every call and grows as shadow roots mount. Components that
  appeared later were never observed, so their DOM changes raised no revision.
  Roots are now observed as they show up.
- observationTruncated was computed and never read, so a scan capped at 12k
  nodes reported 'nothing appeared' with the same confidence as a complete
  one — and portalled overlays live at the end of <body>, exactly what the cap
  drops. Hover now says the page was too large to scan and to confirm visually.

* Stop the browser agent acting on the wrong element, and say why it refused

Four findings from the module audit, the first of which could silently do the
wrong thing rather than merely fail.

- A ref whose node is gone is re-adopted by structural resemblance, matching on
  ORIGIN only so a pushState between snapshot and act does not kill every ref.
  That leniency also let a ref to a row control in one view rebind to the
  identical control in a view the app had since navigated to — acting on the
  wrong message, signalled by nothing louder than recovered: true. Adoption now
  requires the same path; a view swap reports the ref stale, and the caller
  re-snapshots. Revalidating a still-connected node stays lenient, because that
  is literally the node the model chose.

- A hit INSIDE the requested element is its own nested control, not an overlay.
  Both produced 'covered by X — close or move the overlay', advice that cannot
  be followed because there is nothing to close. Nested hits now say so and
  point at retargeting.

- browser_click_at, browser_insert_text, and browser_drag listed targetChanged
  in their effect formulas, but none passes an elementId, so no targetState is
  ever captured and the term was always false — coverage that read as real.
  Removed, with a test pinning the dependency.

- The seven effect formulas are deliberately NOT collapsed into one predicate:
  drag must trust domChanged where others must not, hover must ignore field and
  focus changes, click counts focus only for editables. Forcing one would make
  each tool wrong differently. The differences are now documented in one place
  next to the shared computation, so divergence is a declared policy rather
  than an accident.

* Let edit_workflow configure block retries

* Updates

* Always focus the resource the agent is working on, and its browser tab

The resource panel had a carve-out: an already-open browser session declined
to replace another selection and only got an attention marker, so agent
browser work happened off-screen. The panel now follows the agent to whatever
it touches — browser included — and an event can still opt out explicitly.

The browser panel also follows the agent BETWEEN tabs: the store already
tracked automationTabId (and the strip marked it), but the visible tab never
changed. It now switches when the agent's target tab changes, so watching the
agent never means hunting for the tab it moved to. Keyed on the target
changing rather than on it being set, so a user who browses elsewhere
mid-run is only pulled along when the agent itself moves.

* Never paint a browser snapshot at stale geometry (the modal-open flash)

Opening a modal locks scroll, which removes the window scrollbar and reflows
the panel — so a capture taken before the lock describes a rect the panel no
longer occupies. The handshake painted that frame anyway and only then
retried, so the replacement landed visibly offset from the page it stands in
for: the flash. A capture is now checked against the host's live rect before
it is painted; a mismatched frame is skipped and re-captured at the settled
layout instead (modal retries go 2 -> 3 to absorb the extra settle).

* Name the workflow in deployment and workflow-scoped tool titles

'Checked deployment status' never said which workflow — nor did the deployed-
state read, run settings, block outputs/inputs, redeploy, promote, or the
global-variable write. These tools carry a workflowId (often defaulting to the
current workflow), so only the client can resolve a name: the enrichment layer
now resolves it for the whole workflow-scoped family and passes it as
workflowName, which every workflow title already reads.

Titles: Checking {workflow} deployment status, Reading deployed {workflow},
Checking {workflow} run settings, Reading {workflow} block outputs, Tracing
{workflow} block inputs, Redeploying {workflow}, Promoting {workflow} version
{n} to live, and 'Adding workflow variable {name} in {workflow}' — each
falling back to its unnamed form when no workflow resolves.

* Name the block that ran; never fall back to a raw block id

run_block and set_block_enabled carry only a blockId, so their titles would
have printed an opaque UUID ('Running 7f3a2b91-… in Invoice Sync'). The
enrichment layer now resolves blockId against the workflow store the same way
it already did for run_from_block's startBlockId, and the base titles no
longer accept an id as a name — an unresolved block reads 'Running block'
rather than a UUID.

* Add the missing Removing -> Removed rewrite

The table work introduced 'Removing automation'/'Removing enrichment' with no
past form, so those rows kept their present tense after completing.

* Name the target resource in the remaining tool titles

Table tools keep their operands nested under args and identify the table by
id, so their rows said 'Adding rows' with no hint where: enrichment now lifts
the nested args and resolves tableId against the cached workspace table list,
giving 'Adding rows to Runtimes', 'Adding column status in Runtimes',
'Reading views of Runtimes'.

Also: a block-schema read names the block instead of the file ('Loading
Slack', 'Loading Google Sheets tips'); browser type/insert show the text they
send, middle-ellipsized; downloads name the file; library-docs searches name
the library and query; knowledge-base searches include the query; generated
media names its output file; and diff_workflows, list_deployment_versions,
and publish_custom_block joined the workflow-name enrichment set.

* Bubble nested agents' tool calls into the parent's status line

The collapsed status only scanned a group's OWN tool items and skipped nested
agent groups, so a parent that had delegated froze on its last own tool while
its child did the actual work — the line described nothing that was running.
Status now walks the whole subtree: any tool at any depth counts, the most
recently started running one is shown, and the rest become the same '+ n'
overflow. With nothing running it falls back to the last tool at any depth,
so an idle parent still reflects where its subtree got to.

* Align nested tool call status rows

* Revert branch-local KB connector error-message edits

Restores apps/sim/connectors/ to staging state. Two copilot-focused commits
on this branch (3a9fc1c5a5, 24b24e5f8e) drove by nine KB source connectors
(airtable, confluence, discord, github, gitlab, google-drive,
microsoft-teams, notion, slack) to enrich credential-validation error
messages. The env-reference resolution machinery those errors supported is
kept; the product connector surface stays unchanged in this branch so the
staging promotion remains scoped to copilot work.

* Fix the failing audits: NUL escape and route-count ratchet

check:source-text: resource-vfs.ts used a raw NUL byte as its folder-index
key separator (comment and template literal), which makes git treat the file
as binary and hide it from review. Written as the '\u0000' escape — the
runtime string is identical.

check:api-validation:strict: baseline 1120 -> 1122 for the two routes added
on this branch since the last bump.

* Add Force Reload (Cmd+Shift+R) to desktop View menu

* Route Force Reload through focused-resource boundary; regen docs manifest

* Align the title-bar surface audit with the zoom rework

'Scale desktop title bar with page zoom' (833d2f126d) changed the CSS contract
in two ways its audit test still pinned the old shape of: the lane vars gained
a max() floor around the platform env() terms so page zoom cannot shrink the
lane below the OS-drawn lights, and the control square became fixed px — CSS px
already scale under zoom — leaving only the centering offset derived from the
lane height. The test required the bare env() prefix and calc() on all three
control vars, so it failed the commit that implemented its own regression
comment.

Pins now assert the env() term inside the clamp (still platform-derived, the
test's actual intent) and split the control vars: offset must stay computed,
size and icon are explicit constants.

* Budget the two structurally slow tests explicitly

sso-trust imports the whole Better Auth module graph (2.5s on an idle
machine) and events.attribution scans call sites across the repo. Under a
fully-parallel uncached run on a loaded machine both blow the default
timeout while passing in isolation and on CI — a verdict decided by machine
load, not by the code. 30s budgets make a loaded local run mean what it says.

* Carry the cross-service trace id in sim log lines

* Improve nested tool status presentation

* Refresh secret schemas and shared test mocks

* Open the deployed graph of org-published blocks, read-only, org-wide

A consuming workspace could see a published block's interface but never what
it does: the backing workflow lives in the publishing workspace, and other
workspaces are nameable, not readable. Publishing a block org-wide is the act
of sharing it, so the graph it executes is now readable from any org
workspace — the DEPLOYED graph, not the publishing workspace's live editor
state, so nothing in-progress leaks and what you read is what runs.

The namespace also adopts the root's index/detail split: custom-blocks.json
slims to names with a detail pointer, organization/custom-blocks/{type}.json
carries provenance plus the deployed graph (loaded lazily through the cached
loadDeployedWorkflowState; credential ids and env references inside it belong
to the publishing workspace and say so), and organization/README.md is the
namespace guide WORKSPACE.md is at the root — files, usage, the in-depth
block inventory, and forks.json documented only when actually mounted.

The block list moves to materialize time (same indexed query the components
pass already runs) because the README, the index, and the per-block key-view
entries all need it; only the graph stays lazy.

* Withhold the deployed graph from external collaborators

Workspace access and org membership are different grants: an external
collaborator can open the workspace and use the published block, so the names
index and the interface schema stay visible to them — but the deployed graph
is org implementation internals, and their detail files now simply do not
exist. isHostOrganizationMember is the viewer bit the host context already
resolves for exactly this distinction.

* Fill out the organization namespace: workspaces, permission groups, credential groups

Three more read-only files, all lazily loaded — the paths appear in the key
view so glob discovers them, but no query runs until a read — and all gated by
registration, so an unpermitted viewer's file simply does not exist:

- workspaces.json (org members): the org's full workspace map with the
  viewer's access flag and fork parentage — account/workspaces.json only ever
  showed what the viewer can reach. Inaccessible workspaces stay nameable,
  not readable.
- permission-groups.json (org admins): every group with member count,
  targeted workspaces, and the restrictions its config activates.
  access-control.json remains the per-viewer binding. The queries are lifted
  into lib/permission-groups/queries.ts because their only prior home was
  inline drizzle in the route handlers, which the VFS cannot import.
- credential-groups.json (entitlement-gated): per-option configuration
  readiness and enrollment progress — the two facts that decide whether a
  credential_group workflow will do anything at runtime. The note teaches the
  contract that bit the audit: an active group with zero completed
  enrollments yields an empty loop, not an error. Enrollee emails are
  workspace-admin-only, matching the settings page; counts come from the
  first enrollment page and say so when truncated.

The README documents each file only when mounted for this viewer.

* Stop reporting a click that navigated as a failed click

The field case: 'Begin Assessment' submits a form. The navigation tears the
origin document down while the press completes, so everything after dispatch —
the CDP call's own completion, the synthetic dispatch's return value, the
postcondition reads — fails against a destroyed context, and a maximally
successful click was reported 'Failed clicking element'. The agent's own
follow-up investigation in the transcript diagnosed exactly this.

navigationRescue detects it at the driver level, where the navigation epoch
and URL survive the renderer teardown: when the page provably navigated since
dispatch began, a dispatch-path failure becomes a success carrying
navigatedDuringDispatch and a note explaining why no postconditions exist.
Applied to all four click dispatch paths (unframed CDP, framed native,
synthetic in-page, click_at).

The soft path had the same blindness: with the after-state unreadable,
urlChanged computed false and a navigating click reported 'no observable
change'. navigatedByDriver now folds into navigated/effectObserved, which also
keeps the new-dialog obstruction check meaningful on real navigations.

* Re-hide the browser under a modal after main loses the occlusion lease

The punch-through: a modal opens, the native view hides behind a painted
snapshot, and the renderer records applied: true. Then one heartbeat commit is
skipped — renderer jank past the 2.5s bounds-lease TTL is enough — and main
expires the lease, resetting panelOccluded on its side. The next heartbeat
finds the modal marker still present and calls setDesired(true), but the
lease's dedupe sees applied === desired and sends nothing; the bounds commit
that follows lays out an unoccluded native view above the open modal, and no
later event ever re-hides it. The comment on this branch already claimed it
'reasserts the lease' — the dedupe made that claim false exactly when the
lease had been lost.

While the occlusion marker is present, each heartbeat now drops the applied
belief (assumeRevealed) before setDesired, so the reassert is a real, forced,
idempotent hide IPC — one per second while a modal covers the browser — and
any main-side lease loss self-heals within a heartbeat.

* Make a stale ref name which of its five causes fired

A field run burned five snapshot->click cycles on a STATIC landing page, every
one refused with the same sentence — 'the page changed since the last
snapshot' — and the agent reasonably concluded the page was regenerating its
DOM. It was not; the resolver was refusing, and the message could not say why.
Five distinct conditions produced that one string: an id missing from the
registry, a connected node whose identity drifted, the view-changed adoption
gate, no confident replacement, and a replacement tie.

The resolver now stamps the reason (with the drifted node's current identity,
or the from->to paths for the view gate) and every stale producer carries it
into the driver message. Same pattern as not-editable: a refusal that names
its cause costs one round; an opaque one costs a loop and a wrong theory in
the bug report.

* Pulse throttling off when the browser view is revealed, so it actually paints

The blank-page report: a navigation completes while the view is hidden, the
page 'finishes loading', and the panel shows white until the user re-navigates
by hand. invalidate() on reveal was already there but recomposites the LAST
frame — and the last frame is blank, because background throttling suspended
the rAF the page's SPA paints its first frame from. The reveal now pulses
throttling off (forcing the renderer to produce a real frame), invalidates,
and hands the policy back to the session a second later through
reassertTabThrottling, which preserves the automation-tab exemption.

* Let the agent browser join meetings and finish passkey sign-ins

Camera and microphone: 'media' joins the agent partition's allowlist, but
every grant is gated on the macOS grant first — asked via
systemPreferences.askForMediaAccess so the system prompt appears on first use,
and answered from getMediaAccessStatus on checks — so System Settings stays
the real authority and a page can never hold a grant the OS refused. Granting
site permission without the OS grant produced the misleading NotReadableError
Google Meet showed. Packaging gains the camera entitlement and usage string
(macOS kills the process on prompt without one) and the mic string now covers
meetings.

Passkeys: WebAuthn itself is Chromium-native and nothing in our handlers
blocks it — USB security keys need no permission at all. The hybrid transport
(passkey on a nearby phone via QR) rides Bluetooth, which signed builds
silently lacked: the bluetooth entitlement and usage string enable it.
iCloud-Keychain platform passkeys remain outside what an entitlement here can
grant — Apple restricts that to approved browsers.

* Compile and preview Sim-styled pages

* Wait for the batched prepare intent instead of instantly failing apply_file_edit

The model batches prepare_file_edit and apply_file_edit into one round and
the Go loop runs same-round tools concurrently, so apply could reach the
executor before its prepare staged the intent. The instant no-intent error
cost a model retry round and flashed 'Failed creating …' on the shared file
row before the retry succeeded. The apply handler now polls briefly (10s
cap) for the intent; a truly missing prepare still errors at the deadline.

* Store page source, render docs-styled documents on view

The pdf model for agent pages: the .html file keeps the markdown-shaped
source (frontmatter + prose + sim: fences) and every surface renders the
docs-styled document on demand — preview panel, /api/files/serve, public
shares, and downloads all call the same pure compiler, now shared in
lib/workspace-files. The docs chrome is reproduced from the real fumadocs
source: the left sidebar's exact pill metrics, the clerk TOC with its
animated scroll indicator, divider-style tables; cards and stats left the
vocabulary. Table cells and kv values render inline markdown, and
sim:workflow/table/knowledge/file links resolve to real workspace routes,
bridged out of the sandboxed preview to the app router. Hand-written
imitations of rendered output are rejected at apply_file_edit with a steer
back to source, and a streaming page hides its source behind the live
rendered preview (batched ~2s) the way a generating pdf hides its script.

* Stagger the page rails so the resource panel keeps the docs sidebar

Rails were gated at 1100px of iframe width — the chat resource panel never
reaches that, so pages rendered single-column there. The rails now stagger
the way the docs do on a laptop: >=640px keeps the section sidebar (240px)
beside the content, >=1060px restores the full three-column frame with the
clerk TOC, and only a truly narrow pane collapses to one column.

* Fix in-page anchors escaping the preview; add the docs' toggle, code frames, pagination, and images

Clicking a TOC or section link (or pressing Enter in the section filter,
which clicks one) navigated the sandboxed frame off about:srcdoc in
Electron and landed on a cookie-less sign-in page — the shell now
intercepts every '#' anchor and scrolls directly. The page chrome gains
the docs' exact theme toggle (emcn Sun/Moon, 30px rounded-lg, top right),
framed code blocks with language label and copy button, and footer
previous/next cards from prev/next frontmatter. Workspace images
(![alt](sim:file/<id>)) compile to /api/files/view and the preview host
inlines them as blob: URLs so the cookie-less frame can render them;
sim:accordion joins the vocabulary as the faq component with title keys.

* Size the section sidebar to its content so it appears at panel widths

The left rail was a fixed 240/300px column, so it only earned its place
once the pane was wide. fit-content caps at the docs width but shrinks to
the longest section title (150px floor for the pills), and the two-column
tier now starts at 560px instead of 640.

* Let the clerk TOC join at 860px by sizing it to its content

Same move as the section sidebar: the TOC column fits its longest link
(capped at the docs' 268px, 150px floor), so the full three-column frame
starts at 860px of pane width instead of 1060.

* Open external links from pages in a new tab

The preview bootstrap cancelled every non-anchor click, so an external
link (the Sim docs, a vendor page) did nothing. External http(s) links now
compile with target=_blank rel=noopener for the standalone and share
surfaces, and the sandboxed preview bridges the click to the host, which
window.opens a new tab — same channel the workspace deep links use.

* Lock Sim pages to the rendered view via an internal record type

The record's contentType is stamped text/x-sim-page when apply_file_edit
detects page source — the file stays .html to the user (serving and
downloads still emit text/html), but every surface now knows what the file
holds before content loads. The viewer forces the rendered view for these
files at every moment: the first streamed chunk (whose frontmatter is
still partial) no longer flashes raw source, the gaps between an agent's
tool calls no longer flip back to raw HTML, and both toggle surfaces (the
Files toolbar and the resource-panel tabs) stop offering a code view for
them. Mid-stream compiles run lenient — a fence still being written is
malformed by definition, so its skip-notice callout is suppressed until
the stream settles.

* Honor the model's declared page type; default copilot .html to a page

An explicit contentType on create_empty_file always wins (the skill now
declares text/x-sim-page for pages, text/html for bespoke raw pages);
with no declaration a copilot-created .html defaults to the page type.
The first apply_file_edit still re-confirms from the actual content, and
the category map knows the internal mime explicitly instead of falling
through to the extension.

* Default undeclared .html back to plain text/html

A file is a Sim page only when the model declares it at creation or the
first written content proves it — never by extension alone.

* Match the docs' PageFooter for page navigation

The invented bordered cards with Previous/Next labels are replaced by the
docs' actual footer: the destination name with a 14px emcn chevron on a
flex-1 hover pill (rounded-lg, px-3 py-3, --surface-active), next
right-justified, and a spacer holding the empty half — verified against
apps/docs/components/docs-layout/page-footer.tsx.

* Scroll the rails invisibly, like the docs

The sticky TOC box is overflow-y auto, and the clerk track's absolutely
positioned SVGs could tip it a few pixels into overflow — Chromium then
painted a full scrollbar beside the rail. Rails now hide their scrollbar
chrome entirely (scrollbar-width none + webkit display none), matching
how the docs scroll their sidebar and TOC.

* Send sim:file links to the Files page, like a markdown link

A workspace-file link in a page now navigates exactly as one tagged in a
.md does: an in-app SPA push to /workspace/{ws}/files/{id} (the Files
page with the file open). The fullscreen /view route stays reserved for
the standalone surface; image refs keep the /api/files/view byte route.

* Inline workspace images after the page compiles, not before

The blob substitution ran on the raw source, where the compiled
/api/files/view src it looks for does not exist yet — so the sandboxed
cookie-less frame fetched every image itself and got 401s (broken image
icons). The substitution now runs on the built document, covering
compiled pages, legacy stored-compiled pages, and bespoke HTML alike.

* Highlight the section you are AT in the left rail, not the last one visible

The rail's current-section pick walked every heading visible in the
viewport and kept the last h2 — so clicking a section landed correctly
but highlighted whichever later section peeked in from below. Current is
now the last h2 at or above the top reading line (matching the 72px
scroll-padding a clicked anchor settles at), falling back to the first
visible section when everything is below the line.

* Stop the TOC jittering sideways as the highlight moves

Active TOC links step from weight 430 to 470, and the rail is a
fit-content column — every active-section change re-measured the longest
link and shifted the rail a pixel or two side to side. Each link now
carries a hidden zero-height ghost of itself at the active weight, so
the column always occupies its bold width and the highlight moves
without the layout moving.

* Absolutize links and images in served page documents

A downloaded page must behave like a downloaded .md whose links are
absolute: clicking a workflow reference opens Sim in the browser at that
workflow. The standalone renderer (plain download, fullscreen viewer,
shares) now compiles sim: links and workspace image refs against
getBaseUrl(); in-app surfaces keep relative paths and SPA navigation.

* Drop the eyebrow; add the docs' top page controls

The docs have no eyebrow line, so compiled pages no longer render one
(old sources still parse; the field is ignored). The title row gains the
docs' top controls: Copy page (copies the page text) and prev/next
chevrons wired to the same neighbors as the footer cards, disabled-dim
when a side is missing.

* Read kv keys and table first columns as labels, the docs way

kv keys dropped the blanket monospace — they render as the docs' row
labels (500, primary, sans), with backticks in the source opting a
code-like key (a path, an env var) into the inline-code chip; keys now
run through inline markdown to make that work. Table body first columns
pick up the same label treatment the docs tables show.

* Platform font and emcn chrome for pages

Pages live inside the app, and the platform — emcn, every workspace
surface — renders the system stack, not the docs' Inter webfont; Inter
made pages read as foreign next to the app around them. The face is now
the platform stack with weights on the platform scale (400/500/600), the
Inter delivery machinery (page-font.ts, the preview data-URI fetch, the
public woff2) is gone, and the section filter wears emcn ChipInput's
exact chrome (30px rounded-lg, --surface-5 fill flipping to --surface-4
in dark, --border, 14px, no focus ring). The docs' geometry — layout,
spacing, rails, tables, code frames — is unchanged.

* Color-only active state in the TOC — width can never move again

Two attempts at reserving the bold width (a hidden ghost, then freezing
measured rail widths) each traded one artifact for another: the ghost
did not stop the fit-content column re-measuring, and the freeze made a
long link wrap to two lines when it gained weight. The root cause was
letting the active state change a width-affecting property at all: the
active TOC link now shifts color only (muted to primary — the clerk
thumb already carries the emphasis), the search input is a plain text
field (the native search clear button is not emcn chrome), and the
ghost/freeze machinery is gone.

* Drop the Copy page control; keep the top chevrons

The title-row actions keep only the previous/next chevrons (rendered
when the page has neighbors); the Copy page button is gone.

* Set-level sidebar: docs-style groups with the current page expanded

Multi-page sets can now carry the whole set's sidebar. nav frontmatter
(groups of labelled page links, identical on every page of the set)
compiles into hidden set-nav markup whose sim: links resolve like any
other; the shell lifts it into the left rail as muted group labels over
page links, recognises the current page by title, and nests that page's
section list beneath it — the docs sidebar's exact shape. Pages without
nav keep the plain section list.

* Center the content column at the docs' measure

On wide panes the 1fr center cell stretched, so content hugged the left
rail with dead space before the TOC. The main column now caps at the
docs' ~760px measure and centers in its cell, matching how the docs
balance a wide viewport.

* Docs Steps, code-tab groups, and API method chips

Three docs components join the vocabulary: sim:steps renders the
numbered timeline (muted circle markers, hairline connector, title and
content per step); sim:tabs renders the docs' grouped code block (mono
tab chips, one pane at a time, the icon copy control targeting the
visible pane); and a METHOD prefix on a set-nav page entry renders the
API-reference chip — sidebar entries only, on the platform badge tokens
(blue and purple added to the mirrors and the live bridge).

Also: preview images switched from blob: to data: URIs — blob URLs are
origin-bound and the sandboxed frame's origin is opaque, so Chromium
refused to render them — and the page view-lock is sticky per file so a
patch stream cannot flash raw source.

* Downloaded pages carry their images

Absolute URLs made LINKS survive a download, but an embedded image
request from a downloaded file is cross-site and carries no session
cookie, so images 401ed outside the app. The standalone renderer now
inlines every workspace image the page references as a data: URI at
serve time — like a pdf carrying its images — capped at 8MB per image,
restricted to the page's own workspace, falling back to the URL
reference on any miss. Applies to serve, download, and public shares.

* Dead-center the content column between equal gutters

The rails are content-sized and unequal, so the old grid (fit-content /
1fr / fit-content) skewed the middle cell toward whichever rail was
narrower. The wide tier now uses the docs' geometry: a fixed 760px
content column centered between two equal flexible gutters, the sidebar
hugging the container's left edge and the TOC its right — rail widths
can no longer move the content.

* Defer title-bar history state out of currententrychange dispatch

The Navigation API fires currententrychange synchronously from the
history mutation that caused it, which can originate inside another
component's useInsertionEffect (style libraries navigating during
commit) — setState there trips React's 'useInsertionEffect must not
schedule updates'. The arrow-state sync now defers to a microtask,
flushing after the commit unwinds, with a disposal guard.

* Show the section sidebar only when there are sections to list

Fewer than two sections (and no set nav): the left rail and its filter
disappear and the reserved left gutter collapses — the content column
leads the container with the TOC trailing. Two or more sections, or a
multi-page set, keep the full centered docs frame.

* Execute the page shell in a DOM harness

jsdom runs the real shell against compiled pages and asserts the layout
decisions: both rails on a many-section page, only the left rail dropped
on a one-section page.

* Medium panes keep the TOC, not the sidebar

Between 560 and 860px the frame showed the section sidebar and hid the
clerk TOC — backwards by our own reasoning, since the sidebar is the
redundant list on a single page. The TOC now survives at medium widths
and the sidebar joins only on wide panes.

* Sidebar is for doc sets only; stagger the rails like the docs

The left rail now exists only for multi-page sets — on a lone page it
just repeated the TOC. A set opens its sidebar at 560px with the TOC
joining on wide panes (the docs stagger); a lone page waits until 700px
and then shows the TOC alone. Set-sidebar spacing tightens to the docs
values, with the current page's nested sections styled as small muted
entries behind a hairline instead of full chips.

* Center the lone-page content and TOC as a pair

On a page with no sidebar the content column stretched while the TOC
hugged the far edge, leaving a field of dead space between them. The
content now caps at reading width with the TOC directly beside it and
the pair centered in the pane, and the TOC waits until 800px so narrow
panes stay single-column a while longer.

* Equalize grid-template specificity across the rail tiers

The 560px tier selects .art-cols:not(.no-side-nav) at (0,2,0), so the
860px tier's bare .art-cols template at (0,1,0) could never win and a
set page on a wide pane kept the 2-column template — wrapping the TOC
to the next grid row, bottom-left. The wide template now carries the
same :not() guard, the 860 block's duplicate of the 800px no-side-nav
rules is gone, and a test pins every template rule to equal specificity
so a future tier can't silently lose the cascade again.

* extract_doc_assets: pull a reference deck's assets into the workspace

Sim-side handler for the new file-agent tool: given an uploaded .pptx
or .docx, unzip it (OOXML is a zip), parse theme1.xml into theme.json
(color scheme as hex, major/minor fonts, slide size from
presentation.xml) and write every ppt|word/media file into a
"<Name> assets" folder with original bytes and real content types.
Re-runs overwrite the set in place. Pure extractor unit-tested against
in-test-built packages; display label "Extracting assets from <file>".

* extract_doc_assets learns .pdf via the doc sandbox

PDFs have no zip structure or declared theme, so extraction runs in the
same vetted sandbox that compiles and renders documents: poppler's
pdfimages dumps every embedded image in its native format (masks
filtered via -list), pdfplumber contributes each image's placement
rects in page points plus the document's font names, and rendered pages
are sampled into an explicitly-inferred color palette. theme.json for a
pdf carries fonts, page size and count, the inferred palette, and a
per-asset placement map.

* Pages have one navigation rail; compile errors go to the agent

The left sidebar leaves the renderer and the DSL: the shell builds only
the content column and the clerk TOC (pair centered at 800px, one bare
.art-cols selector per tier so the cascade cannot invert), the filter
box goes with it, and nav frontmatter is tolerated but no longer
rendered — sidebar METHOD chips and the set-nav markup are gone.

Malformed sim: blocks no longer render a reader-facing "block was
skipped" card: the block is omitted and the failure is reported as a
diagnostic that apply_file_edit appends to its result, so the authoring
agent sees exactly which fence to fix. The lenient flag existed only to
suppress those cards mid-stream and is removed.

The steps timeline connector now derives its position from the marker
size, so it stays centered under the number circles.

* Sync tool catalog: extract_doc_assets accepts pdf

* Asset extraction yields the rebuild recipe, not just the parts

pptx: theme.json now maps every image to its slide-by-slide placements
(slide rels resolve rIds to media names; each pic frame's EMU offset and
extent convert to inches) plus the slide count.

pdf: a second layout.json is written — per page, the text blocks with
content, position, font, size, and fill color; the filled rects
(backgrounds and scrims); and rect-over-image overlay detection with
coverage, which is the "image opacity" effect decks fake with a tinted
rect. Stream alpha is unrecoverable, so overlays name the color and the
rendered page remains the reference for strength.

* Split shared-baseline text runs into separate blocks

Two text boxes sitting at the same height merged into one wide line;
a gap much wider than a space now starts a new block, so columns and
label/value pairs land as distinct entries in layout.json.

* Extract faithful document layout recipes

* Add .chart files: live interactive ECharts docs, static or table-backed

* Size charts by width-driven aspect, not panel height; separate title and legend

* Map table chart rows from storage column ids to display names

* Inject table rows as datasetIndex 0 so specs can transform; stagger array legends

* Give .chart files their own bar-chart icon

* Chart table sources gain groupBy/aggregate/pivot shaping; renderer-owned chrome

* sim:chart page fence: ECharts SSR to themed inline SVG; shared option builder

* sim:chart hydrated embeds: inline or .chart file refs, live table reads per serve

* Finish extensionless pages and document staging

* Render live charts without server hydration

* Cover active-theme page token overrides

* Keep artifact tokens synced with the app theme

* Use tabs for multi-page Sim docs

* Preserve dollar-prefixed tool credentials

* Build chart specs from validated fields

* Sync new integration docs into Copilot manifest

* Add in-document tabs to Sim pages

* Rebuild page TOC on tab changes

* Keep page tabs with docs chrome

* Stabilize tabbed page layout

* Regenerate docs manifest for staging's Modal docs page

* Share one divider between the bar and the chrome tab row

* Pin the keyless OCR path in the unreadable-document test

---------

Co-authored-by: Justin Blumencranz <96924014+j15z@users.noreply.github.com>
Co-authored-by: Vikhyath Mondreti <vikhyath@simstudio.ai>
---
 .github/workflows/test-build.yml              |    3 +
 apps/desktop/build/entitlements.mac.plist     |   10 +
 apps/desktop/electron-builder.yml             |    4 +-
 .../src/main/browser-agent/cdp.test.ts        |   89 +-
 apps/desktop/src/main/browser-agent/cdp.ts    |  251 +-
 .../src/main/browser-agent/driver.test.ts     |  495 ++-
 apps/desktop/src/main/browser-agent/driver.ts |  714 +++-
 .../main/browser-agent/page-functions.test.ts |  196 +-
 .../src/main/browser-agent/page-functions.ts  |  456 ++-
 .../src/main/browser-agent/panel.test.ts      |   24 +
 apps/desktop/src/main/browser-agent/panel.ts  |   23 +-
 .../src/main/browser-agent/session.test.ts    |   34 +-
 .../desktop/src/main/browser-agent/session.ts |   94 +-
 .../main/browser-search/suggestions.test.ts   |   74 +
 .../src/main/browser-search/suggestions.ts    |  102 +
 apps/desktop/src/main/config.ts               |    3 +
 .../desktop/src/main/desktop-settings.test.ts |   11 +
 apps/desktop/src/main/desktop-settings.ts     |    7 +
 apps/desktop/src/main/ipc.test.ts             |   23 +
 apps/desktop/src/main/ipc.ts                  |   20 +
 apps/desktop/src/main/menu.test.ts            |   27 +-
 apps/desktop/src/main/menu.ts                 |   66 +-
 apps/desktop/src/main/resource-shortcuts.ts   |    1 +
 apps/desktop/src/main/terminal/index.ts       |    3 +-
 apps/desktop/src/main/terminal/session.ts     |    2 +-
 apps/desktop/src/preload/index.test.ts        |    4 +
 apps/desktop/src/preload/index.ts             |    4 +
 apps/desktop/src/test/electron-mock.ts        |   13 +
 .../content/docs/en/platform/permissions.mdx  |    5 +-
 .../_shell/desktop-title-bar-surfaces.test.ts |   16 +-
 apps/sim/app/_styles/globals.css              |   29 +-
 .../app/api/copilot/chat/steer/route.test.ts  |  128 +
 apps/sim/app/api/copilot/chat/steer/route.ts  |  128 +
 .../api/copilot/tools/execute/route.test.ts   |  114 +
 .../app/api/copilot/tools/execute/route.ts    |  206 +
 .../api/files/public/[token]/content/route.ts |   20 +
 .../app/api/files/serve/[...path]/route.ts    |   34 +-
 apps/sim/app/api/files/utils.ts               |   14 +-
 .../app/api/mothership/execute/route.test.ts  |   10 +-
 apps/sim/app/api/mothership/execute/route.ts  |    3 +-
 apps/sim/app/api/table/utils.ts               |   23 +-
 .../[id]/execute/route.async.test.ts          |   38 +-
 .../app/api/workflows/[id]/execute/route.ts   |   60 +-
 .../find-bar/find-bar.test.tsx}               |   28 +-
 .../find-bar/find-bar.tsx}                    |   56 +-
 .../[workspaceId]/components/index.ts         |    3 +
 .../components/resource/resource.tsx          |   14 +-
 .../search-highlight/search-highlight.tsx     |    0
 .../workspace-chrome/workspace-chrome.tsx     |   66 +-
 .../components/file-viewer/chart-preview.tsx  |  178 +
 .../components/file-viewer/file-category.ts   |    4 +
 .../components/file-viewer/preview-panel.tsx  |  234 +-
 .../components/file-viewer/text-editor.tsx    |   31 +-
 .../workspace/[workspaceId]/files/files.tsx   |  167 +-
 .../agent-group/agent-group.test.ts           |   81 +
 .../components/agent-group/agent-group.tsx    |   83 +-
 .../components/agent-group/tool-call-item.tsx |   16 +-
 .../special-tags/special-tags.test.ts         |  156 +
 .../special-tags/special-tags.test.tsx        |   45 +
 .../components/special-tags/special-tags.tsx  |  202 +-
 .../message-content/message-content.test.ts   |   26 +-
 .../message-content/message-content.tsx       |    6 +-
 .../home/components/message-content/utils.ts  |   15 +-
 .../mothership-chat/mothership-chat.tsx       |   35 +-
 .../browser-panel-occlusion.test.ts           |   42 +
 .../browser-panel-occlusion.ts                |   37 +-
 .../browser-session/browser-session.test.ts   |    4 +
 .../browser-session/browser-session.tsx       |  129 +-
 .../browser-session/url-suggestions.test.ts   |   62 +
 .../browser-session/url-suggestions.ts        |   55 +
 .../resource-content/resource-content.tsx     |    1 +
 .../resource-tabs/resource-tabs.tsx           |    4 +-
 .../mothership-view/mothership-view.tsx       |    6 +-
 .../app/workspace/[workspaceId]/home/home.tsx |   23 +-
 .../[workspaceId]/home/hooks/index.ts         |    2 +
 .../home/hooks/stream/handle-tool-event.ts    |   17 +-
 .../home/hooks/stream/stream-helpers.ts       |  144 +-
 .../hooks/stream/turn-model-serialize.test.ts |   20 +-
 .../home/hooks/stream/turn-model-serialize.ts |    6 +-
 .../home/hooks/stream/turn-model.test.ts      |  167 +-
 .../home/hooks/stream/turn-model.ts           |   52 +-
 .../[workspaceId]/home/hooks/use-chat.test.ts |   73 +
 .../[workspaceId]/home/hooks/use-chat.ts      |  166 +-
 .../app/workspace/[workspaceId]/home/types.ts |   10 +-
 .../connect-slack-bot-modal.tsx               |   11 +-
 .../knowledge/[id]/[documentId]/document.tsx  |    3 +-
 .../[workspaceId]/knowledge/[id]/base.tsx     |    2 +-
 .../knowledge/[id]/components/index.ts        |    1 -
 .../[id]/components/search-highlight/index.ts |    1 -
 .../components/browser/browser.test.tsx       |   42 +-
 .../settings/components/browser/browser.tsx   |   28 +
 .../components/table-grid/table-grid.tsx      |    5 +-
 .../[workspaceId]/tables/[tableId]/table.tsx  |   28 +-
 .../utils/workflow-execution-utils.ts         |    5 +-
 apps/sim/components/icons/document-icons.tsx  |   30 +
 .../components/group-detail.tsx               |  148 +-
 .../utils/permission-check.test.ts            |  122 +
 .../access-control/utils/permission-check.ts  |  102 +-
 apps/sim/hooks/queries/tables.ts              |   41 +
 apps/sim/hooks/queries/utils/table-keys.ts    |    3 +
 apps/sim/hooks/use-smooth-text.test.tsx       |   36 +-
 apps/sim/hooks/use-smooth-text.ts             |   41 +-
 apps/sim/instrumentation-node.ts              |   33 +
 apps/sim/lib/api/contracts/copilot.ts         |   22 +
 apps/sim/lib/api/contracts/custom-blocks.ts   |    2 +-
 apps/sim/lib/api/contracts/logs.ts            |    4 +
 apps/sim/lib/api/contracts/organization.ts    |    4 +-
 apps/sim/lib/api/contracts/primitives.test.ts |   11 +
 apps/sim/lib/api/contracts/primitives.ts      |    6 +
 apps/sim/lib/api/contracts/workspaces.test.ts |   32 +
 apps/sim/lib/api/contracts/workspaces.ts      |    8 +-
 apps/sim/lib/auth/sso-trust.test.ts           |    5 +
 .../core/account-billing-snapshot.test.ts     |  100 +
 .../billing/core/account-billing-snapshot.ts  |   58 +
 apps/sim/lib/billing/core/subscription.ts     |    2 +-
 apps/sim/lib/billing/core/usage.ts            |   48 +-
 apps/sim/lib/browser-agent/open-in-panel.ts   |    2 +-
 apps/sim/lib/browser-agent/transport.test.ts  |   29 +
 apps/sim/lib/browser-agent/transport.ts       |   22 +
 apps/sim/lib/charts/option.ts                 |   86 +
 apps/sim/lib/charts/spec.test.ts              |  116 +
 apps/sim/lib/charts/spec.ts                   |  203 +
 apps/sim/lib/copilot/application/error.ts     |   37 +-
 .../execute-platform-context-use-case.ts      |   40 +
 .../application/table-commands.test.ts        |    2 +-
 .../lib/copilot/async-runs/repository.test.ts |   28 +-
 .../auth/application-delegation.test.ts       |   22 +
 .../copilot/auth/application-delegation.ts    |   26 +
 .../lib/copilot/chat/desktop-capabilities.ts  |    3 +
 apps/sim/lib/copilot/chat/display-message.ts  |   16 +-
 .../copilot/chat/effective-transcript.test.ts |   45 +-
 .../lib/copilot/chat/effective-transcript.ts  |   22 +
 apps/sim/lib/copilot/chat/payload.test.ts     |    4 +-
 apps/sim/lib/copilot/chat/payload.ts          |    6 +-
 .../sim/lib/copilot/chat/persisted-message.ts |   12 +-
 apps/sim/lib/copilot/chat/post.test.ts        |    6 +-
 apps/sim/lib/copilot/chat/post.ts             |   28 +-
 .../lib/copilot/chat/process-contents.test.ts |  121 +
 apps/sim/lib/copilot/chat/process-contents.ts |   35 +-
 apps/sim/lib/copilot/constants.ts             |   13 +
 apps/sim/lib/copilot/docs/docs-corpus.test.ts |  235 ++
 apps/sim/lib/copilot/docs/docs-corpus.ts      |  251 ++
 apps/sim/lib/copilot/docs/docs-path.test.ts   |   35 +
 apps/sim/lib/copilot/docs/docs-path.ts        |   44 +
 apps/sim/lib/copilot/docs/docs-search.test.ts |  292 ++
 apps/sim/lib/copilot/docs/docs-search.ts      |  207 +
 apps/sim/lib/copilot/entitlements.ts          |   14 +
 .../lib/copilot/generated/docs-manifest.ts    |  422 ++
 apps/sim/lib/copilot/generated/metrics-v1.ts  |    2 +
 .../generated/mothership-stream-v1-schema.ts  |   31 +-
 .../copilot/generated/mothership-stream-v1.ts |    3 +
 .../lib/copilot/generated/tool-catalog-v1.ts  | 3386 ++++++++++++-----
 .../lib/copilot/generated/tool-schemas-v1.ts  | 3104 ++++++++++-----
 .../generated/trace-attribute-values-v1.ts    |   64 +
 .../copilot/generated/trace-attributes-v1.ts  |   96 +-
 .../lib/copilot/generated/trace-spans-v1.ts   |   20 +
 .../lib/copilot/generated/vfs-snapshot-v1.ts  |   14 -
 .../copilot/request/context/result.test.ts    |   10 +-
 .../request/go/file-preview-adapter.test.ts   |    8 +-
 .../request/go/file-preview-adapter.ts        |   41 +-
 .../sim/lib/copilot/request/go/stream.test.ts |   88 +-
 apps/sim/lib/copilot/request/go/stream.ts     |   19 +
 .../copilot/request/handlers/handlers.test.ts |  300 +-
 apps/sim/lib/copilot/request/handlers/span.ts |   41 +
 apps/sim/lib/copilot/request/handlers/tool.ts |  161 +-
 .../sim/lib/copilot/request/handlers/types.ts |   34 +-
 .../request/lifecycle/headless.test.ts        |   18 +
 .../lib/copilot/request/lifecycle/headless.ts |    1 +
 .../lifecycle/resume-leg-context.test.ts      |   35 +
 .../lib/copilot/request/lifecycle/run.test.ts |  196 +
 apps/sim/lib/copilot/request/lifecycle/run.ts |  217 +-
 apps/sim/lib/copilot/request/metrics.ts       |   15 +
 apps/sim/lib/copilot/request/otel.ts          |    9 +
 .../copilot/request/session/contract.test.ts  |    2 +-
 .../lib/copilot/request/session/contract.ts   |   12 +-
 .../lib/copilot/request/session/event.test.ts |    4 +-
 apps/sim/lib/copilot/request/session/steer.ts |   79 +
 .../copilot/request/session/writer.test.ts    |    2 +-
 .../sim/lib/copilot/request/sse-utils.test.ts |    2 +-
 .../copilot/request/tools/executor.test.ts    |   64 +-
 .../sim/lib/copilot/request/tools/executor.ts |   82 +-
 .../lib/copilot/request/tools/files.test.ts   |   44 +-
 apps/sim/lib/copilot/request/tools/files.ts   |   10 +-
 .../copilot/request/tools/permission.test.ts  |   20 +-
 .../lib/copilot/request/tools/permissions.ts  |    4 +-
 .../tools/resolved-secret-result.test.ts      |   30 +-
 .../request/tools/resolved-secret-result.ts   |   42 +-
 .../lib/copilot/request/tools/tables.test.ts  |   16 +-
 apps/sim/lib/copilot/request/tools/tables.ts  |    4 +-
 .../tools/workflow-client-fallback.test.ts    |  177 +
 .../request/tools/workflow-client-fallback.ts |  143 +
 apps/sim/lib/copilot/request/types.ts         |    6 +-
 .../lib/copilot/resources/extraction.test.ts  |   18 +-
 apps/sim/lib/copilot/resources/extraction.ts  |   40 +-
 apps/sim/lib/copilot/resources/types.ts       |    2 +
 .../copilot/tool-executor/executor.test.ts    |   46 +-
 .../sim/lib/copilot/tool-executor/executor.ts |    2 +-
 .../tool-executor/register-handlers.ts        |   45 +-
 apps/sim/lib/copilot/tool-executor/types.ts   |   10 +
 .../client/browser-tool-execution.test.ts     |   35 +
 .../tools/client/browser-tool-execution.ts    |   30 +
 .../lib/copilot/tools/client/completion.ts    |   13 +-
 .../tools/client/run-tool-execution.test.ts   |   76 +-
 .../tools/client/run-tool-execution.ts        |   32 +-
 .../copilot/tools/client/store-utils.test.ts  |   77 +-
 .../lib/copilot/tools/client/store-utils.ts   |   87 +-
 .../tools/handlers/deployment/context.test.ts |    2 +-
 .../handlers/deployment/custom-block.test.ts  |    2 +-
 .../tools/handlers/deployment/custom-block.ts |    8 +-
 .../tools/handlers/deployment/deploy.test.ts  |    4 +-
 .../tools/handlers/deployment/deploy.ts       |   22 +-
 .../tools/handlers/deployment/manage.ts       |    3 +-
 .../tools/handlers/function-execute.test.ts   |    8 +-
 .../tools/handlers/function-execute.ts        |   24 +-
 .../management/connect-slack-bot.test.ts      |  105 +
 .../handlers/management/connect-slack-bot.ts  |   91 +
 .../handlers/management/manage-custom-tool.ts |    4 +-
 .../handlers/management/manage-mcp-tool.ts    |   11 +-
 .../handlers/management/manage-sandbox.ts     |    6 +-
 .../tools/handlers/materialize-file.test.ts   |    8 +-
 .../tools/handlers/materialize-file.ts        |   14 +-
 .../lib/copilot/tools/handlers/param-types.ts |    3 +
 .../tools/handlers/platform-actions.ts        |  118 -
 .../lib/copilot/tools/handlers/platform.ts    |    9 -
 .../copilot/tools/handlers/resources.test.ts  |   55 +
 .../lib/copilot/tools/handlers/resources.ts   |   38 +-
 .../lib/copilot/tools/handlers/run-code.ts    |    2 +-
 .../tools/handlers/upload-file-reader.test.ts |    6 +-
 .../copilot/tools/handlers/vfs-mutate.test.ts |  200 +-
 .../lib/copilot/tools/handlers/vfs-mutate.ts  |  327 +-
 .../lib/copilot/tools/handlers/vfs.test.ts    |  213 +-
 apps/sim/lib/copilot/tools/handlers/vfs.ts    |  192 +-
 .../tools/handlers/workflow/mutations.ts      |   10 +
 .../tools/handlers/workflow/queries.test.ts   |    2 +-
 .../tools/handlers/workflow/queries.ts        |   18 -
 .../sim/lib/copilot/tools/permissions.test.ts |    4 +-
 .../registry/server-tool-adapter.test.ts      |   10 +-
 .../tools/registry/server-tool-adapter.ts     |    5 +-
 apps/sim/lib/copilot/tools/retired-tools.ts   |   19 +
 .../sim/lib/copilot/tools/server/base-tool.ts |    2 +-
 .../server/docs/search-docs-dispatch.test.ts  |   39 +
 .../tools/server/docs/search-docs.test.ts     |  152 +
 .../copilot/tools/server/docs/search-docs.ts  |   79 +
 .../server/docs/search-documentation.test.ts  |   56 -
 .../tools/server/docs/search-documentation.ts |   60 -
 .../tools/server/enrichment/enrichment-run.ts |    4 +-
 .../lib/copilot/tools/server/env-reference.ts |   39 +
 .../copilot/tools/server/files/create-file.ts |   77 +-
 .../server/files/doc-asset-extract-pdf.ts     |  477 +++
 .../server/files/doc-asset-extract.test.ts    |  156 +
 .../tools/server/files/doc-asset-extract.ts   |  418 ++
 .../tools/server/files/doc-compile.test.ts    |   23 +-
 .../copilot/tools/server/files/doc-compile.ts |   47 +-
 .../files/download-to-workspace-file.ts       |   14 +-
 .../tools/server/files/edit-content.test.ts   |    8 +-
 .../tools/server/files/edit-content.ts        |   88 +-
 .../tools/server/files/extract-doc-assets.ts  |  221 ++
 .../server/files/file-intent-store.test.ts    |   35 +-
 .../tools/server/files/file-intent-store.ts   |   32 +-
 .../tools/server/files/file-preview.ts        |    6 +-
 .../copilot/tools/server/files/share-file.ts  |   16 +-
 .../tools/server/files/workspace-file.ts      |   20 +-
 .../tools/server/image/generate-image.ts      |   14 +
 .../server/knowledge/knowledge-base.test.ts   |  118 +-
 .../tools/server/knowledge/knowledge-base.ts  |  114 +-
 .../server/knowledge/search-knowledge-base.ts |    4 +-
 .../lib/copilot/tools/server/media/ffmpeg.ts  |    5 +-
 .../tools/server/media/generate-audio.ts      |   11 +
 .../tools/server/media/generate-video.ts      |   11 +
 .../tools/server/other/search-online.test.ts  |    2 +-
 .../tools/server/other/search-online.ts       |    8 +-
 apps/sim/lib/copilot/tools/server/router.ts   |   38 +-
 .../tools/server/table/table-automations.ts   |   49 +
 .../tools/server/table/table-columns.ts       |   42 +
 .../tools/server/table/table-enrichments.ts   |   40 +
 .../tools/server/table/table-manage.ts        |   37 +
 .../copilot/tools/server/table/table-rows.ts  |   46 +
 .../tools/server/table/table-split.test.ts    |   60 +
 .../tools/server/table/table-views.test.ts    |  123 +
 .../copilot/tools/server/table/table-views.ts |  199 +
 .../tools/server/table/user-table.test.ts     |    4 +-
 .../copilot/tools/server/table/user-table.ts  |   55 +-
 .../workflow/edit-workflow/builders.test.ts   |   79 +
 .../server/workflow/edit-workflow/builders.ts |   83 +
 .../workflow/edit-workflow/operations.ts      |   12 +
 .../server/workflow/edit-workflow/types.ts    |    1 +
 .../workflow/edit-workflow/validation.ts      |   21 +-
 .../tools/server/workflow/query-logs.test.ts  |  108 +-
 .../tools/server/workflow/query-logs.ts       |  110 +-
 .../lib/copilot/tools/tool-display.test.ts    |  220 +-
 apps/sim/lib/copilot/tools/tool-display.ts    |  577 ++-
 .../lib/copilot/tools/workflow-tools.test.ts  |   86 +
 apps/sim/lib/copilot/tools/workflow-tools.ts  |  101 +
 apps/sim/lib/copilot/vfs/file-reader.ts       |   10 +-
 apps/sim/lib/copilot/vfs/operations.test.ts   |   57 +-
 apps/sim/lib/copilot/vfs/operations.ts        |   44 +-
 .../lib/copilot/vfs/resource-writer.test.ts   |   54 +
 apps/sim/lib/copilot/vfs/resource-writer.ts   |   63 +-
 apps/sim/lib/copilot/vfs/serializers.test.ts  |  371 ++
 apps/sim/lib/copilot/vfs/serializers.ts       |  633 ++-
 .../sim/lib/copilot/vfs/workspace-vfs.test.ts |  102 +
 apps/sim/lib/copilot/vfs/workspace-vfs.ts     |  599 ++-
 apps/sim/lib/core/config/feature-flags.ts     |    3 +-
 apps/sim/lib/core/utils/with-route-handler.ts |   16 +-
 apps/sim/lib/desktop/index.test.ts            |   38 +
 apps/sim/lib/desktop/index.ts                 |   27 +-
 .../lib/folders/application/resource-vfs.ts   |  438 +++
 .../knowledge/application/documents.test.ts   |  122 +
 .../lib/knowledge/application/documents.ts    |   83 +-
 .../knowledge/application/knowledge-bases.ts  |    2 +
 .../knowledge/application/knowledge-vfs.ts    |  160 +-
 .../knowledge/application/operations.test.ts  |    2 +
 .../lib/knowledge/application/operations.ts   |   12 +
 .../documents/unreadable-document.test.ts     |   14 +-
 .../lib/knowledge/orchestration/connectors.ts |    6 +-
 apps/sim/lib/knowledge/service.ts             |    5 +-
 apps/sim/lib/logs/list-logs.ts                |   33 +
 apps/sim/lib/logs/log-views.test.ts           |   73 +-
 apps/sim/lib/logs/log-views.ts                |  118 +-
 apps/sim/lib/logs/stats-logs.ts               |  214 ++
 .../mcp/application/workflow-deployments.ts   |    2 +-
 apps/sim/lib/mcp/workflow-mcp-sync.ts         |    2 +-
 .../lib/organizations/settings-access.test.ts |    8 +
 apps/sim/lib/organizations/settings-access.ts |    5 +-
 .../lib/permission-groups/features.test.ts    |   97 +
 apps/sim/lib/permission-groups/features.ts    |  228 ++
 apps/sim/lib/permission-groups/queries.ts     |  107 +
 .../application/authorization.ts              |   12 +
 .../platform-context/application/context.ts   |   14 +
 .../application/operations.ts                 |   24 +
 .../platform-context-use-cases.test.ts        |  221 ++
 .../application/read-account-billing.ts       |   22 +
 .../application/read-enterprise-context.ts    |   88 +
 .../pptx-renderer/renderer/chart-renderer.ts  |   10 +-
 .../pptx-renderer/renderer/text-renderer.ts   |    7 +-
 .../pptx-renderer/utils/font-stack.test.ts    |   43 +
 .../sim/lib/pptx-renderer/utils/font-stack.ts |   69 +
 .../sim/lib/table/application/context.test.ts |   17 +-
 apps/sim/lib/table/application/context.ts     |    5 +-
 apps/sim/lib/table/application/operations.ts  |    6 +
 apps/sim/lib/table/application/table-vfs.ts   |  157 +-
 apps/sim/lib/table/application/tables.ts      |   11 +-
 apps/sim/lib/table/application/views.ts       |   36 +-
 .../application/workspace-file-imports.ts     |    2 +-
 apps/sim/lib/table/events.attribution.test.ts |    7 +-
 apps/sim/lib/table/views/service.test.ts      |   63 +-
 apps/sim/lib/table/views/service.ts           |   82 +
 apps/sim/lib/uploads/archive.test.ts          |    2 +-
 apps/sim/lib/uploads/archive.ts               |    2 +-
 .../workspace/track-chat-upload.test.ts       |    2 +-
 .../workspace/workspace-file-manager.ts       |    2 +-
 .../workspace-file-secret-provenance.ts       |    6 +-
 .../lib/uploads/utils/file-utils.server.ts    |   25 +-
 apps/sim/lib/uploads/utils/file-utils.ts      |    2 +-
 apps/sim/lib/uploads/utils/validation.ts      |    5 +-
 .../run-workflow-from-copilot.test.ts         |   65 +
 .../application/run-workflow-from-copilot.ts  |   34 +-
 .../lib/workflows/custom-blocks/operations.ts |    2 +-
 .../orchestration/chat-deploy.test.ts         |    2 +-
 .../workflows/orchestration/chat-deploy.ts    |   84 +-
 .../sanitization/json-sanitizer.test.ts       |   44 +-
 .../workflows/sanitization/json-sanitizer.ts  |   37 +-
 .../workflows/search-replace/indexer.test.ts  |   40 +
 .../lib/workflows/search-replace/indexer.ts   |   15 +-
 .../search-replace/resources/references.ts    |   18 +-
 .../search-replace/resources/resolvers.ts     |    6 +-
 .../artifact-stylesheet.test.ts               |  299 ++
 .../workspace-files/artifact-stylesheet.ts    |  948 +++++
 .../lib/workspace-files/page-compile.test.ts  |  328 ++
 apps/sim/lib/workspace-files/page-compile.ts  |  524 +++
 .../workspace-files/page-document.server.ts   |   50 +
 apps/sim/lib/workspace-files/page-document.ts |   25 +
 .../workspace-files/page-tabs-rail.test.ts    |  129 +
 .../lib/workspace-files/shell-layout.test.ts  |   58 +
 apps/sim/lib/workspaces/host-context.test.ts  |    3 +
 apps/sim/lib/workspaces/host-context.ts       |    3 +-
 apps/sim/package.json                         |    3 +
 apps/sim/tools/index.ts                       |   23 +-
 apps/sim/tools/params.ts                      |   10 +
 apps/sim/triggers/constants.ts                |   10 +
 apps/sim/triggers/webhook-url.ts              |   10 +
 bun.lock                                      |    9 +-
 package.json                                  |    2 +
 packages/browser-protocol/src/index.ts        |    3 +
 packages/desktop-bridge/src/index.ts          |   12 +
 packages/logger/package.json                  |    1 +
 packages/logger/src/index.ts                  |   61 +-
 packages/logger/src/request-context.ts        |   20 +
 packages/testing/src/mocks/logger.mock.ts     |    1 +
 .../testing/src/mocks/permissions.mock.ts     |    5 +
 scripts/check-api-validation-contracts.ts     |    4 +-
 ...check-tool-registry-boundary.baseline.json |  168 +-
 scripts/sync-docs-manifest.ts                 |  113 +
 393 files changed, 28352 insertions(+), 4121 deletions(-)
 create mode 100644 apps/desktop/src/main/browser-search/suggestions.test.ts
 create mode 100644 apps/desktop/src/main/browser-search/suggestions.ts
 create mode 100644 apps/sim/app/api/copilot/chat/steer/route.test.ts
 create mode 100644 apps/sim/app/api/copilot/chat/steer/route.ts
 create mode 100644 apps/sim/app/api/copilot/tools/execute/route.test.ts
 create mode 100644 apps/sim/app/api/copilot/tools/execute/route.ts
 rename apps/sim/app/workspace/[workspaceId]/{tables/[tableId]/components/table-grid/table-find.test.tsx => components/find-bar/find-bar.test.tsx} (89%)
 rename apps/sim/app/workspace/[workspaceId]/{tables/[tableId]/components/table-grid/table-find.tsx => components/find-bar/find-bar.tsx} (73%)
 rename apps/sim/app/workspace/[workspaceId]/{knowledge/[id] => }/components/search-highlight/search-highlight.tsx (100%)
 create mode 100644 apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/chart-preview.tsx
 delete mode 100644 apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/search-highlight/index.ts
 create mode 100644 apps/sim/lib/api/contracts/workspaces.test.ts
 create mode 100644 apps/sim/lib/billing/core/account-billing-snapshot.test.ts
 create mode 100644 apps/sim/lib/billing/core/account-billing-snapshot.ts
 create mode 100644 apps/sim/lib/charts/option.ts
 create mode 100644 apps/sim/lib/charts/spec.test.ts
 create mode 100644 apps/sim/lib/charts/spec.ts
 create mode 100644 apps/sim/lib/copilot/application/execute-platform-context-use-case.ts
 create mode 100644 apps/sim/lib/copilot/chat/desktop-capabilities.ts
 create mode 100644 apps/sim/lib/copilot/docs/docs-corpus.test.ts
 create mode 100644 apps/sim/lib/copilot/docs/docs-corpus.ts
 create mode 100644 apps/sim/lib/copilot/docs/docs-path.test.ts
 create mode 100644 apps/sim/lib/copilot/docs/docs-path.ts
 create mode 100644 apps/sim/lib/copilot/docs/docs-search.test.ts
 create mode 100644 apps/sim/lib/copilot/docs/docs-search.ts
 create mode 100644 apps/sim/lib/copilot/generated/docs-manifest.ts
 create mode 100644 apps/sim/lib/copilot/request/session/steer.ts
 create mode 100644 apps/sim/lib/copilot/request/tools/workflow-client-fallback.test.ts
 create mode 100644 apps/sim/lib/copilot/request/tools/workflow-client-fallback.ts
 create mode 100644 apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.test.ts
 create mode 100644 apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.ts
 delete mode 100644 apps/sim/lib/copilot/tools/handlers/platform-actions.ts
 delete mode 100644 apps/sim/lib/copilot/tools/handlers/platform.ts
 create mode 100644 apps/sim/lib/copilot/tools/retired-tools.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/docs/search-docs-dispatch.test.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/docs/search-docs.test.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/docs/search-docs.ts
 delete mode 100644 apps/sim/lib/copilot/tools/server/docs/search-documentation.test.ts
 delete mode 100644 apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/env-reference.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/files/doc-asset-extract-pdf.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/files/doc-asset-extract.test.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/files/doc-asset-extract.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/files/extract-doc-assets.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-automations.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-columns.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-enrichments.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-manage.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-rows.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-split.test.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-views.test.ts
 create mode 100644 apps/sim/lib/copilot/tools/server/table/table-views.ts
 create mode 100644 apps/sim/lib/copilot/tools/workflow-tools.test.ts
 create mode 100644 apps/sim/lib/folders/application/resource-vfs.ts
 create mode 100644 apps/sim/lib/logs/stats-logs.ts
 create mode 100644 apps/sim/lib/permission-groups/features.test.ts
 create mode 100644 apps/sim/lib/permission-groups/features.ts
 create mode 100644 apps/sim/lib/permission-groups/queries.ts
 create mode 100644 apps/sim/lib/platform-context/application/authorization.ts
 create mode 100644 apps/sim/lib/platform-context/application/context.ts
 create mode 100644 apps/sim/lib/platform-context/application/operations.ts
 create mode 100644 apps/sim/lib/platform-context/application/platform-context-use-cases.test.ts
 create mode 100644 apps/sim/lib/platform-context/application/read-account-billing.ts
 create mode 100644 apps/sim/lib/platform-context/application/read-enterprise-context.ts
 create mode 100644 apps/sim/lib/pptx-renderer/utils/font-stack.test.ts
 create mode 100644 apps/sim/lib/pptx-renderer/utils/font-stack.ts
 create mode 100644 apps/sim/lib/workspace-files/artifact-stylesheet.test.ts
 create mode 100644 apps/sim/lib/workspace-files/artifact-stylesheet.ts
 create mode 100644 apps/sim/lib/workspace-files/page-compile.test.ts
 create mode 100644 apps/sim/lib/workspace-files/page-compile.ts
 create mode 100644 apps/sim/lib/workspace-files/page-document.server.ts
 create mode 100644 apps/sim/lib/workspace-files/page-document.ts
 create mode 100644 apps/sim/lib/workspace-files/page-tabs-rail.test.ts
 create mode 100644 apps/sim/lib/workspace-files/shell-layout.test.ts
 create mode 100644 scripts/sync-docs-manifest.ts

diff --git a/.github/workflows/test-build.yml b/.github/workflows/test-build.yml
index 80a0ec6235..007df411aa 100644
--- a/.github/workflows/test-build.yml
+++ b/.github/workflows/test-build.yml
@@ -123,6 +123,9 @@ jobs:
       - name: Repo audits
         run: bun run check:audits
 
+      - name: Verify docs manifest is in sync
+        run: bun run docs-manifest:check
+
       - name: Migration safety (zero-downtime) audit
         run: |
           if [ "${{ github.event_name }}" = "pull_request" ]; then
diff --git a/apps/desktop/build/entitlements.mac.plist b/apps/desktop/build/entitlements.mac.plist
index 152179c439..51ec6a97a5 100644
--- a/apps/desktop/build/entitlements.mac.plist
+++ b/apps/desktop/build/entitlements.mac.plist
@@ -9,5 +9,15 @@
          even after the user grants access in System Settings. -->
     <key>com.apple.security.device.audio-input</key>
     <true/>
+    <!-- The agent browser joins real meetings (Google Meet, Zoom web): its
+         getUserMedia grant is gated on the OS grant, and without this key the
+         Hardened Runtime denies the camera no matter what the user allowed. -->
+    <key>com.apple.security.device.camera</key>
+    <true/>
+    <!-- WebAuthn hybrid transport (passkey on the user's phone via QR) rides
+         Bluetooth proximity; without this the QR option silently never
+         completes in signed builds. -->
+    <key>com.apple.security.device.bluetooth</key>
+    <true/>
   </dict>
 </plist>
diff --git a/apps/desktop/electron-builder.yml b/apps/desktop/electron-builder.yml
index f7e226725e..4f0629d125 100644
--- a/apps/desktop/electron-builder.yml
+++ b/apps/desktop/electron-builder.yml
@@ -58,7 +58,9 @@ mac:
   # macOS refuses to show the microphone prompt at all — it kills the process —
   # unless the bundle declares why it wants the device.
   extendInfo:
-    NSMicrophoneUsageDescription: Sim uses your microphone for voice input in Chat.
+    NSMicrophoneUsageDescription: Sim uses your microphone for voice input in Chat and for meetings you join in the built-in browser.
+    NSCameraUsageDescription: Sim uses your camera for meetings you join in the built-in browser, such as Google Meet.
+    NSBluetoothAlwaysUsageDescription: Sim uses Bluetooth to complete passkey sign-ins with a nearby phone in the built-in browser.
   entitlements: build/entitlements.mac.plist
   entitlementsInherit: build/entitlements.mac.plist
   notarize: true
diff --git a/apps/desktop/src/main/browser-agent/cdp.test.ts b/apps/desktop/src/main/browser-agent/cdp.test.ts
index 2efa344dd7..2f21c1ea6d 100644
--- a/apps/desktop/src/main/browser-agent/cdp.test.ts
+++ b/apps/desktop/src/main/browser-agent/cdp.test.ts
@@ -2,8 +2,9 @@ import { describe, expect, it, vi } from 'vitest'
 
 vi.mock('electron', () => import('@/test/electron-mock'))
 
-import { WebContentsView, type WebFrameMain } from 'electron'
+import { nativeImage, type WebContents, WebContentsView, type WebFrameMain } from 'electron'
 import {
+  captureScreenshot,
   clickAt,
   ensureInstrumented,
   evaluateInIsolatedFrame,
@@ -482,3 +483,89 @@ describe('browser-agent CDP theme', () => {
     })
   })
 })
+
+/**
+ * The browser panel shows a LIVE view, so a capture must not perturb the page.
+ * Chromium serves `clip` by applying device-emulation params to the widget and
+ * syncing visual properties, which the user sees as the page rescaling and
+ * snapping back. Resolution is bounded on the returned image instead.
+ */
+describe('browser-agent screenshot capture', () => {
+  function captureFixture(imageSize: { width: number; height: number } | null) {
+    const contents = new WebContentsView().webContents
+    vi.mocked(contents.debugger.sendCommand).mockImplementation((method: string) => {
+      if (method === 'Page.getLayoutMetrics') {
+        return Promise.resolve({ cssLayoutViewport: { clientWidth: 2048, clientHeight: 1024 } })
+      }
+      if (method === 'Page.captureScreenshot') return Promise.resolve({ data: 'c2lt' })
+      return Promise.resolve(undefined)
+    })
+    const resized = {
+      toJPEG: vi.fn(() => Buffer.from('resized')),
+    }
+    // Shared module-level mock: without this, a later fixture reads the
+    // earlier test's decoded image.
+    vi.mocked(nativeImage.createFromBuffer).mockReset()
+    vi.mocked(nativeImage.createFromBuffer).mockReturnValue({
+      isEmpty: vi.fn(() => imageSize === null),
+      getSize: vi.fn(() => imageSize ?? { width: 0, height: 0 }),
+      resize: vi.fn(() => resized),
+      toJPEG: vi.fn(() => Buffer.alloc(0)),
+    } as unknown as ReturnType<typeof nativeImage.createFromBuffer>)
+    return { contents, resized }
+  }
+
+  function screenshotParams(contents: WebContents): Record<string, unknown> {
+    const call = vi
+      .mocked(contents.debugger.sendCommand)
+      .mock.calls.find(([method]) => method === 'Page.captureScreenshot')
+    if (!call) throw new Error('no capture was requested')
+    return call[1] as Record<string, unknown>
+  }
+
+  it('never sends a clip, which would emulate the live page for the capture', async () => {
+    const { contents } = captureFixture({ width: 4096, height: 2048 })
+
+    await captureScreenshot(contents)
+
+    expect(screenshotParams(contents)).not.toHaveProperty('clip')
+  })
+
+  /**
+   * A 2048px CSS viewport bounded to 1024px is scale 0.5, and the capture
+   * arrives at device resolution (4096px on a 2x display). The resize is what
+   * lands the image on the CSS-relative size the coordinate contract
+   * (cssX = imageX / scale) assumes.
+   */
+  it('downscales the returned image to the CSS-relative size', async () => {
+    const { contents, resized } = captureFixture({ width: 4096, height: 2048 })
+
+    const shot = await captureScreenshot(contents)
+
+    const image = vi.mocked(nativeImage.createFromBuffer).mock.results[0].value
+    expect(image.resize).toHaveBeenCalledWith({ width: 1024, height: 512, quality: 'good' })
+    expect(resized.toJPEG).toHaveBeenCalled()
+    expect(shot).toEqual({
+      dataUrl: `data:image/jpeg;base64,${Buffer.from('resized').toString('base64')}`,
+      scale: 0.5,
+    })
+  })
+
+  it('skips the re-encode when the capture already matches the target size', async () => {
+    const { contents } = captureFixture({ width: 1024, height: 512 })
+
+    const shot = await captureScreenshot(contents)
+
+    const image = vi.mocked(nativeImage.createFromBuffer).mock.results[0].value
+    expect(image.resize).not.toHaveBeenCalled()
+    expect(shot).toEqual({ dataUrl: 'data:image/jpeg;base64,c2lt', scale: 0.5 })
+  })
+
+  it('returns the raw capture when the image cannot be decoded', async () => {
+    const { contents } = captureFixture(null)
+
+    const shot = await captureScreenshot(contents)
+
+    expect(shot).toEqual({ dataUrl: 'data:image/jpeg;base64,c2lt', scale: 0.5 })
+  })
+})
diff --git a/apps/desktop/src/main/browser-agent/cdp.ts b/apps/desktop/src/main/browser-agent/cdp.ts
index 4a7088e1b2..36dffe4da0 100644
--- a/apps/desktop/src/main/browser-agent/cdp.ts
+++ b/apps/desktop/src/main/browser-agent/cdp.ts
@@ -10,7 +10,8 @@
  */
 import type { BrowserTheme } from '@sim/browser-protocol'
 import { createLogger } from '@sim/logger'
-import type { WebContents, WebFrameMain } from 'electron'
+import { sleep } from '@sim/utils/helpers'
+import { nativeImage, type WebContents, type WebFrameMain } from 'electron'
 
 const logger = createLogger('BrowserAgentCdp')
 
@@ -127,12 +128,29 @@ export async function setColorScheme(contents: WebContents, theme: BrowserTheme)
   })
 }
 
+/** Live drag-interception state while a dragPointer call is in flight. */
+interface DragInterception {
+  intercepted: boolean
+  data: Record<string, unknown> | null
+}
+const dragInterceptionsByContents = new WeakMap<WebContents, DragInterception>()
+
 function handleDebuggerEvent(
   contents: WebContents,
   method: string,
   params: Record<string, unknown>,
   parentSessionId?: string
 ): void {
+  if (method === 'Input.dragIntercepted') {
+    const interception = dragInterceptionsByContents.get(contents)
+    if (interception) {
+      interception.intercepted = true
+      const data = params.data
+      interception.data =
+        data && typeof data === 'object' ? (data as Record<string, unknown>) : null
+    }
+    return
+  }
   if (method === 'Target.attachedToTarget') {
     const sessionId = typeof params.sessionId === 'string' ? params.sessionId : ''
     const targetInfo = params.targetInfo
@@ -352,6 +370,14 @@ export async function evaluateInIsolatedFrame(
  */
 const MAX_SCREENSHOT_EDGE = 1024
 const SCREENSHOT_QUALITY = 70
+/**
+ * Quality of the intermediate capture, before the in-process downscale
+ * re-encodes at {@link SCREENSHOT_QUALITY}. Higher than the final quality so
+ * the two lossy passes together land near where one pass did — the model reads
+ * text out of these frames, and compression artifacts on glyphs cost more than
+ * the transient bytes do.
+ */
+const SCREENSHOT_CAPTURE_QUALITY = 90
 
 interface CdpViewport {
   clientWidth: number
@@ -361,13 +387,23 @@ interface CdpViewport {
 /**
  * Screenshot via CDP (works while the view is hidden), bounded in resolution.
  *
- * `clip.scale` is relative to CSS pixels, so passing the CSS viewport with a
- * scale of 1 already sidesteps the device pixel ratio — an unclipped capture
- * on a 2x display returns a 2x image. Scaling further down keeps the longest
- * edge within {@link MAX_SCREENSHOT_EDGE}. Falls back to an unclipped capture
- * when layout metrics are unavailable.
+ * The capture is deliberately UNCLIPPED. Chromium implements `clip` by applying
+ * device-emulation parameters (viewport offset and scale) to the widget and
+ * synchronizing visual properties, then restoring them. On a headless target
+ * that is invisible; against the live, composited WebContentsView the Sim
+ * resource panel shows, it is a real visual-properties round-trip, and the page
+ * visibly rescales and snaps back — the screenshot flash. `panel.ts`'s own
+ * snapshot capture refuses to scale a visible surface for the same reason.
+ *
+ * Bounding resolution therefore happens here instead, on the returned image.
+ * The output keeps the dimensions the clipped capture produced, so `scale`
+ * still maps image pixels back to CSS pixels for the coordinate tools
+ * (cssX = imageX / scale) — including on a 2x display, where an unclipped
+ * capture arrives at device resolution and this is what brings it back down.
  */
-export async function captureScreenshot(contents: WebContents): Promise<string> {
+export async function captureScreenshot(
+  contents: WebContents
+): Promise<{ dataUrl: string; scale: number }> {
   const metrics = await send<{
     cssLayoutViewport?: CdpViewport
     layoutViewport?: CdpViewport
@@ -376,23 +412,34 @@ export async function captureScreenshot(contents: WebContents): Promise<string>
   const viewport = metrics?.cssLayoutViewport ?? metrics?.layoutViewport
   const width = viewport?.clientWidth ?? 0
   const height = viewport?.clientHeight ?? 0
-  const clip =
-    width > 0 && height > 0
-      ? {
-          x: 0,
-          y: 0,
-          width,
-          height,
-          scale: Math.min(1, MAX_SCREENSHOT_EDGE / Math.max(width, height)),
-        }
-      : undefined
+  const scale =
+    width > 0 && height > 0 ? Math.min(1, MAX_SCREENSHOT_EDGE / Math.max(width, height)) : 1
 
   const result = await send<{ data: string }>(contents, 'Page.captureScreenshot', {
     format: 'jpeg',
-    quality: SCREENSHOT_QUALITY,
-    ...(clip ? { clip } : {}),
+    quality: SCREENSHOT_CAPTURE_QUALITY,
   })
-  return `data:image/jpeg;base64,${result.data}`
+  const captured = `data:image/jpeg;base64,${result.data}`
+
+  const targetWidth = Math.round(width * scale)
+  const targetHeight = Math.round(height * scale)
+  // Without layout metrics there is no CSS frame of reference to resize
+  // against, so the raw capture is the honest answer — the same fallback the
+  // clipped path took.
+  if (targetWidth <= 0 || targetHeight <= 0) return { dataUrl: captured, scale }
+
+  const image = nativeImage.createFromBuffer(Buffer.from(result.data, 'base64'))
+  const size = image.isEmpty() ? { width: 0, height: 0 } : image.getSize()
+  if (size.width === 0 || size.height === 0) return { dataUrl: captured, scale }
+  if (size.width === targetWidth && size.height === targetHeight) {
+    return { dataUrl: captured, scale }
+  }
+
+  const resized = image.resize({ width: targetWidth, height: targetHeight, quality: 'good' })
+  return {
+    dataUrl: `data:image/jpeg;base64,${resized.toJPEG(SCREENSHOT_QUALITY).toString('base64')}`,
+    scale,
+  }
 }
 
 /** One half of a trusted key press (`Input.dispatchKeyEvent` params). */
@@ -430,7 +477,8 @@ export async function clickAt(
   contents: WebContents,
   x: number,
   y: number,
-  moveBeforePress = true
+  moveBeforePress = true,
+  clickCount = 1
 ): Promise<void> {
   if (moveBeforePress) await moveMouse(contents, x, y)
   let pressed = false
@@ -439,22 +487,26 @@ export async function clickAt(
     // response (navigation/process swap). In that ambiguous case a release is
     // safer than leaving Blink's pointer state stuck down.
     pressed = true
-    await sendInput(contents, 'Input.dispatchMouseEvent', {
-      type: 'mousePressed',
-      x,
-      y,
-      button: 'left',
-      buttons: 1,
-      clickCount: 1,
-    })
-    await sendInput(contents, 'Input.dispatchMouseEvent', {
-      type: 'mouseReleased',
-      x,
-      y,
-      button: 'left',
-      buttons: 0,
-      clickCount: 1,
-    })
+    // A multi-click is a sequence of press/release pairs with an increasing
+    // clickCount — Blink synthesizes dblclick from the pair whose count is 2.
+    for (let count = 1; count <= clickCount; count++) {
+      await sendInput(contents, 'Input.dispatchMouseEvent', {
+        type: 'mousePressed',
+        x,
+        y,
+        button: 'left',
+        buttons: 1,
+        clickCount: count,
+      })
+      await sendInput(contents, 'Input.dispatchMouseEvent', {
+        type: 'mouseReleased',
+        x,
+        y,
+        button: 'left',
+        buttons: 0,
+        clickCount: count,
+      })
+    }
     pressed = false
   } finally {
     if (pressed && !contents.isDestroyed()) {
@@ -473,6 +525,131 @@ export async function clickAt(
   }
 }
 
+/**
+ * Drags the pointer from one viewport point to another through the trusted
+ * pipeline: press, a threshold-crossing nudge, interpolated moves with the
+ * button held, a settle hold over the target, then release or drop.
+ *
+ * Two drag models are covered by the one call. Pointer-sensor libraries
+ * (dnd-kit, react-beautiful-dnd, canvas apps) treat the held-button move
+ * sequence exactly like a human drag. Native HTML5 `draggable="true"`
+ * sources instead START a Blink drag session on the press+move — with
+ * `Input.setInterceptDrags` enabled, Chromium reports it as
+ * `Input.dragIntercepted` and the remaining movement is delivered as trusted
+ * `Input.dispatchDragEvent` dragEnter/dragOver events ending in a `drop`
+ * (the technique Playwright uses). Both paths are trusted input.
+ */
+export async function dragPointer(
+  contents: WebContents,
+  from: { x: number; y: number },
+  to: { x: number; y: number },
+  steps = 12,
+  stepDelayMs = 20
+): Promise<{ nativeDragIntercepted: boolean }> {
+  const interception: DragInterception = { intercepted: false, data: null }
+  dragInterceptionsByContents.set(contents, interception)
+  let interceptEnabled = false
+  try {
+    await send(contents, 'Input.setInterceptDrags', { enabled: true })
+    interceptEnabled = true
+  } catch {
+    // Chromium without drag interception: the pointer-only path still works
+    // for pointer-sensor drags; native HTML5 sources will report no effect.
+  }
+  await moveMouse(contents, from.x, from.y)
+  let pressed = false
+  let dragEnterSent = false
+  const dragMove = async (x: number, y: number) => {
+    if (interception.intercepted && interception.data) {
+      await sendInput(contents, 'Input.dispatchDragEvent', {
+        type: dragEnterSent ? 'dragOver' : 'dragEnter',
+        x,
+        y,
+        data: interception.data,
+      })
+      dragEnterSent = true
+    } else {
+      await sendInput(contents, 'Input.dispatchMouseEvent', {
+        type: 'mouseMoved',
+        x,
+        y,
+        button: 'left',
+        buttons: 1,
+      })
+    }
+  }
+  try {
+    pressed = true
+    await sendInput(contents, 'Input.dispatchMouseEvent', {
+      type: 'mousePressed',
+      x: from.x,
+      y: from.y,
+      button: 'left',
+      buttons: 1,
+      clickCount: 1,
+    })
+    // Small first nudge so libraries with a start threshold (commonly 3-8px)
+    // register the drag before the pointer sweeps across the page.
+    await dragMove(from.x + Math.sign(to.x - from.x || 1) * 4, from.y + 2)
+    await sleep(stepDelayMs)
+    const stepCount = Math.max(2, steps)
+    for (let step = 1; step <= stepCount; step++) {
+      const progress = step / stepCount
+      await dragMove(from.x + (to.x - from.x) * progress, from.y + (to.y - from.y) * progress)
+      await sleep(stepDelayMs)
+    }
+    // Hold over the target so drop zones running enter/over animations settle
+    // before the release lands.
+    await sleep(120)
+    if (interception.intercepted && interception.data) {
+      await sendInput(contents, 'Input.dispatchDragEvent', {
+        type: 'drop',
+        x: to.x,
+        y: to.y,
+        data: interception.data,
+      })
+      // Blink ended the intercepted drag session itself; a trailing
+      // mouseReleased would be a stray click on the drop target.
+      pressed = false
+    } else {
+      await sendInput(contents, 'Input.dispatchMouseEvent', {
+        type: 'mouseReleased',
+        x: to.x,
+        y: to.y,
+        button: 'left',
+        buttons: 0,
+        clickCount: 1,
+      })
+      pressed = false
+    }
+    return { nativeDragIntercepted: interception.intercepted }
+  } finally {
+    if (pressed && !contents.isDestroyed()) {
+      if (interception.intercepted && interception.data) {
+        await sendInput(contents, 'Input.dispatchDragEvent', {
+          type: 'dragCancel',
+          x: to.x,
+          y: to.y,
+          data: interception.data,
+        }).catch(() => {})
+      } else {
+        await sendInput(contents, 'Input.dispatchMouseEvent', {
+          type: 'mouseReleased',
+          x: to.x,
+          y: to.y,
+          button: 'left',
+          buttons: 0,
+          clickCount: 1,
+        }).catch(() => {})
+      }
+    }
+    dragInterceptionsByContents.delete(contents)
+    if (interceptEnabled && !contents.isDestroyed()) {
+      await send(contents, 'Input.setInterceptDrags', { enabled: false }).catch(() => {})
+    }
+  }
+}
+
 /**
  * Inserts text at the focused element's selection (replacing it) through the
  * native IME path — works in plain fields and code editors alike.
diff --git a/apps/desktop/src/main/browser-agent/driver.test.ts b/apps/desktop/src/main/browser-agent/driver.test.ts
index f98083e1ad..d63d828c32 100644
--- a/apps/desktop/src/main/browser-agent/driver.test.ts
+++ b/apps/desktop/src/main/browser-agent/driver.test.ts
@@ -1121,6 +1121,20 @@ describe('credential protection', () => {
     expect(cdpCalls(contents, 'Input.dispatchKeyEvent').length).toBeGreaterThan(0)
   })
 
+  it('still dispatches input after the user has interacted with the visible tab', async () => {
+    const contents = await openPage()
+    respondWith(contents, { activeElementSecrecy: 'safe', readActiveElementState: {} })
+    // User interaction claims the visible tab for panel-level ownership
+    // (popups, close protection) but must never block agent input.
+    session.claimActiveTabForUser()
+    expect(session.automationTabClaimedByUser()).toBe(true)
+
+    const result = await driver.executeTool('chat-test', 'browser_press_key', { key: 'a' })
+
+    expect(result.ok).toBe(true)
+    expect(cdpCalls(contents, 'Input.dispatchKeyEvent').length).toBeGreaterThan(0)
+  })
+
   it('sends the keystroke when nothing sensitive is focused', async () => {
     const contents = await openPage()
     respondWith(contents, { activeElementSecrecy: 'safe', readActiveElementState: {} })
@@ -1646,7 +1660,90 @@ describe('credential protection', () => {
     expect(mainFrame.executeJavaScript).not.toHaveBeenCalled()
   })
 
-  it('reports navigation that remains obstructed by a DOM dialog', async () => {
+  // A dialog that was ALREADY open before the click is not obstructing the
+  // navigation it survived — reporting it made every SPA route change under a
+  // persistent role=dialog (cookie banner, side drawer, picker) read as a
+  // failed click. Only a dialog that arrives with the navigation obstructs it.
+  // targetChanged can only fire when pageActionState was given an elementId.
+  // Tools without one listed it in their effect formula for a long time, where
+  // it was silently always false — coverage that read as real. This pins the
+  // dependency so the next tool that adds the term has to earn it.
+  it('cannot observe a target change for a tool that passes no elementId', async () => {
+    const contents = await openPage()
+    let actionReads = 0
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'readActiveElementState')) return Promise.resolve({})
+      if (isPageCall(expression, 'readPageActionState')) {
+        actionReads++
+        // No targetState in either sample: that is what a call without an
+        // elementId returns.
+        return Promise.resolve({
+          url: 'https://example.com/a',
+          title: 'A',
+          focus: 'body',
+          mutationRevision: actionReads === 1 ? 0 : 3,
+          dialogs: [],
+          popups: [],
+          scroll: [0],
+        })
+      }
+      return Promise.resolve(undefined)
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_press_key', { key: 'Enter' })
+
+    expect(result).toMatchObject({ ok: true })
+    const effect = (result as { result?: { effect?: Record<string, boolean> } }).result?.effect
+    expect(effect?.targetChanged).toBe(false)
+  })
+
+  // The click-that-navigates race from the field: "Begin Assessment" submits a
+  // form, the navigation tears the origin document down, and the CDP dispatch
+  // rejects mid-press. The press already reached the page — the navigation IS
+  // the success — so this must come back dispatched, not failed.
+  it('reports a click whose navigation destroyed the page as a success', async () => {
+    const contents = await openPage()
+    let currentUrl = 'https://example.com/tests/IPIP-BFFM/'
+    vi.mocked(contents.getURL).mockImplementation(() => currentUrl)
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'describePointTarget')) {
+        return Promise.resolve({ found: true, element: 'Begin Assessment', cursor: 'pointer' })
+      }
+      if (isPageCall(expression, 'readActiveElementState')) return Promise.resolve({})
+      if (isPageCall(expression, 'readPageActionState')) {
+        return Promise.resolve({
+          url: currentUrl,
+          title: 'Test',
+          focus: 'body',
+          mutationRevision: 0,
+          dialogs: [],
+          popups: [],
+          scroll: [0],
+        })
+      }
+      return Promise.resolve(undefined)
+    })
+    vi.mocked(contents.debugger.sendCommand).mockImplementation(async (method: string) => {
+      if (method === 'Input.dispatchMouseEvent') {
+        currentUrl = 'https://example.com/tests/IPIP-BFFM/1.php'
+        throw new Error('Execution context was destroyed, most likely because of a navigation.')
+      }
+      return {}
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click_at', { x: 100, y: 200 })
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: {
+        dispatched: true,
+        navigatedDuringDispatch: true,
+        effectObserved: true,
+      },
+    })
+  })
+
+  it('ignores a dialog that was already open before the click', async () => {
     const contents = await openPage()
     let actionReads = 0
     vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
@@ -1681,13 +1778,52 @@ describe('credential protection', () => {
 
     const result = await driver.executeTool('chat-test', 'browser_click', { elementId: 0 })
 
+    expect(result).toMatchObject({
+      ok: true,
+      result: { effectObserved: true, obstructedAfterNavigation: false, dialogs: ['Search'] },
+    })
+  })
+
+  it('reports navigation obstructed by a dialog that opened with it', async () => {
+    const contents = await openPage()
+    let actionReads = 0
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'clickElement')) {
+        return Promise.resolve({ dispatched: false, x: 24, y: 48, element: 'Search result' })
+      }
+      if (isPageCall(expression, 'readActiveElementState')) return Promise.resolve({})
+      if (isPageCall(expression, 'readPageActionState')) {
+        actionReads++
+        return Promise.resolve(
+          actionReads === 1
+            ? {
+                url: 'https://example.com/search',
+                title: 'Search',
+                focus: 'body',
+                mutationRevision: 0,
+                dialogs: [],
+                scroll: [0],
+              }
+            : {
+                url: 'https://example.com/channel/eng-bugs',
+                title: 'eng-bugs',
+                focus: 'body',
+                mutationRevision: 1,
+                dialogs: ['Open in the Slack app?'],
+                scroll: [0],
+              }
+        )
+      }
+      return Promise.resolve(undefined)
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click', { elementId: 0 })
+
     expect(result).toMatchObject({
       ok: true,
       result: {
-        effectObserved: true,
         obstructedAfterNavigation: true,
-        dialogs: ['Search'],
-        note: expect.stringContaining('dialog is still open'),
+        note: expect.stringContaining('Open in the Slack app?'),
       },
     })
   })
@@ -1732,4 +1868,355 @@ describe('credential protection', () => {
         'Element ids are not valid in this tab. Call browser_snapshot and use an id from that result.',
     })
   })
+
+  /** Fires every instrumentation listener registered for a WebContents event. */
+  function emitContentsEvent(
+    contents: Awaited<ReturnType<typeof openPage>>,
+    event: string,
+    ...args: unknown[]
+  ): void {
+    for (const [name, listener] of vi.mocked(contents.on).mock.calls) {
+      if (name === event) (listener as (...listenerArgs: unknown[]) => void)({}, ...args)
+    }
+  }
+
+  it('keeps element ids across a same-document (SPA) navigation', async () => {
+    const contents = await openPage()
+    respondWith(contents, {})
+
+    emitContentsEvent(contents, 'did-navigate-in-page')
+    const result = await driver.executeTool('chat-test', 'browser_click', { elementId: 0 })
+
+    expect(result).toMatchObject({ ok: true, result: { dispatched: true } })
+  })
+
+  it('still invalidates element ids on a cross-document navigation', async () => {
+    const contents = await openPage()
+    respondWith(contents, {})
+
+    emitContentsEvent(contents, 'did-navigate')
+    const result = await driver.executeTool('chat-test', 'browser_click', { elementId: 0 })
+
+    expect(result).toEqual({
+      ok: false,
+      error:
+        'Element ids are not valid in this tab. Call browser_snapshot and use an id from that result.',
+    })
+  })
+
+  it('tolerates same-document URL churn during a keypress', async () => {
+    const contents = await openPage()
+    let urlReads = 0
+    vi.mocked(contents.getURL).mockImplementation(() =>
+      ++urlReads === 1 ? 'https://example.com/channel-a' : 'https://example.com/channel-b'
+    )
+    respondWith(contents, {
+      activeElementSecrecy: 'safe',
+      readActiveElementState: {},
+      readPageActionState: {
+        url: 'https://example.com/channel-a',
+        title: 'Example',
+        focus: 'body',
+        mutationRevision: 0,
+        dialogs: [],
+        scroll: [0],
+      },
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_press_key', { key: 'Escape' })
+
+    expect(result.ok).toBe(true)
+    expect(cdpCalls(contents, 'Input.dispatchKeyEvent').length).toBeGreaterThan(0)
+  })
+
+  it('aborts a keypress when a cross-document navigation lands mid-flight', async () => {
+    const contents = await openPage()
+    let navigated = false
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'activeElementSecrecy')) return Promise.resolve('safe')
+      if (isPageCall(expression, 'readActiveElementState')) return Promise.resolve({})
+      if (isPageCall(expression, 'readPageActionState')) {
+        if (!navigated) {
+          navigated = true
+          emitContentsEvent(contents, 'did-navigate')
+        }
+        return Promise.resolve({
+          url: 'https://example.com/login',
+          title: 'Example',
+          focus: 'body',
+          mutationRevision: 0,
+          dialogs: [],
+          scroll: [0],
+        })
+      }
+      return Promise.resolve(undefined)
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_press_key', { key: 'Escape' })
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/active tab or page changed/)
+    expect(cdpCalls(contents, 'Input.dispatchKeyEvent')).toHaveLength(0)
+  })
+
+  it('waits for a late-mounting editor before typing', async () => {
+    const contents = await openPage()
+    let focusReads = 0
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'focusElementForTyping')) {
+        focusReads++
+        return Promise.resolve(
+          focusReads === 1
+            ? { error: 'not-editable' }
+            : { focused: true, kind: 'contenteditable', x: 24, y: 48 }
+        )
+      }
+      if (isPageCall(expression, 'activeElementSecrecy')) return Promise.resolve('safe')
+      if (isPageCall(expression, 'readActiveElementState')) {
+        return Promise.resolve({ activeElement: 'div', valueLength: 5 })
+      }
+      return Promise.resolve(undefined)
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_type', {
+      elementId: 0,
+      text: 'hello',
+    })
+
+    expect(result.ok).toBe(true)
+    expect(focusReads).toBeGreaterThan(1)
+    expect(cdpCalls(contents, 'Input.insertText')).toHaveLength(1)
+  })
+
+  it('reprobes a transiently stale click target before giving up', async () => {
+    const contents = await openPage()
+    let clickReads = 0
+    vi.mocked(contents.executeJavaScript).mockImplementation((expression: string) => {
+      if (isPageCall(expression, 'clickElement')) {
+        clickReads++
+        return Promise.resolve(
+          clickReads === 1
+            ? { error: 'stale' }
+            : { dispatched: false, x: 24, y: 48, element: 'Channel row' }
+        )
+      }
+      if (isPageCall(expression, 'readActiveElementState')) return Promise.resolve({})
+      if (isPageCall(expression, 'readPageActionState')) return Promise.resolve({})
+      return Promise.resolve(undefined)
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click', { elementId: 0 })
+
+    expect(result).toMatchObject({ ok: true, result: { dispatched: true } })
+    expect(clickReads).toBeGreaterThan(1)
+  })
+
+  it('clicks a coordinate point with native input and reports the target', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      describePointTarget: {
+        found: true,
+        element: 'button "Send"',
+        editable: false,
+        secret: false,
+        fileInput: false,
+        cursor: 'pointer',
+      },
+      readActiveElementState: {},
+      readPageActionState: {},
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click_at', { x: 120, y: 240 })
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: {
+        dispatched: true,
+        trusted: true,
+        clickedAt: { x: 120, y: 240 },
+        target: 'button "Send"',
+      },
+    })
+    const presses = cdpCalls(contents, 'Input.dispatchMouseEvent').filter(
+      ([, event]) => (event as { type?: string }).type === 'mousePressed'
+    )
+    expect(presses).toHaveLength(1)
+  })
+
+  it('double-clicks a coordinate point as a rising clickCount sequence', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      describePointTarget: { found: true, element: 'canvas', editable: false },
+      readActiveElementState: {},
+      readPageActionState: {},
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click_at', {
+      x: 10,
+      y: 20,
+      clickCount: 2,
+    })
+
+    expect(result).toMatchObject({ ok: true, result: { clickCount: 2 } })
+    const counts = cdpCalls(contents, 'Input.dispatchMouseEvent')
+      .filter(([, event]) => (event as { type?: string }).type === 'mousePressed')
+      .map(([, event]) => (event as { clickCount?: number }).clickCount)
+    expect(counts).toEqual([1, 2])
+  })
+
+  it('refuses a coordinate click on a file input', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      describePointTarget: { found: true, element: 'input', fileInput: true },
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click_at', { x: 5, y: 5 })
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/file input/)
+    expect(cdpCalls(contents, 'Input.dispatchMouseEvent')).toHaveLength(0)
+  })
+
+  it('rejects a coordinate click outside the viewport with mapping guidance', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      describePointTarget: { error: 'outside-viewport' },
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_click_at', { x: 9999, y: 5 })
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/divide image pixels by its scale/)
+  })
+
+  it('inserts text into the focused editable at the caret', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      activeElementSecrecy: 'safe',
+      describeFocusedEditable: { editable: true, kind: 'contenteditable' },
+      readActiveElementState: { activeElement: 'div', valueLength: 12 },
+      readPageActionState: {},
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_insert_text', {
+      text: 'hello world',
+    })
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: { dispatched: true, trusted: true, kind: 'contenteditable', insertedChars: 11 },
+    })
+    expect(cdpCalls(contents, 'Input.insertText')).toHaveLength(1)
+  })
+
+  it('refuses insertion when nothing editable holds focus', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      activeElementSecrecy: 'safe',
+      describeFocusedEditable: { editable: false, reason: 'none' },
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_insert_text', { text: 'x' })
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/No element is focused/)
+    expect(cdpCalls(contents, 'Input.insertText')).toHaveLength(0)
+  })
+
+  it('refuses insertion while a password field holds focus', async () => {
+    const contents = await openPage()
+    respondWith(contents, { activeElementSecrecy: 'secret' })
+
+    const result = await driver.executeTool('chat-test', 'browser_insert_text', { text: 'x' })
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/Refusing to act on a password field/)
+    expect(cdpCalls(contents, 'Input.insertText')).toHaveLength(0)
+  })
+
+  it('drags between coordinate points through the trusted pointer pipeline', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      describePointTarget: { found: true, element: 'div "Card"' },
+      readActiveElementState: {},
+      readPageActionState: {},
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_drag', {
+      fromX: 40,
+      fromY: 50,
+      toX: 200,
+      toY: 260,
+    })
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: { dispatched: true, trusted: true, from: { x: 40, y: 50 }, to: { x: 200, y: 260 } },
+    })
+    const events = cdpCalls(contents, 'Input.dispatchMouseEvent').map(
+      ([, event]) => (event as { type?: string }).type
+    )
+    expect(events[0]).toBe('mouseMoved')
+    expect(events).toContain('mousePressed')
+    expect(events[events.length - 1]).toBe('mouseReleased')
+    expect(cdpCalls(contents, 'Input.setInterceptDrags').length).toBeGreaterThan(0)
+  })
+
+  it('drags from a snapshot element to a coordinate target', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      clickElement: { dispatched: false, x: 24, y: 48, element: 'Card "Ship it"' },
+      describePointTarget: { found: true, element: 'section "Done"' },
+      readActiveElementState: {},
+      readPageActionState: {},
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_drag', {
+      fromElementId: 0,
+      toX: 300,
+      toY: 60,
+    })
+
+    expect(result).toMatchObject({
+      ok: true,
+      result: { dispatched: true, from: { x: 24, y: 48, element: 'Card "Ship it"' } },
+    })
+  })
+
+  it('rejects a drag whose endpoints are the same point', async () => {
+    const contents = await openPage()
+    respondWith(contents, {
+      describePointTarget: { found: true, element: 'div' },
+    })
+
+    const result = await driver.executeTool('chat-test', 'browser_drag', {
+      fromX: 10,
+      fromY: 10,
+      toX: 10,
+      toY: 10,
+    })
+
+    expect(result.ok).toBe(false)
+    expect(result.error).toMatch(/same point/)
+  })
+
+  it('returns the screenshot scale for coordinate mapping', async () => {
+    const contents = await openPage()
+    vi.mocked(contents.debugger.sendCommand).mockImplementation((method: string) => {
+      if (method === 'Page.getLayoutMetrics') {
+        return Promise.resolve({
+          cssLayoutViewport: { clientWidth: 2048, clientHeight: 1024 },
+        })
+      }
+      if (method === 'Page.captureScreenshot') {
+        return Promise.resolve({ data: 'c2lt' })
+      }
+      return Promise.resolve(undefined)
+    })
+    respondWith(contents, { getViewportInfo: { width: 2048, height: 1024 } })
+
+    const result = await driver.executeTool('chat-test', 'browser_screenshot', {})
+
+    expect(result).toMatchObject({ ok: true, result: { scale: 0.5 } })
+  })
 })
diff --git a/apps/desktop/src/main/browser-agent/driver.ts b/apps/desktop/src/main/browser-agent/driver.ts
index 5c1b43c0d0..371a1b78a8 100644
--- a/apps/desktop/src/main/browser-agent/driver.ts
+++ b/apps/desktop/src/main/browser-agent/driver.ts
@@ -46,6 +46,8 @@ import {
   activeElementSecrecy,
   clickElement,
   collectSnapshot,
+  describeFocusedEditable,
+  describePointTarget,
   focusElementForTyping,
   getViewportInfo,
   hoverElement,
@@ -174,6 +176,29 @@ function invalidateSnapshot(state = driverScopeState()): void {
   state.snapshotCaptureEpoch++
 }
 
+/**
+ * Cross-document navigation counters, bumped by tab instrumentation. A live
+ * SPA rewrites its URL with pushState/replaceState between a snapshot and the
+ * input dispatched from it, so URL equality cannot distinguish "the document
+ * the model saw is gone" from routine same-document churn — only a real
+ * document swap increments these.
+ */
+const crossDocumentNavigations = new WeakMap<WebContents, number>()
+const crossDocumentFrameNavigations = new WeakMap<WebContents, Map<string, number>>()
+
+function navigationEpoch(contents: WebContents): number {
+  return crossDocumentNavigations.get(contents) ?? 0
+}
+
+function frameEpochKey(processId: number, routingId: number): string {
+  return `${processId}:${routingId}`
+}
+
+function frameNavigationEpoch(contents: WebContents, frame: WebFrameMain): number {
+  const key = frameEpochKey(frame.processId, frame.routingId)
+  return crossDocumentFrameNavigations.get(contents)?.get(key) ?? 0
+}
+
 const driverScopeStates = new Map<string, DriverScopeState>()
 const driverScopeAliases = new Map<string, string>()
 const CANCELLED_TOOL_TTL_MS = 5 * 60_000
@@ -312,6 +337,7 @@ function instrumentTab(contents: WebContents): void {
   contents.on(
     'did-navigate',
     inScope(() => {
+      crossDocumentNavigations.set(contents, navigationEpoch(contents) + 1)
       if (session.automationTab()?.view.webContents === contents) {
         invalidateSnapshot()
       }
@@ -320,6 +346,21 @@ function instrumentTab(contents: WebContents): void {
       pushTabsState()
     })
   )
+  contents.on(
+    'did-frame-navigate',
+    inScope(
+      (_event, _url, _httpResponseCode, _httpStatusText, _isMainFrame, processId, routingId) => {
+        const frames = crossDocumentFrameNavigations.get(contents) ?? new Map<string, number>()
+        const key = frameEpochKey(processId, routingId)
+        frames.set(key, (frames.get(key) ?? 0) + 1)
+        crossDocumentFrameNavigations.set(contents, frames)
+      }
+    )
+  )
+  // Same-document navigation deliberately does NOT invalidate the snapshot: a
+  // live SPA (Slack) pushStates continuously, and invalidating here made every
+  // ref die between snapshot and act. Element-level identity checks and the
+  // in-page ref resolver keep individual actions honest instead.
   for (const event of [
     'did-navigate-in-page',
     'page-title-updated',
@@ -330,12 +371,6 @@ function instrumentTab(contents: WebContents): void {
     contents.on(
       event as 'did-navigate',
       inScope(() => {
-        if (
-          event === 'did-navigate-in-page' &&
-          session.automationTab()?.view.webContents === contents
-        ) {
-          invalidateSnapshot()
-        }
         pushPageState(contents)
         pushTabsState()
       })
@@ -824,9 +859,12 @@ function unwrapPageResult(result: unknown): unknown {
   if (isRecordLike(result) && 'error' in result) {
     const code = (result as { error: string }).error
     if (code === 'stale') {
+      const reason =
+        isRecordLike(result) && typeof result.reason === 'string' && result.reason
+          ? result.reason
+          : 'the page changed since the last snapshot'
       throw new ToolError(
-        'That element id is stale (the page changed since the last snapshot). ' +
-          'Call browser_snapshot again and use a fresh id.'
+        `That element id is stale (${reason}). Call browser_snapshot again and use a fresh id.`
       )
     }
     if (code === 'password') {
@@ -851,17 +889,41 @@ function unwrapPageResult(result: unknown): unknown {
         `That element is covered by ${blocker}. Close or move the overlay, then take a fresh browser_snapshot.`
       )
     }
+    if (code === 'nested-control') {
+      const blocker = String((result as { blocker?: unknown }).blocker || 'a nested control')
+      throw new ToolError(
+        `The point you targeted lands on ${blocker}, which is its own control inside that element — nothing is covering it. Take a fresh browser_snapshot and use the id of the control you actually want.`
+      )
+    }
     if (code === 'suggestions-open') {
       throw new ToolError(
         'That editable field is already focused and covered by its own suggestions popup. Use browser_type on the same element; do not dismiss the popup first.'
       )
     }
     if (code === 'not-editable') {
-      throw new ToolError('That element is not a text input — pick an editable element.')
+      const tag = isRecordLike(result) ? String(result.elementTag ?? '') : ''
+      const role = isRecordLike(result) ? String(result.elementRole ?? '') : ''
+      const described = [tag ? `<${tag}>` : '', role ? `role="${role}"` : '']
+        .filter(Boolean)
+        .join(' ')
+      throw new ToolError(
+        `That element is not a text input${described ? ` (it is ${described})` : ''} — take a fresh browser_snapshot and target the editable field itself.`
+      )
+    }
+    if (code === 'outside-viewport') {
+      throw new ToolError(
+        'That point is outside the visible viewport. Coordinates are CSS pixels within the current viewport — when reading them off a browser_screenshot, divide image pixels by its scale, and scroll the target into view first.'
+      )
     }
     if (code === 'ambiguous-editable') {
+      const candidates =
+        isRecordLike(result) && Array.isArray(result.candidates)
+          ? result.candidates.map(String).filter(Boolean)
+          : []
       throw new ToolError(
-        'That composite control contains multiple editable fields. Take a fresh browser_snapshot and target the exact field.'
+        `That composite control contains multiple editable fields${
+          candidates.length > 0 ? ` (${candidates.join(', ')})` : ''
+        }. Take a fresh browser_snapshot and target the exact field.`
       )
     }
     if (code === 'different') {
@@ -1037,14 +1099,53 @@ function pageTargetForElement(contents: WebContents, elementId: number): PageExe
   return target
 }
 
-function assertActiveContents(contents: WebContents, expectedUrl?: string): void {
+// The user's claim on the visible tab (visibleTabUserSelected) deliberately
+// does NOT gate input here: the user clicking or typing in the panel must
+// never leave the agent unable to act — hand-off is cooperative via
+// browser_request_takeover, whose serialized tool slot already keeps agent
+// input out while the user drives.
+/**
+ * The click-that-navigates race: a press submits a form, the navigation tears
+ * the origin document down, and everything AFTER the dispatch — the CDP call's
+ * own completion, the confirmation probe, the postcondition reads — fails
+ * against a destroyed context. Reporting that as a failed click is wrong twice
+ * over: the press reached the page, and the navigation IS the strongest
+ * possible evidence it worked. This detects that case at the driver level,
+ * where the navigation epoch and URL survive the renderer teardown.
+ *
+ * Returns a success result when the page provably navigated since dispatch
+ * began, and null otherwise (caller keeps its original failure).
+ */
+function navigationRescue(
+  contents: WebContents,
+  epochAtDispatch: number,
+  urlAtDispatch: string,
+  base: { trusted: boolean; activation: string }
+): Record<string, unknown> | null {
+  if (contents.isDestroyed()) return null
+  const navigated =
+    navigationEpoch(contents) !== epochAtDispatch || contents.getURL() !== urlAtDispatch
+  if (!navigated) return null
+  return {
+    dispatched: true,
+    trusted: base.trusted,
+    activation: base.activation,
+    effectObserved: true,
+    possibleEffectObserved: true,
+    navigatedDuringDispatch: true,
+    effect: { urlChanged: true },
+    dialogs: [],
+    note: 'The click triggered a page navigation, and the origin document was torn down before its result could be read — that teardown is why no postconditions are reported, not a failure. Take a fresh browser_snapshot of the new page.',
+  }
+}
+
+function assertActiveContents(contents: WebContents, expectedNavigationEpoch?: number): void {
   const active = session.automationTab()
   if (
-    session.automationTabClaimedByUser() ||
     !active ||
     active.view.webContents !== contents ||
     contents.isDestroyed() ||
-    (expectedUrl !== undefined && contents.getURL() !== expectedUrl)
+    (expectedNavigationEpoch !== undefined && navigationEpoch(contents) !== expectedNavigationEpoch)
   ) {
     throw new ToolError('The active tab or page changed before input could be dispatched.')
   }
@@ -1089,7 +1190,7 @@ function sameWebFrame(left: WebFrameMain, right: WebFrameMain): boolean {
 function assertFocusedTargetUnchanged(
   contents: WebContents,
   target: PageExecutionTarget,
-  expectedFrameUrl?: string
+  expectedFrameNavigationEpoch?: number
 ): void {
   const focused = focusedPageTarget(contents)
   const unchanged =
@@ -1106,7 +1207,8 @@ function assertFocusedTargetUnchanged(
     if (
       frame.isDestroyed() ||
       frame.detached ||
-      (expectedFrameUrl !== undefined && frame.url !== expectedFrameUrl) ||
+      (expectedFrameNavigationEpoch !== undefined &&
+        frameNavigationEpoch(contents, frame) !== expectedFrameNavigationEpoch) ||
       !contents.mainFrame.framesInSubtree.some((candidate) => sameWebFrame(candidate, frame))
     ) {
       throw new ToolError(
@@ -1154,16 +1256,25 @@ async function prepareTypingSurface(
   target: PageExecutionTarget,
   elementId: number,
   moveFocus: boolean,
-  executionDeadline?: number
+  executionDeadline?: number,
+  settleGraceMs = 0
 ): Promise<Record<string, unknown>> {
   const prepared = unwrapPageResult(
-    await execInPage(
-      target,
-      focusElementForTyping,
-      [elementId, moveFocus],
-      false,
-      executionDeadline
-    )
+    settleGraceMs > 0
+      ? await execInPageWithSettleGrace(
+          target,
+          focusElementForTyping,
+          [elementId, moveFocus],
+          executionDeadline,
+          settleGraceMs
+        )
+      : await execInPage(
+          target,
+          focusElementForTyping,
+          [elementId, moveFocus],
+          false,
+          executionDeadline
+        )
   )
   if (
     !isRecordLike(prepared) ||
@@ -1178,6 +1289,43 @@ async function prepareTypingSurface(
   return prepared
 }
 
+const TRANSIENT_PROBE_ERRORS = new Set(['stale', 'not-visible', 'not-editable'])
+const SETTLE_GRACE_MS = 1_000
+const SETTLE_PROBE_INTERVAL_MS = 250
+
+/**
+ * First-touch page probe with a short settle grace. A live view re-rendering
+ * under the agent (Slack's virtualized sidebar, its late-mounting composer)
+ * can transiently report an element as stale, invisible, or not yet editable
+ * while its replacement mounts one frame later. These call sites run before
+ * anything is dispatched, so a bounded reprobe safely turns that churn into a
+ * recovery instead of a dead ref.
+ */
+async function execInPageWithSettleGrace<Args extends unknown[], Result>(
+  target: PageExecutionTarget,
+  fn: (...args: Args) => Result,
+  args: Args,
+  executionDeadline?: number,
+  graceMs = SETTLE_GRACE_MS
+): Promise<Result> {
+  const graceDeadline = Date.now() + graceMs
+  for (;;) {
+    const result = await execInPage(target, fn, args, false, executionDeadline)
+    const code =
+      isRecordLike(result) && typeof result.error === 'string' ? String(result.error) : null
+    if (
+      code === null ||
+      !TRANSIENT_PROBE_ERRORS.has(code) ||
+      Date.now() + SETTLE_PROBE_INTERVAL_MS > graceDeadline ||
+      (executionDeadline !== undefined &&
+        Date.now() + SETTLE_PROBE_INTERVAL_MS >= executionDeadline)
+    ) {
+      return result
+    }
+    await sleep(SETTLE_PROBE_INTERVAL_MS)
+  }
+}
+
 function pointFromPrepared(prepared: Record<string, unknown>): { x: number; y: number } {
   return { x: prepared.x as number, y: prepared.y as number }
 }
@@ -1194,6 +1342,29 @@ async function pageActionState(
   return toRecord(state)
 }
 
+/**
+ * Which signals each tool accepts as proof its action reached the page.
+ *
+ * The tools deliberately do NOT share one predicate — the differences are real,
+ * and flattening them would make every tool wrong in a different direction:
+ *
+ * - `browser_drag` is the only tool that trusts `domChanged`, because a drop
+ *   that reorders a list may change nothing else observable. Everywhere else
+ *   background churn (Slack, Gmail) would forge success for an ignored action.
+ * - `browser_hover` ignores `fieldChanged` and `focusChanged`: hovering does not
+ *   type or focus, so those would only ever be someone else's effect.
+ * - `browser_click` / `browser_click_at` count `focusChanged` only when the
+ *   target was editable — otherwise a click that merely moved focus reads as
+ *   success.
+ * - `targetChanged` requires a `targetState`, which `pageActionState` captures
+ *   only when given an `elementId`. Tools without one (click_at, insert_text,
+ *   drag, press_key) cannot use it; listing it there read as coverage they did
+ *   not have, and it was silently always false.
+ *
+ * What IS shared is this function: every signal is computed here once, so a
+ * tool's formula is a statement about which evidence it trusts, not a private
+ * re-derivation of what changed.
+ */
 function pageEffect(
   beforePage: Record<string, unknown>,
   afterPage: Record<string, unknown>,
@@ -1522,7 +1693,7 @@ async function captureSnapshot(contents: WebContents, notAfter?: number): Promis
   invalidateSnapshot(state)
   const captureEpoch = state.snapshotCaptureEpoch
   const capturedTabId = tab.id
-  const capturedUrl = contents.getURL()
+  const capturedNavigationEpoch = navigationEpoch(contents)
   const targets = new Map<number, PageExecutionTarget>()
   const targetLineIndexes = new Map<number, number>()
   const stillCurrent = (): boolean => {
@@ -1532,7 +1703,9 @@ async function captureSnapshot(contents: WebContents, notAfter?: number): Promis
       active?.id === capturedTabId &&
       active.view.webContents === contents &&
       !contents.isDestroyed() &&
-      contents.getURL() === capturedUrl
+      // Same-document URL drift (SPA pushState) must not abort the capture;
+      // only a cross-document navigation makes the collected refs meaningless.
+      navigationEpoch(contents) === capturedNavigationEpoch
     )
   }
 
@@ -1817,7 +1990,8 @@ async function executeToolInner(
         }
       }
       assertCurrentExecution()
-      const tab = session.addAutomationTab()
+      // The agent chose to open this page to work in, so the panel follows it.
+      const tab = session.addAutomationTab({ reveal: true })
       const contents = tab.view.webContents
       if (url) {
         assertCurrentExecution()
@@ -1920,19 +2094,21 @@ async function executeToolInner(
 
     case 'browser_screenshot': {
       const contents = session.requireAutomationTab().view.webContents
-      const dataUrl = await cdp.captureScreenshot(contents).catch(() => null)
-      if (dataUrl === null) {
+      const shot = await cdp.captureScreenshot(contents).catch(() => null)
+      if (shot === null) {
         throw new ToolError(
           'Could not capture the page. Use browser_snapshot or browser_read_text instead.'
         )
       }
-      if (dataUrl.length > 8_000_000) {
+      if (shot.dataUrl.length > 8_000_000) {
         throw new ToolError(
           'The screenshot result was too large to return safely. Use browser_snapshot or browser_read_text instead.'
         )
       }
       const viewport = await execInPage(contents, getViewportInfo, []).catch(() => null)
-      return { dataUrl, viewport }
+      // scale maps image pixels back to CSS viewport pixels for the
+      // coordinate tools: cssX = imageX / scale.
+      return { dataUrl: shot.dataUrl, viewport, scale: shot.scale }
     }
 
     case 'browser_extract': {
@@ -1957,11 +2133,10 @@ async function executeToolInner(
       if (!targetFrame) {
         assertCurrentExecution()
         const first = unwrapPageResult(
-          await execInPage(
+          await execInPageWithSettleGrace(
             target,
             clickElement,
             [elementId, false, false],
-            false,
             executionDeadline
           )
         )
@@ -2010,7 +2185,12 @@ async function executeToolInner(
         assertCurrentExecution()
         assertElementActionCurrent(contents, elementId, target)
         const focused = unwrapPageResult(
-          await execInPage(target, clickElement, [elementId, false, true], false, executionDeadline)
+          await execInPageWithSettleGrace(
+            target,
+            clickElement,
+            [elementId, false, true],
+            executionDeadline
+          )
         )
         if (!isRecordLike(focused)) throw new ToolError('Could not resolve that click target.')
         prepared = focused
@@ -2058,6 +2238,8 @@ async function executeToolInner(
       }
 
       const observeTopPage = targetFrame !== null || Number(prepared.frameDepth || 0) > 0
+      const epochAtDispatch = navigationEpoch(contents)
+      const urlAtDispatch = contents.getURL()
       const beforePage = await pageActionState(target, true, elementId)
       const beforeElement = await activeElementState(target)
       const beforeTopPage = observeTopPage ? await pageActionState(contents, true) : beforePage
@@ -2102,6 +2284,11 @@ async function executeToolInner(
           trusted = true
           activation = 'native-pointer'
         } catch (error) {
+          const rescued = navigationRescue(contents, epochAtDispatch, urlAtDispatch, {
+            trusted: true,
+            activation: 'native-pointer',
+          })
+          if (rescued) return rescued
           throw new ToolError(
             `Native click dispatch failed (${getErrorMessage(error)}). The action was not retried because a partial pointer press may already have reached the page. Take a fresh snapshot before continuing.`
           )
@@ -2138,6 +2325,11 @@ async function executeToolInner(
             activation = 'native-pointer'
             prepared = finalSurface
           } catch (error) {
+            const rescued = navigationRescue(contents, epochAtDispatch, urlAtDispatch, {
+              trusted: true,
+              activation: 'native-pointer',
+            })
+            if (rescued) return rescued
             throw new ToolError(
               `Native framed click dispatch failed (${getErrorMessage(error)}). The action was not retried because a partial pointer press may already have reached the page. Take a fresh snapshot before continuing.`
             )
@@ -2183,16 +2375,33 @@ async function executeToolInner(
           } else {
             assertCurrentExecution()
             assertElementActionCurrent(contents, elementId, target)
-            const synthetic = unwrapPageResult(
-              await execInPage(
-                target,
-                clickElement,
-                [elementId, true, false],
-                true,
-                executionDeadline
+            let synthetic: unknown
+            try {
+              synthetic = unwrapPageResult(
+                await execInPage(
+                  target,
+                  clickElement,
+                  [elementId, true, false],
+                  true,
+                  executionDeadline
+                )
               )
-            )
+            } catch (error) {
+              // A synchronous form-submit navigation destroys the context
+              // before the dispatch's return value crosses the bridge.
+              const rescued = navigationRescue(contents, epochAtDispatch, urlAtDispatch, {
+                trusted: false,
+                activation: 'synthetic',
+              })
+              if (rescued) return rescued
+              throw error
+            }
             if (!isRecordLike(synthetic) || synthetic.dispatched !== true) {
+              const rescued = navigationRescue(contents, epochAtDispatch, urlAtDispatch, {
+                trusted: false,
+                activation: 'synthetic',
+              })
+              if (rescued) return rescued
               throw new ToolError('The frame did not confirm synthetic click dispatch.')
             }
           }
@@ -2221,6 +2430,13 @@ async function executeToolInner(
             )),
         tabChanged,
       }
+      // Page-read URLs go blind when the click navigated and the origin
+      // context died: the after-state reads {} and urlChanged computes false
+      // for a maximally successful click. The driver-level epoch/URL survive
+      // the teardown, so fold them in.
+      const navigatedByDriver =
+        !contents.isDestroyed() &&
+        (navigationEpoch(contents) !== epochAtDispatch || contents.getURL() !== urlAtDispatch)
       const clickEffectObserved =
         observation.effect.urlChanged ||
         observation.effect.dialogChanged ||
@@ -2233,9 +2449,13 @@ async function executeToolInner(
           topObservation.effect.dialogChanged ||
           topObservation.effect.popupChanged ||
           topObservation.effect.targetChanged)
-      const effectObserved = clickEffectObserved || topClickEffectObserved || tabChanged
+      const effectObserved =
+        clickEffectObserved || topClickEffectObserved || tabChanged || navigatedByDriver
       const possibleEffectObserved =
-        observation.possibleEffectObserved || topObservation.possibleEffectObserved || tabChanged
+        observation.possibleEffectObserved ||
+        topObservation.possibleEffectObserved ||
+        tabChanged ||
+        navigatedByDriver
       const dialogs = Array.from(
         new Set([
           ...(Array.isArray(afterPage.dialogs) ? afterPage.dialogs.map(String) : []),
@@ -2243,11 +2463,25 @@ async function executeToolInner(
         ])
       )
       const navigated =
-        observation.effect.urlChanged || topObservation.effect.urlChanged || tabChanged
-      const obstructedAfterNavigation = navigated && dialogs.length > 0
+        observation.effect.urlChanged ||
+        topObservation.effect.urlChanged ||
+        tabChanged ||
+        navigatedByDriver
+      // Only a dialog that ARRIVED with the navigation obstructs it. Comparing
+      // against the union of what was already open stops the false positive
+      // that fires on every SPA route change under a persistent `role=dialog`
+      // (a cookie banner, a side drawer, an emoji picker) — those are not
+      // blocking anything, and reporting them made successful clicks read as
+      // failures.
+      const dialogsBefore = new Set([
+        ...(Array.isArray(beforePage.dialogs) ? beforePage.dialogs.map(String) : []),
+        ...(Array.isArray(beforeTopPage.dialogs) ? beforeTopPage.dialogs.map(String) : []),
+      ])
+      const newDialogs = dialogs.filter((dialog) => !dialogsBefore.has(dialog))
+      const obstructedAfterNavigation = navigated && newDialogs.length > 0
       const notes: string[] = []
       if (obstructedAfterNavigation) {
-        notes.push('The page navigated, but a dialog is still open above it.')
+        notes.push(`The page navigated, but a dialog opened above it (${newDialogs.join(', ')}).`)
       }
       if (!effectObserved) {
         notes.push(
@@ -2292,7 +2526,16 @@ async function executeToolInner(
       // synthetic value-setter when CDP is unavailable.
       assertCurrentExecution()
       assertElementActionCurrent(contents, elementId, target)
-      const initialSurface = await prepareTypingSurface(target, elementId, true, executionDeadline)
+      // The settle grace covers a composer whose real contenteditable mounts a
+      // beat after the surrounding view renders (Slack); nothing has been
+      // dispatched yet, so reprobing is safe.
+      const initialSurface = await prepareTypingSurface(
+        target,
+        elementId,
+        true,
+        executionDeadline,
+        SETTLE_GRACE_MS
+      )
       assertCurrentExecution()
       assertElementActionCurrent(contents, elementId, target)
       if (targetFrame) {
@@ -2591,9 +2834,10 @@ async function executeToolInner(
       const requestedKey = requireStr(params, 'key')
       const combo = parseKeyCombo(requestedKey)
       const contents = session.requireAutomationTab().view.webContents
-      const pressedPageUrl = contents.getURL()
+      const pressedNavigationEpoch = navigationEpoch(contents)
       let target: PageExecutionTarget = focusedPageTarget(contents)
-      let pressedFrameUrl = target === contents ? undefined : (target as WebFrameMain).url
+      let pressedFrameEpoch =
+        target === contents ? undefined : frameNavigationEpoch(contents, target as WebFrameMain)
       // Pasting would move the user's clipboard into the page, where the next
       // snapshot reports it as an ordinary field value — clipboards routinely
       // hold a password copied out of a password manager. Copy and cut would
@@ -2612,7 +2856,8 @@ async function executeToolInner(
       const dispatchTarget = focusedPageTarget(contents)
       if (dispatchTarget !== target) {
         target = dispatchTarget
-        pressedFrameUrl = target === contents ? undefined : (target as WebFrameMain).url
+        pressedFrameEpoch =
+          target === contents ? undefined : frameNavigationEpoch(contents, target as WebFrameMain)
         beforePage = await pageActionState(target, true)
         beforeElement = await activeElementState(target)
       }
@@ -2648,8 +2893,8 @@ async function executeToolInner(
       let fallbackState: Record<string, unknown> = {}
       try {
         assertCurrentExecution()
-        assertActiveContents(contents, pressedPageUrl)
-        assertFocusedTargetUnchanged(contents, target, pressedFrameUrl)
+        assertActiveContents(contents, pressedNavigationEpoch)
+        assertFocusedTargetUnchanged(contents, target, pressedFrameEpoch)
         await dispatchKeyCombo(contents, combo)
       } catch (error) {
         if (error instanceof KeyDispatchError && error.keyDownDispatched) {
@@ -2661,8 +2906,8 @@ async function executeToolInner(
         // CDP unavailable (debugger detached): synthetic DOM fallback. It
         // cannot trigger default editing actions, so say so in the result.
         assertCurrentExecution()
-        assertActiveContents(contents, pressedPageUrl)
-        assertFocusedTargetUnchanged(contents, target, pressedFrameUrl)
+        assertActiveContents(contents, pressedNavigationEpoch)
+        assertFocusedTargetUnchanged(contents, target, pressedFrameEpoch)
         const fallbackSecrecy = await execInPage(target, activeElementSecrecy, []).catch(
           () => 'opaque'
         )
@@ -2673,8 +2918,8 @@ async function executeToolInner(
           )
         }
         assertCurrentExecution()
-        assertActiveContents(contents, pressedPageUrl)
-        assertFocusedTargetUnchanged(contents, target, pressedFrameUrl)
+        assertActiveContents(contents, pressedNavigationEpoch)
+        assertFocusedTargetUnchanged(contents, target, pressedFrameEpoch)
         const fallback = unwrapPageResult(
           await execInPage(
             target,
@@ -2867,16 +3112,29 @@ async function executeToolInner(
       const elementId = requireNum(params, 'elementId')
       const target = pageTargetForElement(contents, elementId)
       const targetFrame = frameExecutionTarget(target, contents)
-      const beforePage = await pageActionState(target, true, elementId)
-      const beforeElement = await activeElementState(target)
-      const beforeTopPage = targetFrame ? await pageActionState(contents, true) : beforePage
-      const beforeTopElement = targetFrame ? await activeElementState(contents) : beforeElement
+      let beforePage = await pageActionState(target, true, elementId)
+      let beforeElement = await activeElementState(target)
+      let beforeTopPage = targetFrame ? await pageActionState(contents, true) : beforePage
+      let beforeTopElement = targetFrame ? await activeElementState(contents) : beforeElement
+      // Preparing the surface scrolls the element into view, so a baseline
+      // taken before it always reports scrollChanged — the tool's own probe,
+      // not the hover's effect. That pinned every unproductive hover to
+      // "background churn" instead of the honest "nothing happened", and hid
+      // real scrolling caused by the hover itself. Re-baseline once the scroll
+      // has settled and before the pointer moves.
+      const rebaseline = async (): Promise<void> => {
+        beforePage = await pageActionState(target, true, elementId)
+        beforeElement = await activeElementState(target)
+        beforeTopPage = targetFrame ? await pageActionState(contents, true) : beforePage
+        beforeTopElement = targetFrame ? await activeElementState(contents) : beforeElement
+      }
       let trusted = false
       let result: unknown
       if (!targetFrame) {
         assertCurrentExecution()
         assertElementActionCurrent(contents, elementId, target)
         let prepared = await prepareElementSurface(target, elementId, executionDeadline, true)
+        await rebaseline()
         let stable = false
         for (let attempt = 0; attempt < 2; attempt++) {
           assertCurrentExecution()
@@ -2900,6 +3158,7 @@ async function executeToolInner(
         assertCurrentExecution()
         assertElementActionCurrent(contents, elementId, target)
         let surface = await prepareElementSurface(target, elementId, executionDeadline, true)
+        await rebaseline()
         assertCurrentExecution()
         assertElementActionCurrent(contents, elementId, target)
         let embedding = await assertFrameEmbeddingVisible(
@@ -3000,9 +3259,338 @@ async function executeToolInner(
         effectObserved,
         ...(!effectObserved
           ? {
-              note: possibleEffectObserved
-                ? 'Only background DOM/title churn followed the hover; a tooltip/menu was not confirmed.'
-                : 'No tooltip, menu, focus, or other strong hover effect was observed.',
+              // A capped scan cannot claim nothing appeared: overlays are
+              // commonly portalled to the END of <body>, which is exactly the
+              // part a truncated walk misses. Say so instead of reporting a
+              // partial look with full confidence.
+              note:
+                afterPage.observationTruncated === true ||
+                afterTopPage.observationTruncated === true
+                  ? 'This page is too large to scan completely, so a tooltip or menu that opened may not have been seen. Confirm with browser_snapshot or browser_screenshot before concluding the hover did nothing.'
+                  : possibleEffectObserved
+                    ? 'Only background DOM/title churn followed the hover; a tooltip/menu was not confirmed.'
+                    : 'No tooltip, menu, focus, or other strong hover effect was observed.',
+            }
+          : {}),
+      }
+    }
+
+    case 'browser_click_at': {
+      const clickedTab = session.requireAutomationTab()
+      const contents = clickedTab.view.webContents
+      const x = requireNum(params, 'x')
+      const y = requireNum(params, 'y')
+      const clickCount = num(params, 'clickCount') ?? 1
+      if (![1, 2, 3].includes(clickCount)) {
+        throw new ToolError('clickCount must be 1 (click), 2 (double-click), or 3 (triple-click).')
+      }
+      const clickNavigationEpoch = navigationEpoch(contents)
+      const urlAtDispatch = contents.getURL()
+      assertCurrentExecution()
+      assertActiveContents(contents)
+      const pointTarget = unwrapPageResult(
+        await execInPage(contents, describePointTarget, [x, y], false, executionDeadline)
+      )
+      if (!isRecordLike(pointTarget) || pointTarget.found !== true) {
+        throw new ToolError(
+          'Nothing is rendered at that point. Coordinates are CSS pixels in the current viewport — when reading them off a browser_screenshot, divide image pixels by its scale.'
+        )
+      }
+      if (pointTarget.fileInput === true) {
+        throw new ToolError(
+          'Refusing to click a file input because it opens a native chooser the browser agent cannot inspect or complete. Ask the user to upload the file themselves.'
+        )
+      }
+      const beforePage = await pageActionState(contents, true)
+      const beforeElement = await activeElementState(contents)
+      assertCurrentExecution()
+      assertActiveContents(contents, clickNavigationEpoch)
+      try {
+        await cdp.clickAt(contents, x, y, true, clickCount)
+      } catch (error) {
+        const rescued = navigationRescue(contents, clickNavigationEpoch, urlAtDispatch, {
+          trusted: true,
+          activation: 'native-pointer',
+        })
+        if (rescued) return rescued
+        throw new ToolError(
+          `Native click dispatch failed (${getErrorMessage(error)}). The action was not retried because a partial pointer press may already have reached the page. Take a fresh snapshot before continuing.`
+        )
+      }
+      await sleep(150)
+      const afterElement = await activeElementState(contents)
+      const afterPage = await pageActionState(contents)
+      const observation = pageEffect(beforePage, afterPage, beforeElement, afterElement)
+      const activeTab = session.automationTab()
+      const tabChanged = activeTab?.id !== clickedTab.id
+      // targetChanged is deliberately absent: this tool has no elementId, so
+      // pageActionState captures no targetState and the term could only ever
+      // be false. Listing it read as coverage this tool does not have.
+      const effectObserved =
+        observation.effect.urlChanged ||
+        observation.effect.dialogChanged ||
+        observation.effect.popupChanged ||
+        (pointTarget.editable === true && observation.effect.focusChanged) ||
+        tabChanged
+      const dialogs = Array.isArray(afterPage.dialogs) ? afterPage.dialogs.map(String) : []
+      const notes: string[] = []
+      if (pointTarget.secret === true) {
+        notes.push(
+          'The point resolves to a password field. Focusing it is fine, but typing there is refused — call browser_request_takeover for credentials.'
+        )
+      }
+      if (pointTarget.crossOriginFrame === true) {
+        notes.push(
+          'The point lands inside an embedded frame that could not be inspected; the click was dispatched but its target is unverified.'
+        )
+      }
+      if (!effectObserved) {
+        notes.push(
+          observation.possibleEffectObserved || tabChanged
+            ? 'Only background DOM/title churn followed the click; inspect the page before treating it as successful.'
+            : 'No strong observable page change followed the click; inspect the page before treating it as successful.'
+        )
+      }
+      return {
+        dispatched: true,
+        trusted: true,
+        activation: 'native-pointer',
+        clickedAt: { x, y },
+        clickCount,
+        target: pointTarget.element,
+        targetCursor: pointTarget.cursor,
+        effectObserved,
+        possibleEffectObserved: observation.possibleEffectObserved || tabChanged,
+        effect: { ...observation.effect, tabChanged },
+        dialogs,
+        ...(tabChanged && activeTab
+          ? { activeTab: { tabId: activeTab.id, url: activeTab.view.webContents.getURL() } }
+          : {}),
+        ...(notes.length > 0 ? { note: notes.join(' ') } : {}),
+      }
+    }
+
+    case 'browser_insert_text': {
+      const text = requireStr(params, 'text')
+      const submit = params.submit === true
+      const contents = session.requireAutomationTab().view.webContents
+      const insertNavigationEpoch = navigationEpoch(contents)
+      const target: PageExecutionTarget = focusedPageTarget(contents)
+      const secrecy = await execInPage(target, activeElementSecrecy, []).catch(() => 'opaque')
+      if (secrecy === 'secret') throw new ToolError(PASSWORD_REFUSAL)
+      if (secrecy === 'opaque') {
+        throw new ToolError(
+          'Focus is inside a cross-origin frame whose contents cannot be inspected, so this ' +
+            'insertion could reach a password field. Call browser_request_takeover if the user needs to type here.'
+        )
+      }
+      const focusState = unwrapPageResult(
+        await execInPage(target, describeFocusedEditable, [], false, executionDeadline)
+      )
+      if (!isRecordLike(focusState) || focusState.editable !== true) {
+        const reason = isRecordLike(focusState) ? String(focusState.reason || '') : ''
+        // Name the element that actually held focus. Without it the agent
+        // cannot tell "I focused the wrong thing" from "this tool cannot type
+        // here", and it retries variations of the same failing approach.
+        const focused = isRecordLike(focusState)
+          ? [
+              focusState.focusedTag ? `<${String(focusState.focusedTag)}>` : '',
+              focusState.focusedRole ? `role="${String(focusState.focusedRole)}"` : '',
+              focusState.contentEditable && focusState.contentEditable !== 'unset'
+                ? `contenteditable="${String(focusState.contentEditable)}"`
+                : '',
+            ]
+              .filter(Boolean)
+              .join(' ')
+          : ''
+        throw new ToolError(
+          reason === 'none'
+            ? 'No element is focused. Click the field first (browser_click or browser_click_at), then insert text.'
+            : `The focused element does not accept text${reason ? ` (${reason})` : ''}${
+                focused ? `; focus is on ${focused}` : ''
+              }. Click the field you want to type into, then insert text.`
+        )
+      }
+      const beforePage = await pageActionState(target, true)
+      const beforeElement = await activeElementState(target)
+      // Observe the TOP document too when typing inside a frame. A submit that
+      // navigates the top page is invisible to a frame-scoped observation, so a
+      // successful send reported effectObserved: false. Newly reachable now
+      // that the focus check descends into frames at all.
+      const insertInFrame = target !== contents
+      const beforeTopPage = insertInFrame ? await pageActionState(contents, true) : beforePage
+      assertCurrentExecution()
+      assertActiveContents(contents, insertNavigationEpoch)
+      assertFocusedTargetUnchanged(contents, target)
+      try {
+        await cdp.insertText(contents, text)
+      } catch (error) {
+        throw new ToolError(
+          `Native text insertion failed (${getErrorMessage(error)}). Take a fresh snapshot before retrying.`
+        )
+      }
+      let submitDispatched = false
+      if (submit) {
+        await sleep(25)
+        assertCurrentExecution()
+        assertActiveContents(contents, insertNavigationEpoch)
+        try {
+          await dispatchKeyCombo(contents, parseKeyCombo('Enter'))
+          submitDispatched = true
+        } catch {
+          // Reported below through submitDispatched: false.
+        }
+      }
+      await sleep(150)
+      const state = await activeElementState(target)
+      const afterPage = await pageActionState(target)
+      const observation = pageEffect(beforePage, afterPage, beforeElement, state)
+      const topObservation = insertInFrame
+        ? pageEffect(beforeTopPage, await pageActionState(contents, true), beforeElement, state)
+        : observation
+      // targetChanged is deliberately absent: this tool has no elementId, so
+      // pageActionState captures no targetState and the term could only ever
+      // be false. Listing it read as coverage this tool does not have.
+      const effectObserved =
+        observation.effect.fieldChanged ||
+        observation.effect.urlChanged ||
+        observation.effect.dialogChanged ||
+        topObservation.effect.urlChanged ||
+        topObservation.effect.dialogChanged
+      return {
+        dispatched: true,
+        trusted: true,
+        kind: focusState.kind,
+        insertedChars: text.length,
+        ...state,
+        effectObserved,
+        possibleEffectObserved: observation.possibleEffectObserved,
+        effect: observation.effect,
+        submitRequested: submit,
+        submitDispatched,
+        ...(focusState.kind === 'canvas' || focusState.kind === 'textbox-role'
+          ? {
+              note: 'The focused editor is canvas/model-backed, so field readback cannot confirm the text — verify visually with browser_screenshot.',
+            }
+          : !effectObserved
+            ? {
+                note: 'Insertion produced no observable field or page change; inspect the page before continuing.',
+              }
+            : {}),
+      }
+    }
+
+    case 'browser_drag': {
+      const draggedTab = session.requireAutomationTab()
+      const contents = draggedTab.view.webContents
+      const dragNavigationEpoch = navigationEpoch(contents)
+
+      const resolveEndpoint = async (
+        which: 'from' | 'to'
+      ): Promise<{ x: number; y: number; element?: string }> => {
+        const elementId = num(params, `${which}ElementId`)
+        if (elementId !== undefined) {
+          const target = pageTargetForElement(contents, elementId)
+          if (frameExecutionTarget(target, contents)) {
+            throw new ToolError(
+              `Dragging elements inside embedded frames is not supported. Use ${which}X/${which}Y viewport coordinates instead.`
+            )
+          }
+          const prepared = unwrapPageResult(
+            await execInPageWithSettleGrace(
+              target,
+              clickElement,
+              [elementId, false, false],
+              executionDeadline
+            )
+          )
+          if (
+            !isRecordLike(prepared) ||
+            typeof prepared.x !== 'number' ||
+            typeof prepared.y !== 'number'
+          ) {
+            throw new ToolError(`Could not resolve the ${which} element for the drag.`)
+          }
+          return {
+            x: prepared.x,
+            y: prepared.y,
+            ...(typeof prepared.element === 'string' ? { element: prepared.element } : {}),
+          }
+        }
+        const pointX = num(params, `${which}X`)
+        const pointY = num(params, `${which}Y`)
+        if (pointX === undefined || pointY === undefined) {
+          throw new ToolError(
+            `Provide either ${which}ElementId or both ${which}X and ${which}Y for the drag ${which === 'from' ? 'source' : 'target'}.`
+          )
+        }
+        const probe = unwrapPageResult(
+          await execInPage(
+            contents,
+            describePointTarget,
+            [pointX, pointY],
+            false,
+            executionDeadline
+          )
+        )
+        if (!isRecordLike(probe) || probe.found !== true) {
+          throw new ToolError(
+            `Nothing is rendered at the ${which} point. Coordinates are CSS pixels in the current viewport — when reading them off a browser_screenshot, divide image pixels by its scale.`
+          )
+        }
+        return {
+          x: pointX,
+          y: pointY,
+          ...(typeof probe.element === 'string' ? { element: probe.element } : {}),
+        }
+      }
+
+      assertCurrentExecution()
+      assertActiveContents(contents)
+      const from = await resolveEndpoint('from')
+      const to = await resolveEndpoint('to')
+      if (Math.abs(from.x - to.x) < 1 && Math.abs(from.y - to.y) < 1) {
+        throw new ToolError('The drag source and target are the same point; nothing to drag.')
+      }
+      const beforePage = await pageActionState(contents, true)
+      const beforeElement = await activeElementState(contents)
+      assertCurrentExecution()
+      assertActiveContents(contents, dragNavigationEpoch)
+      let interception: { nativeDragIntercepted: boolean }
+      try {
+        interception = await cdp.dragPointer(contents, from, to)
+      } catch (error) {
+        throw new ToolError(
+          `Native drag dispatch failed (${getErrorMessage(error)}). The pointer may have been mid-drag; take a fresh snapshot to see the page's current state before retrying.`
+        )
+      }
+      await sleep(200)
+      const afterElement = await activeElementState(contents)
+      const afterPage = await pageActionState(contents)
+      const observation = pageEffect(beforePage, afterPage, beforeElement, afterElement)
+      // targetChanged is deliberately absent: this tool has no elementId, so
+      // pageActionState captures no targetState and the term could only ever be
+      // false. domChanged IS trusted here — unlike every other tool — because a
+      // drop that reorders a list may change nothing else observable.
+      const effectObserved =
+        observation.effect.domChanged ||
+        observation.effect.urlChanged ||
+        observation.effect.dialogChanged ||
+        observation.effect.scrollChanged
+      const dialogs = Array.isArray(afterPage.dialogs) ? afterPage.dialogs.map(String) : []
+      return {
+        dispatched: true,
+        trusted: true,
+        nativeHtml5Drag: interception.nativeDragIntercepted,
+        from,
+        to,
+        effectObserved,
+        possibleEffectObserved: observation.possibleEffectObserved,
+        effect: observation.effect,
+        dialogs,
+        ...(!effectObserved
+          ? {
+              note: 'No observable page change followed the drag. Verify with browser_snapshot or browser_screenshot; some drop targets only commit on their own animation frame.',
             }
           : {}),
       }
diff --git a/apps/desktop/src/main/browser-agent/page-functions.test.ts b/apps/desktop/src/main/browser-agent/page-functions.test.ts
index 52a84235db..1219a7eac8 100644
--- a/apps/desktop/src/main/browser-agent/page-functions.test.ts
+++ b/apps/desktop/src/main/browser-agent/page-functions.test.ts
@@ -5,6 +5,8 @@ import {
   activeElementSecrecy,
   clickElement,
   collectSnapshot,
+  describeFocusedEditable,
+  describePointTarget,
   focusElementForTyping,
   getViewportInfo,
   hoverElement,
@@ -155,6 +157,8 @@ describe('serialization contract', () => {
     ['readPageText', readPageText, []],
     ['pageContainsText', pageContainsText, ['needle']],
     ['getViewportInfo', getViewportInfo, []],
+    ['describePointTarget', describePointTarget, [10, 10]],
+    ['describeFocusedEditable', describeFocusedEditable, []],
   ]
 
   it.each(cases)('%s is self-contained', (_name, fn, args) => {
@@ -257,8 +261,11 @@ describe('secret-field detection', () => {
     expect(typeIntoElement(0, 'change', false)).toEqual({ error: 'readonly' })
     expect(focusElementForTyping(1)).toEqual({ error: 'disabled' })
     expect(typeIntoElement(1, 'change', false)).toEqual({ error: 'disabled' })
-    expect(focusElementForTyping(2)).toEqual({ error: 'not-editable' })
-    expect(typeIntoElement(2, 'change', false)).toEqual({ error: 'not-editable' })
+    expect(focusElementForTyping(2)).toMatchObject({ error: 'not-editable', elementTag: 'input' })
+    expect(typeIntoElement(2, 'change', false)).toMatchObject({
+      error: 'not-editable',
+      elementTag: 'input',
+    })
   })
 
   it('detects a password field reached through a same-origin iframe', () => {
@@ -379,7 +386,12 @@ describe('combobox typing surfaces', () => {
     for (const input of Array.from(document.querySelectorAll('input'))) visible(input)
     register(ambiguous, secret)
 
-    expect(focusElementForTyping(0)).toEqual({ error: 'ambiguous-editable' })
+    // The candidate list is the whole point of this error — it is the only
+    // thing that lets the agent pick a narrower target.
+    expect(focusElementForTyping(0)).toMatchObject({
+      error: 'ambiguous-editable',
+      candidates: expect.arrayContaining([expect.stringContaining('input')]),
+    })
     expect(focusElementForTyping(1)).toEqual({ error: 'password' })
     expect(typeIntoElement(1, 'nope', false)).toEqual({ error: 'password' })
   })
@@ -589,8 +601,11 @@ describe('collectSnapshot', () => {
     })
 
     expect(card.contains(nestedButton)).toBe(true)
+    // Nothing is covering the card — its own button owns the point. Reporting
+    // this as an obstruction told the agent to close an overlay that does not
+    // exist; the recovery is to target the nested control instead.
     expect(clickElement(ref, false)).toEqual({
-      error: 'obstructed',
+      error: 'nested-control',
       blocker: 'Delete channel',
     })
   })
@@ -766,7 +781,39 @@ describe('collectSnapshot', () => {
       document.body.append(replacement)
     }
 
-    expect(focusElementForTyping(ref)).toEqual({ error: 'stale' })
+    expect(focusElementForTyping(ref)).toMatchObject({ error: 'stale' })
+  })
+
+  it('keeps a connected ref usable after a same-document URL change', () => {
+    document.body.innerHTML = '<button data-testid="composer-send">Send</button>'
+    const button = visible(document.querySelector('button') as HTMLButtonElement)
+    const ref = refFor(outlineOf(collectSnapshot()), 'Send')
+    let clicked = false
+    button.addEventListener('click', () => {
+      clicked = true
+    })
+
+    window.history.pushState({}, '', '/client/T123/C456')
+
+    expect(clickElement(ref)).toMatchObject({ dispatched: true, refRecovered: false })
+    expect(clicked).toBe(true)
+  })
+
+  it('recovers a replaced ref after a same-document URL change', () => {
+    document.body.innerHTML = '<button data-testid="messages-tab">Messages</button>'
+    const original = visible(document.querySelector('button') as HTMLButtonElement)
+    const ref = refFor(outlineOf(collectSnapshot()), 'Messages')
+    const replacement = visible(original.cloneNode(true) as HTMLButtonElement)
+    let clicked = false
+    replacement.addEventListener('click', () => {
+      clicked = true
+    })
+
+    window.history.pushState({}, '', '/client/T123/C456')
+    original.replaceWith(replacement)
+
+    expect(clickElement(ref)).toMatchObject({ dispatched: true, refRecovered: true })
+    expect(clicked).toBe(true)
   })
 
   it('refuses to recover a ref when replacement is ambiguous', () => {
@@ -777,7 +824,7 @@ describe('collectSnapshot', () => {
     const second = visible(original.cloneNode(true) as HTMLButtonElement)
     original.replaceWith(first, second)
 
-    expect(clickElement(ref)).toEqual({ error: 'stale' })
+    expect(clickElement(ref)).toMatchObject({ error: 'stale' })
   })
 
   it('invalidates a connected virtual row when its identity is recycled in place', () => {
@@ -788,7 +835,7 @@ describe('collectSnapshot', () => {
     row.textContent = 'random'
     row.dataset.key = 'channel-2'
 
-    expect(clickElement(ref)).toEqual({ error: 'stale' })
+    expect(clickElement(ref)).toMatchObject({ error: 'stale' })
   })
 
   it('invalidates a generic connected row action when its surrounding item is recycled', () => {
@@ -802,7 +849,7 @@ describe('collectSnapshot', () => {
     ;(document.querySelector('span') as HTMLSpanElement).textContent = 'random'
 
     expect(button.isConnected).toBe(true)
-    expect(clickElement(ref)).toEqual({ error: 'stale' })
+    expect(clickElement(ref)).toMatchObject({ error: 'stale' })
   })
 
   it('never recycles numeric refs across snapshots', () => {
@@ -812,10 +859,32 @@ describe('collectSnapshot', () => {
     const secondRef = refFor(outlineOf(collectSnapshot()), 'Pins')
 
     expect(secondRef).toBeGreaterThan(firstRef)
-    expect(clickElement(firstRef)).toEqual({ error: 'stale' })
+    expect(clickElement(firstRef)).toMatchObject({ error: 'stale' })
     expect(clickElement(secondRef)).toMatchObject({ dispatched: true })
   })
 
+  // The exact shape of the reported failure: hovering a Slack message mounts an
+  // action bar, but it is a role="toolbar"/"group" — none of the three roles the
+  // popup scan used to match. The hover therefore observed no popup change, no
+  // target change, and so no effect at all, and the agent concluded hovering
+  // did not work and fell back to clicking pixels off screenshots.
+  it('sees a row action bar that mounts on hover', () => {
+    document.body.innerHTML = '<div data-testid="message">Hello</div>'
+    visible(document.querySelector('[data-testid="message"]') as HTMLElement)
+
+    const before = readPageActionState(true) as { popups: string[] }
+    expect(before.popups).toEqual([])
+
+    const toolbar = visible(document.createElement('div'))
+    toolbar.setAttribute('role', 'toolbar')
+    toolbar.setAttribute('aria-label', 'Message shortcuts')
+    document.body.append(toolbar)
+
+    const after = readPageActionState(false) as { popups: string[] }
+    expect(after.popups).toEqual(['Message shortcuts'])
+    expect(after.popups).not.toEqual(before.popups)
+  })
+
   it('reports a targeted control semantic disappearance after its panel closes', () => {
     document.body.innerHTML = `
       <aside aria-label="Thread panel"><button data-testid="close-thread">Close thread</button></aside>
@@ -1341,3 +1410,112 @@ describe('pressKeyOnPage', () => {
     expect(seen).toEqual(['a'])
   })
 })
+
+describe('describePointTarget', () => {
+  function pointAt(el: Element | null): void {
+    Object.defineProperty(document, 'elementFromPoint', {
+      configurable: true,
+      value: () => el,
+    })
+  }
+
+  it('describes the element at a viewport point', () => {
+    document.body.innerHTML = '<button aria-label="Send message">Send</button>'
+    pointAt(document.querySelector('button'))
+
+    expect(describePointTarget(10, 10)).toMatchObject({
+      found: true,
+      tag: 'button',
+      element: 'button "Send message"',
+      editable: false,
+      fileInput: false,
+      secret: false,
+    })
+  })
+
+  it('flags file inputs and password fields at the point', () => {
+    document.body.innerHTML = '<input type="file" />'
+    pointAt(document.querySelector('input'))
+    expect(describePointTarget(10, 10)).toMatchObject({ found: true, fileInput: true })
+
+    document.body.innerHTML = '<input type="password" />'
+    pointAt(document.querySelector('input'))
+    expect(describePointTarget(10, 10)).toMatchObject({
+      found: true,
+      secret: true,
+      editable: true,
+    })
+  })
+
+  it('rejects points outside the viewport', () => {
+    expect(describePointTarget(-5, 10)).toEqual({ error: 'outside-viewport' })
+    expect(describePointTarget(10, window.innerHeight + 5)).toEqual({
+      error: 'outside-viewport',
+    })
+  })
+})
+
+describe('describeFocusedEditable', () => {
+  it('reports no focus when the body holds focus', () => {
+    setActiveElement(document, document.body)
+    expect(describeFocusedEditable()).toEqual({ editable: false, reason: 'none' })
+  })
+
+  // The bug this pins: focus inside a same-origin frame surfaces on the outer
+  // document as the FRAME element, which is not an input, not contentEditable,
+  // not a canvas, and carries no textbox role — so a composer that press-key
+  // typed into fine was reported `not-editable` and insert_text refused. The
+  // descent here must match activeElementReadback's exactly.
+  it('descends a same-origin frame to the editable that really holds focus', () => {
+    document.body.innerHTML = ''
+    const frame = document.createElement('iframe')
+    document.body.append(frame)
+    const inner = frame.contentDocument as Document
+    inner.body.innerHTML = '<div contenteditable="true">composer</div>'
+    const composer = inner.querySelector('div') as HTMLElement
+    Object.defineProperty(composer, 'isContentEditable', { value: true, configurable: true })
+    setActiveElement(inner, composer)
+    setActiveElement(document, frame)
+
+    expect(describeFocusedEditable()).toEqual({ editable: true, kind: 'contenteditable' })
+  })
+
+  it('names the focused element when it refuses, so the agent can recover', () => {
+    document.body.innerHTML = '<div role="button">Send</div>'
+    setActiveElement(document, document.querySelector('div'))
+
+    expect(describeFocusedEditable()).toEqual({
+      editable: false,
+      reason: 'not-editable',
+      focusedTag: 'div',
+      focusedRole: 'button',
+      contentEditable: 'unset',
+    })
+  })
+
+  it('reports a writable input as insertable', () => {
+    document.body.innerHTML = '<input type="text" />'
+    setActiveElement(document, document.querySelector('input'))
+    expect(describeFocusedEditable()).toEqual({ editable: true, kind: 'input:text' })
+  })
+
+  it('reports a read-only input as not insertable', () => {
+    document.body.innerHTML = '<input type="text" readonly />'
+    setActiveElement(document, document.querySelector('input'))
+    expect(describeFocusedEditable()).toEqual({ editable: false, reason: 'readonly' })
+  })
+
+  it('reports a focused contenteditable editor as insertable', () => {
+    document.body.innerHTML = '<div></div>'
+    const editor = document.querySelector('div') as HTMLElement
+    Object.defineProperty(editor, 'isContentEditable', { get: () => true })
+    setActiveElement(document, editor)
+    expect(describeFocusedEditable()).toEqual({ editable: true, kind: 'contenteditable' })
+  })
+
+  it('treats a focused canvas editor surface as insertable', () => {
+    document.body.innerHTML = '<canvas></canvas>'
+    setActiveElement(document, document.querySelector('canvas'))
+    expect(describeFocusedEditable()).toEqual({ editable: true, kind: 'canvas' })
+  })
+})
diff --git a/apps/desktop/src/main/browser-agent/page-functions.ts b/apps/desktop/src/main/browser-agent/page-functions.ts
index f5f4cb2f9a..e9924381d9 100644
--- a/apps/desktop/src/main/browser-agent/page-functions.ts
+++ b/apps/desktop/src/main/browser-agent/page-functions.ts
@@ -34,8 +34,14 @@ declare global {
       root: Node
       observer: MutationObserver
       revision: number
+      /** Roots already passed to observe(), so re-observing stays cheap. */
+      observedRoots: WeakSet<ParentNode>
     }>
     __simAgentNextElementId?: number
+    /** Why the last __simAgentResolveElement call returned null — read by the
+     * shared stale-error producers so a refusal names its cause instead of
+     * the blanket "the page changed". Cleared on every successful resolve. */
+    __simAgentStaleReason?: string
   }
 }
 
@@ -109,6 +115,7 @@ export function collectSnapshot(startingElementId = 0): unknown {
     '[onclick]',
     '[contenteditable="true"]',
     '[contenteditable=""]',
+    '[contenteditable="plaintext-only"]',
   ].join(', ')
   const landmarkSelector = [
     'nav',
@@ -593,13 +600,29 @@ export function collectSnapshot(startingElementId = 0): unknown {
 
   /**
    * React commonly replaces a control's DOM node while preserving its
-   * semantics. Recover only when the old page URL and a strong semantic
+   * semantics. Recover only when the old page origin and a strong semantic
    * fingerprint still identify one candidate; a weak or ambiguous match is a
    * real stale ref, never permission to click something nearby.
    */
   window.__simAgentResolveElement = (id: number) => {
     const locator = locators[id]
-    if (!locator) return null
+    if (!locator) {
+      window.__simAgentStaleReason = `id ${id} is not in the current snapshot's registry`
+      return null
+    }
+
+    // Origin, not full URL: a live SPA rewrites its path with pushState
+    // between snapshot and act (Slack does so continuously), while the
+    // element the model chose is often still the same mounted node. The
+    // origin still pins the document/frame; the role/name/attribute and
+    // ancestor/context signatures below pin the element itself.
+    const pageOriginOf = (url: string): string => {
+      try {
+        return new URL(url).origin
+      } catch {
+        return url
+      }
+    }
 
     const stableAttributes = [
       'id',
@@ -620,7 +643,7 @@ export function collectSnapshot(startingElementId = 0): unknown {
     const identityMatches = (candidate: Element, connected = false): boolean => {
       if (
         candidate.tagName.toUpperCase() !== locator.tag ||
-        pageUrlFor(candidate) !== locator.url ||
+        pageOriginOf(pageUrlFor(candidate)) !== pageOriginOf(locator.url) ||
         roleFor(candidate) !== locator.role
       ) {
         return false
@@ -704,8 +727,40 @@ export function collectSnapshot(startingElementId = 0): unknown {
 
     const current = registry[id]
     if (current?.isConnected) {
-      if (!identityMatches(current, true)) return null
-      if (isCurrentlyVisible(current)) return { element: current, recovered: false }
+      if (!identityMatches(current, true)) {
+        window.__simAgentStaleReason = `the node is still mounted but its identity drifted (now <${String(current.tagName || '').toLowerCase()}> role=${roleFor(current) || 'none'} name="${nameFor(current).slice(0, 60)}")`
+        return null
+      }
+      if (isCurrentlyVisible(current)) {
+        window.__simAgentStaleReason = undefined
+        return { element: current, recovered: false }
+      }
+    }
+
+    // Past this point the original node is gone or hidden, so anything returned
+    // is a DIFFERENT node adopted by structural resemblance. Identity matching
+    // compares origins only — deliberately, so a pushState between snapshot and
+    // act does not kill every ref — but that same leniency let a ref to "More
+    // actions" on a row in one view rebind to the identical control in another
+    // view the app had since navigated to, and act on the wrong thing with no
+    // signal beyond `recovered: true`.
+    //
+    // A same-document path change means the view was swapped, so resemblance is
+    // no longer evidence of sameness. Refuse to adopt and report the ref stale:
+    // the caller re-snapshots, which is cheap and always correct. Revalidating
+    // the still-connected node above stays lenient — it is literally the node
+    // the model chose.
+    const pathOf = (url: string): string => {
+      try {
+        const parsed = new URL(url)
+        return `${parsed.origin}${parsed.pathname}`
+      } catch {
+        return url
+      }
+    }
+    if (pathOf(window.location.href) !== pathOf(locator.url)) {
+      window.__simAgentStaleReason = `the view changed since the snapshot (${pathOf(locator.url)} -> ${pathOf(window.location.href)}), so a lookalike must not be adopted`
+      return null
     }
 
     const reachable: Element[] = []
@@ -786,12 +841,20 @@ export function collectSnapshot(startingElementId = 0): unknown {
       .filter((entry) => entry.score >= 45)
       .sort((a, b) => b.score - a.score)
 
-    if (scored.length === 0) return null
+    if (scored.length === 0) {
+      window.__simAgentStaleReason =
+        'the original node left the DOM and no confident replacement matched'
+      return null
+    }
     const bestScore = scored[0].score
     const best = scored.filter((entry) => entry.score === bestScore)
     const chosen = best.length === 1 ? best[0] : undefined
-    if (!chosen) return null
+    if (!chosen) {
+      window.__simAgentStaleReason = `the original node left the DOM and ${best.length} equally-plausible replacements tied`
+      return null
+    }
     registry[id] = chosen.candidate
+    window.__simAgentStaleReason = undefined
     return { element: chosen.candidate, recovered: true }
   }
 
@@ -828,7 +891,7 @@ export function clickElement(
   const resolver = window.__simAgentResolveElement
   const resolved = resolver?.(id)
   const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-  if (!el || !el.isConnected) return { error: 'stale' }
+  if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
   const isDisabled = (node: Element | null): boolean =>
     Boolean(
       node &&
@@ -862,7 +925,7 @@ export function clickElement(
   el.scrollIntoView({ block: 'center', inline: 'center', behavior: 'instant' })
 
   const view = el.ownerDocument.defaultView
-  if (!view) return { error: 'stale' }
+  if (!view) return { error: 'stale', reason: window.__simAgentStaleReason }
   for (let current: Element | null = el; current; ) {
     const currentView: Window | null = current.ownerDocument.defaultView
     const style = currentView?.getComputedStyle(current)
@@ -1028,7 +1091,7 @@ export function clickElement(
       addCandidate(el)
       for (const candidate of Array.from(
         el.querySelectorAll<HTMLElement>(
-          'input, textarea, [contenteditable="true"], [contenteditable=""]'
+          'input, textarea, [contenteditable="true"], [contenteditable=""], [contenteditable="plaintext-only"], [role="textbox"]'
         )
       )) {
         addCandidate(candidate)
@@ -1087,6 +1150,22 @@ export function clickElement(
     if (suggestionsCoverFocusedEditable()) {
       return { error: 'suggestions-open', blocker: blockerLabel(blocker) }
     }
+    // A hit INSIDE the requested element is not an overlay — it is the ref
+    // wrapping its own control (a row containing a button, a card containing a
+    // link). hitBelongsToTarget rejects both cases identically, so this was
+    // reported as "covered by X, close or move the overlay", advice that cannot
+    // be followed because there is nothing to close. Name it for what it is so
+    // the agent retargets instead of hunting a phantom overlay.
+    let nested = false
+    for (let current = blocker; current; current = composedParent(current)) {
+      if (current === el) {
+        nested = true
+        break
+      }
+    }
+    if (nested) {
+      return { error: 'nested-control', blocker: blockerLabel(blocker) }
+    }
     return { error: 'obstructed', blocker: blockerLabel(blocker) }
   }
 
@@ -1212,7 +1291,7 @@ export function focusElementForTyping(id: number, moveFocus = true): unknown {
   const resolver = window.__simAgentResolveElement
   const resolved = resolver?.(id)
   const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-  if (!el || !el.isConnected) return { error: 'stale' }
+  if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
 
   const isWritableTextField = (
     field: HTMLInputElement | HTMLTextAreaElement
@@ -1236,7 +1315,12 @@ export function focusElementForTyping(id: number, moveFocus = true): unknown {
       tag === 'TEXTAREA' ||
       (tag === 'INPUT' &&
         ['text', 'search', 'email', 'url', 'tel', 'number', 'password'].includes(inputType)) ||
-      (node as HTMLElement).isContentEditable
+      (node as HTMLElement).isContentEditable ||
+      // An ARIA-only textbox. The snapshot already advertises these as
+      // `[textbox]` with a ref, and browser_insert_text accepts them, so
+      // refusing here meant one tool rejecting exactly what the outline told
+      // the model to type into and what its sibling would have accepted.
+      node.getAttribute('role') === 'textbox'
     ) {
       potentialEditables.push(node as HTMLElement)
     }
@@ -1244,14 +1328,34 @@ export function focusElementForTyping(id: number, moveFocus = true): unknown {
   addEditable(el)
   for (const candidate of Array.from(
     el.querySelectorAll<HTMLElement>(
-      'input, textarea, [contenteditable="true"], [contenteditable=""]'
+      'input, textarea, [contenteditable="true"], [contenteditable=""], [contenteditable="plaintext-only"], [role="textbox"]'
     )
   )) {
     addEditable(candidate)
   }
   const editables = Array.from(new Set(potentialEditables))
-  if (editables.length === 0) return { error: 'not-editable' }
-  if (editables.length > 1) return { error: 'ambiguous-editable' }
+  if (editables.length === 0) {
+    // Describe the element instead of only refusing it. Without this the agent
+    // cannot tell "wrong ref" from "this tool cannot type here" and retries
+    // variations of the same failing call.
+    return {
+      error: 'not-editable',
+      elementTag: String(el.tagName || '').toLowerCase(),
+      ...(el.getAttribute('role') ? { elementRole: el.getAttribute('role') } : {}),
+    }
+  }
+  if (editables.length > 1) {
+    // The candidate list is right here; discarding it left the agent unable to
+    // pick a narrower target, which is the only recovery this error allows.
+    return {
+      error: 'ambiguous-editable',
+      candidates: editables.slice(0, 5).map((field) => {
+        const fieldTag = String(field.tagName || '').toLowerCase()
+        const label = field.getAttribute('aria-label') || field.getAttribute('placeholder') || ''
+        return label ? `${fieldTag} "${label}"` : fieldTag
+      }),
+    }
+  }
   const editable = editables[0]
   const editableTag = tagFor(editable)
 
@@ -1274,7 +1378,7 @@ export function focusElementForTyping(id: number, moveFocus = true): unknown {
   const rawRects = Array.from(editable.getClientRects())
   if (rawRects.length === 0) rawRects.push(editable.getBoundingClientRect())
   const view = editable.ownerDocument.defaultView
-  if (!view) return { error: 'stale' }
+  if (!view) return { error: 'stale', reason: window.__simAgentStaleReason }
   const rects = rawRects
     .map((rect) => ({
       left: Math.max(0, rect.left),
@@ -1737,7 +1841,7 @@ export function typeIntoElement(id: number, text: string, submit: boolean): unkn
   const resolver = window.__simAgentResolveElement
   const resolved = resolver?.(id)
   const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-  if (!el || !el.isConnected) return { error: 'stale' }
+  if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
 
   const isWritableTextField = (
     field: HTMLInputElement | HTMLTextAreaElement
@@ -1762,7 +1866,12 @@ export function typeIntoElement(id: number, text: string, submit: boolean): unkn
       candidateTag === 'TEXTAREA' ||
       (candidateTag === 'INPUT' &&
         ['text', 'search', 'email', 'url', 'tel', 'number', 'password'].includes(inputType)) ||
-      (node as HTMLElement).isContentEditable
+      (node as HTMLElement).isContentEditable ||
+      // An ARIA-only textbox. The snapshot already advertises these as
+      // `[textbox]` with a ref, and browser_insert_text accepts them, so
+      // refusing here meant one tool rejecting exactly what the outline told
+      // the model to type into and what its sibling would have accepted.
+      node.getAttribute('role') === 'textbox'
     ) {
       potentialEditables.push(node as HTMLElement)
     }
@@ -1770,14 +1879,34 @@ export function typeIntoElement(id: number, text: string, submit: boolean): unkn
   addEditable(el)
   for (const candidate of Array.from(
     el.querySelectorAll<HTMLElement>(
-      'input, textarea, [contenteditable="true"], [contenteditable=""]'
+      'input, textarea, [contenteditable="true"], [contenteditable=""], [contenteditable="plaintext-only"], [role="textbox"]'
     )
   )) {
     addEditable(candidate)
   }
   const editables = Array.from(new Set(potentialEditables))
-  if (editables.length === 0) return { error: 'not-editable' }
-  if (editables.length > 1) return { error: 'ambiguous-editable' }
+  if (editables.length === 0) {
+    // Describe the element instead of only refusing it. Without this the agent
+    // cannot tell "wrong ref" from "this tool cannot type here" and retries
+    // variations of the same failing call.
+    return {
+      error: 'not-editable',
+      elementTag: String(el.tagName || '').toLowerCase(),
+      ...(el.getAttribute('role') ? { elementRole: el.getAttribute('role') } : {}),
+    }
+  }
+  if (editables.length > 1) {
+    // The candidate list is right here; discarding it left the agent unable to
+    // pick a narrower target, which is the only recovery this error allows.
+    return {
+      error: 'ambiguous-editable',
+      candidates: editables.slice(0, 5).map((field) => {
+        const fieldTag = String(field.tagName || '').toLowerCase()
+        const label = field.getAttribute('aria-label') || field.getAttribute('placeholder') || ''
+        return label ? `${fieldTag} "${label}"` : fieldTag
+      }),
+    }
+  }
   const editable = editables[0]
   const tag = String(editable.tagName || '').toUpperCase()
   editable.scrollIntoView({ block: 'nearest', inline: 'nearest', behavior: 'instant' })
@@ -1859,9 +1988,37 @@ export function pressKeyOnPage(
       .some((token) => token === 'current-password' || token === 'new-password')
   }
 
-  const target = (document.activeElement as HTMLElement | null) ?? document.body
+  // Descend to what is really focused, like every other focus reader here.
+  // Without this the synthetic key lands on the shadow HOST or the <iframe>
+  // element: the event bubbles from there but never enters the shadow tree or
+  // the frame document, so the editor's keymap never sees it — and the result
+  // still reports success. It also made this function's `target` disagree with
+  // the `activeElement` reported alongside it in the same tool result.
+  let target = (document.activeElement as HTMLElement | null) ?? document.body
+  for (let depth = 0; depth < 10; depth++) {
+    const shadow = target.shadowRoot
+    if (shadow?.activeElement) {
+      target = shadow.activeElement as HTMLElement
+      continue
+    }
+    const targetTag = String(target.tagName || '').toUpperCase()
+    if (targetTag === 'IFRAME' || targetTag === 'FRAME') {
+      try {
+        const inner = (target as HTMLIFrameElement).contentDocument
+        if (inner?.activeElement && inner.activeElement !== inner.body) {
+          target = inner.activeElement as HTMLElement
+          continue
+        }
+      } catch {
+        // Cross-origin frame — not inspectable; dispatch to the frame itself.
+      }
+    }
+    break
+  }
   // The driver checks focus before taking the trusted CDP path; this covers
   // the synthetic fallback, which is reached independently when CDP is down.
+  // Descending first is what makes this guard reach a password field nested in
+  // a shadow root or frame, rather than only inspecting the host.
   if (isSecretField(target)) return { error: 'password' }
   const opts = {
     bubbles: true,
@@ -1916,6 +2073,23 @@ export function readPageActionState(resetMutationRevision = false, elementId?: n
     if (allElements.length >= stateNodeCap) break
   }
 
+  const mutationOptions: MutationObserverInit = {
+    subtree: true,
+    childList: true,
+    characterData: true,
+    attributes: true,
+    attributeFilter: [
+      'aria-activedescendant',
+      'aria-expanded',
+      'aria-hidden',
+      'aria-selected',
+      'checked',
+      'disabled',
+      'hidden',
+      'open',
+      'selected',
+    ],
+  }
   const mutationStates = (window.__simAgentMutationStates ??= [])
   let mutationState = observationRoot
     ? mutationStates.find((state) => state.root === observationRoot)
@@ -1925,33 +2099,29 @@ export function readPageActionState(resetMutationRevision = false, elementId?: n
       root: observationRoot,
       observer: null as unknown as MutationObserver,
       revision: 0,
+      observedRoots: new WeakSet<ParentNode>(),
     }
     const state = mutationState
     state.observer = new MutationObserver((records) => {
       state.revision += records.length
     })
-    for (const root of roots) {
-      state.observer.observe(root, {
-        subtree: true,
-        childList: true,
-        characterData: true,
-        attributes: true,
-        attributeFilter: [
-          'aria-activedescendant',
-          'aria-expanded',
-          'aria-hidden',
-          'aria-selected',
-          'checked',
-          'disabled',
-          'hidden',
-          'open',
-          'selected',
-        ],
-      })
-    }
     mutationStates.push(state)
     if (mutationStates.length > 10) mutationStates.shift()?.observer.disconnect()
   }
+  // Observe on EVERY call, not only the first. The roots list is rebuilt each
+  // time and grows as shadow roots mount, so attaching once left every
+  // component that appeared later unobserved — its DOM changes raised no
+  // revision, and an action that mounted UI inside one reported no effect at
+  // all. `observe` on an already-observed root with the same options is a
+  // documented no-op, and observedRoots keeps the common case cheap.
+  if (mutationState) {
+    const state = mutationState
+    for (const root of roots) {
+      if (state.observedRoots.has(root)) continue
+      state.observer.observe(root as Node, mutationOptions)
+      state.observedRoots.add(root)
+    }
+  }
   if (resetMutationRevision) {
     mutationState?.observer.takeRecords()
     if (mutationState) mutationState.revision = 0
@@ -2024,8 +2194,18 @@ export function readPageActionState(resetMutationRevision = false, elementId?: n
         .replace(/[\uD800-\uDBFF]$/, '')
     )
 
+  // Roles an app uses for something that APPEARS over the page. The first three
+  // were the whole list, which missed the most common hover affordance there
+  // is: a row's action bar (Slack's message shortcuts is role="toolbar"/"group"
+  // with an aria-label). A hover that mounted one produced no popup change, no
+  // target change, and so no observed effect at all — the agent concluded its
+  // hover had failed and escalated to clicking pixels.
   const visiblePopupLabels = allElements
-    .filter((element) => element.matches('[role="tooltip"], [role="menu"], [role="listbox"]'))
+    .filter((element) =>
+      element.matches(
+        '[role="tooltip"], [role="menu"], [role="listbox"], [role="toolbar"], [role="menubar"], [role="group"][aria-label], [popover]'
+      )
+    )
     .filter((element) => {
       const rect = element.getBoundingClientRect()
       const view = element.ownerDocument.defaultView
@@ -2254,7 +2434,8 @@ export function scrollPage(direction: string, amount?: number, elementId?: numbe
     const resolver = window.__simAgentResolveElement
     const resolved = resolver?.(elementId)
     const element = resolver ? resolved?.element : (window.__simAgentElements || [])[elementId]
-    if (!element || !element.isConnected) return { error: 'stale' }
+    if (!element || !element.isConnected)
+      return { error: 'stale', reason: window.__simAgentStaleReason }
     const candidates = ancestors(element)
     target = candidates.find(canMove) ?? candidates[0]
     source = target && canMove(target) ? 'element' : 'element-boundary'
@@ -2361,7 +2542,7 @@ export function selectOptionInElement(id: number, value: string): unknown {
   const resolver = window.__simAgentResolveElement
   const resolved = resolver?.(id)
   const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-  if (!el || !el.isConnected) return { error: 'stale' }
+  if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
   if (String(el.tagName || '').toUpperCase() !== 'SELECT') return { error: 'not-select' }
   const select = el as HTMLSelectElement
   if (select.disabled || select.getAttribute('aria-disabled') === 'true') {
@@ -2401,7 +2582,7 @@ export function readSelectElementState(id: number): unknown {
   const resolver = window.__simAgentResolveElement
   const resolved = resolver?.(id)
   const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-  if (!el || !el.isConnected) return { error: 'stale' }
+  if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
   if (String(el.tagName || '').toUpperCase() !== 'SELECT') return { error: 'not-select' }
   const select = el as HTMLSelectElement
   return {
@@ -2414,7 +2595,7 @@ export function hoverElement(id: number): unknown {
   const resolver = window.__simAgentResolveElement
   const resolved = resolver?.(id)
   const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-  if (!el || !el.isConnected) return { error: 'stale' }
+  if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
   el.scrollIntoView({ block: 'center', behavior: 'instant' })
   const rect = el.getBoundingClientRect()
   const opts = {
@@ -2635,7 +2816,7 @@ export function readPageText(id?: number): unknown {
     const resolver = window.__simAgentResolveElement
     const resolved = resolver?.(id)
     const el = resolver ? resolved?.element : (window.__simAgentElements || [])[id]
-    if (!el || !el.isConnected) return { error: 'stale' }
+    if (!el || !el.isConnected) return { error: 'stale', reason: window.__simAgentStaleReason }
     text = (el as HTMLElement).innerText ?? el.textContent ?? ''
   } else {
     text = document.body?.innerText ?? ''
@@ -2662,3 +2843,184 @@ export function getViewportInfo(): unknown {
     height: window.innerHeight,
   }
 }
+
+/**
+ * Describes whatever sits at a viewport point, descending through open shadow
+ * roots and same-origin iframes. Coordinate-addressed actions have no
+ * snapshot ref to revalidate, so this probe is their safety check: the driver
+ * refuses file inputs outright and reports what the point resolves to so the
+ * model can confirm it hit what the screenshot showed.
+ */
+export function describePointTarget(x: number, y: number): unknown {
+  if (
+    !Number.isFinite(x) ||
+    !Number.isFinite(y) ||
+    x < 0 ||
+    y < 0 ||
+    x >= window.innerWidth ||
+    y >= window.innerHeight
+  ) {
+    return { error: 'outside-viewport' }
+  }
+
+  let doc: Document = document
+  let localX = x
+  let localY = y
+  let element: Element | null = null
+  for (let depth = 0; depth < 10; depth++) {
+    if (typeof doc.elementFromPoint !== 'function') break
+    let found: Element | null = doc.elementFromPoint(localX, localY)
+    // Open shadow roots re-hit-test at the same point until a leaf host.
+    for (let shadowDepth = 0; shadowDepth < 10; shadowDepth++) {
+      const shadow = (found as HTMLElement | null)?.shadowRoot
+      const inner = shadow?.elementFromPoint(localX, localY)
+      if (!inner || inner === found) break
+      found = inner
+    }
+    element = found
+    const tag = String(found?.tagName || '').toUpperCase()
+    if ((tag !== 'IFRAME' && tag !== 'FRAME') || !found) break
+    try {
+      const innerDoc = (found as HTMLIFrameElement).contentDocument
+      if (!innerDoc) break
+      const rect = found.getBoundingClientRect()
+      localX -= rect.left + (found as HTMLIFrameElement).clientLeft
+      localY -= rect.top + (found as HTMLIFrameElement).clientTop
+      doc = innerDoc
+    } catch {
+      // Cross-origin frame — cannot inspect further; report the frame itself.
+      break
+    }
+  }
+  if (!element) return { found: false }
+
+  const tag = String(element.tagName || '').toUpperCase()
+  const inputType =
+    tag === 'INPUT' ? String((element as HTMLInputElement).type || 'text').toLowerCase() : ''
+  const secret =
+    tag === 'INPUT' &&
+    (inputType === 'password' ||
+      String(element.getAttribute('autocomplete') || '')
+        .toLowerCase()
+        .split(/\s+/)
+        .some((token) => token === 'current-password' || token === 'new-password'))
+  const editable = Boolean(
+    tag === 'TEXTAREA' ||
+      (tag === 'INPUT' &&
+        ['text', 'search', 'email', 'url', 'tel', 'number', 'password'].includes(inputType)) ||
+      (element as HTMLElement).isContentEditable
+  )
+
+  const name = (
+    element.getAttribute('aria-label') ||
+    element.getAttribute('title') ||
+    element.getAttribute('alt') ||
+    ((element as HTMLElement).innerText ?? element.textContent ?? '')
+  )
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 80)
+  const role = element.getAttribute('role') || ''
+  const style = element.ownerDocument.defaultView?.getComputedStyle(element)
+
+  return {
+    found: true,
+    element: name
+      ? `${tag.toLowerCase()}${role ? `[${role}]` : ''} "${name}"`
+      : `${tag.toLowerCase()}${role ? `[${role}]` : ''}`,
+    tag: tag.toLowerCase(),
+    role,
+    editable,
+    secret,
+    fileInput: tag === 'INPUT' && inputType === 'file',
+    disabled:
+      (element as HTMLInputElement).disabled === true ||
+      element.getAttribute('aria-disabled') === 'true',
+    canvas: tag === 'CANVAS',
+    crossOriginFrame: tag === 'IFRAME' || tag === 'FRAME',
+    cursor: style?.cursor || '',
+  }
+}
+
+/**
+ * Reports whether the currently-focused element accepts text insertion, for
+ * browser_insert_text — which types at the caret instead of addressing a
+ * snapshot ref. Secrecy is separately (and authoritatively) probed by
+ * activeElementSecrecy before any insertion.
+ */
+export function describeFocusedEditable(): unknown {
+  // Descend shadow roots AND same-origin frames, matching activeElementReadback
+  // exactly. Focus inside a frame surfaces on the outer document as the FRAME
+  // element, which is not an input, not contentEditable, not a canvas and has no
+  // textbox role — so stopping here reported a perfectly writable field as
+  // `not-editable`, while press-key (which does descend) typed into it fine.
+  // Any divergence between these two loops is a tool that refuses what its
+  // sibling accepts on the same page state.
+  let active = document.activeElement as HTMLElement | null
+  for (let depth = 0; active && depth < 10; depth++) {
+    const shadow = active.shadowRoot
+    if (shadow?.activeElement) {
+      active = shadow.activeElement as HTMLElement
+      continue
+    }
+    const activeTag = String(active.tagName || '').toUpperCase()
+    if (activeTag === 'IFRAME' || activeTag === 'FRAME') {
+      try {
+        const inner = (active as HTMLIFrameElement).contentDocument
+        if (inner?.activeElement && inner.activeElement !== inner.body) {
+          active = inner.activeElement as HTMLElement
+          continue
+        }
+      } catch {
+        // Cross-origin frame — not inspectable. The caller refuses separately on
+        // opaque secrecy, so report the frame itself rather than guessing.
+      }
+    }
+    break
+  }
+  if (!active || active === document.body) return { editable: false, reason: 'none' }
+  const tag = String(active.tagName || '').toUpperCase()
+  const inputType =
+    tag === 'INPUT' ? String((active as HTMLInputElement).type || 'text').toLowerCase() : ''
+  if (tag === 'INPUT' || tag === 'TEXTAREA') {
+    const field = active as HTMLInputElement | HTMLTextAreaElement
+    if (field.disabled || active.getAttribute('aria-disabled') === 'true') {
+      return { editable: false, reason: 'disabled' }
+    }
+    if (field.readOnly || active.getAttribute('aria-readonly') === 'true') {
+      return { editable: false, reason: 'readonly' }
+    }
+    if (
+      tag === 'INPUT' &&
+      !['text', 'search', 'email', 'url', 'tel', 'number', 'password'].includes(inputType)
+    ) {
+      return { editable: false, reason: 'not-text' }
+    }
+    return { editable: true, kind: tag === 'TEXTAREA' ? 'textarea' : `input:${inputType}` }
+  }
+  if (active.isContentEditable) {
+    if (active.getAttribute('aria-disabled') === 'true') {
+      return { editable: false, reason: 'disabled' }
+    }
+    if (active.getAttribute('aria-readonly') === 'true') {
+      return { editable: false, reason: 'readonly' }
+    }
+    return { editable: true, kind: 'contenteditable' }
+  }
+  // A canvas-rendered editor (Google Docs) focuses a hidden proxy or the
+  // canvas region itself; trusted IME insertion still reaches it, so report
+  // it as insertable rather than refusing.
+  if (tag === 'CANVAS' || active.getAttribute('role') === 'textbox') {
+    return { editable: true, kind: tag === 'CANVAS' ? 'canvas' : 'textbox-role' }
+  }
+  // Describe what actually held focus. A bare "not-editable" tells the agent
+  // nothing it can act on, so it guesses at the cause and burns rounds on the
+  // wrong recovery; naming the element lets it click the real field instead.
+  return {
+    editable: false,
+    reason: 'not-editable',
+    focusedTag: tag.toLowerCase(),
+    ...(active.getAttribute('role') ? { focusedRole: active.getAttribute('role') } : {}),
+    contentEditable: String(active.getAttribute('contenteditable') ?? 'unset'),
+  }
+}
diff --git a/apps/desktop/src/main/browser-agent/panel.test.ts b/apps/desktop/src/main/browser-agent/panel.test.ts
index 4af126c526..91fd776cd1 100644
--- a/apps/desktop/src/main/browser-agent/panel.test.ts
+++ b/apps/desktop/src/main/browser-agent/panel.test.ts
@@ -53,6 +53,30 @@ describe('panel chat scope', () => {
     panel = freshPanel()
   })
 
+  it('returns keyboard focus to the renderer when attaching a view steals it mid-typing', () => {
+    const win = new BrowserWindow()
+    const view = new WebContentsView()
+    const active = { id: 'tab-1', scopeId: 'chat-test', view, pinned: false }
+    vi.mocked(win.webContents.isFocused).mockReturnValue(true)
+    panel.initPanel({
+      getMainWindow: () => win,
+      activeTab: () => active,
+      backgroundColor: () => '#0c0c0c',
+      ensureInitialTab: () => {},
+      onViewDetached: () => {},
+    })
+    panel.activatePanelScope('chat-test')
+    panel.setPanelBounds(PANEL_RECT, win)
+    expect(win.contentView.addChildView).toHaveBeenCalledWith(view)
+    expect(win.webContents.focus).toHaveBeenCalled()
+  })
+
+  it('leaves focus untouched when the renderer was not focused at attach time', () => {
+    const { win, view } = showPanel(panel)
+    expect(win.contentView.addChildView).toHaveBeenCalledWith(view)
+    expect(win.webContents.focus).not.toHaveBeenCalled()
+  })
+
   it('requires fresh bounds for the newly active chat and ignores stale reports', () => {
     const { win, view } = showPanel(panel)
     const previousScope = panel.getActivePanelScopeId()
diff --git a/apps/desktop/src/main/browser-agent/panel.ts b/apps/desktop/src/main/browser-agent/panel.ts
index 992f2f2b66..27b609ca8c 100644
--- a/apps/desktop/src/main/browser-agent/panel.ts
+++ b/apps/desktop/src/main/browser-agent/panel.ts
@@ -20,6 +20,7 @@ import { getErrorMessage } from '@sim/utils/errors'
 import type { BrowserWindow, WebContentsView } from 'electron'
 import { zoomPercentOf } from '@/main/browser-agent/context-menu'
 import type { AgentTab } from '@/main/browser-agent/session'
+import { reassertTabThrottling } from '@/main/browser-agent/session'
 
 const logger = createLogger('BrowserAgentPanel')
 
@@ -379,9 +380,17 @@ export function layout(): void {
   }
 
   if (attachedView !== active.view) {
+    // addChildView hands keyboard focus to the newly attached WebContentsView.
+    // Agent-driven attaches happen while the user may be typing in the chat
+    // composer, so if the renderer held focus before the attach, give it back —
+    // automation drives the page over CDP and never needs OS focus.
+    const rendererHadFocus = !win.webContents.isDestroyed() && win.webContents.isFocused()
     win.contentView.addChildView(active.view)
     hostedWindow = win
     attachedView = active.view
+    if (rendererHadFocus) {
+      win.webContents.focus()
+    }
   }
   bindHostResize(win)
   const zoom = win.webContents.getZoomFactor()
@@ -412,7 +421,19 @@ export function layout(): void {
     lastAppliedVisibility = visible
     active.view.setVisible(visible)
     if (visible && !active.view.webContents.isDestroyed()) {
-      active.view.webContents.invalidate()
+      // invalidate() recomposites the LAST frame — which is blank when the
+      // page finished loading while this view was hidden and background
+      // throttling suspended the rAF its SPA paints from. The page then sits
+      // "loaded" but white until the user re-navigates by hand. Pulse
+      // throttling off so the renderer actually produces a first frame, then
+      // hand the policy back to the session (which keeps the automation-tab
+      // exemption intact).
+      const contents = active.view.webContents
+      contents.setBackgroundThrottling(false)
+      contents.invalidate()
+      setTimeout(() => {
+        if (!contents.isDestroyed()) reassertTabThrottling()
+      }, 1_000)
     }
   }
 }
diff --git a/apps/desktop/src/main/browser-agent/session.test.ts b/apps/desktop/src/main/browser-agent/session.test.ts
index f846cb9074..68152b337b 100644
--- a/apps/desktop/src/main/browser-agent/session.test.ts
+++ b/apps/desktop/src/main/browser-agent/session.test.ts
@@ -1715,6 +1715,21 @@ describe('browser-agent session', () => {
     expect(contents.loadURL).not.toHaveBeenCalled()
   })
 
+  it('brings an agent-opened working tab into view, unless the user claimed the visible one', () => {
+    // browser_open_tab is the agent choosing a page to work in — the panel
+    // follows it so the work is visible, which a popup deliberately does not.
+    const first = session.ensureTab()
+    const working = session.addAutomationTab({ reveal: true })
+    expect(session.activeTab()).toBe(working)
+    expect(working.id).not.toBe(first.id)
+
+    // Once the user claims what they are looking at, the next agent tab opens
+    // behind it rather than yanking the page out from under them.
+    session.claimActiveTabForUser()
+    const background = session.addAutomationTab({ reveal: true })
+    expect(session.activeTab()).not.toBe(background)
+  })
+
   it('keeps agent popups in the background and context-menu links user-owned', () => {
     const onTabCreated = vi.fn()
     session = freshSession(win, { onTabCreated })
@@ -1770,28 +1785,39 @@ describe('browser-agent session', () => {
     expect(event.preventDefault).toHaveBeenCalledOnce()
   })
 
-  it('permission handlers deny every request on the agent partition but the copy button', () => {
+  it('permission handlers deny everything on the agent partition but the copy button and media', async () => {
     const tab = session.ensureTab()
     const ses = (tab.view as unknown as MockView).webContents.session
     const requestHandler = ses.setPermissionRequestHandler.mock.calls[0][0] as (
       wc: unknown,
       permission: string,
-      callback: (granted: boolean) => void
+      callback: (granted: boolean) => void,
+      details?: unknown
     ) => void
     const checkHandler = ses.setPermissionCheckHandler.mock.calls[0][0] as (
       wc: unknown,
-      permission: string
+      permission: string,
+      origin?: string,
+      details?: unknown
     ) => boolean
 
     // Reading the clipboard would leak whatever the user last copied anywhere
     // else, so it stays denied alongside everything a page could spy through.
-    for (const permission of ['media', 'geolocation', 'notifications', 'clipboard-read']) {
+    for (const permission of ['geolocation', 'notifications', 'clipboard-read']) {
       const callback = vi.fn()
       requestHandler(null, permission, callback)
       expect(callback).toHaveBeenCalledWith(false)
       expect(checkHandler(null, permission)).toBe(false)
     }
 
+    // Media is the deliberate exception — the agent browser joins real
+    // meetings — but the grant is gated on the OS grant (mocked as granted
+    // here), so System Settings remains the real authority.
+    const mediaCallback = vi.fn()
+    requestHandler(null, 'media', mediaCallback, { mediaTypes: ['audio', 'video'] })
+    await vi.waitFor(() => expect(mediaCallback).toHaveBeenCalledWith(true))
+    expect(checkHandler(null, 'media', undefined, { mediaType: 'audio' })).toBe(true)
+
     // Chromium routes navigator.clipboard.writeText through this one; denying
     // it silently broke every copy button that does not use execCommand.
     const writeCallback = vi.fn()
diff --git a/apps/desktop/src/main/browser-agent/session.ts b/apps/desktop/src/main/browser-agent/session.ts
index fbedb905a3..08f91419f9 100644
--- a/apps/desktop/src/main/browser-agent/session.ts
+++ b/apps/desktop/src/main/browser-agent/session.ts
@@ -35,6 +35,7 @@ import {
   Menu,
   nativeTheme,
   shell,
+  systemPreferences,
   WebContentsView,
 } from 'electron'
 import { isDispatchingAgentInput } from '@/main/browser-agent/cdp'
@@ -826,19 +827,61 @@ export async function importAgentCookies(
  */
 const ALLOWED_SITE_PERMISSIONS = new Set(['clipboard-sanitized-write'])
 
+/**
+ * Grants a getUserMedia request only when macOS has actually authorized the
+ * devices it names. Granting site permission without the OS grant makes the
+ * page fail with a misleading NotReadableError instead of a permission prompt,
+ * and macOS kills the process outright when the bundle lacks usage strings —
+ * so the OS is asked FIRST, which surfaces the system prompt on first use.
+ */
+async function ensureOsMediaAccess(mediaTypes: readonly string[] | undefined): Promise<boolean> {
+  if (process.platform !== 'darwin') return true
+  const wanted = mediaTypes && mediaTypes.length > 0 ? mediaTypes : ['audio', 'video']
+  for (const type of wanted) {
+    const device = type === 'video' ? 'camera' : 'microphone'
+    if (systemPreferences.getMediaAccessStatus(device) === 'granted') continue
+    const granted = await systemPreferences.askForMediaAccess(device).catch(() => false)
+    if (!granted) return false
+  }
+  return true
+}
+
 /**
  * Default-deny hardening for the agent partition. Site permissions remain
- * denied apart from ALLOWED_SITE_PERMISSIONS, while uploads use Chromium's
- * native file chooser and downloads are saved into the device-level browser
- * download directory.
+ * denied apart from ALLOWED_SITE_PERMISSIONS and camera/microphone — the agent
+ * browser has to join a Google Meet or a Zoom web client like a real browser,
+ * and those are dead without getUserMedia. The OS grant still gates every
+ * media request, so the user's System Settings choice is the real authority.
+ * Uploads use Chromium's native file chooser and downloads are saved into the
+ * device-level browser download directory.
  */
 function configureAgentPartition(ses: Session): void {
   if (configuredPartitions.has(ses)) return
   configuredPartitions.add(ses)
-  ses.setPermissionRequestHandler((_wc, permission, callback) =>
+  ses.setPermissionRequestHandler((_wc, permission, callback, details) => {
+    if (permission === 'media') {
+      const mediaTypes = (details as { mediaTypes?: readonly string[] })?.mediaTypes
+      void ensureOsMediaAccess(mediaTypes).then(callback)
+      return
+    }
     callback(ALLOWED_SITE_PERMISSIONS.has(permission))
-  )
-  ses.setPermissionCheckHandler((_wc, permission) => ALLOWED_SITE_PERMISSIONS.has(permission))
+  })
+  ses.setPermissionCheckHandler((_wc, permission, _origin, details) => {
+    if (permission === 'media') {
+      if (process.platform !== 'darwin') return true
+      const mediaType = (details as { mediaType?: string })?.mediaType
+      if (mediaType === 'video')
+        return systemPreferences.getMediaAccessStatus('camera') === 'granted'
+      if (mediaType === 'audio') {
+        return systemPreferences.getMediaAccessStatus('microphone') === 'granted'
+      }
+      return (
+        systemPreferences.getMediaAccessStatus('microphone') === 'granted' ||
+        systemPreferences.getMediaAccessStatus('camera') === 'granted'
+      )
+    }
+    return ALLOWED_SITE_PERMISSIONS.has(permission)
+  })
   // Service workers do not inherit a tab's user agent. With only the tab's set,
   // the document request carries the browser string while the worker's own
   // script request still announces Electron — and on a site that routes its
@@ -1359,6 +1402,15 @@ export function setAutomationNeedsAttention(needsAttention: boolean): void {
  * other tab. Call after anything that changes which tab is active, so the
  * exemption follows the active tab rather than being stranded on the old one.
  */
+/**
+ * Re-applies the tab throttling policy after a caller temporarily suspended it
+ * (the panel's reveal pulse). Exempts the automation-active tab exactly as the
+ * internal policy does.
+ */
+export function reassertTabThrottling(): void {
+  applyActiveTabThrottling()
+}
+
 function applyActiveTabThrottling(): void {
   for (const tab of tabs) {
     if (tab.view.webContents.isDestroyed()) continue
@@ -1590,10 +1642,24 @@ export function addTab(): AgentTab {
   return addTabInternal()
 }
 
-/** Opens a tab for agent work without replacing the page the user is viewing. */
-export function addAutomationTab(): AgentTab {
+/**
+ * Opens a tab for agent work.
+ *
+ * `reveal` is for the agent deliberately opening a page to work in
+ * (`browser_open_tab`): the panel follows it, so the user watches the work
+ * instead of staring at a page where nothing is happening. It is NOT set when a
+ * page spawns a tab on its own (popups, `target="_blank"`) — that is the site
+ * grabbing the view, not the agent choosing a workspace.
+ *
+ * Even with `reveal`, a tab the user claimed themselves wins: pulling the view
+ * off the page they are reading is the same interruption as a window stealing
+ * focus mid-sentence. The work still starts, just in the background, and the
+ * tab strip shows it arriving.
+ */
+export function addAutomationTab({ reveal = false }: { reveal?: boolean } = {}): AgentTab {
   restoreBrowserSession()
-  const tab = addTabInternal({ activate: false, notify: false })
+  const followTheWork = reveal && !currentScope.visibleTabUserSelected
+  const tab = addTabInternal({ activate: followTheWork, notify: false })
   currentScope.automationTabId = tab.id
   applyActiveTabThrottling()
   persistBrowserSession()
@@ -1950,6 +2016,9 @@ export function handleFocusedShortcut(
     case 'reload-or-clear':
       shortcutTab.view.webContents.reload()
       return true
+    case 'hard-reload':
+      shortcutTab.view.webContents.reloadIgnoringCache()
+      return true
   }
 
   const zoomAction = zoomActionForShortcut(shortcut)
@@ -2194,6 +2263,13 @@ export function automationTab(): AgentTab | null {
   return tab
 }
 
+/**
+ * Whether the user has interacted with the visible tab while it is also the
+ * agent's automation tab. Governs panel-level ownership only — popup
+ * adoption and protection against the agent closing the tab out from under
+ * the user. It must never gate agent input: the user clicking or typing in
+ * the panel does not revoke the agent's ability to act there.
+ */
 export function automationTabClaimedByUser(): boolean {
   return (
     currentScope.visibleTabUserSelected &&
diff --git a/apps/desktop/src/main/browser-search/suggestions.test.ts b/apps/desktop/src/main/browser-search/suggestions.test.ts
new file mode 100644
index 0000000000..c9b839d25c
--- /dev/null
+++ b/apps/desktop/src/main/browser-search/suggestions.test.ts
@@ -0,0 +1,74 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it, vi } from 'vitest'
+import {
+  parseSearchSuggestionResponse,
+  SearchSuggestionService,
+} from '@/main/browser-search/suggestions'
+
+describe('parseSearchSuggestionResponse', () => {
+  it('keeps unique non-empty completions and omits the exact query row', () => {
+    expect(
+      parseSearchSuggestionResponse(
+        [
+          'what is the be',
+          [
+            'what is the be',
+            'what is the best sleeping position',
+            ' WHAT IS THE BEST SLEEPING POSITION ',
+            '',
+            42,
+            'what is the benefit of creatine',
+          ],
+        ],
+        'what is the be'
+      )
+    ).toEqual(['what is the best sleeping position', 'what is the benefit of creatine'])
+  })
+
+  it('rejects malformed provider payloads', () => {
+    expect(parseSearchSuggestionResponse(null, 'sim')).toEqual([])
+    expect(parseSearchSuggestionResponse(['sim', {}], 'sim')).toEqual([])
+  })
+})
+
+describe('SearchSuggestionService', () => {
+  it('uses only the fixed provider URL and caches repeated queries', async () => {
+    const fetcher = vi.fn(
+      async (_url: string, _init: RequestInit): Promise<Response> =>
+        Response.json(['sim studio', ['sim studio ai', 'sim studio workflow']])
+    )
+    const service = new SearchSuggestionService(fetcher, () => 1_000)
+
+    await expect(service.suggest(' sim studio ')).resolves.toEqual([
+      'sim studio ai',
+      'sim studio workflow',
+    ])
+    await expect(service.suggest('SIM STUDIO')).resolves.toEqual([
+      'sim studio ai',
+      'sim studio workflow',
+    ])
+
+    expect(fetcher).toHaveBeenCalledTimes(1)
+    const [url, init] = fetcher.mock.calls[0]
+    expect(new URL(url).origin).toBe('https://suggestqueries.google.com')
+    expect(new URL(url).searchParams.get('q')).toBe('sim studio')
+    expect(init).toMatchObject({ method: 'GET', redirect: 'error' })
+  })
+
+  it('fails silently for short, oversized, rejected, and unsuccessful requests', async () => {
+    const fetcher = vi.fn(
+      async (_url: string, _init: RequestInit): Promise<Response> =>
+        new Response(null, { status: 503 })
+    )
+    const service = new SearchSuggestionService(fetcher)
+
+    await expect(service.suggest('s')).resolves.toEqual([])
+    await expect(service.suggest('x'.repeat(201))).resolves.toEqual([])
+    await expect(service.suggest('search me')).resolves.toEqual([])
+
+    fetcher.mockRejectedValueOnce(new Error('offline'))
+    await expect(service.suggest('another search')).resolves.toEqual([])
+  })
+})
diff --git a/apps/desktop/src/main/browser-search/suggestions.ts b/apps/desktop/src/main/browser-search/suggestions.ts
new file mode 100644
index 0000000000..139588aaac
--- /dev/null
+++ b/apps/desktop/src/main/browser-search/suggestions.ts
@@ -0,0 +1,102 @@
+import { net } from 'electron'
+
+const GOOGLE_SUGGESTIONS_ENDPOINT = 'https://suggestqueries.google.com/complete/search'
+const SEARCH_SUGGESTION_TIMEOUT_MS = 2_500
+const SEARCH_SUGGESTION_CACHE_TTL_MS = 5 * 60 * 1_000
+const MAX_SEARCH_SUGGESTION_CACHE_ENTRIES = 100
+const MAX_SEARCH_SUGGESTION_QUERY_LENGTH = 200
+const MAX_SEARCH_SUGGESTION_LENGTH = 256
+const MAX_SEARCH_SUGGESTIONS = 7
+
+type SearchSuggestionFetch = (url: string, init: RequestInit) => Promise<Response>
+
+interface CachedSearchSuggestions {
+  expiresAt: number
+  values: string[]
+}
+
+/**
+ * Validates the small portion of Google's Firefox-completion response that the
+ * omnibox consumes. Everything else in the provider payload is ignored.
+ */
+export function parseSearchSuggestionResponse(payload: unknown, query: string): string[] {
+  if (!Array.isArray(payload) || !Array.isArray(payload[1])) return []
+
+  const queryKey = query.toLocaleLowerCase()
+  const seen = new Set([queryKey])
+  const suggestions: string[] = []
+  for (const candidate of payload[1]) {
+    if (typeof candidate !== 'string') continue
+    const value = candidate.trim()
+    const key = value.toLocaleLowerCase()
+    if (!value || value.length > MAX_SEARCH_SUGGESTION_LENGTH || seen.has(key)) continue
+    seen.add(key)
+    suggestions.push(value)
+    if (suggestions.length === MAX_SEARCH_SUGGESTIONS) break
+  }
+  return suggestions
+}
+
+/**
+ * In-memory, bounded search completion client. Queries go only to the fixed
+ * Google suggestions origin and are never logged or written to disk.
+ */
+export class SearchSuggestionService {
+  private readonly cache = new Map<string, CachedSearchSuggestions>()
+
+  constructor(
+    private readonly fetcher: SearchSuggestionFetch,
+    private readonly now: () => number = Date.now
+  ) {}
+
+  async suggest(rawQuery: unknown): Promise<string[]> {
+    if (typeof rawQuery !== 'string') return []
+    const query = rawQuery.trim()
+    if (query.length < 2 || query.length > MAX_SEARCH_SUGGESTION_QUERY_LENGTH) return []
+
+    const cacheKey = query.toLocaleLowerCase()
+    const cached = this.cache.get(cacheKey)
+    if (cached && cached.expiresAt > this.now()) return [...cached.values]
+    if (cached) this.cache.delete(cacheKey)
+
+    const url = new URL(GOOGLE_SUGGESTIONS_ENDPOINT)
+    url.searchParams.set('client', 'firefox')
+    url.searchParams.set('q', query)
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), SEARCH_SUGGESTION_TIMEOUT_MS)
+
+    try {
+      const response = await this.fetcher(url.toString(), {
+        method: 'GET',
+        redirect: 'error',
+        signal: controller.signal,
+      })
+      if (!response.ok) return []
+      const values = parseSearchSuggestionResponse(await response.json(), query)
+      this.remember(cacheKey, values)
+      return [...values]
+    } catch {
+      return []
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  private remember(key: string, values: string[]): void {
+    if (this.cache.size >= MAX_SEARCH_SUGGESTION_CACHE_ENTRIES) {
+      const oldest = this.cache.keys().next().value
+      if (typeof oldest === 'string') this.cache.delete(oldest)
+    }
+    this.cache.set(key, {
+      expiresAt: this.now() + SEARCH_SUGGESTION_CACHE_TTL_MS,
+      values: [...values],
+    })
+  }
+}
+
+const searchSuggestionService = new SearchSuggestionService((url, init) => net.fetch(url, init))
+
+/** Fetches live Google completions, failing closed to an empty local-only list. */
+export function getSearchSuggestions(query: unknown): Promise<string[]> {
+  return searchSuggestionService.suggest(query)
+}
diff --git a/apps/desktop/src/main/config.ts b/apps/desktop/src/main/config.ts
index 3e0d10949a..654fbacfa3 100644
--- a/apps/desktop/src/main/config.ts
+++ b/apps/desktop/src/main/config.ts
@@ -101,6 +101,8 @@ export interface DesktopSettings {
   launchAtLogin?: boolean
   autoDownloadUpdates?: boolean
   browserEnabled?: boolean
+  /** Whether omnibox typing may request live Google search completions. */
+  browserSearchSuggestionsEnabled?: boolean
   terminalEnabled?: boolean
   /** Device-wide browser page appearance; `app` follows Sim. */
   browserTheme?: 'app' | 'light' | 'dark'
@@ -216,6 +218,7 @@ const DEFAULT_SETTINGS: DesktopSettings = {
   launchAtLogin: false,
   autoDownloadUpdates: true,
   browserEnabled: true,
+  browserSearchSuggestionsEnabled: true,
   terminalEnabled: true,
 }
 
diff --git a/apps/desktop/src/main/desktop-settings.test.ts b/apps/desktop/src/main/desktop-settings.test.ts
index b7849a5755..d2bcac944a 100644
--- a/apps/desktop/src/main/desktop-settings.test.ts
+++ b/apps/desktop/src/main/desktop-settings.test.ts
@@ -117,6 +117,17 @@ describe('desktop settings service', () => {
     expect(setTerminalEnabled).toHaveBeenCalledWith(false)
   })
 
+  it('defaults live browser search suggestions on and persists the privacy switch', () => {
+    const { config, service } = makeService()
+
+    expect(service.getPreferences().browserSearchSuggestionsEnabled).toBe(true)
+
+    const preferences = service.setBrowserSearchSuggestionsEnabled(false)
+
+    expect(config.get('browserSearchSuggestionsEnabled')).toBe(false)
+    expect(preferences.browserSearchSuggestionsEnabled).toBe(false)
+  })
+
   it('persists browser and terminal appearance with match-Sim defaults', () => {
     const { config, service, setBrowserTheme, onBrowserThemeChanged } = makeService()
     expect(service.getPreferences()).toMatchObject({
diff --git a/apps/desktop/src/main/desktop-settings.ts b/apps/desktop/src/main/desktop-settings.ts
index f84b364b40..7f25296b99 100644
--- a/apps/desktop/src/main/desktop-settings.ts
+++ b/apps/desktop/src/main/desktop-settings.ts
@@ -36,6 +36,7 @@ export function isDesktopPreferenceKey(value: unknown): value is DesktopPreferen
 export interface DesktopSettingsService {
   getPreferences(): DesktopPreferences
   setPreference(key: DesktopPreferenceKey, value: boolean): DesktopPreferences
+  setBrowserSearchSuggestionsEnabled(enabled: boolean): DesktopPreferences
   setAppearancePreference(
     key: DesktopAppearanceSettingKey,
     value: DesktopAppearanceTheme
@@ -90,6 +91,7 @@ function readPreferences(
     autoDownloadUpdates: config.get('autoDownloadUpdates') ?? true,
     trayEnabled: config.get('trayEnabled') ?? true,
     browserEnabled: config.get('browserEnabled') ?? true,
+    browserSearchSuggestionsEnabled: config.get('browserSearchSuggestionsEnabled') ?? true,
     terminalEnabled: config.get('terminalEnabled') ?? true,
     browserTheme: isDesktopAppearanceTheme(browserTheme) ? browserTheme : 'app',
     browserDefaultZoom: isDesktopZoomPercent(browserDefaultZoom) ? browserDefaultZoom : 100,
@@ -153,6 +155,11 @@ export function createDesktopSettingsService(
       }
       return read()
     },
+    setBrowserSearchSuggestionsEnabled(enabled) {
+      deps.config.set('browserSearchSuggestionsEnabled', enabled)
+      deps.config.flush()
+      return read()
+    },
     setAppearancePreference(key, value) {
       const previousBrowserTheme = key === 'browserTheme' ? read().browserTheme : undefined
       deps.config.set(key, value)
diff --git a/apps/desktop/src/main/ipc.test.ts b/apps/desktop/src/main/ipc.test.ts
index 60f5ddc6ea..c20e907e55 100644
--- a/apps/desktop/src/main/ipc.test.ts
+++ b/apps/desktop/src/main/ipc.test.ts
@@ -18,6 +18,10 @@ vi.mock('@/main/browser-import', () => ({
   })),
 }))
 
+vi.mock('@/main/browser-search/suggestions', () => ({
+  getSearchSuggestions: vi.fn(async () => ['sim ai workflow']),
+}))
+
 const { terminalThemeProfile } = vi.hoisted(() => ({
   terminalThemeProfile: {
     id: 'iterm2:ocean',
@@ -124,6 +128,7 @@ import {
   importChromePasswords,
   listChromeImportProfiles,
 } from '@/main/browser-import'
+import { getSearchSuggestions } from '@/main/browser-search/suggestions'
 import { trackInputActivity } from '@/main/input-activity'
 import { type IpcDeps, registerIpcHandlers } from '@/main/ipc'
 import { LocalFilesystemService } from '@/main/local-filesystem'
@@ -252,6 +257,7 @@ describe('registerIpcHandlers', () => {
     vi.mocked(listChromeImportProfiles).mockClear()
     vi.mocked(importChromeCookies).mockClear()
     vi.mocked(importChromePasswords).mockClear()
+    vi.mocked(getSearchSuggestions).mockClear()
     vi.mocked(findCachedTerminalThemeProfile).mockClear()
     vi.mocked(listTerminalThemeProfiles).mockClear()
     vi.mocked(credentialsAvailable).mockClear()
@@ -282,6 +288,7 @@ describe('registerIpcHandlers', () => {
       settings: {
         getPreferences: vi.fn(() => DEFAULT_DESKTOP_PREFERENCES),
         setPreference: vi.fn(),
+        setBrowserSearchSuggestionsEnabled: vi.fn(),
         setAppearancePreference: vi.fn(),
         setBrowserDefaultZoom: vi.fn(),
         setTerminalDefaultZoom: vi.fn(),
@@ -325,6 +332,22 @@ describe('registerIpcHandlers', () => {
     expect(shell.openExternal).toHaveBeenCalledTimes(1)
   })
 
+  it('keeps live search suggestions behind the app origin and privacy preference', async () => {
+    const { invoke } = collectHandlers()
+    const handler = invoke.get('browser-agent:search-suggestions')
+
+    expect(await handler?.(evilEvent, 'sim ai')).toEqual([])
+
+    expect(await handler?.(appEvent, 'sim ai')).toEqual(['sim ai workflow'])
+    expect(getSearchSuggestions).toHaveBeenCalledWith('sim ai')
+
+    vi.mocked(deps.settings.getPreferences).mockReturnValue({
+      ...DEFAULT_DESKTOP_PREFERENCES,
+      browserSearchSuggestionsEnabled: false,
+    })
+    expect(await handler?.(appEvent, 'sim ai')).toEqual([])
+  })
+
   it('restricts the OAuth connect handoff to the app origin', async () => {
     const { invoke } = collectHandlers()
     const handler = invoke.get('desktop:oauth-connect')
diff --git a/apps/desktop/src/main/ipc.ts b/apps/desktop/src/main/ipc.ts
index 0ad0a1b942..b230af7ad4 100644
--- a/apps/desktop/src/main/ipc.ts
+++ b/apps/desktop/src/main/ipc.ts
@@ -70,6 +70,7 @@ import {
   importChromePasswords,
   listChromeImportProfiles,
 } from '@/main/browser-import'
+import { getSearchSuggestions } from '@/main/browser-search/suggestions'
 import { listSites } from '@/main/browser-sites'
 import { isSafeInternalPath } from '@/main/config'
 import type { DesktopSettingsService } from '@/main/desktop-settings'
@@ -661,6 +662,15 @@ export function registerIpcHandlers(deps: IpcDeps): void {
           ? deps.settings.setPreference(key, value)
           : deps.settings.getPreferences(),
     },
+    'desktop:settings:set-browser-search-suggestions': {
+      kind: 'invoke',
+      gate: 'app-origin',
+      denied: null,
+      handler: (enabled) =>
+        typeof enabled === 'boolean'
+          ? deps.settings.setBrowserSearchSuggestionsEnabled(enabled)
+          : deps.settings.getPreferences(),
+    },
     'desktop:settings:set-appearance': {
       kind: 'invoke',
       gate: 'app-origin',
@@ -928,6 +938,16 @@ export function registerIpcHandlers(deps: IpcDeps): void {
       denied: { sessions: [] },
       handler: () => getKnownSessions(),
     },
+    'browser-agent:search-suggestions': {
+      kind: 'invoke',
+      gate: 'app-origin',
+      requires: 'browser',
+      denied: [],
+      handler: (query) =>
+        deps.settings.getPreferences().browserSearchSuggestionsEnabled === false
+          ? []
+          : getSearchSuggestions(query),
+    },
     'browser-agent:clear-browsing-data': {
       kind: 'invoke',
       gate: 'app-origin',
diff --git a/apps/desktop/src/main/menu.test.ts b/apps/desktop/src/main/menu.test.ts
index faf1648b41..b98be44043 100644
--- a/apps/desktop/src/main/menu.test.ts
+++ b/apps/desktop/src/main/menu.test.ts
@@ -62,20 +62,27 @@ describe('buildMenuTemplate', () => {
       'separator',
       'quit',
     ])
-    expect(submenu(template, 'File').map((item) => item.label ?? item.role ?? item.type)).toEqual([
+    const file = submenu(template, 'File')
+    expect(
+      file.filter((item) => item.visible !== false).map((item) => item.label ?? item.type)
+    ).toEqual(['New Window', 'New Chat', 'separator', 'Close Window'])
+    // Resource-scoped shortcuts stay registered but never appear in the menu.
+    expect(file.filter((item) => item.visible === false).map((item) => item.label)).toEqual([
       'New Tab',
-      'New Window',
-      'New Chat',
-      'separator',
       'Reopen Closed Tab',
       'Focus Address Bar',
-      'separator',
       'Next Tab',
       'Previous Tab',
-      'Select Tab',
-      'separator',
+      'Tab 1',
+      'Tab 2',
+      'Tab 3',
+      'Tab 4',
+      'Tab 5',
+      'Tab 6',
+      'Tab 7',
+      'Tab 8',
+      'Last Tab',
       'Close Tab',
-      'Close Window',
     ])
     expect(submenu(template, 'View').map((item) => item.label ?? item.role ?? item.type)).toEqual([
       'Search',
@@ -83,6 +90,7 @@ describe('buildMenuTemplate', () => {
       'separator',
       'Back',
       'Reload',
+      'Force Reload',
       'separator',
       'Actual Size',
       'Zoom In',
@@ -152,7 +160,6 @@ describe('buildMenuTemplate', () => {
       })
     )
     const file = submenu(template, 'File')
-    const selectTabs = submenu(file, 'Select Tab')
     const focusedWindow = new BrowserWindow()
     const invoke = (item: MenuItemConstructorOptions | undefined) =>
       (item?.click as unknown as (menuItem: unknown, browserWindow: BrowserWindow) => void)(
@@ -162,7 +169,7 @@ describe('buildMenuTemplate', () => {
 
     invoke(file.find((item) => item.accelerator === 'Ctrl+Tab'))
     invoke(file.find((item) => item.accelerator === 'Ctrl+Shift+Tab'))
-    invoke(selectTabs.find((item) => item.accelerator === 'CmdOrCtrl+9'))
+    invoke(file.find((item) => item.accelerator === 'CmdOrCtrl+9'))
 
     expect(handleFocusedResourceShortcut).toHaveBeenNthCalledWith(1, focusedWindow, 'next-tab')
     expect(handleFocusedResourceShortcut).toHaveBeenNthCalledWith(2, focusedWindow, 'previous-tab')
diff --git a/apps/desktop/src/main/menu.ts b/apps/desktop/src/main/menu.ts
index 25d4a4c602..d5594f2c5d 100644
--- a/apps/desktop/src/main/menu.ts
+++ b/apps/desktop/src/main/menu.ts
@@ -63,6 +63,7 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]
     return {
       label: number === 9 ? 'Last Tab' : `Tab ${number}`,
       accelerator: `CmdOrCtrl+${number}`,
+      visible: false,
       click: resourceShortcut(shortcut),
     }
   })
@@ -124,6 +125,22 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]
         win.webContents.reload()
       },
     },
+    /**
+     * Hard refresh, cache ignored. A focused Browser tab claims it first
+     * (same boundary as Reload/Close Tab); otherwise it reloads the Sim
+     * shell — the recovery lever for picking up freshly deployed client
+     * code.
+     */
+    {
+      label: 'Force Reload',
+      accelerator: 'CmdOrCtrl+Shift+R',
+      click: (_item, focusedWindow) => {
+        const win = focusedOrMain(focusedWindow)
+        if (!win || win.isDestroyed()) return
+        if (deps.handleFocusedResourceShortcut(win, 'hard-reload')) return
+        win.webContents.reloadIgnoringCache()
+      },
+    },
     { type: 'separator' },
     { label: 'Actual Size', accelerator: 'CmdOrCtrl+0', click: setZoom('reset') },
     { label: 'Zoom In', accelerator: 'CmdOrCtrl+Plus', click: setZoom('in') },
@@ -153,13 +170,6 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]
     {
       label: 'File',
       submenu: [
-        {
-          label: 'New Tab',
-          accelerator: 'CmdOrCtrl+T',
-          click: (_item, focusedWindow) => {
-            deps.handleFocusedResourceShortcut(focusedOrMain(focusedWindow), 'new-tab')
-          },
-        },
         {
           label: 'New Window',
           accelerator: 'CmdOrCtrl+Shift+N',
@@ -167,9 +177,35 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]
         },
         { label: 'New Chat', accelerator: 'CmdOrCtrl+N', click: deps.newChat },
         { type: 'separator' },
+        {
+          label: 'Close Window',
+          accelerator: 'CmdOrCtrl+Shift+W',
+          click: (_item, focusedWindow) => {
+            const win = focusedOrMain(focusedWindow)
+            if (win && !win.isDestroyed()) win.close()
+          },
+        },
+        /**
+         * Resource-scoped shortcuts: these act on whichever Browser/Terminal
+         * panel is focused, not on the app, so they stay out of the visible
+         * File menu. The accelerators still fire — macOS registers a hidden
+         * item's accelerator (`acceleratorWorksWhenHidden` defaults to true).
+         * The numbered tab items sit flat here rather than under a "Select
+         * Tab" submenu because children of a hidden submenu do not reliably
+         * register their accelerators.
+         */
+        {
+          label: 'New Tab',
+          accelerator: 'CmdOrCtrl+T',
+          visible: false,
+          click: (_item, focusedWindow) => {
+            deps.handleFocusedResourceShortcut(focusedOrMain(focusedWindow), 'new-tab')
+          },
+        },
         {
           label: 'Reopen Closed Tab',
           accelerator: 'CmdOrCtrl+Shift+T',
+          visible: false,
           click: (_item, focusedWindow) => {
             deps.handleFocusedResourceShortcut(focusedOrMain(focusedWindow), 'reopen-closed-tab')
           },
@@ -177,37 +213,31 @@ export function buildMenuTemplate(deps: MenuDeps): MenuItemConstructorOptions[]
         {
           label: 'Focus Address Bar',
           accelerator: 'CmdOrCtrl+L',
+          visible: false,
           click: resourceShortcut('focus-omnibox'),
         },
-        { type: 'separator' },
         {
           label: 'Next Tab',
           accelerator: 'Ctrl+Tab',
+          visible: false,
           click: resourceShortcut('next-tab'),
         },
         {
           label: 'Previous Tab',
           accelerator: 'Ctrl+Shift+Tab',
+          visible: false,
           click: resourceShortcut('previous-tab'),
         },
-        { label: 'Select Tab', submenu: numberedTabItems },
-        { type: 'separator' },
+        ...numberedTabItems,
         {
           label: 'Close Tab',
           accelerator: 'CmdOrCtrl+W',
+          visible: false,
           click: (_item, focusedWindow) => {
             const win = focusedOrMain(focusedWindow)
             deps.handleFocusedResourceShortcut(win, 'close-tab')
           },
         },
-        {
-          label: 'Close Window',
-          accelerator: 'CmdOrCtrl+Shift+W',
-          click: (_item, focusedWindow) => {
-            const win = focusedOrMain(focusedWindow)
-            if (win && !win.isDestroyed()) win.close()
-          },
-        },
       ],
     },
     { role: 'editMenu' },
diff --git a/apps/desktop/src/main/resource-shortcuts.ts b/apps/desktop/src/main/resource-shortcuts.ts
index 2e5d8dab62..24aa02d735 100644
--- a/apps/desktop/src/main/resource-shortcuts.ts
+++ b/apps/desktop/src/main/resource-shortcuts.ts
@@ -12,6 +12,7 @@ export type FocusedResourceShortcut =
   | 'focus-omnibox'
   | ResourceTabSelectionShortcut
   | 'reload-or-clear'
+  | 'hard-reload'
   | `zoom-${DesktopZoomAction}`
 
 export type ResourceTabSelectionShortcut =
diff --git a/apps/desktop/src/main/terminal/index.ts b/apps/desktop/src/main/terminal/index.ts
index 859f80088e..1dcfd7a127 100644
--- a/apps/desktop/src/main/terminal/index.ts
+++ b/apps/desktop/src/main/terminal/index.ts
@@ -498,7 +498,8 @@ export class TerminalService {
     emitRendererCommand: (command: TerminalShortcutCommand, terminalId: string) => void,
     confirmCloseRunning?: (running: string) => boolean
   ): boolean {
-    if (shortcut === 'focus-omnibox') return false
+    // Hard reload has no terminal meaning — leave it to the Browser or shell.
+    if (shortcut === 'focus-omnibox' || shortcut === 'hard-reload') return false
     const visibleTabShortcut =
       shortcut === 'new-tab' || shortcut === 'reopen-closed-tab' || shortcut === 'close-tab'
     const ownsVisibleTabs =
diff --git a/apps/desktop/src/main/terminal/session.ts b/apps/desktop/src/main/terminal/session.ts
index 350c1aa070..beb64a403a 100644
--- a/apps/desktop/src/main/terminal/session.ts
+++ b/apps/desktop/src/main/terminal/session.ts
@@ -851,7 +851,7 @@ export class TerminalSession {
       (pending) => ({
         command: pending.command,
         output:
-          'This opened a full-screen interactive program, which now holds the terminal until it exits. terminal_read renders its current screen, so you can watch it: if it is doing work the user is waiting on, keep polling with wait + terminal_read until it finishes, exactly as you would a long command. Type into it with terminal_input and stop it with terminal_kill. The user can also drive it in the panel. terminal_run reports BUSY until it exits.',
+          'This opened a full-screen interactive program, which now holds the terminal until it exits. terminal_read renders its current screen, so you can watch it: if it is doing work the user is waiting on, keep polling with wait + terminal_read until it finishes, exactly as you would a long command. Type into it with terminal_input and stop it with terminal_kill. If it is a pager (less, git log, man — the screen ends with ":" or "(END)"), nothing more is coming: exit it by sending terminal_input text "q"; terminal_kill delivers Ctrl-C, which a pager ignores. The user can also drive it in the panel. terminal_run reports BUSY until it exits.',
         status: 'interactive',
         exitCode: null,
         durationMs: Date.now() - pending.startedAt,
diff --git a/apps/desktop/src/preload/index.test.ts b/apps/desktop/src/preload/index.test.ts
index dea8ac8957..42cab747db 100644
--- a/apps/desktop/src/preload/index.test.ts
+++ b/apps/desktop/src/preload/index.test.ts
@@ -32,6 +32,8 @@ describe('desktop preload bridge', () => {
     await exposed.browserAgent.setPanelOccluded(true, 'chat-default')
     await exposed.browserAgent.setPanelOccluded(false, 'chat-explicit-false', false)
     await exposed.browserAgent.setPanelOccluded(true, 'chat-force', true)
+    await exposed.browserAgent.getSearchSuggestions?.('sim ai')
+    await exposed.settings.setBrowserSearchSuggestionsEnabled?.(false)
 
     expect(invoke.mock.calls).toEqual([
       ['browser-agent:cancel-tool', 'tool-1', 'chat-default'],
@@ -39,6 +41,8 @@ describe('desktop preload bridge', () => {
       ['browser-agent:set-panel-occluded', true, 'chat-default', false],
       ['browser-agent:set-panel-occluded', false, 'chat-explicit-false', false],
       ['browser-agent:set-panel-occluded', true, 'chat-force', true],
+      ['browser-agent:search-suggestions', 'sim ai'],
+      ['desktop:settings:set-browser-search-suggestions', false],
     ])
   })
 })
diff --git a/apps/desktop/src/preload/index.ts b/apps/desktop/src/preload/index.ts
index ffb5314df7..afe84f2a42 100644
--- a/apps/desktop/src/preload/index.ts
+++ b/apps/desktop/src/preload/index.ts
@@ -147,6 +147,8 @@ const api: SimDesktopApi = {
     getPreferences: (): Promise<DesktopPreferences> => ipcRenderer.invoke('desktop:settings:get'),
     setPreference: (key: DesktopPreferenceKey, value: boolean): Promise<DesktopPreferences> =>
       ipcRenderer.invoke('desktop:settings:set', key, value),
+    setBrowserSearchSuggestionsEnabled: (enabled: boolean): Promise<DesktopPreferences> =>
+      ipcRenderer.invoke('desktop:settings:set-browser-search-suggestions', enabled),
     notify: (payload: DesktopNotificationPayload): Promise<boolean> =>
       ipcRenderer.invoke('desktop:settings:notify', payload),
     setBrowserTheme: (theme: DesktopAppearanceTheme): Promise<DesktopPreferences> =>
@@ -281,6 +283,8 @@ const api: SimDesktopApi = {
       ipcRenderer.invoke('browser-agent:get-tabs-state', scopeId),
     getKnownSessions: (): Promise<BrowserKnownSessionsState> =>
       ipcRenderer.invoke('browser-agent:get-known-sessions'),
+    getSearchSuggestions: (query: string): Promise<string[]> =>
+      ipcRenderer.invoke('browser-agent:search-suggestions', query),
     clearBrowsingData: (kinds?: readonly BrowserDataKind[]): Promise<BrowserKnownSessionsState> =>
       ipcRenderer.invoke('browser-agent:clear-browsing-data', kinds),
     getDownloadsState: (scopeId: string): Promise<BrowserDownloadsState> =>
diff --git a/apps/desktop/src/test/electron-mock.ts b/apps/desktop/src/test/electron-mock.ts
index 476e391d9b..348fe5c1f6 100644
--- a/apps/desktop/src/test/electron-mock.ts
+++ b/apps/desktop/src/test/electron-mock.ts
@@ -107,6 +107,17 @@ export const nativeImage = {
     setTemplateImage: vi.fn(),
     getSize: vi.fn(() => ({ width: options.width, height: options.height })),
   })),
+  /**
+   * Decodes nothing: tests pass short base64 stand-ins rather than real images.
+   * Reports empty so callers take their undecodable-capture fallback, and let a
+   * test opt into the resize path by overriding this mock with a sized image.
+   */
+  createFromBuffer: vi.fn((_buffer: unknown) => ({
+    isEmpty: vi.fn(() => true),
+    getSize: vi.fn(() => ({ width: 0, height: 0 })),
+    resize: vi.fn(),
+    toJPEG: vi.fn(() => Buffer.alloc(0)),
+  })),
 }
 
 export class Tray {
@@ -226,6 +237,8 @@ export class BrowserWindow {
     getZoomFactor: vi.fn(() => 1),
     executeJavaScript: vi.fn(() => Promise.resolve(true)),
     focus: vi.fn(),
+    isFocused: vi.fn(() => false),
+    isDestroyed: vi.fn(() => false),
     send: vi.fn(),
     setWindowOpenHandler: vi.fn(),
     isDevToolsOpened: vi.fn(() => false),
diff --git a/apps/docs/content/docs/en/platform/permissions.mdx b/apps/docs/content/docs/en/platform/permissions.mdx
index b5f1969c24..2f45f5c1a4 100644
--- a/apps/docs/content/docs/en/platform/permissions.mdx
+++ b/apps/docs/content/docs/en/platform/permissions.mdx
@@ -126,7 +126,7 @@ Here's a detailed breakdown of what users can do with each permission level:
 **What they can do:**
 - Everything Read users can do, plus:
 - Create, edit, and delete workflows
-- Run and deploy workflows
+- Run workflows
 - Add, edit, and delete workspace environment variables
 - Use all available tools and integrations
 - Collaborate in real-time on workflow editing
@@ -140,6 +140,7 @@ Here's a detailed breakdown of what users can do with each permission level:
 
 **What they can do:**
 - Everything Write users can do, plus:
+- Deploy workflows
 - Invite new users to the workspace with any permission level
 - Remove users from the workspace
 - Manage workspace settings and integrations
@@ -254,4 +255,4 @@ import { FAQ } from '@/components/ui/faq'
   { question: "Who can manage a workspace's credentials and secrets?", answer: "Workspace Admins are automatically Credential Admins of the workspace's shared credentials — OAuth connections, service accounts, and workspace environment variables — so they can use, edit, delete, and share them, and run workflows that rely on them. Organization Owners and Admins get this too because they are workspace Admins everywhere. Read and Write members get use-only access to shared credentials unless they are explicitly made a Credential Admin. Personal environment variables are never shared; they stay private to their owner." },
   { question: "What are permission groups and how do they work?", answer: "Permission groups are an Enterprise access control feature that lets organization owners and admins define granular restrictions beyond the standard Read/Write/Admin roles. The organization's default group is org-wide; every other group targets specific workspaces and, by default, governs all members of those workspaces (including external members) — add members to restrict it to specific people. A user is governed by one group per workspace: a group they're an explicit member of takes precedence over an all-members group (one with no members) on that workspace, which takes precedence over the organization's default group. A permission group can hide UI sections (like trace spans, knowledge base, API keys, or deployment options), disable features (MCP tools, custom tools, skills, invitations), and restrict which integrations and model providers its members can access. Only one group per organization can be the default; it ignores members and governs everyone not covered by a workspace group, including external members. Restrictions are enforced based on the organization that owns the workflow's workspace, not on which workspace you're currently viewing." },
   { question: "How should I set up permissions for a new team member?", answer: "Start with the lowest permission level they need. Invite them with Read workspace access if they only need visibility, Write if they need to create and run workflows, or Admin if they need to manage the workspace and its users, and leave Membership on Member. For clients, partners, and contractors, choose External so they collaborate without joining your organization or using a seat — this requires them to already be on a paid Sim plan, either their own Pro or Max subscription or another organization that seats them." },
-]} />
\ No newline at end of file
+]} />
diff --git a/apps/sim/app/_shell/desktop-title-bar-surfaces.test.ts b/apps/sim/app/_shell/desktop-title-bar-surfaces.test.ts
index 53b0f298bf..2584ea88c3 100644
--- a/apps/sim/app/_shell/desktop-title-bar-surfaces.test.ts
+++ b/apps/sim/app/_shell/desktop-title-bar-surfaces.test.ts
@@ -86,8 +86,10 @@ describe('desktop title-bar surface audit', () => {
   // Regression: a px clearance shrinks under page zoom while the OS-drawn lights
   // do not, so they end up drawn over the sidebar toggle.
   it('reserves the traffic-light lane from the platform, not hardcoded pixels', () => {
-    expect(globalStyles).toContain('--desktop-title-bar-height: env(titlebar-area-height,')
-    expect(globalStyles).toContain('--desktop-title-bar-inset-x: env(titlebar-area-x,')
+    // The env() term is the platform-derived part; the max() floor keeps the
+    // lane from collapsing below the OS-drawn lights under page zoom.
+    expect(globalStyles).toContain('--desktop-title-bar-height: max(env(titlebar-area-height,')
+    expect(globalStyles).toContain('--desktop-title-bar-inset-x: max(env(titlebar-area-x,')
 
     // Scoped to the desktop block: the `:root` zeros are the deliberate
     // no-lane case, so only the overrides must stay derived.
@@ -95,13 +97,17 @@ describe('desktop title-bar surface audit', () => {
       /html\[data-sim-desktop-title-bar="inset"\]\s*\{([^}]*)\}/
     )?.[1]
     expect(insetBlock).toBeTypeOf('string')
+    // The zoom rework split the lane from the control: the lane stays
+    // platform-derived (clamped env() above), while the control is a fixed
+    // square — CSS px already scale under page zoom, so only the centering
+    // offset must remain computed from the lane height.
+    expect(insetBlock).toMatch(/--desktop-title-bar-control-offset: calc\(/)
+    expect(insetBlock).not.toMatch(/--desktop-title-bar-control-offset:\s*[\d.]+px/)
     for (const name of [
       '--desktop-title-bar-control-size',
       '--desktop-title-bar-control-icon-size',
-      '--desktop-title-bar-control-offset',
     ]) {
-      expect(insetBlock).toMatch(new RegExp(`${name}: calc\\(`))
-      expect(insetBlock).not.toMatch(new RegExp(`${name}:\\s*[\\d.]+px`))
+      expect(insetBlock).toMatch(new RegExp(`${name}:\\s*[\\d.]+px`))
     }
 
     // Both lane consumers read those vars; a literal in either is the bug.
diff --git a/apps/sim/app/_styles/globals.css b/apps/sim/app/_styles/globals.css
index 62cb18c353..bf92b92bf9 100644
--- a/apps/sim/app/_styles/globals.css
+++ b/apps/sim/app/_styles/globals.css
@@ -96,23 +96,24 @@
 }
 
 /**
- * Electron's `titleBarOverlay` publishes the window controls' geometry as these
- * `titlebar-area-*` env vars, and Chromium rescales them under page zoom so the
- * lane holds its physical size. Fallbacks are the platform's measured values, for
- * a shell predating the overlay; the `:root` zeros cover the different case of the
- * attribute being absent entirely, where this block never matches.
+ * The lane scales with page zoom like the rest of the UI (Codex-style): the
+ * 38px/81px terms are CSS px, so zooming in grows the lane and its controls
+ * with the content while the OS-drawn traffic lights hold their physical size
+ * inside it. The `env(titlebar-area-*)` terms — which Chromium rescales under
+ * zoom to keep physical geometry — act only as a floor, so zooming OUT can
+ * never shrink the lane under the lights or slide the controls beneath them.
+ * Fallbacks are the platform's measured values, for a shell predating the
+ * overlay; the `:root` zeros cover the different case of the attribute being
+ * absent entirely, where this block never matches.
  */
 html[data-sim-desktop-title-bar="inset"] {
   --sidebar-collapsed-width: 0px;
-  --desktop-title-bar-height: env(titlebar-area-height, 38px);
-  --desktop-title-bar-inset-x: env(titlebar-area-x, 81px);
-  /* 0.79 = 30px of the 38px lane, and 0.53 of that = 16px. Proportions rather
-     than px because px would scale with page zoom while the OS-drawn lights
-     would not — and calc cannot divide a length by a length to get a scale.
-     `navigator.windowControlsOverlay` could, but reading it in JS would race
-     first paint for a value the blocking script needs. */
-  --desktop-title-bar-control-size: calc(var(--desktop-title-bar-height) * 0.79);
-  --desktop-title-bar-control-icon-size: calc(var(--desktop-title-bar-control-size) * 0.53);
+  --desktop-title-bar-height: max(env(titlebar-area-height, 38px), 38px);
+  --desktop-title-bar-inset-x: max(env(titlebar-area-x, 81px), 81px);
+  /* 30px of the 38px lane, and 16px of that — CSS px on purpose, so the
+     controls zoom with the page instead of staying pinned to physical size. */
+  --desktop-title-bar-control-size: 30px;
+  --desktop-title-bar-control-icon-size: 16px;
   --desktop-title-bar-control-offset: calc(
     (var(--desktop-title-bar-height) - var(--desktop-title-bar-control-size)) /
     2
diff --git a/apps/sim/app/api/copilot/chat/steer/route.test.ts b/apps/sim/app/api/copilot/chat/steer/route.test.ts
new file mode 100644
index 0000000000..417d4d9638
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/steer/route.test.ts
@@ -0,0 +1,128 @@
+/**
+ * @vitest-environment node
+ */
+import { createMockRequest } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockAuthenticate, mockGetLatestRunForStream, mockRequestStreamSteering, mockAppend } =
+  vi.hoisted(() => ({
+    mockAuthenticate: vi.fn(),
+    mockGetLatestRunForStream: vi.fn(),
+    mockRequestStreamSteering: vi.fn(),
+    mockAppend: vi.fn(),
+  }))
+
+vi.mock('@/lib/copilot/request/http', () => ({
+  authenticateCopilotRequestSessionOnly: mockAuthenticate,
+}))
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  getLatestRunForStream: mockGetLatestRunForStream,
+}))
+vi.mock('@/lib/copilot/request/session/steer', () => ({
+  requestStreamSteering: mockRequestStreamSteering,
+}))
+vi.mock('@/lib/copilot/chat/messages-store', () => ({
+  appendCopilotChatMessages: mockAppend,
+}))
+
+import { POST } from '@/app/api/copilot/chat/steer/route'
+
+function steerRequest(overrides: Record<string, unknown> = {}) {
+  return createMockRequest('POST', {
+    streamId: 'stream-1',
+    chatId: 'chat-1',
+    steeringId: 'steer-1',
+    content: 'focus on the tests',
+    ...overrides,
+  })
+}
+
+describe('POST /api/copilot/chat/steer', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockAuthenticate.mockResolvedValue({ userId: 'user-1', isAuthenticated: true })
+    mockGetLatestRunForStream.mockResolvedValue({ chatId: 'chat-1', workspaceId: 'workspace-1' })
+    mockRequestStreamSteering.mockResolvedValue({ queued: true, status: 200 })
+    mockAppend.mockResolvedValue(undefined)
+  })
+
+  it('queues steering with Go and persists the user message', async () => {
+    const response = await POST(steerRequest())
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toMatchObject({ ok: true, queued: true })
+    expect(mockRequestStreamSteering).toHaveBeenCalledWith(
+      expect.objectContaining({
+        streamId: 'stream-1',
+        chatId: 'chat-1',
+        steeringId: 'steer-1',
+        content: 'focus on the tests',
+        userId: 'user-1',
+      })
+    )
+    expect(mockAppend).toHaveBeenCalledWith(
+      'chat-1',
+      [
+        expect.objectContaining({
+          id: 'steer-1',
+          role: 'user',
+          content: 'focus on the tests',
+        }),
+      ],
+      { streamId: 'stream-1' }
+    )
+  })
+
+  it('returns 409 when Go rejects the steer so the client falls back to a normal send', async () => {
+    mockRequestStreamSteering.mockResolvedValue({ queued: false, status: 429 })
+
+    const response = await POST(steerRequest())
+
+    expect(response.status).toBe(409)
+    expect(await response.json()).toMatchObject({ ok: false, queued: false })
+    expect(mockAppend).not.toHaveBeenCalled()
+  })
+
+  it('returns 409 when the Go forward throws', async () => {
+    mockRequestStreamSteering.mockRejectedValue(new Error('network down'))
+
+    const response = await POST(steerRequest())
+
+    expect(response.status).toBe(409)
+    expect(mockAppend).not.toHaveBeenCalled()
+  })
+
+  it('rejects a chat that does not own the stream', async () => {
+    mockGetLatestRunForStream.mockResolvedValue({ chatId: 'other-chat' })
+
+    const response = await POST(steerRequest())
+
+    expect(response.status).toBe(403)
+    expect(mockRequestStreamSteering).not.toHaveBeenCalled()
+  })
+
+  it('rejects unauthenticated callers', async () => {
+    mockAuthenticate.mockResolvedValue({ userId: null, isAuthenticated: false })
+
+    const response = await POST(steerRequest())
+
+    expect(response.status).toBe(401)
+    expect(mockRequestStreamSteering).not.toHaveBeenCalled()
+  })
+
+  it('rejects an empty content body', async () => {
+    const response = await POST(steerRequest({ content: '' }))
+
+    expect(response.status).toBe(400)
+    expect(mockRequestStreamSteering).not.toHaveBeenCalled()
+  })
+
+  it('still reports queued when history persistence fails', async () => {
+    mockAppend.mockRejectedValue(new Error('db down'))
+
+    const response = await POST(steerRequest())
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toMatchObject({ ok: true, queued: true })
+  })
+})
diff --git a/apps/sim/app/api/copilot/chat/steer/route.ts b/apps/sim/app/api/copilot/chat/steer/route.ts
new file mode 100644
index 0000000000..7520ac0100
--- /dev/null
+++ b/apps/sim/app/api/copilot/chat/steer/route.ts
@@ -0,0 +1,128 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { copilotChatSteerBodySchema } from '@/lib/api/contracts/copilot'
+import { validationErrorResponse } from '@/lib/api/server'
+import { getLatestRunForStream } from '@/lib/copilot/async-runs/repository'
+import { appendCopilotChatMessages } from '@/lib/copilot/chat/messages-store'
+import { CopilotSteerOutcome } from '@/lib/copilot/generated/trace-attribute-values-v1'
+import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
+import { TraceSpan } from '@/lib/copilot/generated/trace-spans-v1'
+import { authenticateCopilotRequestSessionOnly } from '@/lib/copilot/request/http'
+import { withIncomingGoSpan } from '@/lib/copilot/request/otel'
+import { requestStreamSteering } from '@/lib/copilot/request/session/steer'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+const logger = createLogger('CopilotChatSteerAPI')
+
+// POST /api/copilot/chat/steer — queues a mid-turn steering message with the
+// Go side for a LIVE stream. Acceptance means "queued", not "applied": Go
+// acknowledges application with a `run`/`steering_applied` stream event; a
+// client that never sees that ack before the stream ends re-sends the content
+// as an ordinary message. A 409 here tells the client to take that ordinary
+// path immediately.
+export const POST = withRouteHandler((request: NextRequest) =>
+  withIncomingGoSpan(
+    request.headers,
+    TraceSpan.CopilotChatSteerStream,
+    undefined,
+    async (rootSpan) => {
+      const { userId: authenticatedUserId, isAuthenticated } =
+        await authenticateCopilotRequestSessionOnly()
+      if (!isAuthenticated || !authenticatedUserId) {
+        rootSpan.setAttribute(TraceAttr.CopilotSteerOutcome, CopilotSteerOutcome.BadRequest)
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+      }
+
+      // boundary-raw-json: tolerant parse; validation happens via the contract schema below
+      const body = await request.json().catch(() => ({}))
+      const validation = copilotChatSteerBodySchema.safeParse(body)
+      if (!validation.success) {
+        rootSpan.setAttribute(TraceAttr.CopilotSteerOutcome, CopilotSteerOutcome.BadRequest)
+        return validationErrorResponse(validation.error, 'Invalid request body')
+      }
+      const { streamId, chatId, steeringId, content } = validation.data
+      rootSpan.setAttributes({
+        [TraceAttr.StreamId]: streamId,
+        [TraceAttr.ChatId]: chatId,
+        [TraceAttr.UserId]: authenticatedUserId,
+        [TraceAttr.CopilotSteeringContentChars]: content.length,
+      })
+
+      // Ownership pre-check on the Sim side (Go re-proves it independently):
+      // the stream must belong to a run of the authenticated user, and the
+      // claimed chat must match that run.
+      const run = await getLatestRunForStream(streamId, authenticatedUserId).catch((err) => {
+        logger.warn('getLatestRunForStream failed while resolving steer context', {
+          streamId,
+          error: getErrorMessage(err),
+        })
+        return null
+      })
+      if (run?.chatId && run.chatId !== chatId) {
+        rootSpan.setAttribute(TraceAttr.CopilotSteerOutcome, CopilotSteerOutcome.BadRequest)
+        return NextResponse.json({ error: 'Stream does not belong to this chat' }, { status: 403 })
+      }
+
+      let queued = false
+      let goStatus = 0
+      try {
+        const result = await requestStreamSteering({
+          streamId,
+          userId: authenticatedUserId,
+          chatId,
+          steeringId,
+          content,
+          workspaceId: run?.workspaceId ?? undefined,
+        })
+        queued = result.queued
+        goStatus = result.status
+      } catch (err) {
+        logger.warn('Steer forward to Go failed', {
+          streamId,
+          chatId,
+          error: getErrorMessage(err),
+        })
+      }
+
+      if (!queued) {
+        rootSpan.setAttribute(TraceAttr.CopilotSteerOutcome, CopilotSteerOutcome.NoActiveTurn)
+        // 409 = "could not queue; send it as an ordinary message instead".
+        return NextResponse.json({ ok: false, queued: false, goStatus }, { status: 409 })
+      }
+
+      // Persist the steering text as a user message so reloads include it.
+      // Failure here must not fail the steer — the message is already queued
+      // with Go and will reach the model; persistence is display-only.
+      try {
+        await appendCopilotChatMessages(
+          chatId,
+          [
+            {
+              id: steeringId,
+              role: 'user',
+              content,
+              timestamp: new Date().toISOString(),
+            },
+          ],
+          { streamId }
+        )
+      } catch (err) {
+        logger.warn('Failed to persist steering message to chat history', {
+          chatId,
+          steeringId,
+          error: getErrorMessage(err),
+        })
+      }
+
+      rootSpan.setAttribute(TraceAttr.CopilotSteerOutcome, CopilotSteerOutcome.Queued)
+      logger.info('Queued mid-turn steering message', {
+        streamId,
+        chatId,
+        steeringId,
+        contentChars: content.length,
+      })
+      return NextResponse.json({ ok: true, queued: true })
+    }
+  )
+)
diff --git a/apps/sim/app/api/copilot/tools/execute/route.test.ts b/apps/sim/app/api/copilot/tools/execute/route.test.ts
new file mode 100644
index 0000000000..87e7d1e88f
--- /dev/null
+++ b/apps/sim/app/api/copilot/tools/execute/route.test.ts
@@ -0,0 +1,114 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
+
+const { mockCheckInternalApiKey, mockPrepareEnvironmentContext, mockHandler } = vi.hoisted(() => ({
+  mockCheckInternalApiKey: vi.fn(),
+  mockPrepareEnvironmentContext: vi.fn(),
+  mockHandler: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/http', () => ({
+  checkInternalApiKey: mockCheckInternalApiKey,
+}))
+
+vi.mock('@/lib/copilot/environment-context', () => ({
+  prepareCopilotEnvironmentContext: mockPrepareEnvironmentContext,
+}))
+
+vi.mock('@/lib/copilot/tool-executor', () => ({
+  ensureHandlersRegistered: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/tool-executor/executor', () => ({
+  executeTool: (
+    _toolName: string,
+    params: Record<string, unknown>,
+    context: Record<string, unknown>
+  ) => mockHandler(params, context),
+}))
+
+vi.mock('@/lib/copilot/request/tools/resources', () => ({
+  handleResourceSideEffects: vi.fn().mockResolvedValue(undefined),
+}))
+
+vi.mock('@/lib/copilot/request/otel', () => ({
+  withIncomingGoSpan: (
+    _headers: Headers,
+    _span: string,
+    _attrs: undefined,
+    fn: (span: { setAttributes: () => void }) => Promise<Response>
+  ) => fn({ setAttributes: () => {} }),
+}))
+
+import { POST } from '@/app/api/copilot/tools/execute/route'
+
+function makeRequest(body: Record<string, unknown>): Request {
+  return new Request('http://localhost/api/copilot/tools/execute', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+}
+
+const BASE_BODY = {
+  toolCallId: 'call-1',
+  toolName: 'read',
+  params: { path: 'files/a.md' },
+  userId: 'user-1',
+  workspaceId: 'ws-1',
+  chatId: 'chat-1',
+  messageId: 'msg-1',
+}
+
+describe('POST /api/copilot/tools/execute (in-band)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockCheckInternalApiKey.mockReturnValue({ success: true })
+    // A fresh, complete registry per test: the module-level turn cache is keyed
+    // by messageId, so each test uses a distinct messageId to avoid cross-test
+    // cache hits.
+    mockPrepareEnvironmentContext.mockImplementation(async () => ({
+      resolvedSecretTraceRegistry: new ResolvedSecretTraceRegistry([]),
+    }))
+  })
+
+  it('threads a per-call registry fork into the handler and returns the projected result', async () => {
+    mockHandler.mockResolvedValue({ success: true, output: { content: 'hello' } })
+    const res = await POST(makeRequest({ ...BASE_BODY, messageId: 'msg-fork' }) as never)
+    expect(res.status).toBe(200)
+    await expect(res.json()).resolves.toEqual({ success: true, output: { content: 'hello' } })
+
+    const [, handlerContext] = mockHandler.mock.calls[0]
+    expect(handlerContext.resolvedSecretTraceRegistry).toBeInstanceOf(ResolvedSecretTraceRegistry)
+    expect(handlerContext.userId).toBe('user-1')
+    expect(handlerContext.copilotToolExecution).toBe(true)
+  })
+
+  it('keeps a clean tool failure message intact when the registry is available', async () => {
+    mockHandler.mockResolvedValue({ success: false, error: 'File not found: files/a.md' })
+    const res = await POST(makeRequest({ ...BASE_BODY, messageId: 'msg-clean-error' }) as never)
+    const body = await res.json()
+    expect(body.success).toBe(false)
+    expect(body.error).toBe('File not found: files/a.md')
+  })
+
+  it('withholds results when no egress registry can be built', async () => {
+    mockPrepareEnvironmentContext.mockRejectedValue(new Error('env unavailable'))
+    mockHandler.mockResolvedValue({ success: true, output: { content: 'sensitive' } })
+    const res = await POST(makeRequest({ ...BASE_BODY, messageId: 'msg-no-registry' }) as never)
+    const body = await res.json()
+    expect(body).toEqual({ success: true })
+  })
+
+  it('reuses one turn registry across calls that share a messageId', async () => {
+    mockHandler.mockResolvedValue({ success: true, output: {} })
+    await POST(makeRequest({ ...BASE_BODY, messageId: 'msg-shared' }) as never)
+    await POST(
+      makeRequest({ ...BASE_BODY, toolCallId: 'call-2', messageId: 'msg-shared' }) as never
+    )
+    expect(mockPrepareEnvironmentContext).toHaveBeenCalledTimes(1)
+  })
+})
diff --git a/apps/sim/app/api/copilot/tools/execute/route.ts b/apps/sim/app/api/copilot/tools/execute/route.ts
new file mode 100644
index 0000000000..9da0848f6c
--- /dev/null
+++ b/apps/sim/app/api/copilot/tools/execute/route.ts
@@ -0,0 +1,206 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { type NextRequest, NextResponse } from 'next/server'
+import { copilotToolExecuteInternalBodySchema } from '@/lib/api/contracts/copilot'
+import { validationErrorResponse } from '@/lib/api/server'
+import { prepareCopilotEnvironmentContext } from '@/lib/copilot/environment-context'
+import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
+import { TraceSpan } from '@/lib/copilot/generated/trace-spans-v1'
+import { checkInternalApiKey } from '@/lib/copilot/request/http'
+import { withIncomingGoSpan } from '@/lib/copilot/request/otel'
+import {
+  inspectToolResultForCopilot,
+  projectToolErrorMessageForCopilot,
+} from '@/lib/copilot/request/tools/resolved-secret-result'
+import { handleResourceSideEffects } from '@/lib/copilot/request/tools/resources'
+import type { ToolCallResult } from '@/lib/copilot/request/types'
+import { ensureHandlersRegistered } from '@/lib/copilot/tool-executor'
+import { executeTool } from '@/lib/copilot/tool-executor/executor'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
+
+const logger = createLogger('CopilotToolExecuteInternalAPI')
+
+/**
+ * In-band calls are stateless one-offs, but the turn they serve is not: secret
+ * provenance activated by one tool call must stay visible to the next call's
+ * egress projection, exactly as the request-lifecycle registry accumulates
+ * across a turn. Keyed by the turn (messageId) so one background lane shares
+ * one registry; TTL-evicted since nothing signals turn end on this route.
+ */
+const TURN_REGISTRY_TTL_MS = 10 * 60 * 1000
+const TURN_REGISTRY_CACHE_MAX = 256
+const turnRegistryCache = new Map<
+  string,
+  { registry: ResolvedSecretTraceRegistry; expiresAt: number }
+>()
+
+async function getTurnEgressRegistry(
+  userId: string,
+  workspaceId: string | undefined,
+  messageId: string | undefined
+): Promise<ResolvedSecretTraceRegistry> {
+  const key = `${userId}\u0000${workspaceId ?? ''}\u0000${messageId ?? ''}`
+  const now = Date.now()
+  const hit = turnRegistryCache.get(key)
+  if (hit && hit.expiresAt > now) {
+    hit.expiresAt = now + TURN_REGISTRY_TTL_MS
+    return hit.registry
+  }
+  const environmentContext = await prepareCopilotEnvironmentContext(userId, workspaceId)
+  for (const [cachedKey, cached] of turnRegistryCache) {
+    if (cached.expiresAt <= now) turnRegistryCache.delete(cachedKey)
+  }
+  if (turnRegistryCache.size >= TURN_REGISTRY_CACHE_MAX) {
+    const oldest = turnRegistryCache.keys().next().value
+    if (oldest !== undefined) turnRegistryCache.delete(oldest)
+  }
+  turnRegistryCache.set(key, {
+    registry: environmentContext.resolvedSecretTraceRegistry,
+    expiresAt: now + TURN_REGISTRY_TTL_MS,
+  })
+  return environmentContext.resolvedSecretTraceRegistry
+}
+
+// POST /api/copilot/tools/execute — internal (Go → Sim) in-band execution of
+// one sim-server tool announced on a LIVE mothership turn. This is what lets
+// background (async) subagents — and the main lane while background agents are
+// running — use sim-executed tools without a checkpoint pause: Go calls here
+// synchronously instead of parking the turn, and the tool runs through the
+// same server tool router the resume driver uses. Trusted server-to-server
+// only: Go supplies the acting user, proven by the internal API secret.
+//
+// Results cross a model boundary here just as they do in the resume driver, so
+// this route mirrors its provenance discipline: a per-call registry fork feeds
+// the handler, the settled result is projected before it returns to Go, and
+// the fork is merged back only when the projection was safe and the fork
+// stayed complete. Without this, every result crossed unprojected and every
+// thrown error was replaced by the opaque "could not be returned safely"
+// sentinel (the projection fails closed on a missing registry).
+export const POST = withRouteHandler((request: NextRequest) =>
+  withIncomingGoSpan(
+    request.headers,
+    TraceSpan.CopilotToolsExecuteInband,
+    undefined,
+    async (rootSpan) => {
+      const authResult = checkInternalApiKey(request)
+      if (!authResult.success) {
+        return NextResponse.json(
+          { success: false, error: authResult.error || 'Authentication failed' },
+          { status: 401 }
+        )
+      }
+
+      // boundary-raw-json: tolerant parse; validation happens via the contract schema below
+      const body = await request.json().catch(() => ({}))
+      const validation = copilotToolExecuteInternalBodySchema.safeParse(body)
+      if (!validation.success) {
+        return validationErrorResponse(validation.error, 'Invalid request body')
+      }
+      const {
+        toolCallId,
+        toolName,
+        params,
+        userId,
+        workflowId,
+        workspaceId,
+        chatId,
+        messageId,
+        parentToolCallId,
+        userPermission,
+      } = validation.data
+      rootSpan.setAttributes({
+        [TraceAttr.ToolName]: toolName,
+        [TraceAttr.ToolCallId]: toolCallId,
+        [TraceAttr.UserId]: userId,
+      })
+
+      let toolRegistry: ResolvedSecretTraceRegistry | undefined
+      let turnRegistry: ResolvedSecretTraceRegistry | undefined
+      try {
+        turnRegistry = await getTurnEgressRegistry(userId, workspaceId, messageId)
+        toolRegistry = turnRegistry.forkForInputPaths([])
+      } catch (err) {
+        logger.error('In-band egress registry unavailable; results will be withheld', {
+          toolName,
+          toolCallId,
+          error: getErrorMessage(err),
+        })
+      }
+
+      try {
+        // The relay's comprehensive dispatcher: registry handlers (VFS
+        // glob/read/grep, function execute, ...) plus the server tool router
+        // fallback — the plain server-tool adapter alone rejects VFS tools
+        // with "Unknown server tool".
+        ensureHandlersRegistered()
+        const result = await executeTool(toolName, params, {
+          userId,
+          workflowId: workflowId ?? '',
+          workspaceId,
+          chatId,
+          messageId,
+          toolCallId,
+          parentToolCallId,
+          userPermission,
+          copilotToolExecution: true,
+          resolvedSecretTraceRegistry: toolRegistry,
+        })
+        const projection = inspectToolResultForCopilot(result, toolRegistry, toolName)
+        const projected = projection.result
+        if (projection.safe && toolRegistry?.isComplete() && turnRegistry) {
+          turnRegistry.mergeToolCallRegistry(toolRegistry)
+        }
+        if (!projected.success) {
+          logger.warn('In-band tool execution failed', {
+            toolName,
+            toolCallId,
+            error: projected.error,
+            runtimeSucceeded: result.success,
+            projectionSafe: projection.safe,
+          })
+        }
+        if (result.success && chatId) {
+          // Persist created/deleted resources on the chat (file chips, table
+          // links) exactly like the resume driver does. No live event sink
+          // exists for an out-of-band route, so chips surface from the
+          // persisted chat resources rather than a mid-turn push. Side effects
+          // read the raw result; only model-facing content is projected.
+          const asToolResult = { success: result.success, output: result.output } as ToolCallResult
+          await handleResourceSideEffects(
+            toolName,
+            params,
+            asToolResult,
+            { success: projected.success, output: projected.output } as ToolCallResult,
+            chatId,
+            undefined,
+            () => false
+          ).catch((err) => {
+            logger.warn('In-band resource side effects failed', {
+              toolName,
+              toolCallId,
+              error: getErrorMessage(err),
+            })
+          })
+        }
+        return NextResponse.json({
+          success: projected.success,
+          ...(projected.output !== undefined ? { output: projected.output } : {}),
+          ...(projected.error ? { error: projected.error } : {}),
+        })
+      } catch (err) {
+        const message = projectToolErrorMessageForCopilot(
+          getErrorMessage(err),
+          toolRegistry,
+          toolName
+        )
+        logger.error('In-band tool execution threw', {
+          toolName,
+          toolCallId,
+          error: getErrorMessage(err),
+        })
+        return NextResponse.json({ success: false, error: message }, { status: 500 })
+      }
+    }
+  )
+)
diff --git a/apps/sim/app/api/files/public/[token]/content/route.ts b/apps/sim/app/api/files/public/[token]/content/route.ts
index 49f7d8104e..6c47668fba 100644
--- a/apps/sim/app/api/files/public/[token]/content/route.ts
+++ b/apps/sim/app/api/files/public/[token]/content/route.ts
@@ -12,6 +12,8 @@ import { enforcePublicFileRateLimit } from '@/lib/public-shares/rate-limit'
 import { resolveActiveShareByToken } from '@/lib/public-shares/share-manager'
 import { downloadFile } from '@/lib/uploads/core/storage-service'
 import { resolveServableImageBytes } from '@/lib/uploads/server/image-derivative'
+import { isSimPageSource, SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
+import { renderSimPageDocumentWithAssets } from '@/lib/workspace-files/page-document.server'
 import {
   createErrorResponse,
   createFileResponse,
@@ -89,6 +91,24 @@ export const GET = withRouteHandler(
       if (servable.kind === 'artifact') {
         buffer = servable.buffer
         contentType = servable.contentType
+      } else if (
+        // Sim pages store an extensionless name — the record type marks them;
+        // legacy pages still carry .html.
+        (file.contentType === SIM_PAGE_CONTENT_TYPE ||
+          file.originalName.toLowerCase().endsWith('.html')) &&
+        isSimPageSource(raw.toString('utf8'))
+      ) {
+        // The pdf model for pages: the stored .html is source; a share serves
+        // the fully styled compiled document, matching the preview and serve
+        // routes. sim: links resolve to workspace routes (a viewer without
+        // workspace access simply lands on the sign-in gate).
+        buffer = Buffer.from(
+          await renderSimPageDocumentWithAssets(raw.toString('utf8'), {
+            workspaceId: file.workspaceId ?? undefined,
+          }),
+          'utf8'
+        )
+        contentType = 'text/html'
       } else if (preview) {
         // Only for a render request: the Download button omits `preview`, so a saved
         // file is always the bytes that were shared.
diff --git a/apps/sim/app/api/files/serve/[...path]/route.ts b/apps/sim/app/api/files/serve/[...path]/route.ts
index 7599c1b122..0e18cfd04a 100644
--- a/apps/sim/app/api/files/serve/[...path]/route.ts
+++ b/apps/sim/app/api/files/serve/[...path]/route.ts
@@ -22,6 +22,8 @@ import { resolveStoredFileContext } from '@/lib/uploads/server/metadata'
 import { inferContextFromKey } from '@/lib/uploads/utils/file-utils'
 import { internalWorkspaceFileServeAuth } from '@/lib/workspace-files/api'
 import { readWorkspaceFileContentByKey } from '@/lib/workspace-files/application/read-workspace-file-content-by-key'
+import { isSimPageSource, SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
+import { renderSimPageDocumentWithAssets } from '@/lib/workspace-files/page-document.server'
 import { verifyFileAccess } from '@/app/api/files/authorization'
 import {
   createErrorResponse,
@@ -76,12 +78,39 @@ async function resolveServableBytes(params: {
   options: ServeOptions
   ownerKey: string | undefined
   filePrincipal?: Principal
+  /** The stored record's content type, where the caller has the record. */
+  fileType?: string
   signal: AbortSignal | undefined
 }): Promise<{ buffer: Buffer; contentType: string }> {
-  const { buffer, filename, storageKey, workspaceId, options, ownerKey, filePrincipal, signal } =
-    params
+  const {
+    buffer,
+    filename,
+    storageKey,
+    workspaceId,
+    options,
+    ownerKey,
+    filePrincipal,
+    fileType,
+    signal,
+  } = params
   if (options.raw) return { buffer, contentType: getContentType(filename) }
 
+  // The pdf model for pages: a page file stores its SOURCE (frontmatter +
+  // markdown + sim: fences) and serving compiles it to the rendered document,
+  // the same way a .pdf key stores its script and serves the binary. Raw
+  // requests above still return the source; bespoke/legacy HTML falls through
+  // untouched. Sim pages store an EXTENSIONLESS name — the record type marks
+  // them; legacy pages still carry .html.
+  if (fileType === SIM_PAGE_CONTENT_TYPE || filename.toLowerCase().endsWith('.html')) {
+    const text = buffer.toString('utf8')
+    if (isSimPageSource(text)) {
+      return {
+        buffer: Buffer.from(await renderSimPageDocumentWithAssets(text, { workspaceId }), 'utf8'),
+        contentType: 'text/html',
+      }
+    }
+  }
+
   if (options.preview) {
     // Images resolve independently of the document path: a HEIF has no compiled-source
     // concept, so it never reaches the doc branch.
@@ -271,6 +300,7 @@ async function handleWorkspaceFile(
     options,
     ownerKey,
     filePrincipal: principal,
+    fileType: file.type,
     signal: request.signal,
   })
 
diff --git a/apps/sim/app/api/files/utils.ts b/apps/sim/app/api/files/utils.ts
index 6480da5d0b..0de6ed4b3b 100644
--- a/apps/sim/app/api/files/utils.ts
+++ b/apps/sim/app/api/files/utils.ts
@@ -237,11 +237,21 @@ export function encodeFilenameForHeader(storageKey: string): string {
 }
 
 export function createFileResponse(file: FileResponse): NextResponse {
-  const { contentType, disposition } = getSecureFileHeaders(file.filename, file.contentType)
+  // Sim pages store an extensionless name and serve/download as compiled
+  // HTML — re-append the extension so the saved file opens in a browser.
+  // Decided from the CALLER's content type (getSecureFileHeaders downgrades
+  // text/html), and BEFORE the header decision, so the .html name gets the
+  // same forced-attachment treatment a legacy .html file gets.
+  const servedFilename =
+    file.contentType === 'text/html' && !/\.[A-Za-z0-9]{1,8}$/.test(file.filename)
+      ? `${file.filename}.html`
+      : file.filename
+
+  const { contentType, disposition } = getSecureFileHeaders(servedFilename, file.contentType)
 
   const headers: Record<string, string> = {
     'Content-Type': contentType,
-    'Content-Disposition': `${disposition}; ${encodeFilenameForHeader(file.filename)}`,
+    'Content-Disposition': `${disposition}; ${encodeFilenameForHeader(servedFilename)}`,
     // Default to PRIVATE: this response is served only after access verification, so it must never be
     // stored by a shared cache/CDN and re-served cross-user. Genuinely public assets (avatars, OG images,
     // workspace logos) pass an explicit `cacheControl` (see PUBLIC_ASSET_CACHE_CONTROL in the serve route).
diff --git a/apps/sim/app/api/mothership/execute/route.test.ts b/apps/sim/app/api/mothership/execute/route.test.ts
index 007f9424f1..43893921a3 100644
--- a/apps/sim/app/api/mothership/execute/route.test.ts
+++ b/apps/sim/app/api/mothership/execute/route.test.ts
@@ -237,8 +237,13 @@ describe('mothership private trace provenance transport', () => {
       'user-1',
       'secret-value __var_FOREIGN',
       'workspace-1',
-      'chat-1'
+      'chat-1',
+      expect.any(Object)
     )
+
+    const contextRegistry = mockProcessContextsServer.mock.calls.at(-1)?.[5]
+    const lifecycleOptions = mockRunHeadlessCopilotLifecycle.mock.calls.at(-1)?.[1]
+    expect(contextRegistry).toBe(lifecycleOptions.environmentContext?.resolvedSecretTraceRegistry)
   })
 
   it('keeps context routing and display inputs raw until the lifecycle boundary', async () => {
@@ -290,7 +295,8 @@ describe('mothership private trace provenance transport', () => {
       'user-1',
       'hello',
       'workspace-1',
-      'chat-1'
+      'chat-1',
+      expect.any(Object)
     )
   })
 
diff --git a/apps/sim/app/api/mothership/execute/route.ts b/apps/sim/app/api/mothership/execute/route.ts
index 39f061a92d..e01f727f59 100644
--- a/apps/sim/app/api/mothership/execute/route.ts
+++ b/apps/sim/app/api/mothership/execute/route.ts
@@ -244,7 +244,8 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
           userId,
           lastUserMessage,
           workspaceId,
-          effectiveChatId
+          effectiveChatId,
+          activeResolvedSecretTraceRegistry
         ).catch((error) => {
           reqLogger.warn('Failed to resolve agent contexts for execution', {
             error: toError(error).message,
diff --git a/apps/sim/app/api/table/utils.ts b/apps/sim/app/api/table/utils.ts
index 9c375aa873..b9a2a85534 100644
--- a/apps/sim/app/api/table/utils.ts
+++ b/apps/sim/app/api/table/utils.ts
@@ -21,14 +21,13 @@ import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 import { getWorkspaceOrganizationId } from '@/lib/workspaces/utils'
 
 /**
- * Gate for the v2 tables HTTP API (`tables-v2-api` flag). Returns a 404 response
- * when the flag is off for the caller — the surface behaves as if it doesn't
- * exist — or `null` to proceed. Gated by userId + the workspace's org cohort.
- *
- * **Call this AFTER the authz check, never before.** Ahead of authz it does a
- * primary-DB read keyed on a caller-supplied `workspaceId`, and the 404-vs-403
- * split tells an unauthorized caller whether that workspace's org is in the
- * rollout cohort.
+ * Gate for the internal predicate-grammar table query route (`tables-v2-api`
+ * flag). Runs AFTER authorization, so the caller has already proven read
+ * access to the table — hiding the gate behind a bare 404 at that point
+ * serves nobody and reads as data loss (live incident: the table_v2 block
+ * hard-"Not found"-ing on every query while the copilot gateway, which
+ * bypasses HTTP, found the rows). Authorized callers get an honest 403
+ * naming the gate instead.
  */
 export async function tablesV2GateError(
   userId: string,
@@ -36,7 +35,13 @@ export async function tablesV2GateError(
 ): Promise<NextResponse | null> {
   const orgId = await getWorkspaceOrganizationId(workspaceId)
   if (await isFeatureEnabled('tables-v2-api', { userId, orgId })) return null
-  return NextResponse.json({ error: 'Not found' }, { status: 404 })
+  return NextResponse.json(
+    {
+      error: 'The v2 table query API is not enabled for this workspace',
+      code: 'tables_v2_disabled',
+    },
+    { status: 403 }
+  )
 }
 
 /**
diff --git a/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts b/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts
index 4adac12ff2..20bf4ff7e5 100644
--- a/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts
+++ b/apps/sim/app/api/workflows/[id]/execute/route.async.test.ts
@@ -852,8 +852,13 @@ describe('workflow execute async route', () => {
         status: 'pending',
       },
       { id: 'copilot-run-1', userId: 'session-user-1', workflowId: 'workflow-1' },
+      403,
+      'COPILOT_WORKFLOW_TOOL_BINDING_AWAITING_APPROVAL',
     ],
     [
+      // A finished call is a benign duplicate, not a defect: some other runner
+      // already owns this tool call, so it reports the same conflict the
+      // execution claim does and the client stays silent.
       'terminal tool row',
       {
         toolCallId: 'copilot-tool-1',
@@ -863,6 +868,8 @@ describe('workflow execute async route', () => {
         status: 'completed',
       },
       { id: 'copilot-run-1', userId: 'session-user-1', workflowId: 'workflow-1' },
+      409,
+      'COPILOT_WORKFLOW_EXECUTION_CONFLICT',
     ],
     [
       'different workflow target',
@@ -874,6 +881,8 @@ describe('workflow execute async route', () => {
         status: 'running',
       },
       { id: 'copilot-run-1', userId: 'session-user-1', workflowId: 'workflow-1' },
+      403,
+      'COPILOT_WORKFLOW_TOOL_BINDING_WORKFLOW_MISMATCH',
     ],
     [
       'different execution actor',
@@ -885,19 +894,28 @@ describe('workflow execute async route', () => {
         status: 'running',
       },
       { id: 'copilot-run-1', userId: 'other-user', workflowId: 'workflow-1' },
+      403,
+      'COPILOT_WORKFLOW_TOOL_BINDING_FOREIGN_OWNER',
     ],
-  ])('rejects a Copilot binding owned by a %s', async (_caseName, toolCall, run) => {
-    mockGetAsyncToolCall.mockResolvedValueOnce(toolCall)
-    mockGetRunSegment.mockResolvedValueOnce(run)
+    ['missing tool row', null, null, 404, 'COPILOT_WORKFLOW_TOOL_BINDING_UNKNOWN'],
+  ])(
+    'rejects a Copilot binding owned by a %s',
+    async (_caseName, toolCall, run, expectedStatus, expectedCode) => {
+      mockGetAsyncToolCall.mockResolvedValueOnce(toolCall)
+      mockGetRunSegment.mockResolvedValueOnce(run)
 
-    const response = await POST(createBoundCopilotExecutionRequest(), {
-      params: Promise.resolve({ id: 'workflow-1' }),
-    })
+      const response = await POST(createBoundCopilotExecutionRequest(), {
+        params: Promise.resolve({ id: 'workflow-1' }),
+      })
 
-    expect(response.status).toBe(403)
-    expect(mockExecuteWorkflowCore).not.toHaveBeenCalled()
-    expect(loggingSessionMockFns.mockSetTrustedExecutionCorrelation).not.toHaveBeenCalled()
-  })
+      expect(response.status).toBe(expectedStatus)
+      // The reason must be machine-readable — an opaque 403 is what stopped the
+      // client telling a benign duplicate from a real failure.
+      await expect(response.json()).resolves.toMatchObject({ code: expectedCode })
+      expect(mockExecuteWorkflowCore).not.toHaveBeenCalled()
+      expect(loggingSessionMockFns.mockSetTrustedExecutionCorrelation).not.toHaveBeenCalled()
+    }
+  )
 
   it('rejects Copilot workflow bindings outside the interactive SSE surface', async () => {
     const response = await POST(createBoundCopilotExecutionRequest({ stream: false }), {
diff --git a/apps/sim/app/api/workflows/[id]/execute/route.ts b/apps/sim/app/api/workflows/[id]/execute/route.ts
index 53040cb8ed..1370aea868 100644
--- a/apps/sim/app/api/workflows/[id]/execute/route.ts
+++ b/apps/sim/app/api/workflows/[id]/execute/route.ts
@@ -21,7 +21,6 @@ import {
   type BillingAttributionSnapshot,
   requireBillingAttributionHeader,
 } from '@/lib/billing/core/billing-attribution'
-import { isWorkflowToolExecutionClaimable } from '@/lib/copilot/async-runs/lifecycle'
 import {
   claimWorkflowToolExecution,
   getAsyncToolCall,
@@ -29,10 +28,12 @@ import {
   releaseWorkflowToolExecutionClaim,
 } from '@/lib/copilot/async-runs/repository'
 import { COPILOT_WORKFLOW_EXECUTION_CONFLICT_CODE } from '@/lib/copilot/constants'
+import { CopilotDegradedReason } from '@/lib/copilot/generated/trace-attribute-values-v1'
+import { recordDegraded } from '@/lib/copilot/request/metrics'
 import {
   ASYNC_WORKFLOW_DEPLOYMENT_ERRORS,
-  isWorkflowToolName,
-  resolveWorkflowToolTargetId,
+  type CopilotWorkflowToolBindingResult,
+  classifyWorkflowToolBinding,
 } from '@/lib/copilot/tools/workflow-tools'
 import { admissionRejectedResponse, tryAdmit } from '@/lib/core/admission/gate'
 import {
@@ -168,25 +169,19 @@ const SERVER_EXECUTION_ID_CLAIM_ATTEMPTS = 3
 export const runtime = 'nodejs'
 export const dynamic = 'force-dynamic'
 
-async function isValidCopilotWorkflowToolBinding(params: {
+async function resolveCopilotWorkflowToolBinding(params: {
   toolCallId: string
   userId: string
   workflowId: string
-}): Promise<boolean> {
+}): Promise<CopilotWorkflowToolBindingResult> {
   const toolCall = await getAsyncToolCall(params.toolCallId)
-  if (
-    !toolCall ||
-    !isWorkflowToolName(toolCall.toolName) ||
-    !isWorkflowToolExecutionClaimable(toolCall.status, toolCall.permissionDecision)
-  ) {
-    return false
-  }
-
-  const run = await getRunSegment(toolCall.runId)
-  return (
-    run?.userId === params.userId &&
-    resolveWorkflowToolTargetId(toolCall.args, run.workflowId) === params.workflowId
-  )
+  const run = toolCall ? await getRunSegment(toolCall.runId) : null
+  return classifyWorkflowToolBinding({
+    toolCall,
+    run,
+    userId: params.userId,
+    workflowId: params.workflowId,
+  })
 }
 
 function createExecutionJsonResponse(
@@ -1021,18 +1016,29 @@ async function handleExecutePost(
       )
     }
 
-    if (
-      copilotToolCallId &&
-      !(await isValidCopilotWorkflowToolBinding({
+    if (copilotToolCallId) {
+      const binding = await resolveCopilotWorkflowToolBinding({
         toolCallId: copilotToolCallId,
         userId,
         workflowId,
-      }))
-    ) {
-      return NextResponse.json(
-        { error: 'Copilot workflow tool binding was not found' },
-        { status: 403 }
-      )
+      })
+      if (!binding.ok) {
+        // This rejection happens before any LoggingSession exists, so it leaves
+        // no execution log and no workflow span — log the reason or it is
+        // invisible everywhere except the browser console.
+        // This rejection happens before a LoggingSession or any workflow span
+        // exists, so the counter is the only place it becomes visible.
+        recordDegraded(CopilotDegradedReason.BindingRejected)
+        reqLogger.warn('Rejected Copilot workflow tool execution', {
+          copilotToolCallId,
+          workflowId,
+          reason: binding.rejection.code,
+        })
+        return NextResponse.json(
+          { error: binding.rejection.message, code: binding.rejection.code },
+          { status: binding.rejection.statusCode }
+        )
+      }
     }
 
     if (inputFromExecutionId) {
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-find.test.tsx b/apps/sim/app/workspace/[workspaceId]/components/find-bar/find-bar.test.tsx
similarity index 89%
rename from apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-find.test.tsx
rename to apps/sim/app/workspace/[workspaceId]/components/find-bar/find-bar.test.tsx
index f6ef59ecb3..1a4c4db0f1 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-find.test.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/components/find-bar/find-bar.test.tsx
@@ -35,7 +35,10 @@ vi.mock('@sim/emcn/icons', () => ({
   X: () => <span data-icon='x' />,
 }))
 
-import { TableFind, type TableFindProps } from './table-find'
+import {
+  FindBar,
+  type FindBarProps,
+} from '@/app/workspace/[workspaceId]/components/find-bar/find-bar'
 
 let container: HTMLDivElement
 let root: Root
@@ -53,16 +56,15 @@ afterEach(() => {
   container.remove()
 })
 
-function render(overrides: Partial<TableFindProps> = {}) {
-  const props: TableFindProps = {
+function render(overrides: Partial<FindBarProps> = {}) {
+  const props: FindBarProps = {
+    ariaLabel: 'Find in table',
     query: '',
     onQueryChange: vi.fn(),
     onNext: vi.fn(),
     onPrev: vi.fn(),
     onSubmit: vi.fn(),
     onClose: vi.fn(),
-    isStale: false,
-    canNavigate: true,
     count: 0,
     currentIndex: 0,
     truncated: false,
@@ -70,7 +72,7 @@ function render(overrides: Partial<TableFindProps> = {}) {
     inputRef: createRef<HTMLInputElement>(),
     ...overrides,
   }
-  act(() => root.render(<TableFind {...props} />))
+  act(() => root.render(<FindBar {...props} />))
   return props
 }
 
@@ -96,7 +98,7 @@ function press(key: string, init: KeyboardEventInit = {}) {
   })
 }
 
-describe('TableFind counter', () => {
+describe('FindBar counter', () => {
   it('shows nothing before the user has typed', () => {
     render({ query: '' })
     expect(counterText()).toBe('')
@@ -138,7 +140,7 @@ describe('TableFind counter', () => {
   })
 })
 
-describe('TableFind keyboard', () => {
+describe('FindBar keyboard', () => {
   it('navigates on Enter rather than submitting a search', () => {
     const props = render({ query: 'a', count: 3 })
     press('Enter')
@@ -190,9 +192,17 @@ describe('TableFind keyboard', () => {
     expect(props.onSubmit).toHaveBeenCalledTimes(2)
     expect(props.onPrev).not.toHaveBeenCalled()
   })
+
+  // A surface that matches synchronously passes neither flag; Enter must still
+  // step rather than stall on the defaults.
+  it('steps on Enter when the surface declares no staleness model', () => {
+    const props = render({ query: 'a', count: 3, onSubmit: undefined })
+    press('Enter')
+    expect(props.onNext).toHaveBeenCalledTimes(1)
+  })
 })
 
-describe('TableFind controls', () => {
+describe('FindBar controls', () => {
   it('offers a clear button only once there is text', () => {
     render({ query: '' })
     expect(container.querySelector('button[aria-label="Clear search"]')).toBeNull()
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-find.tsx b/apps/sim/app/workspace/[workspaceId]/components/find-bar/find-bar.tsx
similarity index 73%
rename from apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-find.tsx
rename to apps/sim/app/workspace/[workspaceId]/components/find-bar/find-bar.tsx
index a48a7e0122..24008ca1ff 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-find.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/components/find-bar/find-bar.tsx
@@ -5,61 +5,77 @@ import { memo } from 'react'
 import { Button, ChipInput } from '@sim/emcn'
 import { ChevronDown, ChevronUp, Loader, Search, X } from '@sim/emcn/icons'
 
-export interface TableFindProps {
+export interface FindBarProps {
+  /** Accessible name for the input, naming the surface: "Find in table", "Find in files". */
+  ariaLabel: string
   query: string
   onQueryChange: (query: string) => void
   onNext: () => void
   onPrev: () => void
-  /** Adopts the typed term immediately, skipping the debounce. */
-  onSubmit: () => void
   onClose: () => void
-  /** Whether the typed term has yet to be searched, so Enter should commit it. */
-  isStale: boolean
+  /**
+   * Adopts the typed term immediately, skipping the surface's debounce. Only
+   * meaningful on a surface that debounces; omit it and Enter always steps.
+   */
+  onSubmit?: () => void
+  /**
+   * Whether the typed term has yet to be searched, so Enter should commit it
+   * rather than step. Defaults to false — a surface that searches
+   * synchronously is never stale.
+   */
+  isStale?: boolean
   /**
    * Whether the matches on screen belong to the term that was searched. False
    * while a term's own results are in flight, when the count still describes
    * the previous term and stepping through it would land on a cell the box no
-   * longer names.
+   * longer names. Defaults to true for surfaces that match synchronously.
    */
-  canNavigate: boolean
-  /** Number of matches after dropping columns not in the current view. */
+  canNavigate?: boolean
+  /** Number of matches after dropping any the current view cannot show. */
   count: number
   /** 0-based index of the active match. Ignored when `count` is 0. */
   currentIndex: number
-  /** Whether the server capped the match set. */
+  /** Whether the producer capped the match set. */
   truncated: boolean
   isLoading: boolean
   inputRef: React.RefObject<HTMLInputElement | null>
 }
 
 /**
- * Memoized: while the bar is open it is a child of the grid, which re-renders
- * on scroll, hover and selection. Every prop is a primitive or a stable
+ * The find bar every Cmd/Ctrl+F surface shares (tables, files, ...). Purely
+ * presentational and fully controlled: the surface owns the query, the match
+ * model and the stepping; this renders the input, the tally and the
+ * next/prev/close controls. Positioned absolutely against the nearest
+ * relative container, top-right, the way an in-page find sits in Chrome.
+ *
+ * Memoized: while the bar is open it is a child of a view that re-renders on
+ * scroll, hover and selection. Every prop is a primitive or a stable
  * identity, so this collapses to renders where a find value actually changed.
  */
-export const TableFind = memo(function TableFind({
+export const FindBar = memo(function FindBar({
+  ariaLabel,
   query,
   onQueryChange,
   onNext,
   onPrev,
-  onSubmit,
   onClose,
-  isStale,
-  canNavigate,
+  onSubmit,
+  isStale = false,
+  canNavigate = true,
   count,
   currentIndex,
   truncated,
   isLoading,
   inputRef,
-}: TableFindProps) {
+}: FindBarProps) {
   const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
     if (e.key === 'Enter') {
       e.preventDefault()
       // Commit an unsearched term; otherwise step — but only once the results
       // describe it. In between (committed, still loading) Enter does nothing
-      // rather than walk the previous term's matches; the auto-reveal lands on
-      // the first hit as soon as they arrive.
-      if (isStale) onSubmit()
+      // rather than walk the previous term's matches; the surface's auto-reveal
+      // lands on the first hit as soon as they arrive.
+      if (isStale && onSubmit) onSubmit()
       else if (!canNavigate) return
       else if (e.shiftKey) onPrev()
       else onNext()
@@ -89,7 +105,7 @@ export const TableFind = memo(function TableFind({
         ref={inputRef}
         value={query}
         placeholder='Search'
-        aria-label='Find in table'
+        aria-label={ariaLabel}
         spellCheck={false}
         autoComplete='off'
         icon={Search}
diff --git a/apps/sim/app/workspace/[workspaceId]/components/index.ts b/apps/sim/app/workspace/[workspaceId]/components/index.ts
index 2c16cc15fb..95adab9b7b 100644
--- a/apps/sim/app/workspace/[workspaceId]/components/index.ts
+++ b/apps/sim/app/workspace/[workspaceId]/components/index.ts
@@ -6,6 +6,8 @@ export { ResourceNotFound } from '@/app/workspace/[workspaceId]/components/resou
 export { ConversationListItem } from './conversation-list-item'
 export type { ErrorBoundaryProps, ErrorStateProps } from './error'
 export { ErrorShell, ErrorState } from './error'
+export type { FindBarProps } from './find-bar/find-bar'
+export { FindBar } from './find-bar/find-bar'
 export { InlineRenameInput } from './inline-rename-input'
 export { IntegrationTabsHeader } from './integration-tabs-header'
 export { MessageActions } from './message-actions'
@@ -52,4 +54,5 @@ export { selectionLabel } from './resource/selection-label'
 export type { ResourceRowSelection } from './resource/use-resource-row-selection'
 export { useResourceRowSelection } from './resource/use-resource-row-selection'
 export { ResourceTile } from './resource-tile'
+export { SearchHighlight } from './search-highlight/search-highlight'
 export { SkillTile } from './skill-tile'
diff --git a/apps/sim/app/workspace/[workspaceId]/components/resource/resource.tsx b/apps/sim/app/workspace/[workspaceId]/components/resource/resource.tsx
index 5e26ddce69..cf548ac70e 100644
--- a/apps/sim/app/workspace/[workspaceId]/components/resource/resource.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/components/resource/resource.tsx
@@ -31,6 +31,7 @@ import { FloatingOverflowText } from '@/app/workspace/[workspaceId]/components/r
 import type { BreadcrumbDropConfig } from '@/app/workspace/[workspaceId]/components/resource/components/resource-header'
 import { ResourceHeader } from '@/app/workspace/[workspaceId]/components/resource/components/resource-header'
 import { ResourceOptions } from '@/app/workspace/[workspaceId]/components/resource/components/resource-options'
+import { SearchHighlight } from '@/app/workspace/[workspaceId]/components/search-highlight/search-highlight'
 
 export interface ResourceColumn {
   id: string
@@ -72,6 +73,12 @@ export interface ResourceCell {
    * layout, and the rename field replaces the label entirely while it is open.
    */
   pinned?: boolean
+  /**
+   * Find term to tint inside the label (Cmd/Ctrl+F match). Honoured only on the
+   * plain label cell, like `pinned` — a `content` cell owns its own rendering
+   * and the rename field replaces the label while open.
+   */
+  highlight?: string
 }
 
 export interface ResourceRow {
@@ -559,6 +566,7 @@ interface CellContentProps {
   content?: ReactNode
   editing?: ResourceCellEditing
   pinned?: boolean
+  highlight?: string
 }
 
 const CellContent = memo(function CellContent({
@@ -567,6 +575,7 @@ const CellContent = memo(function CellContent({
   content,
   editing,
   pinned,
+  highlight,
 }: CellContentProps) {
   if (editing) {
     return (
@@ -586,7 +595,9 @@ const CellContent = memo(function CellContent({
   return (
     <span className={cn('flex min-w-0 items-center', chipContentGap)}>
       {icon && <span className={cellIconNodeClass}>{icon}</span>}
-      <FloatingOverflowText label={label} className={cn('block', chipContentLabelClass)} />
+      <FloatingOverflowText label={label} className={cn('block', chipContentLabelClass)}>
+        {highlight ? <SearchHighlight text={label} searchQuery={highlight} /> : undefined}
+      </FloatingOverflowText>
       {pinned && (
         <Pin
           className='size-[12px] shrink-0 text-[var(--text-icon)]'
@@ -767,6 +778,7 @@ const DataRow = memo(function DataRow({
               content={cell?.content}
               editing={cell?.editing}
               pinned={cell?.pinned}
+              highlight={cell?.highlight}
             />
           </div>
         )
diff --git a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/search-highlight/search-highlight.tsx b/apps/sim/app/workspace/[workspaceId]/components/search-highlight/search-highlight.tsx
similarity index 100%
rename from apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/search-highlight/search-highlight.tsx
rename to apps/sim/app/workspace/[workspaceId]/components/search-highlight/search-highlight.tsx
diff --git a/apps/sim/app/workspace/[workspaceId]/components/workspace-chrome/workspace-chrome.tsx b/apps/sim/app/workspace/[workspaceId]/components/workspace-chrome/workspace-chrome.tsx
index 38caceaca2..f782b93d2f 100644
--- a/apps/sim/app/workspace/[workspaceId]/components/workspace-chrome/workspace-chrome.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/components/workspace-chrome/workspace-chrome.tsx
@@ -2,7 +2,7 @@
 
 import { useEffect, useLayoutEffect, useRef, useState } from 'react'
 import { cn } from '@sim/emcn'
-import { PanelLeft } from '@sim/emcn/icons'
+import { ArrowLeft, ArrowRight, PanelLeft } from '@sim/emcn/icons'
 import { usePathname } from 'next/navigation'
 import { getDesktopBridge } from '@/lib/desktop'
 import { applyDesktopTitleBarMode, type DesktopTitleBarMode } from '@/app/_shell/desktop-title-bar'
@@ -86,6 +86,69 @@ interface WorkspaceChromeProps {
   initialSidebarCollapsed?: boolean
 }
 
+/** Chromium Navigation API slice (absent from TS lib.dom). */
+type ChromiumNavigation = EventTarget & { canGoBack: boolean; canGoForward: boolean }
+
+const LANE_NAV_BUTTON =
+  'flex size-[var(--desktop-title-bar-control-size)] items-center justify-center rounded-lg transition-colors disabled:pointer-events-none disabled:opacity-40 hover-hover:bg-[var(--surface-active)]'
+const LANE_NAV_ICON = 'size-[var(--desktop-title-bar-control-icon-size)] text-[var(--text-icon)]'
+
+/**
+ * Back/forward history arrows in the desktop title-bar lane, right of the
+ * sidebar toggle. Only the macOS shell sets the inset attribute, so the web
+ * app never shows them; the shell's renderer is Chromium, so the Navigation
+ * API is always there for the arrow state.
+ */
+function TitleBarHistoryNav() {
+  const [can, setCan] = useState({ back: false, forward: false })
+
+  useEffect(() => {
+    const nav = (window as { navigation?: ChromiumNavigation }).navigation
+    if (!nav) return
+    let disposed = false
+    // currententrychange dispatches SYNCHRONOUSLY from the history mutation
+    // that caused it, which can originate inside another component's
+    // useInsertionEffect (style libraries navigate during commit). Scheduling
+    // state there is forbidden ("useInsertionEffect must not schedule
+    // updates"), so the update defers to a microtask, which flushes after
+    // the commit's synchronous work unwinds.
+    const sync = () => {
+      queueMicrotask(() => {
+        if (!disposed) setCan({ back: nav.canGoBack, forward: nav.canGoForward })
+      })
+    }
+    sync()
+    nav.addEventListener('currententrychange', sync)
+    return () => {
+      disposed = true
+      nav.removeEventListener('currententrychange', sync)
+    }
+  }, [])
+
+  return (
+    <div className='absolute top-[var(--desktop-title-bar-control-offset)] left-[calc(var(--desktop-title-bar-inset-x)+var(--desktop-title-bar-control-size)+4px)] z-30 hidden h-[var(--desktop-title-bar-control-size)] items-center gap-[2px] [-webkit-app-region:no-drag] [[data-sim-desktop-title-bar=inset]_&]:flex'>
+      <button
+        type='button'
+        aria-label='Back'
+        disabled={!can.back}
+        onClick={() => window.history.back()}
+        className={LANE_NAV_BUTTON}
+      >
+        <ArrowLeft className={LANE_NAV_ICON} />
+      </button>
+      <button
+        type='button'
+        aria-label='Forward'
+        disabled={!can.forward}
+        onClick={() => window.history.forward()}
+        className={LANE_NAV_BUTTON}
+      >
+        <ArrowRight className={LANE_NAV_ICON} />
+      </button>
+    </div>
+  )
+}
+
 function isFullscreenPath(pathname: string | null): boolean {
   return FULLSCREEN_SUFFIXES.some((s) => pathname?.endsWith(s))
 }
@@ -374,6 +437,7 @@ export function WorkspaceChrome({
           </SidebarTooltip>
         </div>
       )}
+      {!isFullscreen && <TitleBarHistoryNav />}
     </div>
   )
 }
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/chart-preview.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/chart-preview.tsx
new file mode 100644
index 0000000000..b3d4606b95
--- /dev/null
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/chart-preview.tsx
@@ -0,0 +1,178 @@
+'use client'
+
+import { memo, useEffect, useMemo, useRef, useState } from 'react'
+import { getErrorMessage } from '@sim/utils/errors'
+import type { EChartsOption } from 'echarts'
+import { useTheme } from 'next-themes'
+import { buildChartRenderOption } from '@/lib/charts/option'
+import {
+  CHART_ROWS_DEFAULT,
+  CHART_ROWS_MAX,
+  type ChartSpec,
+  mapRowsToColumnNames,
+  parseChartSpec,
+  shapeTableRows,
+} from '@/lib/charts/spec'
+import { useTable, useTableRowsSample } from '@/hooks/queries/tables'
+import { PreviewLoadingFrame } from './preview-shared'
+
+function buildOption(spec: ChartSpec, rows: Array<Record<string, unknown>> | null): EChartsOption {
+  return buildChartRenderOption({ title: spec.title, option: spec.option, rows }) as EChartsOption
+}
+
+function ChartErrorCard({ message, content }: { message: string; content: string }) {
+  return (
+    <div className='overflow-hidden rounded-lg border border-[var(--border)]'>
+      <div className='flex items-center justify-between border-[var(--border)] border-b bg-[var(--surface-3)] px-3 py-1.5'>
+        <span className='text-[11px] text-[var(--text-tertiary)]'>chart</span>
+        <span className='text-[11px] text-[var(--text-muted)]'>{message}</span>
+      </div>
+      <div className='code-editor-theme bg-[var(--surface-5)]'>
+        <pre className='m-0 overflow-x-auto whitespace-pre p-4 font-mono text-[13px] text-[var(--text-primary)] leading-[1.6]'>
+          <code>{content}</code>
+        </pre>
+      </div>
+    </div>
+  )
+}
+
+function ChartErrorPanel({ message, content }: { message: string; content: string }) {
+  return (
+    <div className='min-h-0 flex-1 overflow-auto p-6'>
+      <ChartErrorCard message={message} content={content} />
+    </div>
+  )
+}
+
+type EChartsModule = typeof import('echarts')
+
+/**
+ * Renders a `.chart` document with ECharts, lazy-loading the (heavy) library
+ * on first use. Static sources render inline rows; table sources read the
+ * table live through React Query, so the chart reflects the table's current
+ * data every time it is opened.
+ */
+export const ChartPreview = memo(function ChartPreview({
+  content,
+  workspaceId,
+  isStreaming = false,
+}: {
+  content: string
+  workspaceId: string
+  isStreaming?: boolean
+}) {
+  const containerRef = useRef<HTMLDivElement>(null)
+  const [echartsLib, setEchartsLib] = useState<EChartsModule | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const [renderError, setRenderError] = useState<string | null>(null)
+
+  useEffect(() => {
+    let active = true
+    import('echarts')
+      .then((mod) => {
+        if (active) setEchartsLib(mod)
+      })
+      .catch((e) => {
+        if (active) setLoadError(getErrorMessage(e, 'failed to load the chart renderer'))
+      })
+    return () => {
+      active = false
+    }
+  }, [])
+
+  const { spec, error: parseError } = useMemo(() => parseChartSpec(content), [content])
+
+  const tableSource = spec?.source?.type === 'table' ? spec.source : null
+  const rowsQuery = useTableRowsSample({
+    workspaceId,
+    tableId: tableSource?.tableId,
+    filter: tableSource?.filter,
+    sort: tableSource?.sort,
+    limit: Math.min(tableSource?.limit ?? CHART_ROWS_DEFAULT, CHART_ROWS_MAX),
+    enabled: Boolean(tableSource),
+  })
+  const tableQuery = useTable(tableSource ? workspaceId : undefined, tableSource?.tableId)
+
+  const rows = useMemo(() => {
+    if (!spec) return null
+    if (spec.source?.type === 'static') return spec.source.rows ?? null
+    if (!tableSource) return null
+    const fetched = rowsQuery.data?.rows
+    const columns = tableQuery.data?.schema.columns
+    if (!fetched || !columns) return null
+    return shapeTableRows(mapRowsToColumnNames(fetched, columns), tableSource)
+  }, [spec, tableSource, rowsQuery.data, tableQuery.data])
+
+  const option = useMemo(() => (spec ? buildOption(spec, rows) : null), [spec, rows])
+  /** Stable identity for the effect below — option is a fresh object per memo. */
+  const optionKey = useMemo(() => (option ? JSON.stringify(option) : ''), [option])
+
+  const { resolvedTheme } = useTheme()
+
+  useEffect(() => {
+    setRenderError(null)
+    const el = containerRef.current
+    if (!el || !echartsLib || !option) return
+    const chart = echartsLib.init(el, resolvedTheme === 'dark' ? 'dark' : undefined)
+    try {
+      chart.setOption(option)
+    } catch (e) {
+      setRenderError(getErrorMessage(e, 'invalid ECharts option'))
+      chart.dispose()
+      return
+    }
+    const resizeObserver = new ResizeObserver(() => chart.resize())
+    resizeObserver.observe(el)
+    return () => {
+      resizeObserver.disconnect()
+      chart.dispose()
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [echartsLib, optionKey, resolvedTheme])
+
+  if (parseError) {
+    // A file the agent is still writing is expected to be truncated JSON.
+    if (isStreaming) return <PreviewLoadingFrame className='h-full flex-1' />
+    return <ChartErrorPanel message={parseError} content={content} />
+  }
+  if (loadError) return <ChartErrorPanel message={loadError} content={content} />
+  if (tableSource && rowsQuery.isError) {
+    return (
+      <ChartErrorPanel
+        message={getErrorMessage(rowsQuery.error, 'failed to read the table')}
+        content={content}
+      />
+    )
+  }
+
+  if (tableSource && tableQuery.isError) {
+    return (
+      <ChartErrorPanel
+        message={getErrorMessage(tableQuery.error, 'failed to read the table')}
+        content={content}
+      />
+    )
+  }
+
+  const waitingOnRows = Boolean(tableSource) && rows === null
+  // Width-driven aspect box, not full-bleed: a chart stretched to the whole
+  // panel height is unreadable in a tall resource pane. ECharts follows the
+  // box through the ResizeObserver above.
+  //
+  // A render error (setOption threw) HIDES the chart box rather than
+  // unmounting it: the render effect only re-runs when the option changes,
+  // and it needs the container mounted at that moment to re-initialize —
+  // an unmounted container would leave the fixed chart blank until a
+  // second edit.
+  return (
+    <div className='min-h-0 flex-1 overflow-auto p-6'>
+      {renderError !== null && <ChartErrorCard message={renderError} content={content} />}
+      <div className={renderError !== null ? 'hidden' : 'relative mx-auto w-full max-w-[1024px]'}>
+        {(!echartsLib || waitingOnRows) && (
+          <PreviewLoadingFrame className='absolute inset-0 z-10' />
+        )}
+        <div ref={containerRef} className='aspect-[16/10] min-h-[280px] w-full' />
+      </div>
+    </div>
+  )
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
index 485ebdeda5..4fb3110f96 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-category.ts
@@ -8,6 +8,8 @@ const TEXT_EDITABLE_MIME_TYPES = new Set([
   'application/x-yaml',
   'text/csv',
   'text/html',
+  // Sim pages: internal record type; the file itself is .html.
+  'text/x-sim-page',
   'text/xml',
   'application/xml',
   'text/css',
@@ -20,6 +22,8 @@ const TEXT_EDITABLE_MIME_TYPES = new Set([
   'text/x-sql',
   'image/svg+xml',
   'text/x-mermaid',
+  // Chart documents: declarative ECharts specs rendered live (chart-preview.tsx).
+  'text/x-sim-chart',
 ])
 
 const TEXT_EDITABLE_EXTENSIONS = new Set([
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
index 8fca660715..af49d02047 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel.tsx
@@ -1,23 +1,39 @@
 'use client'
 
 import { memo, useEffect, useMemo, useRef, useState } from 'react'
+import { useRouter } from 'next/navigation'
+import { useTheme } from 'next-themes'
 import '@sim/emcn/components/code/code.css'
 import { CSV_PREVIEW_MAX_ROWS } from '@/lib/api/contracts/workspace-file-table'
 import { getFileExtension } from '@/lib/uploads/utils/file-utils'
+import {
+  SIM_ARTIFACT_SHELL,
+  SIM_ARTIFACT_STYLESHEET,
+  simTokenOverrides,
+  usesSimArtifactStyles,
+} from '@/lib/workspace-files/artifact-stylesheet'
+import { compileSimPage, isSimPageSource } from '@/lib/workspace-files/page-compile'
 import { useHorizontalWheelScroll } from '@/app/workspace/[workspaceId]/files/components/file-viewer/use-horizontal-wheel-scroll'
+import { useWorkspaceFileBinary } from '@/hooks/queries/workspace-files'
+import { ChartPreview } from './chart-preview'
 import { type CsvImportFileDescriptor, useCsvTruncationImport } from './csv-import'
 import { DataTable } from './data-table'
 import { MermaidDiagram } from './mermaid-diagram'
 import { ZoomablePreview } from './zoomable-preview'
 
-type PreviewType = 'markdown' | 'html' | 'csv' | 'svg' | 'mermaid' | null
+type PreviewType = 'markdown' | 'html' | 'csv' | 'svg' | 'mermaid' | 'chart' | null
 
 const PREVIEWABLE_MIME_TYPES: Record<string, PreviewType> = {
+  // Sim pages store an EXTENSIONLESS name — without this mapping the record
+  // type resolves to no preview at all and the viewer renders a blank pane
+  // (including the live compile-as-it-streams view).
+  'text/x-sim-page': 'html',
   'text/markdown': 'markdown',
   'text/html': 'html',
   'text/csv': 'csv',
   'image/svg+xml': 'svg',
   'text/x-mermaid': 'mermaid',
+  'text/x-sim-chart': 'chart',
 }
 
 const PREVIEWABLE_EXTENSIONS: Record<string, PreviewType> = {
@@ -27,6 +43,7 @@ const PREVIEWABLE_EXTENSIONS: Record<string, PreviewType> = {
   csv: 'csv',
   svg: 'svg',
   mmd: 'mermaid',
+  chart: 'chart',
 }
 
 /** All extensions that have a rich preview renderer. */
@@ -66,7 +83,16 @@ export const PreviewPanel = memo(function PreviewPanel({
 }: PreviewPanelProps) {
   const previewType = resolvePreviewType(mimeType, filename)
 
-  if (previewType === 'html') return <HtmlPreview content={content} />
+  if (previewType === 'html')
+    return (
+      <HtmlPreview
+        content={content}
+        isStreaming={isStreaming}
+        workspaceId={workspaceId}
+        fileId={fileId}
+        fileKey={fileKey}
+      />
+    )
   if (previewType === 'csv')
     return (
       <CsvPreview
@@ -79,6 +105,8 @@ export const PreviewPanel = memo(function PreviewPanel({
   if (previewType === 'svg') return <SvgPreview content={content} />
   if (previewType === 'mermaid')
     return <MermaidFilePreview content={content} isStreaming={isStreaming} />
+  if (previewType === 'chart')
+    return <ChartPreview content={content} workspaceId={workspaceId} isStreaming={isStreaming} />
 
   return null
 })
@@ -112,6 +140,12 @@ const HTML_PREVIEW_BOOTSTRAP = `<script>
       const href = anchor.getAttribute('href') || ''
       if (allowHref(href)) return
       event.preventDefault()
+      // The sandbox can neither navigate nor open windows, so hand the click
+      // to the host: workspace routes go through the app router, external
+      // http(s) links open a new tab.
+      if (href.startsWith('/workspace/') || /^https?:\\/\\//i.test(href)) {
+        parent.postMessage({ __simPageNav: href }, '*')
+      }
     },
     true
   )
@@ -127,27 +161,211 @@ const HTML_PREVIEW_BOOTSTRAP = `<script>
 })()
 </script>`
 
-function buildHtmlPreviewDocument(content: string): string {
+function stampTheme(html: string, theme: 'dark' | 'light'): string {
+  if (/<html[\s>]/i.test(html)) {
+    return html.replace(/<html(\s[^>]*)?>/i, (match, attrs: string | undefined) =>
+      /\sdata-theme=/i.test(attrs ?? '') ? match : `<html data-theme="${theme}"${attrs ?? ''}>`
+    )
+  }
+  return html
+}
+
+export function buildHtmlPreviewDocument(
+  content: string,
+  theme: 'dark' | 'light' = 'light',
+  workspaceId?: string
+): string {
+  // The pdf model: a page file STORES its source (frontmatter + markdown +
+  // sim: fences) and every rendering surface compiles on demand. Partial
+  // source mid-stream compiles too, so the page builds up live as the agent
+  // appends. Raw HTML (bespoke and legacy stored-compiled pages) skips this.
+  if (isSimPageSource(content)) {
+    content = compileSimPage(content, { workspaceId })
+  }
   const headInjection = [
     '<meta charset="utf-8">',
     `<base href="${HTML_PREVIEW_BASE_URL}">`,
     `<meta http-equiv="Content-Security-Policy" content="${HTML_PREVIEW_CSP}">`,
+    // Ahead of the page's own <style>, so anything it declares still wins. The
+    // token overrides follow the sheet so the app's live values beat its
+    // fallbacks, and the shell follows both.
+    usesSimArtifactStyles(content)
+      ? `<style>${SIM_ARTIFACT_STYLESHEET}</style><style>${simTokenOverrides(theme)}</style>${SIM_ARTIFACT_SHELL}`
+      : '',
     HTML_PREVIEW_BOOTSTRAP,
   ].join('')
 
   if (/<head[\s>]/i.test(content)) {
-    return content.replace(/<head(\s[^>]*)?>/i, (match) => `${match}${headInjection}`)
+    return stampTheme(
+      content.replace(/<head(\s[^>]*)?>/i, (match) => `${match}${headInjection}`),
+      theme
+    )
   }
 
   if (/<html[\s>]/i.test(content)) {
-    return content.replace(/<html(\s[^>]*)?>/i, (match) => `${match}<head>${headInjection}</head>`)
+    return stampTheme(
+      content.replace(/<html(\s[^>]*)?>/i, (match) => `${match}<head>${headInjection}</head>`),
+      theme
+    )
   }
 
-  return `<!DOCTYPE html><html><head>${headInjection}</head><body>${content}</body></html>`
+  return `<!DOCTYPE html><html data-theme="${theme}"><head>${headInjection}</head><body>${content}</body></html>`
 }
 
-const HtmlPreview = memo(function HtmlPreview({ content }: { content: string }) {
-  const wrappedContent = buildHtmlPreviewDocument(content)
+/**
+ * Batches iframe content updates while an agent streams. Every content change
+ * replaces the srcDoc (a full document reload), so applying each chunk as it
+ * arrives would reload the page several times a second; ~2s batches keep the
+ * growing page readable. Off-stream, the live value passes straight through.
+ */
+function useStreamBatchedValue(value: string, streaming: boolean, intervalMs: number): string {
+  const [batched, setBatched] = useState(value)
+  const lastAppliedAtRef = useRef(0)
+  useEffect(() => {
+    if (!streaming) {
+      lastAppliedAtRef.current = 0
+      setBatched(value)
+      return
+    }
+    const elapsed = Date.now() - lastAppliedAtRef.current
+    if (elapsed >= intervalMs) {
+      lastAppliedAtRef.current = Date.now()
+      setBatched(value)
+      return
+    }
+    const timer = setTimeout(() => {
+      lastAppliedAtRef.current = Date.now()
+      setBatched(value)
+    }, intervalMs - elapsed)
+    return () => clearTimeout(timer)
+  }, [value, streaming, intervalMs])
+  return streaming ? batched : value
+}
+
+/**
+ * The sandboxed frame carries no cookies, so a workspace image
+ * (`/api/files/view/<id>`, what `![alt](sim:file/<id>)` compiles to) would
+ * 401 inside it. The host fetches the bytes with its own session and hands
+ * the frame blob: URLs, which the preview CSP already allows.
+ */
+function useInlinedWorkspaceImages(content: string): string {
+  const [resolved, setResolved] = useState<Record<string, string>>({})
+  const cacheRef = useRef<Map<string, string> | null>(null)
+  cacheRef.current ??= new Map()
+  useEffect(() => {
+    const cache = cacheRef.current
+    if (!cache) return
+    const urls = [...content.matchAll(/src="(\/api\/files\/view\/[^"]+)"/g)].map((m) => m[1])
+    const missing = [...new Set(urls)].filter((url) => !cache.has(url))
+    if (missing.length === 0) return
+    let cancelled = false
+    for (const url of missing) {
+      // boundary-raw-fetch: binary image bytes for the cookie-less sandboxed preview
+      fetch(url)
+        .then((response) => (response.ok ? response.blob() : null))
+        .then(
+          (blob) =>
+            new Promise<string | null>((resolve) => {
+              if (!blob) return resolve(null)
+              // data: URIs, NOT blob: URLs — blob URLs are origin-bound and
+              // the sandboxed frame's origin is opaque, so Chromium refuses
+              // to render a parent-origin blob inside it. data: is
+              // origin-independent and already allowed by the preview CSP.
+              const reader = new FileReader()
+              reader.onload = () =>
+                resolve(typeof reader.result === 'string' ? reader.result : null)
+              reader.onerror = () => resolve(null)
+              reader.readAsDataURL(blob)
+            })
+        )
+        .then((dataUri) => {
+          if (!dataUri || cancelled) return
+          cache.set(url, dataUri)
+          setResolved((prev) => ({ ...prev, [url]: dataUri }))
+        })
+        .catch(() => {})
+    }
+    return () => {
+      cancelled = true
+    }
+  }, [content])
+  return useMemo(
+    () =>
+      content.replace(/src="(\/api\/files\/view\/[^"]+)"/g, (match, url: string) => {
+        const blobUrl = cacheRef.current?.get(url) ?? resolved[url]
+        return blobUrl ? `src="${blobUrl}"` : match
+      }),
+    [content, resolved]
+  )
+}
+
+const HtmlPreview = memo(function HtmlPreview({
+  content,
+  isStreaming,
+  workspaceId,
+  fileId,
+  fileKey,
+}: {
+  content: string
+  isStreaming?: boolean
+  workspaceId?: string
+  fileId?: string
+  fileKey?: string
+}) {
+  const { resolvedTheme } = useTheme()
+  const router = useRouter()
+  const batchedContent = useStreamBatchedValue(content, isStreaming === true, 2000)
+  // A SAVED sim page prefers the server-compiled document — the pptx/docx
+  // model: the serve route resolves chart references (reading a table's
+  // CURRENT rows under the viewer's authorization) and inlines the chart
+  // runtime, and reopening/refocusing refetches, so the page recompiles on
+  // reload. While it loads — and always while streaming/editing — the client
+  // compile below stands in, with chart figures as placeholders.
+  const isSavedPage =
+    Boolean(fileId && fileKey && workspaceId) && isStreaming !== true && isSimPageSource(content)
+  const served = useWorkspaceFileBinary(workspaceId ?? '', fileId ?? '', fileKey ?? '', {
+    enabled: isSavedPage,
+  })
+  const servedHtml = useMemo(
+    () => (isSavedPage && served.data ? new TextDecoder().decode(served.data) : null),
+    [isSavedPage, served.data]
+  )
+  const builtContent = buildHtmlPreviewDocument(
+    servedHtml ?? batchedContent,
+    resolvedTheme === 'dark' ? 'dark' : 'light',
+    workspaceId
+  )
+  // AFTER the build: workspace image srcs (/api/files/view/…) only exist in
+  // the COMPILED document — the raw source says sim:file/… — so substituting
+  // the host-fetched blob: URLs must run on the built output, or the
+  // sandboxed (cookie-less) frame 401s every image.
+  const wrappedContent = useInlinedWorkspaceImages(builtContent)
+
+  // Receives sim-resource link clicks bridged out of the sandboxed page and
+  // routes them in the app. Only workspace-internal paths are honored.
+  useEffect(() => {
+    const onMessage = (event: MessageEvent) => {
+      const href = (event.data as { __simPageNav?: unknown } | null)?.__simPageNav
+      if (typeof href !== 'string') return
+      if (href.startsWith('/workspace/')) {
+        router.push(href)
+      } else if (/^https?:\/\//i.test(href)) {
+        // The server-compiled document absolutizes workspace links (so a
+        // DOWNLOADED copy reaches Sim) — recognize our own origin and route
+        // in-app rather than spawning a new tab of the whole app.
+        try {
+          const url = new URL(href)
+          if (url.origin === window.location.origin && url.pathname.startsWith('/workspace/')) {
+            router.push(`${url.pathname}${url.search}${url.hash}`)
+            return
+          }
+        } catch {}
+        window.open(href, '_blank', 'noopener,noreferrer')
+      }
+    }
+    window.addEventListener('message', onMessage)
+    return () => window.removeEventListener('message', onMessage)
+  }, [router])
   const containerRef = useRef<HTMLDivElement>(null)
   const [isRenderable, setIsRenderable] = useState(false)
   const [resumeNonce, setResumeNonce] = useState(0)
diff --git a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor.tsx b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor.tsx
index ac323e27f2..4405280ff5 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/text-editor.tsx
@@ -11,6 +11,7 @@ import {
 } from '@/lib/copilot/chat/selection-context'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
 import { getFileExtension } from '@/lib/uploads/utils/file-utils'
+import { isSimPageSource, SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
 import { useAddToChat } from '@/hooks/use-add-to-chat'
 import type { ChatContext } from '@/stores/panel'
 import { EditorContextMenu } from './editor-context-menu'
@@ -20,6 +21,9 @@ import { PreviewLoadingFrame } from './preview-shared'
 import { useEditableFileContent } from './use-editable-file-content'
 import { useSelectionCopyBridge } from './use-selection-copy-bridge'
 
+/** File ids observed rendering as Sim pages this session (see the sticky lock). */
+const KNOWN_PAGE_FILE_IDS = new Set<string>()
+
 const SIM_DARK_RULES: MonacoEditorTypes.ITokenThemeRule[] = [
   { token: 'comment', foreground: '606060', fontStyle: 'italic' },
   { token: 'string', foreground: '3ab872' },
@@ -584,7 +588,32 @@ export const TextEditor = memo(function TextEditor({
 
   const previewType = resolvePreviewType(file.type, file.name)
   const isIframeRendered = previewType === 'html' || previewType === 'svg'
-  const effectiveMode = isStreaming && isIframeRendered ? 'editor' : previewMode
+  // A Sim page NEVER shows its source here — the pdf model: the rendered
+  // document is the file's face on every surface, at every moment. The
+  // record's internal type decides instantly (stamped at write, known before
+  // content loads); content detection is the fallback for files written
+  // before the stamp existed. During the very first streamed chunk even the
+  // frontmatter is partial, so an html stream that has not yet contradicted
+  // the page shape (empty, or an opening '---') already counts — that kills
+  // the raw-header flash at stream start and the raw flips between an
+  // agent's tool calls. Bespoke raw HTML keeps the old behavior.
+  const trimmedContent = content.trimStart()
+  const detectedSimPage =
+    file.type === SIM_PAGE_CONTENT_TYPE ||
+    (previewType === 'html' &&
+      (isSimPageSource(content) ||
+        (isStreaming && (trimmedContent === '' || trimmedContent.startsWith('-')))))
+  // Sticky per file: a PATCH stream carries only the replacement snippet,
+  // which is not frontmatter-shaped — without memory the lock would drop
+  // mid-edit and flash raw source. Once a file is known to be a page, it
+  // stays one for the session.
+  if (detectedSimPage) KNOWN_PAGE_FILE_IDS.add(file.id)
+  const isSimPageFile = detectedSimPage || KNOWN_PAGE_FILE_IDS.has(file.id)
+  const effectiveMode = isSimPageFile
+    ? 'preview'
+    : isStreaming && isIframeRendered
+      ? 'editor'
+      : previewMode
   const showEditor = effectiveMode !== 'preview'
   const showPreviewPane = effectiveMode !== 'editor'
 
diff --git a/apps/sim/app/workspace/[workspaceId]/files/files.tsx b/apps/sim/app/workspace/[workspaceId]/files/files.tsx
index 79f96559e3..71800c82e2 100644
--- a/apps/sim/app/workspace/[workspaceId]/files/files.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/files/files.tsx
@@ -47,18 +47,21 @@ import {
   SUPPORTED_IMAGE_EXTENSIONS,
   SUPPORTED_VIDEO_EXTENSIONS,
 } from '@/lib/uploads/utils/validation'
+import { SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
 import type {
   BreadcrumbItem,
   FilterTag,
   ResourceAction,
   ResourceColumn,
   ResourceRow,
+  ResourceTableHandle,
   SearchConfig,
   SortConfig,
 } from '@/app/workspace/[workspaceId]/components'
 import {
   EMPTY_CELL_PLACEHOLDER,
   FILTER_SECTION_LABEL_CLASS,
+  FindBar,
   OwnerAvatar,
   ownerCell,
   Resource,
@@ -222,11 +225,13 @@ const MIME_TYPE_LABELS: Record<string, string> = {
   'text/csv': 'CSV',
   'text/plain': 'Text',
   'text/html': 'HTML',
+  'text/x-sim-page': 'Page',
   'text/markdown': 'Markdown',
 }
 
 const EMPTY_WORKSPACE_FILES: WorkspaceFileRecord[] = []
 const EMPTY_WORKSPACE_FILE_FOLDERS: WorkspaceFileFolderApi[] = []
+const EMPTY_FIND_MATCH_IDS: readonly string[] = Object.freeze([])
 
 const hasExternalFiles = (dataTransfer: DataTransfer): boolean =>
   dataTransfer.types.includes('Files')
@@ -780,6 +785,79 @@ export function Files() {
     })
   }, [baseRows, listRename.editingId, listRename.editValue, listRename.isSaving])
 
+  // Find (Cmd/Ctrl+F): the shared find bar over the visible list, stepping
+  // through rows whose name matches. The list is client-side, so matching is
+  // synchronous — no debounce or loading states.
+  const [findOpen, setFindOpen] = useState(false)
+  const [findQuery, setFindQuery] = useState('')
+  const [findIndex, setFindIndex] = useState(0)
+  const findInputRef = useRef<HTMLInputElement>(null)
+  const tableApiRef = useRef<ResourceTableHandle | null>(null)
+
+  const trimmedFindQuery = findQuery.trim().toLowerCase()
+  const findMatchIds = useMemo<readonly string[]>(() => {
+    if (!findOpen || trimmedFindQuery.length === 0) return EMPTY_FIND_MATCH_IDS
+    const ids = rows
+      .filter((row) => (row.cells.name?.label ?? '').toLowerCase().includes(trimmedFindQuery))
+      .map((row) => row.id)
+    return ids.length > 0 ? ids : EMPTY_FIND_MATCH_IDS
+  }, [rows, findOpen, trimmedFindQuery])
+  const findMatchIdsRef = useRef(findMatchIds)
+  findMatchIdsRef.current = findMatchIds
+  const findIndexRef = useRef(findIndex)
+  findIndexRef.current = findIndex
+
+  const goToFindMatch = useCallback((index: number) => {
+    const matches = findMatchIdsRef.current
+    if (matches.length === 0) return
+    const wrapped = ((index % matches.length) + matches.length) % matches.length
+    setFindIndex(wrapped)
+    tableApiRef.current?.scrollToRow(matches[wrapped])
+  }, [])
+
+  /**
+   * A new term resets to and reveals its first match. Keyed on the term, not
+   * the match set: rows regenerate on renames, uploads and SSE refreshes, and
+   * re-revealing then would yank a user who has stepped elsewhere back to
+   * match one.
+   */
+  useEffect(() => {
+    setFindIndex(0)
+    if (trimmedFindQuery.length === 0) return
+    const first = findMatchIdsRef.current[0]
+    if (first) tableApiRef.current?.scrollToRow(first)
+  }, [trimmedFindQuery])
+
+  const handleFindNext = useCallback(() => {
+    goToFindMatch(findIndexRef.current + 1)
+  }, [goToFindMatch])
+
+  const handleFindPrev = useCallback(() => {
+    goToFindMatch(findIndexRef.current - 1)
+  }, [goToFindMatch])
+
+  /** Closing clears the search: term, highlights and cursor all go. */
+  const handleFindClose = useCallback(() => {
+    setFindOpen(false)
+    setFindQuery('')
+    setFindIndex(0)
+  }, [])
+
+  /**
+   * Rows for the table, with the active term tinted into matching name cells.
+   * Layered over `rows` so selection, drag-drop and keyboard nav keep reading
+   * the canonical list.
+   */
+  const displayRows: ResourceRow[] = useMemo(() => {
+    if (findMatchIds.length === 0) return rows
+    const matchSet = new Set(findMatchIds)
+    return rows.map((row) =>
+      matchSet.has(row.id)
+        ? { ...row, cells: { ...row.cells, name: { ...row.cells.name, highlight: findQuery } } }
+        : row
+    )
+  }, [rows, findMatchIds, findQuery])
+
   const visibleRowIds = useMemo(() => rows.map((row) => row.id), [rows])
 
   const {
@@ -1445,6 +1523,71 @@ export function Files() {
     return () => window.removeEventListener('keydown', handleKeyDown)
   }, [handleSave])
 
+  const selectedRowIdsRef = useRef(selectedRowIds)
+  selectedRowIdsRef.current = selectedRowIds
+  const visibleRowIdsRef = useRef(visibleRowIds)
+  visibleRowIdsRef.current = visibleRowIds
+  const listRenameActiveRef = useRef(listRename.editingId)
+  listRenameActiveRef.current = listRename.editingId
+  const handleBulkDeleteRef = useRef(handleBulkDelete)
+  handleBulkDeleteRef.current = handleBulkDelete
+
+  useEffect(() => {
+    const handleListKeyDown = (e: KeyboardEvent) => {
+      if (fileIdFromRouteRef.current) return
+      const active = document.activeElement
+      if (
+        active &&
+        (active.tagName === 'INPUT' ||
+          active.tagName === 'TEXTAREA' ||
+          (active as HTMLElement).isContentEditable)
+      )
+        return
+      if (listRenameActiveRef.current) return
+
+      if ((e.key === 'Delete' || e.key === 'Backspace') && selectedRowIdsRef.current.size > 0) {
+        e.preventDefault()
+        handleBulkDeleteRef.current()
+        return
+      }
+
+      if (e.key === 'Escape' && selectedRowIdsRef.current.size > 0) {
+        e.preventDefault()
+        clearSelection()
+        return
+      }
+
+      if ((e.metaKey || e.ctrlKey) && e.key === 'a' && visibleRowIdsRef.current.length > 0) {
+        e.preventDefault()
+        replaceSelection(visibleRowIdsRef.current)
+      }
+    }
+    window.addEventListener('keydown', handleListKeyDown)
+    return () => window.removeEventListener('keydown', handleListKeyDown)
+  }, [])
+
+  /**
+   * Overrides the browser's Cmd/Ctrl+F with the in-list find while the list is
+   * showing. Skipped when a file is open — its editor owns the shortcut there —
+   * and when another surface already claimed the press.
+   */
+  useEffect(() => {
+    const handleFindShortcut = (e: KeyboardEvent) => {
+      if (!(e.metaKey || e.ctrlKey) || e.altKey || e.shiftKey) return
+      if (e.key.toLowerCase() !== 'f') return
+      if (fileIdFromRouteRef.current) return
+      if (e.defaultPrevented) return
+      e.preventDefault()
+      setFindOpen(true)
+      requestAnimationFrame(() => {
+        findInputRef.current?.focus()
+        findInputRef.current?.select()
+      })
+    }
+    document.addEventListener('keydown', handleFindShortcut)
+    return () => document.removeEventListener('keydown', handleFindShortcut)
+  }, [])
+
   const handleCyclePreviewMode = useCallback(() => {
     setPreviewMode((prev) => {
       if (prev === 'editor') return 'split'
@@ -1466,8 +1609,10 @@ export function Files() {
     const canPreview = isPreviewable(selectedFile) && !streamOnly
     // Markdown renders in the single-surface inline editor, which has no raw/split/preview modes.
     const isInlineMarkdown = isMarkdownFile(selectedFile)
-    const hasSplitView = canEditText && canPreview && !isInlineMarkdown
-    const showPreviewToggle = canPreview && !isInlineMarkdown
+    // A Sim page is locked to its rendered view — no code view to toggle to.
+    const isSimPage = selectedFile.type === SIM_PAGE_CONTENT_TYPE
+    const hasSplitView = canEditText && canPreview && !isInlineMarkdown && !isSimPage
+    const showPreviewToggle = canPreview && !isInlineMarkdown && !isSimPage
 
     const nextModeLabel =
       previewMode === 'editor' ? 'Split' : previewMode === 'split' ? 'Preview' : 'Edit'
@@ -2019,7 +2164,8 @@ export function Files() {
         />
         <Resource.Table
           columns={isSearching ? SEARCH_COLUMNS : COLUMNS}
-          rows={rows}
+          rows={displayRows}
+          apiRef={tableApiRef}
           emptyState={
             listState === 'empty' ? (
               <FilesEmptyState
@@ -2040,6 +2186,21 @@ export function Files() {
           onRowContextMenu={handleRowContextMenu}
           overlay={
             <>
+              {findOpen && (
+                <FindBar
+                  ariaLabel='Find in files'
+                  query={findQuery}
+                  onQueryChange={setFindQuery}
+                  onNext={handleFindNext}
+                  onPrev={handleFindPrev}
+                  onClose={handleFindClose}
+                  count={findMatchIds.length}
+                  currentIndex={Math.min(findIndex, Math.max(0, findMatchIds.length - 1))}
+                  truncated={false}
+                  isLoading={false}
+                  inputRef={findInputRef}
+                />
+              )}
               <ResourceActionBar
                 selectedCount={selectedRowIds.size}
                 onDownload={handleBulkDownload}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.test.ts
index 4808893b4e..42f0e367ad 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.test.ts
@@ -213,6 +213,13 @@ describe('AgentGroup browser takeover', () => {
     })
 
     expect(container.querySelector('.animate-stream-fade-in')).toBeNull()
+    // Groups never auto-expand: the answered question lives inside the
+    // collapsed log until the user opens it manually.
+    const headerToggle = container.querySelector('button[class*="group/agent"]')
+    expect(headerToggle).not.toBeNull()
+    act(() => {
+      headerToggle?.dispatchEvent(new MouseEvent('click', { bubbles: true }))
+    })
     const resumedLog = container.querySelector('[data-state="open"]')
     const answeredQuestion = container.querySelector('[data-takeover-answer="true"]')
     expect(answeredQuestion?.textContent).toContain(reason)
@@ -222,3 +229,77 @@ describe('AgentGroup browser takeover', () => {
     act(() => root.unmount())
   })
 })
+
+describe('AgentGroup nested status line', () => {
+  let container: HTMLDivElement
+  let root: Root
+
+  beforeEach(() => {
+    container = document.createElement('div')
+    document.body.appendChild(container)
+    root = createRoot(container)
+  })
+
+  afterEach(() => {
+    act(() => root.unmount())
+    container.remove()
+  })
+
+  const namedTool = (
+    displayTitle: string,
+    status: ToolCallStatus,
+    startedAt?: number
+  ): AgentGroupItem => ({
+    type: 'tool',
+    data: {
+      id: `${displayTitle}-${startedAt ?? 0}`,
+      toolName: 'grep',
+      displayTitle,
+      status,
+      startedAt,
+    },
+  })
+
+  const render = (items: AgentGroupItem[]) => {
+    act(() => {
+      root.render(
+        createElement(AgentGroup, {
+          agentName: 'workflow',
+          agentLabel: 'Workflow Agent',
+          items,
+          isStreaming: true,
+          isLaneOpen: true,
+        })
+      )
+    })
+    return container.textContent ?? ''
+  }
+
+  it("shows a nested agent's running tool instead of the parent's finished one", () => {
+    const header = render([
+      namedTool('Reading workflow', 'success' as ToolCallStatus, 1),
+      group([namedTool('Deploying Invoice Sync as API', 'executing' as ToolCallStatus, 2)]),
+    ])
+    expect(header).toContain('Workflow Agent — Deploying Invoice Sync as API')
+  })
+
+  it('counts running tools across depths with the + n suffix', () => {
+    const header = render([
+      namedTool('Reading workflow', 'executing' as ToolCallStatus, 1),
+      group([
+        namedTool('Deploying Invoice Sync as API', 'executing' as ToolCallStatus, 3),
+        namedTool('Checking deployment status', 'executing' as ToolCallStatus, 2),
+      ]),
+    ])
+    // Latest start wins; the other two running become the overflow count.
+    expect(header).toContain('Deploying Invoice Sync as API + 2')
+  })
+
+  it('falls back to the last tool at any depth when nothing is running', () => {
+    const header = render([
+      namedTool('Reading workflow', 'success' as ToolCallStatus, 1),
+      group([namedTool('Deploying Invoice Sync as API', 'success' as ToolCallStatus, 2)]),
+    ])
+    expect(header).toContain('Workflow Agent — Deploying Invoice Sync as API')
+  })
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
index 103e6ba6e4..f454093ca9 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/agent-group.tsx
@@ -1,10 +1,10 @@
 'use client'
 
-import { useEffect, useLayoutEffect, useRef, useState } from 'react'
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { ChevronDown, cn, Expandable, ExpandableContent } from '@sim/emcn'
 import { ShimmerText } from '@/components/ui'
 import { isBrowserAgentAvailable } from '@/lib/browser-agent/transport'
-import { BrowserRequestTakeover } from '@/lib/copilot/generated/tool-catalog-v1'
+import { RETIRED_BROWSER_REQUEST_TAKEOVER_ID } from '@/lib/copilot/tools/retired-tools'
 import { useSmoothText } from '@/hooks/use-smooth-text'
 import { type ToolCallData, ToolCallStatus } from '../../../../types'
 import { getAgentIcon, isToolDone } from '../../utils'
@@ -43,6 +43,27 @@ interface AgentGroupProps {
   isLaneOpen?: boolean
 }
 
+function toolStatusTitle(tool: ToolCallData): string {
+  return tool.displayTitle || String(tool.toolName ?? '')
+}
+
+/**
+ * Every tool in a group, in stream order, including those run by nested
+ * agents. A parent's status line speaks for the whole subtree it delegated,
+ * so a grandchild's work is what surfaces while the parent itself waits.
+ */
+function collectGroupTools(items: AgentGroupItem[]): ToolCallData[] {
+  const tools: ToolCallData[] = []
+  const walk = (list: AgentGroupItem[]) => {
+    for (const item of list) {
+      if (item.type === 'tool') tools.push(item.data)
+      else if (item.type === 'agent_group') walk(item.group.items)
+    }
+  }
+  walk(items)
+  return tools
+}
+
 /** True when any row in this group (or a nested one) is waiting on a permission decision. */
 function hasAwaitingApproval(items: AgentGroupItem[]): boolean {
   return items.some((item) => {
@@ -63,7 +84,7 @@ function getActiveBrowserTakeover(items: AgentGroupItem[]): ActiveBrowserTakeove
     const item = items[index]
     if (item.type !== 'tool') continue
     if (
-      item.data.toolName === BrowserRequestTakeover.id &&
+      item.data.toolName === RETIRED_BROWSER_REQUEST_TAKEOVER_ID &&
       item.data.status === ToolCallStatus.executing
     ) {
       const reason = item.data.params?.reason
@@ -114,6 +135,30 @@ export function AgentGroup({
   isLaneOpen = false,
 }: AgentGroupProps) {
   const AgentIcon = getAgentIcon(agentName)
+  const isMainAgent = agentName === 'mothership'
+  // Collapsed status line: the latest tool call, always in its RUNNING
+  // phrasing — it never flips to the completed rewrite (that lives in the
+  // expanded log). Work delegated further down bubbles up, so a group whose
+  // own turn is idle still narrates what its nested agent is doing rather
+  // than freezing on its last own tool. With several tools running at any
+  // depth, the most recently started wins and the rest become "+ n"; between
+  // rounds the last tool's title stays frozen; a closed lane shows the bare
+  // name.
+  const status = useMemo(() => {
+    if (isMainAgent || !isLaneOpen) return undefined
+    const tools = collectGroupTools(items)
+    const running = tools.filter((tool) => tool.status === ToolCallStatus.executing)
+    if (running.length > 0) {
+      const latest = running.reduce((newest, tool) =>
+        (tool.startedAt ?? 0) >= (newest.startedAt ?? 0) ? tool : newest
+      )
+      const title = toolStatusTitle(latest)
+      return running.length > 1 ? `${title} + ${running.length - 1}` : title
+    }
+    const last = tools.at(-1)
+    return last ? toolStatusTitle(last) : undefined
+  }, [isLaneOpen, isMainAgent, items])
+  const headerText = status ? `${agentLabel} — ${status}` : agentLabel
   const hasItems = items.length > 0
   const resolved = isAgentGroupResolved(items)
   const browserAgentAvailable = isBrowserAgentAvailable()
@@ -123,17 +168,13 @@ export function AgentGroup({
   const isWorking =
     !activeBrowserTakeover && ((isDelegating && !resolved) || (isStreaming && isLaneOpen))
 
-  // Expand while the turn is live and any of: the lane is open (the subagent is
-  // actively running), this is the current/latest section, or there is unresolved
-  // work. A finished group stays open until the NEXT section starts (it is no
-  // longer the latest), instead of collapsing the instant its own work resolves.
-  // Keying "still running" off the lane-open signal (not `resolved` alone) avoids
-  // a collapse/reopen flicker on parallel siblings: a subagent's tools all
-  // momentarily read "done" in the gap between its last search and its `respond`
-  // ("Gathering thoughts") tool, transiently flipping `resolved` true; the open
-  // lane bridges that gap so the row never collapses mid-run. The turn ending
-  // (isStreaming false) collapses everything; a manual toggle pins the choice.
-  const autoExpanded = isStreaming && (isCurrentSection || isLaneOpen || !resolved)
+  // SUBAGENT groups never auto-expand: the collapsed row IS the live view —
+  // label plus latest running tool title. Expanding is a deliberate user
+  // action; only a pending permission prompt or a browser hand-back forces
+  // one open. The MAIN lane ("Sim") is not a delegation card: its narration
+  // and tool calls are the turn itself, so it keeps the original live-expand
+  // behavior (open while streaming/current, settles when superseded).
+  const autoExpanded = isMainAgent && isStreaming && (isCurrentSection || isLaneOpen || !resolved)
   const [manualExpanded, setManualExpanded] = useState<boolean | null>(null)
   const [expandedTakeoverId, setExpandedTakeoverId] = useState<string | null>(null)
   // An outstanding permission prompt overrides a manual collapse: the turn
@@ -160,32 +201,32 @@ export function AgentGroup({
         <button
           type='button'
           onClick={toggleExpanded}
-          className='group/agent flex cursor-pointer items-center gap-2'
+          className='group/agent flex w-full min-w-0 cursor-pointer items-center gap-2 text-left'
         >
           <div className='flex size-[16px] flex-shrink-0 items-center justify-center'>
             <AgentIcon className='size-[16px] text-[var(--text-icon)]' />
           </div>
           {isWorking ? (
-            <ShimmerText className='text-sm'>{agentLabel}</ShimmerText>
+            <ShimmerText className='min-w-0 truncate text-sm'>{headerText}</ShimmerText>
           ) : (
-            <span className='text-[var(--text-body)] text-sm'>{agentLabel}</span>
+            <span className='min-w-0 truncate text-[var(--text-body)] text-sm'>{headerText}</span>
           )}
           <ChevronDown
             className={cn(
-              'size-[14px] text-[var(--text-icon)] opacity-0 transition-[transform,opacity] duration-150 group-hover/agent:opacity-100 group-focus-visible/agent:opacity-100',
+              'size-[14px] flex-shrink-0 text-[var(--text-icon)] opacity-0 transition-[transform,opacity] duration-150 group-hover/agent:opacity-100 group-focus-visible/agent:opacity-100',
               !expanded && '-rotate-90'
             )}
           />
         </button>
       ) : (
-        <div className='flex items-center gap-2'>
+        <div className='flex min-w-0 items-center gap-2'>
           <div className='flex size-[16px] flex-shrink-0 items-center justify-center'>
             <AgentIcon className='size-[16px] text-[var(--text-icon)]' />
           </div>
           {isWorking ? (
-            <ShimmerText className='text-sm'>{agentLabel}</ShimmerText>
+            <ShimmerText className='min-w-0 truncate text-sm'>{headerText}</ShimmerText>
           ) : (
-            <span className='text-[var(--text-body)] text-sm'>{agentLabel}</span>
+            <span className='min-w-0 truncate text-[var(--text-body)] text-sm'>{headerText}</span>
           )}
         </div>
       )}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
index d03f52d0cc..f9fb73b92e 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/agent-group/tool-call-item.tsx
@@ -2,14 +2,14 @@ import { useEffect, useMemo, useState } from 'react'
 import { isPlainRecord } from '@sim/utils/object'
 import { ShimmerText } from '@/components/ui'
 import {
-  BrowserRequestTakeover,
   CallIntegrationTool,
+  PrepareFileEdit,
   Read as ReadTool,
   Terminal as TerminalTool,
   Wait as WaitTool,
-  WorkspaceFile,
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import { getReadTargetBlock } from '@/lib/copilot/tools/client/read-block'
+import { RETIRED_BROWSER_REQUEST_TAKEOVER_ID } from '@/lib/copilot/tools/retired-tools'
 import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { getToolStatusDisplayTitle, getWaitCountdownTitle } from '@/lib/copilot/tools/tool-display'
 import { BrandIcon } from '@/blocks/brand-icon'
@@ -138,7 +138,7 @@ export function ToolCallItem({
   }, [toolName, params, streamingArgs])
 
   const liveWorkspaceFileTitle = useMemo(() => {
-    if (toolName !== WorkspaceFile.id || !streamingArgs) return null
+    if (toolName !== PrepareFileEdit.id || !streamingArgs) return null
     const titleMatch = streamingArgs.match(/"title"\s*:\s*"([^"]+)"/)
     if (!titleMatch?.[1]) return null
     const opMatch = streamingArgs.match(/"operation"\s*:\s*"(\w+)"/)
@@ -168,7 +168,7 @@ export function ToolCallItem({
 
   const displayState = resolveToolDisplayState(status)
   const isExecuting = displayState === 'spinner'
-  const isBrowserTakeover = toolName === BrowserRequestTakeover.id
+  const isBrowserTakeover = toolName === RETIRED_BROWSER_REQUEST_TAKEOVER_ID
 
   const isCountingDown = toolName === WaitTool.id && isExecuting
   const elapsedMs = useElapsedMs(isCountingDown, startedAt)
@@ -236,14 +236,16 @@ export function ToolCallItem({
   }
 
   return (
-    <div className='flex items-center gap-[6px] pl-6'>
+    <div className='flex min-w-0 items-center gap-[6px] pl-6'>
       {BlockIcon && <BrandIcon icon={BlockIcon} className='size-[14px] flex-shrink-0' />}
       {isExecuting ? (
-        <ShimmerText className='text-[13px] [--shimmer-rest:var(--text-secondary)]'>
+        <ShimmerText className='min-w-0 truncate text-[13px] leading-[18px] [--shimmer-rest:var(--text-secondary)]'>
           {title}
         </ShimmerText>
       ) : (
-        <span className='text-[13px] text-[var(--text-secondary)]'>{title}</span>
+        <span className='min-w-0 truncate text-[13px] text-[var(--text-secondary)] leading-[18px]'>
+          {title}
+        </span>
       )}
     </div>
   )
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts
index e28bf31059..5063faecdb 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.ts
@@ -1218,3 +1218,159 @@ describe('parser properties', () => {
     }
   })
 })
+
+describe('flattened options payload recovery', () => {
+  // Observed in the wild: no <options> wrapper, and the LAST entry lost its
+  // braces so its title sits on the numeric key with the description hoisted.
+  const flattened =
+    'options {"1": {"title": "Test files and a second turn in the same DM thread", "description": "watermark + file-delta live check"}, "2": {"title": "Put /chat/the-elder on Brain with a password", "description": "finish chat cutover"}, "3": "Add thinking-status keepalive for long Brain runs", "description": "refresh shimmer past 2 minutes"}'
+
+  it('renders it as an options card instead of raw JSON', () => {
+    const { segments } = parseSpecialTags(flattened, false)
+    const options = segments.find((segment) => segment.type === 'options')
+    expect(options).toBeDefined()
+    expect(Object.keys((options as { data: Record<string, unknown> }).data)).toEqual([
+      '1',
+      '2',
+      '3',
+    ])
+  })
+
+  it('rebuilds the flattened entry from the hoisted description', () => {
+    const { segments } = parseSpecialTags(flattened, false)
+    const data = (segments.find((s) => s.type === 'options') as { data: Record<string, unknown> })
+      .data
+    expect(data['3']).toEqual({
+      title: 'Add thinking-status keepalive for long Brain runs',
+      description: 'refresh shimmer past 2 minutes',
+    })
+  })
+
+  it('drops the bare "options" label rather than leaving it as prose', () => {
+    const { segments } = parseSpecialTags(flattened, false)
+    expect(segments.some((segment) => segment.type === 'text')).toBe(false)
+  })
+
+  it('repairs the same corruption inside a well-formed tag', () => {
+    const tagged =
+      '<options>{"1": {"title": "A", "description": "a"}, "2": "B", "description": "b"}</options>'
+    const { segments } = parseSpecialTags(tagged, false)
+    const data = (segments.find((s) => s.type === 'options') as { data: Record<string, unknown> })
+      .data
+    expect(data['2']).toEqual({ title: 'B', description: 'b' })
+  })
+
+  it('leaves prose JSON alone', () => {
+    const prose = 'Here is the config: {"name": "x", "description": "y"}'
+    const { segments } = parseSpecialTags(prose, false)
+    expect(segments.some((segment) => segment.type === 'options')).toBe(false)
+  })
+
+  it('does not fire mid-stream', () => {
+    expect(parseSpecialTags(flattened, true).segments.some((s) => s.type === 'options')).toBe(false)
+  })
+})
+
+describe('bare options with a capitalized label', () => {
+  // Well-formed payload, but no wrapper and a "Options:" label instead of the
+  // lowercase bare word — the second shape seen in the wild.
+  const labeled =
+    'Options: {"1": {"title": "Live-test ASK top-level, ASK thread, and a mention in another channel", "description": "confirm the new accept rule in Slack"}, "2": {"title": "Test files and a second turn in the same DM thread", "description": "watermark + file-delta live check"}}'
+
+  it('renders it as an options card', () => {
+    const { segments } = parseSpecialTags(labeled, false)
+    const options = segments.find((segment) => segment.type === 'options')
+    expect(options).toBeDefined()
+    expect(Object.keys((options as { data: Record<string, unknown> }).data)).toEqual(['1', '2'])
+  })
+
+  it('leaves no stray "Options:" prose above the card', () => {
+    const { segments } = parseSpecialTags(labeled, false)
+    expect(segments.some((segment) => segment.type === 'text')).toBe(false)
+  })
+
+  it('keeps real prose that precedes the payload', () => {
+    const withProse = `Here is what I suggest.\n\n${labeled}`
+    const { segments } = parseSpecialTags(withProse, false)
+    const text = segments.find((segment) => segment.type === 'text') as { content: string }
+    expect(text.content).toBe('Here is what I suggest.')
+    expect(segments.some((segment) => segment.type === 'options')).toBe(true)
+  })
+})
+
+describe('bare options JSON with no label at all', () => {
+  const naked =
+    '{"1": {"title": "Live-test ASK top-level, ASK thread, and a mention in another channel", "description": "confirm the new accept rule in Slack"}, "2": {"title": "Test files and a second turn in the same DM thread", "description": "watermark + file-delta live check"}}'
+
+  it('renders the payload alone as an options card', () => {
+    const { segments } = parseSpecialTags(naked, false)
+    const options = segments.find((segment) => segment.type === 'options')
+    expect(options).toBeDefined()
+    expect(Object.keys((options as { data: Record<string, unknown> }).data)).toEqual(['1', '2'])
+    expect(segments.some((segment) => segment.type === 'text')).toBe(false)
+  })
+
+  it('renders it after prose with no label between them', () => {
+    const { segments } = parseSpecialTags(`Two ways to go from here.\n\n${naked}`, false)
+    const text = segments.find((segment) => segment.type === 'text') as { content: string }
+    expect(text.content).toBe('Two ways to go from here.')
+    expect(segments.some((segment) => segment.type === 'options')).toBe(true)
+  })
+
+  it('recovers a flattened payload with no label either', () => {
+    const flattenedNaked = '{"1": {"title": "A", "description": "a"}, "2": "B", "description": "b"}'
+    const { segments } = parseSpecialTags(flattenedNaked, false)
+    const data = (segments.find((s) => s.type === 'options') as { data: Record<string, unknown> })
+      .data
+    expect(data['2']).toEqual({ title: 'B', description: 'b' })
+  })
+})
+
+describe('bare question payload recovery', () => {
+  const bare =
+    '{"type": "single_select", "prompt": "Which channel should the bot post to?", "options": [{"id": "a", "label": "#general"}, {"id": "b", "label": "#alerts"}]}'
+
+  it('renders an unwrapped question payload as a question card', () => {
+    const { segments } = parseSpecialTags(bare, false)
+    const question = segments.find((segment) => segment.type === 'question')
+    expect(question).toBeDefined()
+    expect((question as { data: Array<{ prompt: string }> }).data[0].prompt).toBe(
+      'Which channel should the bot post to?'
+    )
+    expect(segments.some((segment) => segment.type === 'text')).toBe(false)
+  })
+
+  it('accepts an array payload and strips a bare label', () => {
+    const { segments } = parseSpecialTags(`Question: [${bare}]`, false)
+    expect(segments.some((segment) => segment.type === 'question')).toBe(true)
+    expect(segments.some((segment) => segment.type === 'text')).toBe(false)
+  })
+
+  it('keeps prose that precedes the payload', () => {
+    const { segments } = parseSpecialTags(`I need one detail.\n\n${bare}`, false)
+    const text = segments.find((segment) => segment.type === 'text') as { content: string }
+    expect(text.content).toBe('I need one detail.')
+  })
+
+  it('does not fire mid-stream', () => {
+    expect(parseSpecialTags(bare, true).segments.some((s) => s.type === 'question')).toBe(false)
+  })
+})
+
+describe('ordinary JSON in prose is never turned into a card', () => {
+  const prose = [
+    'Here is the config: {"name": "elder", "description": "the bot", "enabled": true}',
+    'The API returned {"1": "ok", "2": "ok"}',
+    'Response shape: {"type": "object", "prompt": "n/a", "options": []}',
+    'Use {"type": "single_select"} as the discriminator.',
+    'Rows: [{"id": "1", "label": "one"}, {"id": "2", "label": "two"}]',
+    'Payload: {"data": {"title": "x", "description": "y"}}',
+    'Env: {"0": {"title": "a", "description": "b"}}',
+  ]
+
+  it.each(prose)('leaves %s as text', (content) => {
+    const { segments } = parseSpecialTags(content, false)
+    expect(segments.some((s) => s.type === 'options' || s.type === 'question')).toBe(false)
+    expect(segments.some((s) => s.type === 'text')).toBe(true)
+  })
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.tsx
index 994a79397d..061dfac82d 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.test.tsx
@@ -1413,3 +1413,48 @@ describe('parseSpecialTags sim_key placeholder', () => {
     }
   })
 })
+
+describe('recoverTrailingBareOptions', () => {
+  const bareOptions =
+    '{"1": {"title": "Fix the tracker", "description": "debug"}, "2": {"title": "Inspect the miss", "description": "look"}}'
+
+  it('renders a trailing bare-JSON options payload as an options card', () => {
+    const { segments } = parseSpecialTags(`Here they are.\n${bareOptions}`, false)
+    const last = segments[segments.length - 1]
+    expect(last.type).toBe('options')
+    if (last.type === 'options') {
+      expect(last.data['1']?.title).toBe('Fix the tracker')
+    }
+    expect(segments[0]).toEqual({ type: 'text', content: 'Here they are.' })
+  })
+
+  it('never recovers mid-stream — a partial JSON tail must not flicker into a card', () => {
+    const { segments } = parseSpecialTags(`Here they are.\n${bareOptions}`, true)
+    expect(segments.every((segment) => segment.type === 'text')).toBe(true)
+  })
+
+  it('leaves ordinary JSON prose alone', () => {
+    const { segments } = parseSpecialTags('The config is {"retries": 3, "mode": "fast"}', false)
+    expect(segments.every((segment) => segment.type === 'text')).toBe(true)
+  })
+
+  it('does not double-render when a real options tag already parsed', () => {
+    const { segments } = parseSpecialTags(`Pick one <options>${bareOptions}</options>`, false)
+    expect(segments.filter((segment) => segment.type === 'options')).toHaveLength(1)
+  })
+
+  it('recovers an options payload wrapped in the singular <option> near-miss tag', () => {
+    const body =
+      '{"1": {"title": "Demo wait — sleep until an agent finishes", "description": "wait_agents demo"}, "2": {"title": "Demo steer — redirect a running agent mid-task", "description": "steer_agent demo"}, "3": {"title": "Demo stop — interrupt a running agent", "description": "interrupt_agent demo"}}'
+    const { segments } = parseSpecialTags(
+      `Next up is usually **wait**, **steer**, or **stop**.\n\n<option>${body}</option>`,
+      false
+    )
+    const last = segments[segments.length - 1]
+    expect(last.type).toBe('options')
+    if (last.type === 'options') {
+      expect(Object.keys(last.data)).toEqual(['1', '2', '3'])
+      expect(last.data['1']?.title).toBe('Demo wait — sleep until an agent finishes')
+    }
+  })
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx
index ddde93e34c..8d5fa1e788 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/special-tags/special-tags.tsx
@@ -370,6 +370,56 @@ function isOptionsItemData(value: unknown): value is OptionsItemData {
   return typeof value.title === 'string' && typeof value.description === 'string'
 }
 
+/**
+ * Repairs the one malformed options payload seen in the wild: the LAST entry
+ * loses its object braces, so its title lands directly on the numeric key and
+ * its description is hoisted to a sibling of the entries —
+ *
+ *   {"1": {…}, "2": {…}, "3": "Third title", "description": "Third desc"}
+ *
+ * — which fails both the per-item shape check and the numeric-key gate, so the
+ * whole card was dropped and the raw JSON rendered as prose.
+ *
+ * Deliberately narrow: a bare string is only accepted under a numeric key, and
+ * only a single stray `description` is absorbed, attaching to the last numeric
+ * entry that lacks one. Anything else is returned untouched so a JSON object
+ * quoted in prose still cannot masquerade as an options card. Returns the input
+ * unchanged when there is nothing to repair.
+ */
+/** Whether keys are exactly "1".."N" in order, the shape the options contract emits. */
+function isSequentialOptionKeys(keys: string[]): boolean {
+  return keys.length > 0 && keys.every((key, index) => key === String(index + 1))
+}
+
+function repairFlattenedOptionEntry(value: unknown): unknown {
+  if (!isRecordLike(value) || Array.isArray(value)) return value
+
+  const entries = Object.entries(value)
+  const numericKeys = entries.filter(([key]) => /^\d+$/.test(key))
+  if (numericKeys.length === 0) return value
+
+  // The hoisted description IS the signature of this corruption. Without one,
+  // a numeric-keyed map of plain strings is just data ({"1": "ok", "2": "ok"})
+  // and must stay prose.
+  const strayKeys = entries.filter(([key]) => !/^\d+$/.test(key))
+  if (strayKeys.length !== 1) return value
+  const [strayKey, strayValue] = strayKeys[0]
+  if (strayKey !== 'description' || typeof strayValue !== 'string') return value
+
+  // Exactly one entry lost its braces, and it is the last one — every earlier
+  // entry must already be a well-formed option.
+  const flattenedCount = numericKeys.filter(([, item]) => typeof item === 'string').length
+  if (flattenedCount !== 1) return value
+  const [lastKey, lastItem] = numericKeys[numericKeys.length - 1]
+  if (typeof lastItem !== 'string') return value
+
+  const repaired: Record<string, unknown> = {}
+  for (const [key, item] of numericKeys) {
+    repaired[key] = key === lastKey ? { title: lastItem, description: strayValue } : item
+  }
+  return repaired
+}
+
 /**
  * Arrays are accepted alongside keyed objects: an agent that emits
  * `<options>[{title,description},…]</options>` still renders, with the array
@@ -592,11 +642,14 @@ export function parseQuestionTagBody(body: string): QuestionTagData | null {
 
 export function parseJsonTagBody<T>(
   body: string,
-  isExpectedShape: (value: unknown) => value is T
+  isExpectedShape: (value: unknown) => value is T,
+  /** Optional normalizer applied before the shape check, for known model typos. */
+  repair?: (value: unknown) => unknown
 ): T | null {
   try {
     const parsed = JSON.parse(body) as unknown
-    return isExpectedShape(parsed) ? parsed : null
+    const candidate = repair ? repair(parsed) : parsed
+    return isExpectedShape(candidate) ? candidate : null
   } catch {
     return null
   }
@@ -667,7 +720,7 @@ function parseSpecialTagData(
   }
 
   if (tagName === 'options') {
-    const data = parseJsonTagBody(body, isOptionsTagData)
+    const data = parseJsonTagBody(body, isOptionsTagData, repairFlattenedOptionEntry)
     return data ? { type: 'options', data } : null
   }
 
@@ -1455,8 +1508,139 @@ export function parseSpecialTags(content: string, isStreaming: boolean): ParsedS
     segments.push({ type: 'text', content })
   }
 
+  if (!isStreaming) {
+    recoverTrailingBareOptions(segments)
+    recoverTrailingBareQuestion(segments)
+  }
+
   return { segments, hasPendingTag }
 }
+/**
+ * Recovers a trailing bare-JSON options payload the model emitted WITHOUT the
+ * `<options>` wrapper (observed when an automation prompt asks the model to
+ * "(re)send suggested actions" and it answers with the JSON as content). The
+ * shape check is strict — a non-empty object whose every value is
+ * { title, description } with numeric-string keys — so ordinary JSON in prose
+ * cannot false-positive. Only a message's FINAL text segment is considered,
+ * mirroring the tag contract (options go last), and only when no options tag
+ * already parsed. Never applied mid-stream: a partial JSON tail must not
+ * flicker between prose and a card.
+ */
+const NEAR_MISS_OPTIONS_WRAPPER = /<option>\s*(\{[\s\S]*\})\s*<\/option>\s*$/
+
+/**
+ * Locates a trailing bare JSON payload: the earliest opening delimiter from
+ * which the whole remainder parses. Nested objects mean the FIRST `{` is not
+ * necessarily the payload's start, so positions are probed left to right and
+ * bounded so a brace-heavy prose block cannot become a hot loop.
+ */
+function findTrailingJsonPayload(
+  text: string,
+  openers: string[]
+): { start: number; body: string } | null {
+  const trimmed = text.trimEnd()
+  if (!openers.some((opener) => trimmed.endsWith(opener === '[' ? ']' : '}'))) return null
+  let probe = -1
+  for (const opener of openers) {
+    const index = text.indexOf(opener)
+    if (index !== -1 && (probe === -1 || index < probe)) probe = index
+  }
+  for (let attempts = 0; probe !== -1 && attempts < 20; attempts++) {
+    const body = text.slice(probe).trim()
+    try {
+      JSON.parse(body)
+      return { start: probe, body }
+    } catch {
+      let next = -1
+      for (const opener of openers) {
+        const index = text.indexOf(opener, probe + 1)
+        if (index !== -1 && (next === -1 || index < next)) next = index
+      }
+      probe = next
+    }
+  }
+  return null
+}
+
+/** Drops a bare `question` / `<question>` label sitting just before a payload. */
+const BARE_QUESTION_LABEL = /(^|\n)\s*<?questions?>?\s*:?\s*$/i
+
+/**
+ * Recovers a trailing `<question>` payload the model emitted WITHOUT the
+ * wrapper, mirroring {@link recoverTrailingBareOptions}.
+ *
+ * Safe to attempt on bare JSON because the question shape is far more
+ * distinctive than the options one: `parseQuestionTagBody` requires a `type` of
+ * exactly `single_select` or `multi_select`, a non-empty `prompt`, and a
+ * non-empty `options` array of `{id, label}`. Ordinary JSON in prose — a config
+ * blob, an API response, a code sample — does not carry that combination, so
+ * the strict validator is the whole gate. Accepts an array or a single object,
+ * exactly as the tagged path does.
+ */
+function recoverTrailingBareQuestion(segments: ContentSegment[]): void {
+  const last = segments[segments.length - 1]
+  if (!last || last.type !== 'text') return
+  if (segments.some((segment) => segment.type === 'question')) return
+  const payload = findTrailingJsonPayload(last.content, ['{', '['])
+  if (!payload) return
+  const data = parseQuestionTagBody(payload.body)
+  if (!data) return
+  const prefix = last.content
+    .slice(0, payload.start)
+    .replace(/\s+$/, '')
+    .replace(BARE_QUESTION_LABEL, '$1')
+    .replace(/\s+$/, '')
+  segments.pop()
+  if (prefix) segments.push({ type: 'text', content: prefix })
+  segments.push({ type: 'question', data })
+}
+
+function recoverTrailingBareOptions(segments: ContentSegment[]): void {
+  const last = segments[segments.length - 1]
+  if (!last || last.type !== 'text') return
+  if (segments.some((segment) => segment.type === 'options')) return
+  let text = last.content
+  // A near-miss wrapper — the singular `<option>` tag observed in the wild —
+  // is neither a parseable tag nor bare JSON (the trailing `</option>` fails
+  // the brace gate below). Unwrap it and let the strict shape check decide.
+  const nearMiss = NEAR_MISS_OPTIONS_WRAPPER.exec(text)
+  if (nearMiss) {
+    text = `${text.slice(0, nearMiss.index)}${nearMiss[1]}`
+  }
+  if (!text.trimEnd().endsWith('}')) return
+  // The payload nests objects, so the START brace is the first one from which
+  // the remainder parses — probe brace positions left to right (bounded).
+  let start = -1
+  let parsed: unknown
+  let probe = text.indexOf('{')
+  for (let attempts = 0; probe !== -1 && attempts < 20; attempts++) {
+    try {
+      parsed = JSON.parse(text.slice(probe).trim())
+      start = probe
+      break
+    } catch {
+      probe = text.indexOf('{', probe + 1)
+    }
+  }
+  if (start === -1) return
+  const repaired = repairFlattenedOptionEntry(parsed)
+  if (!isOptionsTagData(repaired) || Object.keys(repaired as object).length === 0) return
+  // The contract numbers options from 1 upward. Demanding the exact run — not
+  // merely "every key is numeric" — keeps a numeric-keyed map that happens to
+  // hold {title, description} values (e.g. {"0": {…}}) from becoming a card.
+  if (!isSequentialOptionKeys(Object.keys(repaired as object))) return
+  // A bare `options` / `<options>` label immediately before the payload is the
+  // wrapper the model meant to emit, not prose — drop it rather than leaving a
+  // stray word above the card.
+  const prefix = text
+    .slice(0, start)
+    .replace(/\s+$/, '')
+    .replace(/(^|\n)\s*<?options>?\s*:?\s*$/i, '$1')
+    .replace(/\s+$/, '')
+  segments.pop()
+  if (prefix) segments.push({ type: 'text', content: prefix })
+  segments.push({ type: 'options', data: repaired })
+}
 
 interface SpecialTagsProps {
   segment: Exclude<ContentSegment, { type: 'text' }>
@@ -2708,10 +2892,16 @@ export function CredentialDisplay({
   )
 }
 
+/**
+ * The message is the whole user-facing story. The raw `code` is an internal
+ * identifier ("async_resume_aborted") that means nothing to a reader and made
+ * every error line end in parenthesized jargon; it stays in the tag payload for
+ * logs and support, just not on screen.
+ */
 function MothershipErrorDisplay({ data }: { data: MothershipErrorTagData }) {
-  const detail = data.code ? `${data.message} (${data.code})` : data.message
-
-  return <p className='text-[13px] text-[var(--text-secondary)] italic leading-[20px]'>{detail}</p>
+  return (
+    <p className='text-[13px] text-[var(--text-secondary)] italic leading-[20px]'>{data.message}</p>
+  )
 }
 
 function UsageUpgradeDisplay({ data }: { data: UsageUpgradeTagData }) {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts
index 8226865967..d50471c433 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts
@@ -135,7 +135,7 @@ describe('parseBlocks span-identity tree', () => {
       subagentStart('workflow', 'S1', 'main'),
       subagentToolCall('t1', 'create_workflow', 'S1', 'workflow'),
       subagentStart('deploy', 'S2', 'S1'),
-      subagentToolCall('t2', 'check_deployment_status', 'S2', 'deploy'),
+      subagentToolCall('t2', 'get_deployment_status', 'S2', 'deploy'),
     ]
 
     const segments = parseBlocks(blocks)
@@ -185,9 +185,9 @@ describe('parseBlocks span-identity tree', () => {
   it('creates distinct groups for repeated deploy invocations (no collision)', () => {
     const blocks: ContentBlock[] = [
       subagentStart('deploy', 'S2', 'main'),
-      subagentToolCall('t1', 'deploy_api', 'S2', 'deploy'),
+      subagentToolCall('t1', 'deploy_as_api', 'S2', 'deploy'),
       subagentStart('deploy', 'S4', 'main'),
-      subagentToolCall('t2', 'deploy_api', 'S4', 'deploy'),
+      subagentToolCall('t2', 'deploy_as_api', 'S4', 'deploy'),
     ]
 
     const segments = parseBlocks(blocks)
@@ -311,7 +311,7 @@ describe('parseBlocks span-identity tree', () => {
   it('absorbs the dispatch tool of a nested file subagent from its parent span group', () => {
     const blocks: ContentBlock[] = [
       subagentStart('workflow', 'S1', 'main'),
-      subagentToolCall('t1', 'workspace_file', 'S1', 'workflow'),
+      subagentToolCall('t1', 'prepare_file_edit', 'S1', 'workflow'),
       { type: 'subagent', content: 'file', spanId: 'S2', parentSpanId: 'S1', timestamp: 2 },
       { type: 'subagent_text', content: 'writing', spanId: 'S2', timestamp: 3 },
     ]
@@ -321,7 +321,7 @@ describe('parseBlocks span-identity tree', () => {
     const workflow = segments[0]
     if (workflow.type !== 'agent_group') throw new Error('expected workflow group')
 
-    // The workspace_file dispatch tool is absorbed (not shown as a sibling tool);
+    // The prepare_file_edit dispatch tool is absorbed (not shown as a sibling tool);
     // only the nested file subagent remains under workflow.
     expect(workflow.items.some((item) => item.type === 'tool')).toBe(false)
     const nested = workflow.items.find((item) => item.type === 'agent_group')
@@ -476,16 +476,18 @@ describe('completed tool titles', () => {
           type: 'tool_call',
           toolCall: {
             id: 'undeploy-api',
-            name: 'deploy_api',
+            name: 'deploy_as_api',
             status: 'success',
             params: { action: 'undeploy' },
           },
           timestamp: 1,
         },
       ])
-    ).toBe('Undeployed API')
+    ).toBe('Undeployed as API')
 
-    expect(firstToolTitle([mainToolCall('deploy-mcp', 'deploy_mcp')])).toBe('Deployed MCP tool')
+    expect(firstToolTitle([mainToolCall('deploy-mcp', 'deploy_as_mcp')])).toBe(
+      'Deployed as MCP tool'
+    )
   })
 
   it('renders Compared after the full diff_workflows wire lifecycle succeeds', () => {
@@ -591,9 +593,9 @@ describe('completed tool titles', () => {
     expect(failures).toEqual([])
   })
 
-  it('keeps present tense while executing and on error', () => {
+  it('keeps present tense while executing; failed rows say so', () => {
     expect(firstToolTitle([queryLogsCall('executing')])).toBe('Querying logs')
-    expect(firstToolTitle([queryLogsCall('error')])).toBe('Querying logs')
+    expect(firstToolTitle([queryLogsCall('error')])).toBe('Failed querying logs')
   })
 })
 
@@ -755,7 +757,7 @@ describe('assistantMessageHasVisibleExecutingTool', () => {
     const blocks: ContentBlock[] = [
       {
         type: 'tool_call',
-        toolCall: { id: 'dispatch-1', name: 'workspace_file', status: 'executing' },
+        toolCall: { id: 'dispatch-1', name: 'prepare_file_edit', status: 'executing' },
         timestamp: 1,
       },
       {
@@ -785,7 +787,7 @@ describe('deriveThinkingLabel', () => {
 
   it('shows Dispatching for the dispatch call, then yields to the opened lane', () => {
     expect(deriveThinkingLabel([mainToolCall('t1', 'workflow')])).toBe('Dispatching…')
-    expect(deriveThinkingLabel([mainToolCall('t1', 'workspace_file')])).toBe('Dispatching…')
+    expect(deriveThinkingLabel([mainToolCall('t1', 'prepare_file_edit')])).toBe('Dispatching…')
     expect(deriveThinkingLabel([mainToolCall('t1', 'grep')])).toBe('Thinking…')
     expect(deriveThinkingLabel([subagentStart('workflow', 'S1', 'main')])).toBeNull()
   })
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
index 4b230fb4fd..e16282ea66 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx
@@ -11,7 +11,7 @@ import {
   useState,
 } from 'react'
 import { cn } from '@sim/emcn'
-import { Read as ReadTool, WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import { PrepareFileEdit, Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
 import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
 import { resolveToolDisplay } from '@/lib/copilot/tools/client/store-utils'
 import { ClientToolCallState } from '@/lib/copilot/tools/client/tool-call-state'
@@ -127,7 +127,7 @@ const SUBAGENT_KEYS = new Set(Object.keys(SUBAGENT_LABELS))
  * group is absorbed so it doesn't render as a separate Mothership entry.
  */
 const SUBAGENT_DISPATCH_TOOLS: Record<string, string> = {
-  [FILE_SUBAGENT_ID]: WorkspaceFile.id,
+  [FILE_SUBAGENT_ID]: PrepareFileEdit.id,
 }
 
 function isToolResultRead(params?: Record<string, unknown>): boolean {
@@ -380,6 +380,7 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
       const dispatchToolName = SUBAGENT_DISPATCH_TOOLS[block.content]
       if (dispatchToolName) absorbDispatchTool(dispatchToolName, block.parentSpanId)
       const g = ensureSpanGroup(block.content, block.spanId, block.parentSpanId)
+      if (block.subagentName) g.agentLabel = block.subagentName
       if (block.endedAt !== undefined) {
         // Persisted backend path: the lane was stamped closed (endedAt) without
         // a separate subagent_end block (the Sim backend stamps endedAt only;
@@ -623,6 +624,7 @@ function parseBlocksLegacy(blocks: ContentBlock[]): MessageSegment[] {
       }
       groupsByKey.delete(groupKey('mothership', undefined))
       const { group: g } = ensureGroup(key, block.parentToolCallId)
+      if (block.subagentName) g.agentLabel = block.subagentName
       if (inheritedDelegation) g.isDelegating = true
       g.isOpen = true
       activeGroupKey = resolveGroupKey(key, block.parentToolCallId)
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
index 8079fc40de..64176c822c 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/message-content/utils.ts
@@ -33,19 +33,19 @@ const TOOL_ICONS: Record<string, IconComponent> = {
   mv: FolderCode,
   cp: Layout,
   mkdir: FolderCode,
-  search_online: Search,
-  scrape_page: Search,
-  get_page_contents: Search,
+  web_search: Search,
+  web_scrape: Search,
+  web_fetch: Search,
   search_library_docs: Library,
-  manage_mcp_tool: Settings,
+  manage_mcp_connection: Settings,
   manage_skill: Asterisk,
   user_memory: Database,
-  function_execute: TerminalWindow,
+  run_function: TerminalWindow,
   run_code: TerminalWindow,
   superagent: Blimp,
   user_table: TableIcon,
-  workspace_file: File,
-  edit_content: File,
+  prepare_file_edit: File,
+  apply_file_edit: File,
   create_workflow: Layout,
   edit_workflow: Pencil,
   workflow: Hammer,
@@ -64,6 +64,7 @@ const TOOL_ICONS: Record<string, IconComponent> = {
   research: Search,
   scout: Search,
   search: Search,
+  platform: Library,
   context_compaction: Asterisk,
   open_resource: Eye,
   file: File,
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
index 8d4bccd9c9..8402522854 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-chat/mothership-chat.tsx
@@ -664,6 +664,28 @@ export function MothershipChat({
     handleEditQueued(tail.id)
   }, [handleEditQueued])
 
+  /**
+   * A drag-selection that overshoots a message's last line crosses the row
+   * wrappers' block boundaries, which the clipboard serializer renders as
+   * trailing newlines — every copied response pasted with blank lines
+   * appended. Rewrite the plain-text flavor trimmed; the rich flavor is
+   * re-serialized from the selection so formatted pastes keep working.
+   */
+  const handleCopy = useCallback((event: React.ClipboardEvent) => {
+    const selection = window.getSelection()
+    if (!selection || selection.isCollapsed || !event.clipboardData) return
+    const text = selection.toString()
+    const trimmed = text.replace(/\s+$/, '')
+    if (trimmed === text) return
+    event.preventDefault()
+    event.clipboardData.setData('text/plain', trimmed)
+    const html = document.createElement('div')
+    for (let i = 0; i < selection.rangeCount; i++) {
+      html.appendChild(selection.getRangeAt(i).cloneContents())
+    }
+    event.clipboardData.setData('text/html', html.innerHTML)
+  }, [])
+
   /**
    * Land at the most recent message once per chat — on open and when switching
    * chats. The ref tracks which `chatId` we last scrolled for (seeded with
@@ -696,7 +718,7 @@ export function MothershipChat({
       onWorkspaceResourceSelect={onWorkspaceResourceSelect}
     >
       <div className={cn('flex h-full min-h-0 flex-col', className)}>
-        <div ref={setScrollElement} className={styles.scrollContainer}>
+        <div ref={setScrollElement} className={styles.scrollContainer} onCopy={handleCopy}>
           {isLoading && !hasMessages ? (
             <MothershipChatSkeleton layout={layout} />
           ) : (
@@ -714,8 +736,15 @@ export function MothershipChat({
                     key={virtualItem.key}
                     data-index={index}
                     ref={virtualizer.measureElement}
-                    className='absolute top-0 left-0 w-full'
-                    style={{ transform: `translateY(${virtualItem.start}px)` }}
+                    /* Positioned with a real `top`, NOT `top-0` + translateY:
+                       text selection maps a drag's start point to a text
+                       position via the rows' LAYOUT boxes, and with every row
+                       laid out at y=0 a drag starting in the gutter anchors in
+                       the wrong row — selections ran upward from a downward
+                       drag. Transforms move paint and hit-testing but not the
+                       layout box that mapping falls back to. */
+                    className='absolute left-0 w-full'
+                    style={{ top: virtualItem.start }}
                   >
                     {msg.role === 'user' ? (
                       interactionPairing.hiddenUserByIndex[index] ? null : (
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.test.ts
index 63c974fcbc..23b0947471 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.test.ts
@@ -30,6 +30,7 @@ import {
   createBrowserPanelGeometryOcclusionLease,
   hasNativeSurfaceOcclusion,
   NATIVE_SURFACE_OCCLUSION_SELECTOR,
+  snapshotMatchesHost,
   useBrowserPanelOcclusion,
 } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion'
 
@@ -582,3 +583,44 @@ describe('useBrowserPanelOcclusion modal lifecycle', () => {
     hook.unmount()
   })
 })
+
+describe('snapshotMatchesHost', () => {
+  const rect = (x: number, y: number, width: number, height: number) =>
+    ({ x, y, width, height }) as DOMRect
+
+  it('accepts a capture that still describes the host rect', () => {
+    expect(
+      snapshotMatchesHost(
+        { viewportBounds: { x: 10, y: 20, width: 800, height: 600 } },
+        rect(10, 20, 800, 600)
+      )
+    ).toBe(true)
+  })
+
+  it('tolerates sub-pixel drift from rounding', () => {
+    expect(
+      snapshotMatchesHost(
+        { viewportBounds: { x: 10, y: 20, width: 800, height: 600 } },
+        rect(10.4, 19.6, 800.5, 599.5)
+      )
+    ).toBe(true)
+  })
+
+  it('rejects a capture taken before a scroll lock reflowed the panel', () => {
+    // Modal scroll lock removes the scrollbar: the host widens by 15px, so the
+    // pre-lock capture would paint misaligned — the flash this guards.
+    expect(
+      snapshotMatchesHost(
+        { viewportBounds: { x: 10, y: 20, width: 800, height: 600 } },
+        rect(10, 20, 815, 600)
+      )
+    ).toBe(false)
+  })
+
+  it('accepts captures with no viewport bounds (host-tracking fallback style)', () => {
+    expect(snapshotMatchesHost({ viewportBounds: undefined }, rect(0, 0, 100, 100))).toBe(true)
+    expect(
+      snapshotMatchesHost({ viewportBounds: { x: 0, y: 0, width: 10, height: 10 } }, null)
+    ).toBe(true)
+  })
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.ts b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.ts
index b4b76eb936..3f7acedff7 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-panel-occlusion.ts
@@ -184,10 +184,34 @@ async function decodeSnapshot(dataUrl: string): Promise<boolean> {
  * changing layers never reveals or recaptures the native view, and the view is
  * revealed only after the final reason disappears.
  */
+
+/** Largest tolerated drift, in CSS px, between a capture and the live host rect. */
+const SNAPSHOT_GEOMETRY_TOLERANCE_PX = 1
+
+/**
+ * Whether a captured frame still describes the rectangle the panel occupies.
+ * A capture with no viewport bounds is positioned by the fallback
+ * `absolute inset-0` style, which tracks the host by construction.
+ */
+export function snapshotMatchesHost(
+  frame: Pick<BrowserPanelSnapshot, 'viewportBounds'>,
+  hostRect: DOMRect | null
+): boolean {
+  const bounds = frame.viewportBounds
+  if (!bounds || !hostRect) return true
+  return (
+    Math.abs(bounds.x - hostRect.x) <= SNAPSHOT_GEOMETRY_TOLERANCE_PX &&
+    Math.abs(bounds.y - hostRect.y) <= SNAPSHOT_GEOMETRY_TOLERANCE_PX &&
+    Math.abs(bounds.width - hostRect.width) <= SNAPSHOT_GEOMETRY_TOLERANCE_PX &&
+    Math.abs(bounds.height - hostRect.height) <= SNAPSHOT_GEOMETRY_TOLERANCE_PX
+  )
+}
+
 export function useBrowserPanelOcclusion(
   scopeId: string,
   activeTabId: string | null,
-  panelVisible = true
+  panelVisible = true,
+  getHostRect?: () => DOMRect | null
 ): BrowserPanelOcclusion {
   const [snapshotRender, setSnapshotRender] = useState<SnapshotRender | null>(null)
   const [activeOverlay, setActiveOverlay] = useState<BrowserPanelOverlay | null>(null)
@@ -204,8 +228,10 @@ export function useBrowserPanelOcclusion(
   const paintFramesRef = useRef<number[]>([])
   const reconcileChainRef = useRef<Promise<boolean>>(Promise.resolve(true))
   const mountedRef = useRef(true)
+  const getHostRectRef = useRef(getHostRect)
   activeTabIdRef.current = activeTabId
   panelVisibleRef.current = panelVisible
+  getHostRectRef.current = getHostRect
 
   const updateSnapshotRender = useCallback((render: SnapshotRender | null) => {
     snapshotRenderRef.current = render
@@ -303,7 +329,7 @@ export function useBrowserPanelOcclusion(
 
       // Modal scroll locking can alter panel geometry between capture and the
       // final native hide. One fresh capture retries that now-settled layout.
-      const maxAttempts = desired === 'modal' ? 2 : 1
+      const maxAttempts = desired === 'modal' ? 3 : 1
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         const frame = await captureBrowserPanelSnapshot(scopeId).catch(() => null)
         if (!mountedRef.current || version !== transitionVersionRef.current) return false
@@ -318,6 +344,13 @@ export function useBrowserPanelOcclusion(
         desired = desiredLayer()
         if (!desired || !decoded) continue
 
+        // Painting a capture whose geometry no longer matches the host is the
+        // flash: a modal's scroll lock changes the window's content width
+        // between capture and paint, so the replacement lands offset from the
+        // page it is standing in for. Skip that frame and re-capture at the
+        // settled layout instead of showing a misaligned one.
+        if (!snapshotMatchesHost(frame, getHostRectRef.current?.() ?? null)) continue
+
         const paintId = ++paintIdRef.current
         const painted = new Promise<boolean>((resolve) => {
           pendingPaintRef.current = { paintId, resolve }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.test.ts
index 0edd0e9f3f..957dab4d10 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.test.ts
@@ -190,6 +190,10 @@ describe('initialUrlSuggestionIndex', () => {
     expect(initialUrlSuggestionIndex('https://sim.ai', 3)).toBeNull()
   })
 
+  it('selects the exact search row after typing on an existing page', () => {
+    expect(initialUrlSuggestionIndex('https://sim.ai', 3, 'what is the best')).toBe(0)
+  })
+
   it('selects nothing when there are no suggestions', () => {
     expect(initialUrlSuggestionIndex('', 0)).toBeNull()
   })
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.tsx
index 3d241ca738..b4e7d90c0f 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-session.tsx
@@ -39,6 +39,7 @@ import { onFocusVisibleBrowserOmnibox } from '@/lib/browser-agent/renderer-short
 import {
   fillBrowserCredential,
   loadBrowserFillOptions,
+  loadBrowserSearchSuggestions,
   loadBrowserSuggestionSources,
   onBrowserAddToChat,
   onBrowserAppearanceThemeChanged,
@@ -84,12 +85,16 @@ import {
 import { BrowserTabStrip } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-tab-strip'
 import { BrowserThemeNotice } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/browser-theme-notice'
 import {
+  buildOmniboxSuggestions,
+  googleSearchUrl,
+  isSearchQueryInput,
   mergeSuggestionSources,
   moveActiveIndex,
-  rankSuggestions,
+  type OmniboxSuggestion,
   type UrlSuggestion,
 } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions'
 import { ResourceZoomMenuItems } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/resource-zoom-menu-items'
+import { useDebounce } from '@/hooks/use-debounce'
 import { useSettingsNavigation } from '@/hooks/use-settings-navigation'
 import { useBrowserSessionStore } from '@/stores/browser-session/store'
 import { MOTHERSHIP_WIDTH } from '@/stores/constants'
@@ -97,6 +102,7 @@ import type { ChatContext } from '@/stores/panel'
 
 /** Ties the omnibox to its listbox for assistive tech. */
 const SUGGESTIONS_LIST_ID = 'browser-url-suggestions'
+const SEARCH_SUGGESTIONS_DEBOUNCE_MS = 160
 const NEW_TAB_CONFIRM_TIMEOUT_MS = 10_000
 const EMPTY_BROWSER_TABS: BrowserTabState[] = []
 
@@ -156,14 +162,10 @@ export function browserSelectionContext({
 export function resolveUrlBarInput(raw: string): string {
   const input = raw.trim()
   if (/^https?:\/\//i.test(input)) return input
-  const hostLike =
-    /^([a-z0-9-]+(\.[a-z0-9-]+)+|localhost|\d{1,3}(\.\d{1,3}){3}|\[[0-9a-f:]+\])(:\d+)?([/?#].*)?$/i
-  if (!input.includes(' ') && hostLike.test(input)) {
-    const isLocal =
-      /^(localhost|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|0\.0\.0\.0|\[::1?\])(:\d+)?([/?#]|$)/i.test(input)
-    return `${isLocal ? 'http' : 'https'}://${input}`
-  }
-  return `https://www.google.com/search?q=${encodeURIComponent(input)}`
+  if (isSearchQueryInput(input)) return googleSearchUrl(input)
+  const isLocal =
+    /^(localhost|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|0\.0\.0\.0|\[::1?\])(:\d+)?([/?#]|$)/i.test(input)
+  return `${isLocal ? 'http' : 'https'}://${input}`
 }
 
 /**
@@ -302,13 +304,14 @@ export function shouldOpenUrlSuggestions(
   return activeOverlay === 'suggestions' && suggestionCount > 0
 }
 
-/** New tabs submit the best suggestion; existing pages submit their current URL. */
+/** Typed searches and new tabs select the first row; an untouched page URL remains literal. */
 export function initialUrlSuggestionIndex(
   pageUrl: string | undefined,
-  suggestionCount: number
+  suggestionCount: number,
+  query = ''
 ): number | null {
   if (suggestionCount === 0) return null
-  return !pageUrl || pageUrl === 'about:blank' ? 0 : null
+  return query.trim() || !pageUrl || pageUrl === 'about:blank' ? 0 : null
 }
 
 /** A new-tab request is complete only after the authoritative strip grows and activates a new id. */
@@ -369,6 +372,9 @@ export function BrowserSession({
   const suspended = useBrowserSessionStore((state) => state.sessions[scopeId]?.suspended ?? false)
   const panelRef = useRef<HTMLDivElement>(null)
   const hostRef = useRef<HTMLDivElement>(null)
+  // Lets the occlusion handshake reject a capture taken before a modal's
+  // scroll lock reflowed the panel — painting that stale rect is the flash.
+  const getHostRect = useCallback(() => hostRef.current?.getBoundingClientRect() ?? null, [])
   const urlInputRef = useRef<HTMLInputElement>(null)
   const findInputRef = useRef<HTMLInputElement>(null)
   const fillButtonRef = useRef<HTMLButtonElement>(null)
@@ -429,6 +435,15 @@ export function BrowserSession({
   const [suggestionsVisible, setSuggestionsVisible] = useState(false)
   /** Empty on initial focus; follows the typed text once the user edits it. */
   const [suggestionQuery, setSuggestionQuery] = useState<string | null>(null)
+  /** Live completions tagged with the query that produced them, so late replies cannot leak in. */
+  const [searchCompletions, setSearchCompletions] = useState<{
+    query: string
+    values: string[]
+  }>({ query: '', values: [] })
+  const debouncedSuggestionQuery = useDebounce(
+    suggestionQuery ?? '',
+    SEARCH_SUGGESTIONS_DEBOUNCE_MS
+  )
   /** Whether the find bar is docked above the page. */
   const [findOpen, setFindOpen] = useState(false)
   const {
@@ -438,7 +453,7 @@ export function BrowserSession({
     requestOverlay,
     closeOverlay,
     onSnapshotError,
-  } = useBrowserPanelOcclusion(scopeId, activeTabId, panelVisible)
+  } = useBrowserPanelOcclusion(scopeId, activeTabId, panelVisible, getHostRect)
 
   // The resource picker lives above this component in the panel tab bar. Give
   // that one external browser overlay access to the same capture/hide handshake
@@ -502,6 +517,23 @@ export function BrowserSession({
     }
   }, [panelVisible])
 
+  /** Debounced live completions never block the immediate local/search row. */
+  useEffect(() => {
+    const query = debouncedSuggestionQuery.trim()
+    if (!suggestionsVisible || !isSearchQueryInput(query)) {
+      setSearchCompletions({ query: '', values: [] })
+      return
+    }
+
+    let active = true
+    void loadBrowserSearchSuggestions(query).then((values) => {
+      if (active) setSearchCompletions({ query, values })
+    })
+    return () => {
+      active = false
+    }
+  }, [debouncedSuggestionQuery, suggestionsVisible])
+
   useEffect(() => {
     if (appearanceTheme) {
       const next = resolveDesktopAppearanceTheme(appearanceTheme, theme)
@@ -579,6 +611,24 @@ export function BrowserSession({
 
   useEffect(() => onBrowserOmniboxFocus(focusOmnibox, scopeId), [focusOmnibox, scopeId])
 
+  // Follow the agent's tab. The panel already marks the automated tab in the
+  // strip; this makes it the VISIBLE one, so watching the agent never means
+  // hunting for which tab it moved to. Keyed on the automation target
+  // CHANGING, not on it merely being set — the user can still browse a
+  // different tab mid-run and is only pulled along when the agent itself
+  // moves to another tab.
+  const followedAutomationTabRef = useRef<string | null>(null)
+  useEffect(() => {
+    if (!automationActive || !automationTabId) {
+      if (!automationActive) followedAutomationTabRef.current = null
+      return
+    }
+    if (followedAutomationTabRef.current === automationTabId) return
+    followedAutomationTabRef.current = automationTabId
+    if (automationTabId === activeTabId) return
+    sendBrowserPanelAction('switch-tab', { tabId: automationTabId }, scopeId)
+  }, [activeTabId, automationActive, automationTabId, scopeId])
+
   // Sim owns keyboard events while its renderer has focus. Claim Cmd+L here
   // before the workspace's global "Go to Logs" command can navigate away.
   useEffect(() => {
@@ -748,6 +798,17 @@ export function BrowserSession({
         // then report bounds: the WebContentsView is attached hidden from its
         // very first compositor frame. This also reasserts the lease after a
         // minimized/throttled window temporarily loses its bounds.
+        //
+        // The reassert must be REAL, not deduped. Main's bounds lease expires
+        // after 2.5s of missed reports (renderer jank, a skipped commit) and
+        // resets panelOccluded — while this side still remembers `applied:
+        // true`. Without dropping that belief, setDesired(true) is a no-op,
+        // the next bounds commit lays out an unoccluded native view, and the
+        // browser punches above the still-open modal with nothing left to
+        // ever re-hide it. Forgetting `applied` costs one idempotent hide IPC
+        // per heartbeat while a modal is up, and makes any main-side lease
+        // loss self-heal within a second.
+        if (nativeSurfaceOcclusionPresent) geometryOcclusionLease.assumeRevealed()
         void geometryOcclusionLease.setDesired(nativeSurfaceOcclusionPresent).then((settled) => {
           if (disposed) return
           const latestOcclusionPresent = atomicPanelOcclusion && hasNativeSurfaceOcclusion()
@@ -833,17 +894,18 @@ export function BrowserSession({
    * Programmatic focus on a new tab keeps the omnibox ready for typing without
    * opening this list. A pointer interaction or typed edit opts into suggestions.
    */
-  const suggestions = useMemo(
-    () =>
-      suggestionsVisible && suggestionQuery !== null
-        ? rankSuggestions(suggestionCorpus, suggestionQuery)
-        : [],
-    [suggestionCorpus, suggestionQuery, suggestionsVisible]
-  )
+  const suggestions = useMemo((): OmniboxSuggestion[] => {
+    if (!suggestionsVisible || suggestionQuery === null) return []
+    const query = suggestionQuery.trim()
+    const live = searchCompletions.query === query ? searchCompletions.values : []
+    return buildOmniboxSuggestions(suggestionCorpus, suggestionQuery, live)
+  }, [searchCompletions, suggestionCorpus, suggestionQuery, suggestionsVisible])
 
   useEffect(() => {
-    setActiveSuggestion(initialUrlSuggestionIndex(suggestionOriginUrl, suggestions.length))
-  }, [suggestionOriginUrl, suggestions])
+    setActiveSuggestion(
+      initialUrlSuggestionIndex(suggestionOriginUrl, suggestions.length, suggestionQuery ?? '')
+    )
+  }, [suggestionOriginUrl, suggestionQuery, suggestions])
 
   // The suggestion list is renderer UI that extends over the native page.
   // Keep the page's exact captured frame underneath it while it is open so
@@ -1075,6 +1137,7 @@ export function BrowserSession({
                   placeholder='Search Google or enter a URL'
                   autoComplete='off'
                   role='combobox'
+                  aria-autocomplete='list'
                   aria-expanded={suggestionsOpen}
                   aria-controls={SUGGESTIONS_LIST_ID}
                   aria-activedescendant={
@@ -1092,6 +1155,7 @@ export function BrowserSession({
                   onChange={(event) => {
                     setSuggestionsVisible(true)
                     setSuggestionQuery(event.target.value)
+                    setSearchCompletions({ query: '', values: [] })
                     setUrlDraft(event.target.value)
                     // The old highlight pointed at a row that may no longer be
                     // in the list, let alone in the same position.
@@ -1150,7 +1214,11 @@ export function BrowserSession({
             >
               {suggestions.map((suggestion, index) => (
                 <PopoverItem
-                  key={suggestion.hostname}
+                  key={
+                    suggestion.kind === 'site'
+                      ? `site:${suggestion.hostname}`
+                      : `search:${suggestion.query}`
+                  }
                   id={suggestionRowId(index)}
                   role='option'
                   aria-selected={index === activeSuggestion}
@@ -1161,17 +1229,24 @@ export function BrowserSession({
                   onClick={() => navigateTo(suggestion.url)}
                 >
                   <div className='flex w-full min-w-0 items-center gap-2'>
-                    <BrowserSuggestionIcon suggestion={suggestion} />
-                    {suggestion.name ? (
+                    {suggestion.kind === 'search' ? (
+                      <>
+                        <Search className='size-4 shrink-0 text-[var(--text-icon)]' />
+                        <span className='truncate'>{suggestion.query}</span>
+                      </>
+                    ) : (
+                      <BrowserSuggestionIcon suggestion={suggestion} />
+                    )}
+                    {suggestion.kind === 'site' && suggestion.name ? (
                       <div className='flex min-w-0 flex-1 items-center gap-1.5'>
                         <span className='min-w-0 flex-1 truncate'>{suggestion.name}</span>
                         <span className='max-w-[45%] shrink-0 truncate text-[var(--text-muted)]'>
                           — {suggestion.hostname}
                         </span>
                       </div>
-                    ) : (
+                    ) : suggestion.kind === 'site' ? (
                       <span className='truncate'>{suggestion.hostname}</span>
-                    )}
+                    ) : null}
                   </div>
                 </PopoverItem>
               ))}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.test.ts b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.test.ts
index f4407ab3f6..978d67badf 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.test.ts
@@ -2,6 +2,9 @@ import type { BrowserKnownSession, BrowserSessionEvidence } from '@sim/browser-p
 import type { BrowserCredentialMetadata, BrowserSiteInfo } from '@sim/desktop-bridge'
 import { describe, expect, it } from 'vitest'
 import {
+  buildOmniboxSuggestions,
+  googleSearchUrl,
+  isSearchQueryInput,
   mergeSuggestionSources,
   moveActiveIndex,
   rankSuggestions,
@@ -421,6 +424,65 @@ describe('rankSuggestions', () => {
   })
 })
 
+describe('buildOmniboxSuggestions', () => {
+  it('leads with the exact search, keeps matching sites, then adds live completions', () => {
+    const results = buildOmniboxSuggestions(
+      [suggestion('mail.google.com', 100, 'Gmail')],
+      'gmail',
+      ['gmail login', 'gmail account']
+    )
+
+    expect(results.map((result) => [result.kind, result.url])).toEqual([
+      ['search', googleSearchUrl('gmail')],
+      ['site', 'https://mail.google.com'],
+      ['search', googleSearchUrl('gmail login')],
+      ['search', googleSearchUrl('gmail account')],
+    ])
+  })
+
+  it('does not send URL-looking input through search completions', () => {
+    const results = buildOmniboxSuggestions([suggestion('github.com', 100)], 'github.com', [
+      'github.com login',
+    ])
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({ kind: 'site', hostname: 'github.com' })
+  })
+
+  it('deduplicates completions and caps the combined dropdown', () => {
+    const results = buildOmniboxSuggestions(
+      [],
+      'sim ai',
+      ['sim ai', 'SIM AI', 'sim ai workflow', 'sim ai agents'],
+      2
+    )
+
+    expect(results.map((result) => result.kind === 'search' && result.query)).toEqual([
+      'sim ai',
+      'sim ai workflow',
+    ])
+  })
+
+  it('keeps an empty omnibox local-only', () => {
+    const results = buildOmniboxSuggestions([suggestion('github.com', 100)], '', [
+      'ignored remote completion',
+    ])
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toMatchObject({ kind: 'site', hostname: 'github.com' })
+  })
+})
+
+describe('isSearchQueryInput', () => {
+  it('distinguishes searches from navigable addresses', () => {
+    expect(isSearchQueryInput('what is the best browser')).toBe(true)
+    expect(isSearchQueryInput('electron')).toBe(true)
+    expect(isSearchQueryInput('sim.ai/docs')).toBe(false)
+    expect(isSearchQueryInput('https://sim.ai')).toBe(false)
+    expect(isSearchQueryInput('localhost:3000')).toBe(false)
+  })
+})
+
 describe('moveActiveIndex', () => {
   it('highlights nothing until the user arrows in, so Enter still means "go to what I typed"', () => {
     expect(moveActiveIndex(null, 1, 3)).toBe(0)
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.ts b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.ts
index c5ae7399c7..4ab226a38f 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/components/browser-session/url-suggestions.ts
@@ -47,6 +47,25 @@ export interface UrlSuggestion {
   visits?: number
 }
 
+export type OmniboxSuggestion =
+  | ({ kind: 'site' } & UrlSuggestion)
+  | { kind: 'search'; query: string; url: string }
+
+const HOST_LIKE_INPUT =
+  /^([a-z0-9-]+(\.[a-z0-9-]+)+|localhost|\d{1,3}(\.\d{1,3}){3}|\[[0-9a-f:]+\])(:\d+)?([/?#].*)?$/i
+
+/** Whether an omnibox value should search rather than navigate directly. */
+export function isSearchQueryInput(raw: string): boolean {
+  const input = raw.trim()
+  if (!input || /^https?:\/\//i.test(input)) return false
+  return input.includes(' ') || !HOST_LIKE_INPUT.test(input)
+}
+
+/** The canonical Google results URL used by search rows and bare submission. */
+export function googleSearchUrl(query: string): string {
+  return `https://www.google.com/search?q=${encodeURIComponent(query.trim())}`
+}
+
 function timestamp(value: string | undefined): number {
   if (!value) return 0
   const parsed = Date.parse(value)
@@ -189,6 +208,42 @@ export function rankSuggestions(
   return scored.slice(0, limit).map((entry) => entry.suggestion)
 }
 
+/**
+ * Combines immediate navigation/search actions with the user's known sites and
+ * live completions. The exact typed search leads, known sites retain priority,
+ * and remote completions fill whatever room remains.
+ */
+export function buildOmniboxSuggestions(
+  siteCorpus: readonly UrlSuggestion[],
+  rawQuery: string,
+  searchCompletions: readonly string[] = [],
+  limit: number = MAX_URL_SUGGESTIONS
+): OmniboxSuggestion[] {
+  if (limit <= 0) return []
+  const query = rawQuery.trim()
+  const sites = rankSuggestions(siteCorpus, query, limit)
+  if (!query || !isSearchQueryInput(query)) {
+    return sites.map((site) => ({ ...site, kind: 'site' }))
+  }
+
+  const results: OmniboxSuggestion[] = [{ kind: 'search', query, url: googleSearchUrl(query) }]
+  for (const site of sites) {
+    if (results.length === limit) return results
+    results.push({ ...site, kind: 'site' })
+  }
+
+  const seen = new Set([query.toLocaleLowerCase()])
+  for (const candidate of searchCompletions) {
+    const completion = candidate.trim()
+    const key = completion.toLocaleLowerCase()
+    if (!completion || seen.has(key)) continue
+    seen.add(key)
+    results.push({ kind: 'search', query: completion, url: googleSearchUrl(completion) })
+    if (results.length === limit) break
+  }
+  return results
+}
+
 /**
  * How well the browser knows a host, then how much it is used, then how
  * recently, then alphabetically so the same corpus always comes back in the
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
index 4378ba9a3c..48f3769b17 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.tsx
@@ -256,6 +256,7 @@ export const ResourceContent = memo(function ResourceContent({
           tableId={resource.id}
           embedded
           viewsEnabled={tableViewsEnabled}
+          initialViewId={resource.viewId}
         />
       )
 
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
index d907369426..b4333837c4 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-tabs/resource-tabs.tsx
@@ -243,9 +243,9 @@ const ResourceTabItem = memo(function ResourceTabItem({
       >
         {config.renderTabIcon(resource, 'mr-1.5 size-[14px]')}
         {displayName}
-        {hasActivity && !isActive && (
+        {hasActivity && !isActive && !isHovered && (
           <span
-            className='ml-1 size-1.5 shrink-0 rounded-full bg-[var(--brand-primary)]'
+            className='-translate-y-1/2 absolute top-1/2 right-[9px] size-1.5 rounded-full bg-[var(--brand-primary)]'
             aria-label='Background activity'
           />
         )}
diff --git a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
index d82d73db63..621e541fae 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx
@@ -4,6 +4,7 @@ import { forwardRef, memo, useCallback, useMemo, useRef, useState } from 'react'
 import { cn } from '@sim/emcn'
 import type { FilePreviewSession } from '@/lib/copilot/request/session'
 import { getFileExtension } from '@/lib/uploads/utils/file-utils'
+import { SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
 import type { PreviewMode } from '@/app/workspace/[workspaceId]/files/components/file-viewer'
 import {
   isCsvStreamOnly,
@@ -164,7 +165,10 @@ export const MothershipView = memo(
       // the record before deciding so the toggle doesn't flash on for a large CSV — but don't gate
       // other rich types (html, svg, …) on the file list loading.
       !(isActiveCsv && filesLoading) &&
-      !(activeFile && isCsvStreamOnly(activeFile))
+      !(activeFile && isCsvStreamOnly(activeFile)) &&
+      // A Sim page is locked to its rendered view (the pdf model — the raw
+      // source is not a mode this surface offers), so no toggle either.
+      activeFile?.type !== SIM_PAGE_CONTENT_TYPE
 
     return (
       <div
diff --git a/apps/sim/app/workspace/[workspaceId]/home/home.tsx b/apps/sim/app/workspace/[workspaceId]/home/home.tsx
index eba97d8274..66bd244c68 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/home.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/home/home.tsx
@@ -55,7 +55,13 @@ import {
   UserInput,
   type UserInputHandle,
 } from './components'
-import { getMothershipUseChatOptions, useChat, useMothershipResize } from './hooks'
+import {
+  getMothershipUseChatOptions,
+  type ResourceEventOptions,
+  shouldActivateResourceEvent,
+  useChat,
+  useMothershipResize,
+} from './hooks'
 import type {
   FileAttachmentForApi,
   MothershipResource,
@@ -211,14 +217,14 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
   const activeResourceParamRef = useRef(activeResourceParam)
   activeResourceParamRef.current = activeResourceParam
 
-  function handleResourceEvent(resourceId: string) {
-    // Agent work should always make the resource surface available, but it
-    // must never replace an existing selection. Activity in another resource
-    // stays in the background and gets an attention marker instead.
+  function handleResourceEvent(resourceId: string, options?: ResourceEventOptions) {
+    // Agent work surfaces the resource and switches to it as it is created or
+    // edited; only the browser session stays in the background behind an
+    // existing selection (see shouldActivateResourceEvent).
     if (isResourceCollapsedRef.current) setIsResourceCollapsed(false)
 
     const activeResourceId = activeResourceParamRef.current
-    if (activeResourceId && activeResourceId !== resourceId) {
+    if (!shouldActivateResourceEvent(activeResourceId, resourceId, options)) {
       setResourceActivityIds((current) => new Set(current).add(resourceId))
       return
     }
@@ -228,7 +234,10 @@ export function Home({ chatId, userName, userId, tableViewsEnabled }: HomeProps)
       next.delete(resourceId)
       return next
     })
-    if (activeResourceId !== resourceId) setActiveResourceUrl(resourceId)
+    if (activeResourceId !== resourceId) {
+      activeResourceParamRef.current = resourceId
+      setActiveResourceUrl(resourceId)
+    }
   }
 
   const {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/index.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/index.ts
index 995df51986..8c1fa13edd 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/index.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/index.ts
@@ -1,6 +1,8 @@
+export type { ResourceEventOptions } from './use-chat'
 export {
   getMothershipUseChatOptions,
   getWorkflowCopilotUseChatOptions,
+  shouldActivateResourceEvent,
   useChat,
 } from './use-chat'
 export { useMothershipResize } from './use-mothership-resize'
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
index 296f48bc55..3635ac65d5 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts
@@ -4,7 +4,7 @@ import {
   MothershipStreamV1ToolPhase,
   MothershipStreamV1ToolStatus,
 } from '@/lib/copilot/generated/mothership-stream-v1'
-import { WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import { ApplyFileEdit, PrepareFileEdit } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { PersistedStreamEventEnvelope } from '@/lib/copilot/request/session/contract'
 import {
   extractResourcesFromToolResult,
@@ -79,7 +79,7 @@ function runToolResultSideEffects(ctx: StreamLoopContext, node: ToolNode): void
     invalidateResourceQueries(deps.queryClient, deps.workspaceId, resource.type, resource.id)
   }
 
-  if ((name === 'edit_content' || name === WorkspaceFile.id) && isSuccess) {
+  if ((name === ApplyFileEdit.id || name === PrepareFileEdit.id) && isSuccess) {
     const out = output as Record<string, unknown> | undefined
     const editData =
       out && typeof out.data === 'object' && out.data !== null
@@ -102,17 +102,20 @@ function runToolResultSideEffects(ctx: StreamLoopContext, node: ToolNode): void
   deps.onToolResultRef.current?.(name, isSuccess, output)
 
   const workspaceFileOperation =
-    name === WorkspaceFile.id && typeof params?.operation === 'string'
+    name === PrepareFileEdit.id && typeof params?.operation === 'string'
       ? params.operation
       : undefined
   const shouldKeepWorkspacePreviewOpen =
-    name === WorkspaceFile.id &&
+    name === PrepareFileEdit.id &&
     (workspaceFileOperation === 'append' ||
       workspaceFileOperation === 'update' ||
       workspaceFileOperation === 'patch')
 
-  if ((name === WorkspaceFile.id || name === 'edit_content') && !shouldKeepWorkspacePreviewOpen) {
-    if (name === WorkspaceFile.id) {
+  if (
+    (name === PrepareFileEdit.id || name === ApplyFileEdit.id) &&
+    !shouldKeepWorkspacePreviewOpen
+  ) {
+    if (name === PrepareFileEdit.id) {
       deps.removePreviewSessionImmediate(node.id)
     }
     const fileResource = extractedResources.find((r) => r.type === 'file')
@@ -128,7 +131,7 @@ function runToolResultSideEffects(ctx: StreamLoopContext, node: ToolNode): void
 
 /**
  * Side effects for tool events. State (the tool node, its status, args, and the
- * edit_content row merge) is owned by `reduceEvent`; this handler routes preview
+ * apply_file_edit row merge) is owned by `reduceEvent`; this handler routes preview
  * phases, fires client workflow tools, and runs result side effects, then
  * flushes the model-derived snapshot.
  */
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts
index 90e8d0f9ca..afeb703e08 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts
@@ -2,35 +2,37 @@ import { createLogger } from '@sim/logger'
 import { isRecordLike } from '@sim/utils/object'
 import {
   CallIntegrationTool,
-  CrawlWebsite,
-  CreateFile,
+  CreateEmptyFile,
   CreateWorkflow,
-  DeployApi,
-  DeployChat,
-  DeployMcp,
+  DeployAsApi,
+  DeployAsChat,
+  DeployAsMcp,
   EditWorkflow,
-  FunctionExecute,
   Glob,
   Grep,
   ManageCredential,
   ManageCustomTool,
-  ManageMcpTool,
+  ManageMcpConnection,
   ManageSkill,
+  PrepareFileEdit,
+  PrepareFileEditOperation,
   QueryLogs,
   Redeploy,
   Rm,
   RunFromBlock,
+  RunFunction,
   RunWorkflow,
   RunWorkflowUntilBlock,
-  ScrapePage,
-  SearchOnline,
-  WorkspaceFile,
-  WorkspaceFileOperation,
+  WebCrawl,
+  WebScrape,
+  WebSearch,
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { getToolDisplayTitle, mvDisplayVerb } from '@/lib/copilot/tools/tool-display'
+import { getQueryClient } from '@/app/_shell/providers/get-query-client'
 import type { ContentBlock } from '@/app/workspace/[workspaceId]/home/types'
 import { ToolCallStatus } from '@/app/workspace/[workspaceId]/home/types'
+import { tableKeys } from '@/hooks/queries/utils/table-keys'
 import { getWorkflowById } from '@/hooks/queries/utils/workflow-cache'
 import { useWorkflowRegistry } from '@/stores/workflows/registry/store'
 import { useWorkflowStore } from '@/stores/workflows/workflow/store'
@@ -40,9 +42,9 @@ const logger = createLogger('StreamHelpers')
 export const FILE_SUBAGENT_ID = 'file'
 
 export const DEPLOY_TOOL_NAMES: Set<string> = new Set([
-  DeployApi.id,
-  DeployChat.id,
-  DeployMcp.id,
+  DeployAsApi.id,
+  DeployAsChat.id,
+  DeployAsMcp.id,
   Redeploy.id,
 ])
 
@@ -123,6 +125,33 @@ function resolveTargetWorkflowName(args: Record<string, unknown> | undefined): s
   return resolveWorkflowNameForDisplay(args?.workflowId ?? registry.hydration.workflowId)
 }
 
+/**
+ * Table name for a nested `args.tableId`. Tables reach the client through
+ * React Query rather than a Zustand store, so the cached workspace list is
+ * the synchronous source a title can read; an uncached id simply stays
+ * unnamed rather than blocking the row.
+ */
+function resolveTableNameForDisplay(tableId: unknown): string | undefined {
+  const id = stringParam(tableId)
+  if (!id) return undefined
+  const cache = getQueryClient().getQueryCache()
+  for (const query of cache.findAll({ queryKey: tableKeys.lists() })) {
+    const data = query.state.data
+    const tables = Array.isArray(data)
+      ? data
+      : isRecordLike(data) && Array.isArray((data as { tables?: unknown }).tables)
+        ? ((data as { tables: unknown[] }).tables as unknown[])
+        : []
+    for (const table of tables) {
+      if (!isRecordLike(table)) continue
+      if (stringParam(table.id) !== id) continue
+      const name = stringParam(table.name)
+      if (name) return name
+    }
+  }
+  return undefined
+}
+
 function resolveBlockNameForDisplay(blockId: unknown): string | undefined {
   const id = stringParam(blockId)
   if (!id) return undefined
@@ -139,13 +168,13 @@ function resolveWorkspaceFileDisplayTitle(
   let verb = 'Writing'
 
   switch (operation) {
-    case WorkspaceFileOperation.append:
+    case PrepareFileEditOperation.append:
       verb = 'Adding'
       break
-    case WorkspaceFileOperation.patch:
+    case PrepareFileEditOperation.patch:
       verb = 'Editing'
       break
-    case WorkspaceFileOperation.update:
+    case PrepareFileEditOperation.update:
       verb = 'Writing'
       break
   }
@@ -186,6 +215,40 @@ export function resolveIntegrationToolDisplayTitle(tool: {
   return tool.integrationDescription
 }
 
+/**
+ * Tools whose subject is one workflow. They accept a `workflowId` (or imply
+ * the current workflow), so their titles can only name the workflow once the
+ * client resolves the id against the workflow registry.
+ */
+const TABLE_SCOPED_TOOL_IDS = new Set<string>([
+  'table_automations',
+  'table_columns',
+  'table_enrichments',
+  'table_manage',
+  'table_rows',
+  'table_views',
+])
+
+const WORKFLOW_SCOPED_TOOL_IDS = new Set<string>([
+  'deploy_as_api',
+  'diff_workflows',
+  'list_deployment_versions',
+  'publish_custom_block',
+  'deploy_as_chat',
+  'deploy_as_mcp',
+  'get_block_outputs',
+  'get_block_upstream_references',
+  'get_deployed_workflow_state',
+  'get_deployment_status',
+  'get_workflow_data',
+  'get_workflow_run_options',
+  'promote_to_live',
+  'redeploy',
+  'run_block',
+  'set_block_enabled',
+  'set_global_workflow_variables',
+])
+
 export function resolveToolDisplayTitle(name: string, args?: Record<string, unknown>): string {
   // Cases that enrich the title with live workspace/block names from the client
   // stores. Everything else is resolved by the shared name+args resolver, which
@@ -224,6 +287,39 @@ export function resolveToolDisplayTitle(name: string, args?: Record<string, unkn
     if (workflowName) return `Querying logs for ${workflowName}`
   }
 
+  // Workflow-scoped tools carry an id, not a name — and often not even that,
+  // defaulting to the current workflow. Resolve the name here and hand it to
+  // the shared resolver as `workflowName`, which every workflow title already
+  // reads, so deployments, reads, and block work all say WHICH workflow.
+  // Table tools keep their operands nested under `args`, and identify the
+  // table by id — so the shared resolver sees neither the column being added
+  // nor which table it belongs to. Lift both here.
+  if (TABLE_SCOPED_TOOL_IDS.has(name)) {
+    const nested = isRecordLike(args?.args) ? (args?.args as Record<string, unknown>) : undefined
+    const tableName =
+      stringParam(args?.tableName) ?? resolveTableNameForDisplay(nested?.tableId ?? args?.tableId)
+    if (nested || tableName) {
+      return getToolDisplayTitle(name, {
+        ...args,
+        ...(nested ?? {}),
+        ...(tableName ? { tableName } : {}),
+      })
+    }
+  }
+
+  if (WORKFLOW_SCOPED_TOOL_IDS.has(name) && !stringParam(args?.workflowName)) {
+    const workflowName = resolveTargetWorkflowName(args)
+    // Block-scoped tools carry a blockId for the same reason; resolve it too,
+    // so a row says which block ran rather than an opaque id (or nothing).
+    const blockName = stringParam(args?.blockName) ?? resolveBlockNameForDisplay(args?.blockId)
+    const enriched = {
+      ...args,
+      ...(workflowName ? { workflowName } : {}),
+      ...(blockName ? { blockName } : {}),
+    }
+    if (workflowName || blockName) return getToolDisplayTitle(name, enriched)
+  }
+
   return getToolDisplayTitle(name, args)
 }
 
@@ -270,11 +366,11 @@ export function resolveStreamingToolDisplayTitle(
   name: string,
   streamingArgs: string
 ): string | undefined {
-  if (name === FunctionExecute.id) {
+  if (name === RunFunction.id) {
     return functionExecuteTitle(matchStreamingStringArg(streamingArgs, 'title'))
   }
 
-  if (name === WorkspaceFile.id) {
+  if (name === PrepareFileEdit.id) {
     return resolveWorkspaceFileDisplayTitle(
       matchStreamingStringArg(streamingArgs, 'operation'),
       matchStreamingStringArg(streamingArgs, 'title'),
@@ -282,7 +378,7 @@ export function resolveStreamingToolDisplayTitle(
     )
   }
 
-  if (name === CreateFile.id) {
+  if (name === CreateEmptyFile.id) {
     const target =
       matchStreamingStringArg(streamingArgs, 'path') ??
       matchStreamingStringArg(streamingArgs, 'fileName')
@@ -299,7 +395,7 @@ export function resolveStreamingToolDisplayTitle(
     return workflowId ? resolveToolDisplayTitle(name, { workflowId }) : undefined
   }
 
-  if (name === SearchOnline.id) {
+  if (name === WebSearch.id) {
     const toolTitle = matchStreamingStringArg(streamingArgs, 'toolTitle')
     return toolTitle ? `Searching online for ${toolTitle}` : undefined
   }
@@ -349,12 +445,12 @@ export function resolveStreamingToolDisplayTitle(
     return toolTitle ? `Deleting ${toolTitle}` : undefined
   }
 
-  if (name === ScrapePage.id) {
+  if (name === WebScrape.id) {
     const url = matchStreamingStringArg(streamingArgs, 'url')
     return url ? `Scraping ${url}` : undefined
   }
 
-  if (name === CrawlWebsite.id) {
+  if (name === WebCrawl.id) {
     const url = matchStreamingStringArg(streamingArgs, 'url')
     return url ? `Crawling ${url}` : undefined
   }
@@ -363,7 +459,7 @@ export function resolveStreamingToolDisplayTitle(
     return resolveStreamingManagedResourceTitle(name, streamingArgs, ['toolTitle', 'title', 'name'])
   }
 
-  if (name === ManageMcpTool.id) {
+  if (name === ManageMcpConnection.id) {
     return resolveStreamingManagedResourceTitle(name, streamingArgs, [
       'serverName',
       'name',
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.test.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.test.ts
index d4a5b69e3a..a764b32fa9 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.test.ts
@@ -68,7 +68,7 @@ describe('streaming resource titles', () => {
 })
 
 // A main-agent file delegation: trigger tool (main lane), subagent span, inner
-// workspace_file, span end, delegation result.
+// prepare_file_edit, span end, delegation result.
 function fileDelegationEvents(): PersistedStreamEventEnvelope[] {
   const sub: Scope = {
     lane: 'subagent',
@@ -89,13 +89,13 @@ function fileDelegationEvents(): PersistedStreamEventEnvelope[] {
     env(
       4,
       'tool',
-      { phase: 'call', toolCallId: 'wf-1', toolName: 'workspace_file' },
+      { phase: 'call', toolCallId: 'wf-1', toolName: 'prepare_file_edit' },
       { lane: 'subagent', spanId: 'S1' }
     ),
     env(
       5,
       'tool',
-      { phase: 'result', toolCallId: 'wf-1', toolName: 'workspace_file', success: true },
+      { phase: 'result', toolCallId: 'wf-1', toolName: 'prepare_file_edit', success: true },
       { lane: 'subagent', spanId: 'S1' }
     ),
     env(
@@ -124,7 +124,7 @@ describe('modelToContentBlocks', () => {
     expect(trigger?.toolCall?.status).toBe('success')
 
     const innerTool = blocksByType(blocks, 'tool_call').find(
-      (b) => b.toolCall?.name === 'workspace_file'
+      (b) => b.toolCall?.name === 'prepare_file_edit'
     )
     expect(innerTool?.spanId).toBe('S1')
     expect(innerTool?.toolCall?.calledBy).toBe('file')
@@ -220,7 +220,7 @@ describe('modelToContentBlocks', () => {
         env(
           4,
           'tool',
-          { phase: 'call', toolCallId: 'wf-1', toolName: 'workspace_file' },
+          { phase: 'call', toolCallId: 'wf-1', toolName: 'prepare_file_edit' },
           { lane: 'subagent', spanId: 'S1' }
         ),
         env(
@@ -233,7 +233,7 @@ describe('modelToContentBlocks', () => {
       ])
     )
     const types = blocks.map((b) => b.type)
-    const innerIdx = blocks.findIndex((b) => b.toolCall?.name === 'workspace_file')
+    const innerIdx = blocks.findIndex((b) => b.toolCall?.name === 'prepare_file_edit')
     const endIdx = types.indexOf('subagent_end')
     const afterIdx = blocks.findIndex((b) => b.type === 'text' && b.content === 'after')
     // subagent_end sits after the inner work and before the trailing main text — no sibling jumps.
@@ -275,7 +275,7 @@ describe('modelToContentBlocks', () => {
       env(
         3,
         'tool',
-        { phase: 'call', toolCallId: 'wf-1', toolName: 'workspace_file' },
+        { phase: 'call', toolCallId: 'wf-1', toolName: 'prepare_file_edit' },
         { lane: 'subagent', spanId: 'S1' }
       ),
     ])
@@ -309,7 +309,7 @@ describe('modelToContentBlocks', () => {
         env(1, 'tool', {
           phase: 'call',
           toolCallId: 'wf',
-          toolName: 'workspace_file',
+          toolName: 'prepare_file_edit',
           arguments: { operation: 'create', title: 'My Doc' },
         }),
       ])
@@ -322,7 +322,7 @@ describe('modelToContentBlocks', () => {
     const blocks = modelToContentBlocks(build(fileDelegationEvents()))
     const startIdx = blocks.findIndex((b) => b.type === 'subagent')
     const innerIdx = blocks.findIndex(
-      (b) => b.type === 'tool_call' && b.toolCall?.name === 'workspace_file'
+      (b) => b.type === 'tool_call' && b.toolCall?.name === 'prepare_file_edit'
     )
     const endIdx = blocks.findIndex((b) => b.type === 'subagent_end')
     expect(startIdx).toBeGreaterThanOrEqual(0)
@@ -425,7 +425,7 @@ describe('contentBlocksToModel round-trip', () => {
       env(
         3,
         'tool',
-        { phase: 'call', toolCallId: 'wf-1', toolName: 'workspace_file' },
+        { phase: 'call', toolCallId: 'wf-1', toolName: 'prepare_file_edit' },
         { lane: 'subagent', spanId: 'S1' }
       ),
     ])
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.ts
index d82bb65783..6088ee0419 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model-serialize.ts
@@ -167,6 +167,7 @@ export function modelToContentBlocks(model: TurnModel): ContentBlock[] {
       block: {
         type: 'subagent',
         content: node.agentId,
+        ...(node.displayName ? { subagentName: node.displayName } : {}),
         spanId: node.spanId,
         parentSpanId: node.parentSpanId,
         ...(node.triggerToolCallId ? { parentToolCallId: node.triggerToolCallId } : {}),
@@ -267,7 +268,10 @@ export function contentBlocksToModel(blocks: ContentBlock[]): TurnModel {
             kind: 'subagent',
             event: 'start',
             agent: block.content,
-            data: block.parentToolCallId ? { tool_call_id: block.parentToolCallId } : {},
+            data: {
+              ...(block.parentToolCallId ? { tool_call_id: block.parentToolCallId } : {}),
+              ...(block.subagentName ? { name: block.subagentName } : {}),
+            },
           },
           scopeFor(block),
           block.timestamp
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.test.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.test.ts
index 4681ae8e40..85c0b420e7 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.test.ts
@@ -144,17 +144,17 @@ describe('reduceEvent — tool lifecycle', () => {
 
   it('accumulates streaming args across deltas', () => {
     const m = apply([
-      toolCall(1, 'tc-1', 'workspace_file'),
+      toolCall(1, 'tc-1', 'prepare_file_edit'),
       envelope(2, 'tool', {
         phase: 'args_delta',
         toolCallId: 'tc-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         argumentsDelta: '{"a":',
       }),
       envelope(3, 'tool', {
         phase: 'args_delta',
         toolCallId: 'tc-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         argumentsDelta: '1}',
       }),
     ])
@@ -164,11 +164,11 @@ describe('reduceEvent — tool lifecycle', () => {
 
   it('clears streamingArgs once the result settles the tool', () => {
     const m = apply([
-      toolCall(1, 'tc-1', 'workspace_file'),
+      toolCall(1, 'tc-1', 'prepare_file_edit'),
       envelope(2, 'tool', {
         phase: 'args_delta',
         toolCallId: 'tc-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         argumentsDelta: '{"operation":"create"',
       }),
       toolResult(3, 'tc-1', true),
@@ -213,11 +213,11 @@ describe('reduceEvent — tool lifecycle', () => {
 
   it('ignores preview phases (decoupled from tool status)', () => {
     const m = apply([
-      toolCall(1, 'tc-1', 'workspace_file'),
+      toolCall(1, 'tc-1', 'prepare_file_edit'),
       envelope(2, 'tool', {
         previewPhase: 'file_preview_content',
         toolCallId: 'tc-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         content: 'x',
         contentMode: 'delta',
         fileName: 'f',
@@ -237,6 +237,29 @@ describe('reduceEvent — subagent lifecycle', () => {
     expect(agent(m, 'S1').parentSpanId).toBe(MAIN_SPAN)
   })
 
+  it('captures the orchestrator-chosen display name from span start data', () => {
+    const m = apply([
+      envelope(
+        1,
+        'span',
+        {
+          kind: 'subagent',
+          event: 'start',
+          agent: 'research',
+          data: { tool_call_id: 'tc-r', name: 'Pricing research' },
+        },
+        {
+          lane: 'subagent',
+          spanId: 'S1',
+          parentSpanId: MAIN_SPAN,
+          parentToolCallId: 'tc-r',
+          agentId: 'research',
+        }
+      ),
+    ])
+    expect(agent(m, 'S1').displayName).toBe('Pricing research')
+  })
+
   it('settles an agent error when span end carries an error', () => {
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-file'),
@@ -270,8 +293,8 @@ describe('reduceEvent — subagent lifecycle', () => {
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-a'),
       spanStart(2, 'S2', 'file', 'tc-b'),
-      toolCall(3, 'wf-a', 'workspace_file', { lane: 'subagent', spanId: 'S1' }),
-      toolCall(4, 'wf-b', 'workspace_file', { lane: 'subagent', spanId: 'S2' }),
+      toolCall(3, 'wf-a', 'prepare_file_edit', { lane: 'subagent', spanId: 'S1' }),
+      toolCall(4, 'wf-b', 'prepare_file_edit', { lane: 'subagent', spanId: 'S2' }),
       toolResult(5, 'wf-a', true),
       spanEnd(6, 'S1', 'file'),
       toolResult(7, 'wf-b', true),
@@ -327,7 +350,7 @@ describe('reduceEvent — idempotency', () => {
   it('rebuilds the identical model when replayed into a fresh model', () => {
     const events = [
       spanStart(1, 'S1', 'file', 'tc-file'),
-      toolCall(2, 'wf', 'workspace_file', { lane: 'subagent', spanId: 'S1' }),
+      toolCall(2, 'wf', 'prepare_file_edit', { lane: 'subagent', spanId: 'S1' }),
       toolResult(3, 'wf', true),
       spanEnd(4, 'S1', 'file'),
       complete(5),
@@ -340,42 +363,42 @@ describe('reduceEvent — idempotency', () => {
   })
 })
 
-describe('reduceEvent — edit_content row merge', () => {
-  it('folds an edit_content write into its span workspace_file row', () => {
+describe('reduceEvent — apply_file_edit row merge', () => {
+  it('folds an apply_file_edit write into its span prepare_file_edit row', () => {
     const sub: Scope = { lane: 'subagent', spanId: 'S1' }
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-file'),
-      toolCall(2, 'wf-1', 'workspace_file', sub),
+      toolCall(2, 'wf-1', 'prepare_file_edit', sub),
       toolResult(3, 'wf-1', true, undefined, sub),
-      toolCall(4, 'ec-1', 'edit_content', sub),
+      toolCall(4, 'ec-1', 'apply_file_edit', sub),
     ])
-    // No separate edit_content node; the workspace_file row reopened for the edit.
+    // No separate apply_file_edit node; the prepare_file_edit row reopened for the edit.
     expect(m.nodes.has('ec-1')).toBe(false)
     expect(tool(m, 'wf-1').status).toBe('running')
     expect(m.toolAlias.get('ec-1')).toBe('wf-1')
   })
 
-  it('settles the merged row on the edit_content result', () => {
+  it('settles the merged row on the apply_file_edit result', () => {
     const sub: Scope = { lane: 'subagent', spanId: 'S1' }
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-file'),
-      toolCall(2, 'wf-1', 'workspace_file', sub),
-      toolCall(3, 'ec-1', 'edit_content', sub),
+      toolCall(2, 'wf-1', 'prepare_file_edit', sub),
+      toolCall(3, 'ec-1', 'apply_file_edit', sub),
       toolResult(4, 'ec-1', true, undefined, sub),
     ])
     expect(tool(m, 'wf-1').status).toBe('success')
     expect(m.nodes.has('ec-1')).toBe(false)
   })
 
-  it('folds an edit_content result that raced ahead of its call into the merged row', () => {
+  it('folds an apply_file_edit result that raced ahead of its call into the merged row', () => {
     const sub: Scope = { lane: 'subagent', spanId: 'S1' }
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-file'),
-      toolCall(2, 'wf-1', 'workspace_file', sub),
-      // Result for edit_content arrives BEFORE its call (buffered under ec-1)...
+      toolCall(2, 'wf-1', 'prepare_file_edit', sub),
+      // Result for apply_file_edit arrives BEFORE its call (buffered under ec-1)...
       toolResult(3, 'ec-1', true, undefined, sub),
       // ...then the call lands and aliases ec-1 -> wf-1, draining the buffer.
-      toolCall(4, 'ec-1', 'edit_content', sub),
+      toolCall(4, 'ec-1', 'apply_file_edit', sub),
     ])
     expect(tool(m, 'wf-1').status).toBe('success')
     expect(tool(m, 'wf-1').result?.success).toBe(true)
@@ -386,13 +409,13 @@ describe('reduceEvent — edit_content row merge', () => {
     const sub: Scope = { lane: 'subagent', spanId: 'S1' }
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-file'),
-      // Section 1: the workspace_file row is reopened by its edit_content, but the
+      // Section 1: the prepare_file_edit row is reopened by its apply_file_edit, but the
       // edit's closing result is reordered/dropped — wf-1 is left running.
-      toolCall(2, 'wf-1', 'workspace_file', sub),
+      toolCall(2, 'wf-1', 'prepare_file_edit', sub),
       toolResult(3, 'wf-1', true, undefined, sub),
-      toolCall(4, 'ec-1', 'edit_content', sub),
+      toolCall(4, 'ec-1', 'apply_file_edit', sub),
       // Section 2 opens before section 1's edit result lands.
-      toolCall(5, 'wf-2', 'workspace_file', sub),
+      toolCall(5, 'wf-2', 'prepare_file_edit', sub),
     ])
     // The previous section settles instead of spinning until the turn terminal...
     expect(tool(m, 'wf-1').status).toBe('success')
@@ -498,7 +521,7 @@ describe('turn-terminal propagation', () => {
     // A file subagent opened but no span end arrived (mid-stream error/disconnect).
     const m = apply([
       spanStart(1, 'S1', 'file', 'tc-file'),
-      toolCall(2, 'wf-1', 'workspace_file', { lane: 'subagent', spanId: 'S1' }),
+      toolCall(2, 'wf-1', 'prepare_file_edit', { lane: 'subagent', spanId: 'S1' }),
     ])
     expect(agent(m, 'S1').endSeq).toBeUndefined()
     applyTurnTerminal(m, 'error')
@@ -556,3 +579,93 @@ describe('reduceEvent — span-start owner reconciliation', () => {
     expect((lane as AgentNode).agentId).toBe('workflow')
   })
 })
+
+describe('reduceEvent — span end settles stale lane tools', () => {
+  const laneScope = { lane: 'subagent', spanId: 'S1', parentToolCallId: 'd1' } as Scope
+
+  it('marks still-running tools success when their lane ends cleanly', () => {
+    const model = apply([
+      envelope(
+        1,
+        'span',
+        { kind: 'subagent', event: 'start', agent: 'browser', data: { tool_call_id: 'd1' } },
+        laneScope
+      ),
+      toolCall(2, 'click-1', 'browser_click', laneScope),
+      // No result for click-1 — dropped/reordered past the lane end.
+      envelope(
+        3,
+        'span',
+        { kind: 'subagent', event: 'end', agent: 'browser', data: {} },
+        laneScope
+      ),
+    ])
+
+    const click = model.nodes.get('click-1')
+    if (click?.kind !== 'tool') throw new Error('expected tool node')
+    expect(click.status).toBe('success')
+
+    const laneId = model.agentBySpanId.get('S1')
+    const lane = laneId ? model.nodes.get(laneId) : undefined
+    if (lane?.kind !== 'agent') throw new Error('expected agent lane')
+    expect(lane.status).toBe('success')
+  })
+
+  it('marks still-running tools error when the lane ends with an error', () => {
+    const model = apply([
+      envelope(
+        1,
+        'span',
+        { kind: 'subagent', event: 'start', agent: 'browser', data: { tool_call_id: 'd1' } },
+        laneScope
+      ),
+      toolCall(2, 'click-1', 'browser_click', laneScope),
+      envelope(
+        3,
+        'span',
+        { kind: 'subagent', event: 'end', agent: 'browser', data: { error: 'boom' } },
+        laneScope
+      ),
+    ])
+
+    const click = model.nodes.get('click-1')
+    if (click?.kind !== 'tool') throw new Error('expected tool node')
+    expect(click.status).toBe('error')
+  })
+
+  it('leaves settled tools alone and lets a late result overwrite the settle', () => {
+    const model = apply([
+      envelope(
+        1,
+        'span',
+        { kind: 'subagent', event: 'start', agent: 'browser', data: { tool_call_id: 'd1' } },
+        laneScope
+      ),
+      toolCall(2, 'click-1', 'browser_click', laneScope),
+      envelope(
+        3,
+        'span',
+        { kind: 'subagent', event: 'end', agent: 'browser', data: {} },
+        laneScope
+      ),
+      // Late result arrives after the settle — it must win.
+      envelope(
+        4,
+        'tool',
+        {
+          phase: 'result',
+          toolCallId: 'click-1',
+          toolName: 'browser_click',
+          success: false,
+          error: 'nope',
+        },
+        laneScope
+      ),
+    ])
+
+    const click = model.nodes.get('click-1')
+    if (click?.kind !== 'tool') throw new Error('expected tool node')
+    expect(click.status).toBe('error')
+    expect(click.result?.error).toBe('nope')
+  })
+})
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.ts
index 9139fe504e..6097a22cf7 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/stream/turn-model.ts
@@ -85,6 +85,8 @@ export interface AgentNode extends NodeBase {
   agentId: string
   /** The outer delegation tool_use that triggered this run; links the trigger tool node. */
   triggerToolCallId?: string
+  /** Orchestrator-chosen display name for this delegation (falls back to the agent label). */
+  displayName?: string
   status: NodeStatus
   /** Wire seq at which the run terminated (span end), for ordering the close marker. */
   endSeq?: number
@@ -121,7 +123,7 @@ export interface TurnModel {
   >
   /**
    * Maps a tool call id to another tool node it folds into. Used for the
-   * `edit_content` -> `workspace_file` row merge so the write streams into the
+   * `apply_file_edit` -> `prepare_file_edit` row merge so the write streams into the
    * single "writing" row rather than a second row.
    */
   toolAlias: Map<string, string>
@@ -142,16 +144,16 @@ export function createTurnModel(): TurnModel {
   }
 }
 
-const WORKSPACE_FILE_TOOL = 'workspace_file'
-const EDIT_CONTENT_TOOL = 'edit_content'
+const WORKSPACE_FILE_TOOL = 'prepare_file_edit'
+const EDIT_CONTENT_TOOL = 'apply_file_edit'
 
-/** Resolves a tool call id through the alias map (e.g. edit_content -> its workspace_file row). */
+/** Resolves a tool call id through the alias map (e.g. apply_file_edit -> its prepare_file_edit row). */
 export function resolveToolId(model: TurnModel, id: string): string {
   return model.toolAlias.get(id) ?? id
 }
 
 /**
- * Finds the most recent `workspace_file` tool node in a span so an `edit_content`
+ * Finds the most recent `prepare_file_edit` tool node in a span so an `apply_file_edit`
  * write folds into it (the single "writing" row). Co-location in the file
  * subagent's span is the link — no coupling to preview phases. The caller
  * reopens whatever this returns, including an already-settled row (an edit after
@@ -169,11 +171,11 @@ function findWorkspaceFileNodeInSpan(model: TurnModel, spanId: string): ToolNode
 }
 
 /**
- * The file agent writes a file as strictly sequential `workspace_file` +
- * `edit_content` section pairs, waiting for each to finish before the next. So
- * when a new section's `workspace_file` opens, any earlier `workspace_file` row
+ * The file agent writes a file as strictly sequential `prepare_file_edit` +
+ * `apply_file_edit` section pairs, waiting for each to finish before the next. So
+ * when a new section's `prepare_file_edit` opens, any earlier `prepare_file_edit` row
  * still `running` in the same span is a completed section whose closing
- * `edit_content` result was reordered or dropped — finalize it as success so its
+ * `apply_file_edit` result was reordered or dropped — finalize it as success so its
  * "writing" spinner resolves when the next section starts, instead of lingering
  * until the turn-terminal sweep. A no-op on the happy path (prior rows already
  * settled on their own result).
@@ -331,8 +333,8 @@ function appendText(
 /**
  * Applies a result that raced ahead of its tool `call` (buffered under `fromId`)
  * onto `node`, then clears the buffer. Used by the normal call path and by the
- * edit_content -> workspace_file merge, where the buffer is keyed by the
- * edit_content id but folds into the workspace_file row.
+ * apply_file_edit -> prepare_file_edit merge, where the buffer is keyed by the
+ * apply_file_edit id but folds into the prepare_file_edit row.
  */
 function drainBufferedResult(model: TurnModel, fromId: string, node: ToolNode): void {
   const buffered = model.bufferedResults.get(fromId)
@@ -473,12 +475,12 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
       ensureSubagentLane(model, spanId, scope, seq, tsMs)
       const phase = payload.phase
       if (phase === MothershipStreamV1ToolPhase.call) {
-        // edit_content folds into its span's workspace_file row (the write
+        // apply_file_edit folds into its span's prepare_file_edit row (the write
         // continues in the single "writing" row), reopening it for the edit.
         if (toolName === EDIT_CONTENT_TOOL) {
-          // A re-emitted edit_content call (same tool call id — duplicate/replay)
+          // A re-emitted apply_file_edit call (same tool call id — duplicate/replay)
           // must keep its ORIGINAL target row. Re-running the span lookup can
-          // return a newer workspace_file, and folding into that would leave the
+          // return a newer prepare_file_edit, and folding into that would leave the
           // first (already reopened) row running with no result ever closing it —
           // a spinner stuck until the turn-terminal sweep. So once aliased, reuse.
           const aliasedId = model.toolAlias.get(rawToolCallId)
@@ -492,7 +494,7 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
             parent.status = 'running'
             parent.result = undefined
             // A result that raced ahead of this call was buffered under the
-            // edit_content id; fold it into the reopened workspace_file row.
+            // apply_file_edit id; fold it into the reopened prepare_file_edit row.
             drainBufferedResult(model, rawToolCallId, parent)
             break
           }
@@ -563,6 +565,7 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
       const triggerToolCallId =
         scope?.parentToolCallId ?? asString(data?.tool_call_id) ?? asString(data?.toolCallId)
       const agentId = asString(payload.agent) ?? scope?.agentId ?? ''
+      const displayName = asString(data?.name)
       const resolvedSpanId =
         scope?.spanId ?? (triggerToolCallId ? `span:${triggerToolCallId}` : `span:${seq}`)
       const parentSpanId = scope?.parentSpanId ?? MAIN_SPAN
@@ -581,6 +584,7 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
           // scope.agentId can name the forwarding caller (e.g. superagent),
           // while this start's payload.agent is the authoritative lane owner.
           if (agentId && existing.agentId !== agentId) existing.agentId = agentId
+          if (displayName) existing.displayName = displayName
           if (!existing.triggerToolCallId && triggerToolCallId) {
             existing.triggerToolCallId = triggerToolCallId
           }
@@ -602,6 +606,7 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
           seq: seq,
           ...(tsMs !== undefined ? { startedAtMs: tsMs } : {}),
           ...(triggerToolCallId ? { triggerToolCallId } : {}),
+          ...(displayName ? { displayName } : {}),
         }
         model.nodes.set(node.id, node)
         model.order.push(node.id)
@@ -611,10 +616,25 @@ export function reduceEvent(model: TurnModel, envelope: PersistedStreamEventEnve
         if (data?.pending === true) break
         breakLane(model, resolvedSpanId, tsMs)
         const node = model.nodes.get(resolvedSpanId)
+        const spanErrored = Boolean(data && asString(data.error))
         if (node && node.kind === 'agent' && !isNodeTerminal(node.status)) {
-          node.status = data && asString(data.error) ? 'error' : 'success'
+          node.status = spanErrored ? 'error' : 'success'
           node.endSeq = seq
         }
+        // The lane is over: settle any tool row still `running` in it (its
+        // result was dropped or reordered past the end). Left open, the row
+        // pins the whole group expanded and shimmering for the rest of the
+        // turn even though the subagent already returned. A late result event
+        // still corrects this — applyToolResult overwrites unconditionally.
+        for (const id of model.order) {
+          const stale = model.nodes.get(id)
+          if (stale?.kind === 'tool' && stale.spanId === resolvedSpanId) {
+            if (stale.status === 'running') {
+              stale.status = spanErrored ? 'error' : 'success'
+              stale.streamingArgs = undefined
+            }
+          }
+        }
       }
       break
     }
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.test.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.test.ts
index 281714e81d..d0212d24b3 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.test.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.test.ts
@@ -12,7 +12,10 @@ import {
   getReplayCompletedWorkflowToolCallIds,
   panelForExecutingClientTool,
   reconcileLiveAssistantTurn,
+  selectDeletedWorkflowResources,
   selectReconnectReplayState,
+  shouldActivateResourceEvent,
+  shouldQueueOutgoingMessage,
   waitForDetachedChatResolution,
 } from '@/app/workspace/[workspaceId]/home/hooks/use-chat'
 import type {
@@ -30,6 +33,76 @@ vi.mock('next/navigation', () => ({
   }),
 }))
 
+describe('selectDeletedWorkflowResources', () => {
+  const resource = (id: string) => ({ type: 'workflow' as const, id, title: id })
+  const cached = (id: string) => ({
+    id,
+    name: id,
+    lastModified: new Date(0),
+    createdAt: new Date(0),
+    sortOrder: 0,
+  })
+
+  it('selects a hydrated workflow the server no longer has', () => {
+    expect(selectDeletedWorkflowResources([resource('wf-gone')], new Set(), [])).toEqual([
+      resource('wf-gone'),
+    ])
+  })
+
+  it('keeps a workflow present in the fetched list', () => {
+    expect(selectDeletedWorkflowResources([resource('wf-1')], new Set(['wf-1']), [])).toEqual([])
+  })
+
+  it('keeps a workflow the stream inserted into the cache after the list snapshot', () => {
+    expect(
+      selectDeletedWorkflowResources([resource('wf-new')], new Set(), [cached('wf-new')])
+    ).toEqual([])
+  })
+})
+
+describe('shouldActivateResourceEvent', () => {
+  it('surfaces browser work even when another resource is selected', () => {
+    expect(shouldActivateResourceEvent('file-1', 'browser-session')).toBe(true)
+  })
+
+  it('surfaces every other resource the agent touches', () => {
+    expect(shouldActivateResourceEvent('file-1', 'workflow-1')).toBe(true)
+    expect(shouldActivateResourceEvent('browser-session', 'terminal-session')).toBe(true)
+    expect(shouldActivateResourceEvent(null, 'browser-session')).toBe(true)
+  })
+
+  it('honors an explicit request to activate', () => {
+    expect(shouldActivateResourceEvent('file-1', 'browser-session', { activate: true })).toBe(true)
+  })
+
+  it('lets an event opt out of stealing focus', () => {
+    expect(shouldActivateResourceEvent('file-1', 'browser-session', { activate: false })).toBe(
+      false
+    )
+  })
+})
+
+describe('shouldQueueOutgoingMessage', () => {
+  it('queues while a send is in flight', () => {
+    expect(shouldQueueOutgoingMessage(true, false, 0)).toBe(true)
+  })
+
+  it('queues while a stop is still settling', () => {
+    expect(shouldQueueOutgoingMessage(false, true, 0)).toBe(true)
+  })
+
+  it('queues behind messages still waiting after the turn ended', () => {
+    // The regression: a message queued mid-stream must dispatch before one
+    // typed in the idle gap after the turn stopped — a direct send here would
+    // jump the queue and swap the user's message order.
+    expect(shouldQueueOutgoingMessage(false, false, 1)).toBe(true)
+  })
+
+  it('sends directly on an idle chat with an empty queue', () => {
+    expect(shouldQueueOutgoingMessage(false, false, 0)).toBe(false)
+  })
+})
+
 function userMessage(id: string): PersistedMessage {
   return {
     id,
diff --git a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
index acbea0bd61..b3e422d532 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts
@@ -30,7 +30,7 @@ import { onOpenInBrowserPanel } from '@/lib/browser-agent/open-in-panel'
 import {
   cancelActiveBrowserTools,
   initBrowserAgentTransport,
-  sendBrowserPanelAction,
+  openUrlInNewBrowserTab,
 } from '@/lib/browser-agent/transport'
 import { getMothershipAttachmentPreviewUrl } from '@/lib/copilot/chat/attachment-preview'
 import { toDisplayMessage } from '@/lib/copilot/chat/display-message'
@@ -126,8 +126,10 @@ import { getFolderMap } from '@/hooks/queries/utils/folder-cache'
 import { invalidateWorkflowSelectors } from '@/hooks/queries/utils/invalidate-workflow-lists'
 import { getTopInsertionSortOrder } from '@/hooks/queries/utils/top-insertion-sort-order'
 import { getWorkflowById, getWorkflows } from '@/hooks/queries/utils/workflow-cache'
+import { getWorkflowListQueryOptions } from '@/hooks/queries/utils/workflow-list-query'
 import { workflowKeys } from '@/hooks/queries/workflows'
 import { useExecutionStream } from '@/hooks/use-execution-stream'
+import { snapAllSmoothText } from '@/hooks/use-smooth-text'
 import { useExecutionStore } from '@/stores/execution/store'
 import { useMothershipQueueStore } from '@/stores/mothership-queue/store'
 import type {
@@ -228,6 +230,7 @@ const RECONNECT_TAIL_ERROR =
 const MAX_RECONNECT_ATTEMPTS = 10
 const RECONNECT_BASE_DELAY_MS = 1000
 const RECONNECT_MAX_DELAY_MS = 30_000
+const RECONNECT_EXHAUSTED_RECHECK_MS = 30_000
 const STREAM_BATCH_FETCH_TIMEOUT_MS = 10_000
 const STREAM_CHAT_ID_RESOLVE_TIMEOUT_MS = 10_000
 const CHAT_HISTORY_RECOVERY_TIMEOUT_MS = 10_000
@@ -1188,8 +1191,65 @@ function ensureWorkflowInRegistry(resourceId: string, title: string, workspaceId
   return true
 }
 
+/**
+ * Hydrated workflow resources whose workflow exists neither in the fetched
+ * server list nor in the local cache. The cache term protects a workflow the
+ * agent created after the list snapshot was taken — the stream's registry
+ * insert lands it in the cache before any refetch does.
+ */
+export function selectDeletedWorkflowResources(
+  workflowResources: MothershipResource[],
+  fetchedWorkflowIds: ReadonlySet<string>,
+  cachedWorkflows: readonly WorkflowMetadata[]
+): MothershipResource[] {
+  const cachedIds = new Set(cachedWorkflows.map((workflow) => workflow.id))
+  return workflowResources.filter(
+    (resource) => !fetchedWorkflowIds.has(resource.id) && !cachedIds.has(resource.id)
+  )
+}
+
+export interface ResourceEventOptions {
+  activate?: boolean
+}
+
+export type ResourceEventHandler = (resourceId: string, options?: ResourceEventOptions) => void
+
+/**
+ * Whether a streamed resource event should activate its tab. The panel always
+ * follows the agent: whatever it is creating, editing, or driving becomes the
+ * visible resource, browser sessions included. The parameters are retained so
+ * callers stay explicit about the resource in play, and so a future opt-out
+ * (an event that deliberately declines focus) has a place to live.
+ */
+export function shouldActivateResourceEvent(
+  _activeResourceId: string | null,
+  _resourceId: string,
+  options?: ResourceEventOptions
+): boolean {
+  return options?.activate !== false
+}
+
+/**
+ * Whether a fresh outbound message must join the chat's send queue instead of
+ * dispatching directly. Queueing while a send or stop is in flight is the
+ * obvious half; the queued-ahead term preserves FIFO across the
+ * streaming→idle boundary — a message queued while the previous turn streamed
+ * must reach the model before one typed after that turn ended but before the
+ * queue drained. Without it the fresh send jumps the queue and both the
+ * transcript and the model see the user's messages in swapped order. The two
+ * signals never gap mid-dispatch: a queued message stays in the queue until
+ * its optimistic send applies, which is after the in-flight flag is set.
+ */
+export function shouldQueueOutgoingMessage(
+  sendInFlight: boolean,
+  stopPending: boolean,
+  queuedAheadCount: number
+): boolean {
+  return sendInFlight || stopPending || queuedAheadCount > 0
+}
+
 export interface UseChatOptions {
-  onResourceEvent?: (resourceId: string) => void
+  onResourceEvent?: ResourceEventHandler
   apiPath?: string
   stopPath?: string
   workflowId?: string
@@ -1437,6 +1497,10 @@ export function useChat(
     () => {}
   )
   const recoveringQueuedSendHandoffRef = useRef<ActiveQueuedSendHandoffRecovery | null>(null)
+  const recoverActiveStreamRef = useRef<
+    (reason: 'pageshow' | 'visible' | 'online' | 'exhausted_recheck') => Promise<void>
+  >(async () => {})
+  const reconnectExhaustedRecheckTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
 
   const abortControllerRef = useRef<AbortController | null>(null)
   const detachedChatResolutionControllersRef = useRef<Set<AbortController>>(new Set())
@@ -1814,6 +1878,37 @@ export function useChat(
     }
   }, [])
 
+  /**
+   * Drops hydrated workflow tabs whose workflow no longer exists, so an old
+   * chat cannot resurrect a deleted workflow. The check is against a fetched
+   * workflow list rather than the cache: seeding the registry from the chat's
+   * persisted resources (what hydration previously did unconditionally) put
+   * phantom entries in the sidebar that 404 on click. Removal also deletes the
+   * resource from the chat's persisted set, so the tab stays gone next open.
+   */
+  const reconcileHydratedWorkflowResources = useCallback(
+    async (chatId: string, workflowResources: MothershipResource[]) => {
+      let existing: WorkflowMetadata[]
+      try {
+        existing = await getQueryClient().fetchQuery(getWorkflowListQueryOptions(workspaceId))
+      } catch {
+        // Existence is unknowable right now; keep the tabs rather than delete
+        // resources on a network failure. The next hydration retries.
+        return
+      }
+      const deleted = selectDeletedWorkflowResources(
+        workflowResources,
+        new Set(existing.map((workflow) => workflow.id)),
+        getWorkflows(workspaceId)
+      )
+      for (const resource of deleted) {
+        if ((chatIdRef.current ?? selectedChatIdRef.current) !== chatId) return
+        removeResource('workflow', resource.id)
+      }
+    },
+    [workspaceId, removeResource]
+  )
+
   const reorderResources = useCallback((newOrder: MothershipResource[]) => {
     setResources(newOrder)
     const persistChatId = chatIdRef.current ?? selectedChatIdRef.current
@@ -1924,12 +2019,14 @@ export function useChat(
   )
 
   const openBrowserResource = useCallback(() => {
+    // Browser work surfaces like any other agent activity: the panel follows
+    // the agent to the browser whether or not the session was already open.
     addResource({
       type: 'browser',
       id: BROWSER_SESSION_RESOURCE_ID,
       title: 'Browser',
     })
-    onResourceEventRef.current?.(BROWSER_SESSION_RESOURCE_ID)
+    onResourceEventRef.current?.(BROWSER_SESSION_RESOURCE_ID, { activate: true })
   }, [addResource])
 
   const getResourceActivityTracker = useCallback(
@@ -2047,7 +2144,11 @@ export function useChat(
   useEffect(() => {
     return onOpenInBrowserPanel((url) => {
       openBrowserResource()
-      sendBrowserPanelAction('navigate', { url }, desktopScopeIdRef.current)
+      void openUrlInNewBrowserTab(url, desktopScopeIdRef.current).catch((error) => {
+        logger.warn('Failed to open chat link in a new browser tab', {
+          error: getErrorMessage(error),
+        })
+      })
     })
   }, [openBrowserResource])
 
@@ -2355,9 +2456,12 @@ export function useChat(
         setActiveResourceId(hydratedActiveResourceId)
       }
 
-      for (const resource of persistedResources) {
-        if (resource.type !== 'workflow') continue
-        ensureWorkflowInRegistry(resource.id, resource.title, workspaceId)
+      // Restored workflow tabs are verified against the server instead of
+      // seeded into the registry: a chat can outlive its workflows, and
+      // fabricating entries for deleted ones polluted the sidebar.
+      const workflowResources = persistedResources.filter((r) => r.type === 'workflow')
+      if (workflowResources.length > 0) {
+        void reconcileHydratedWorkflowResources(chatHistory.id, workflowResources)
       }
     } else if (hasPersistedStreamingFile) {
       activeResourceIdRef.current = null
@@ -2442,6 +2546,7 @@ export function useChat(
     flushPendingResources,
     openBrowserResource,
     openTerminalResource,
+    reconcileHydratedWorkflowResources,
     recoverPendingClientWorkflowTools,
     seedPreviewSessions,
     setTransportIdle,
@@ -3199,7 +3304,29 @@ export function useChat(
         maxAttempts: MAX_RECONNECT_ATTEMPTS,
       })
       if (streamGenRef.current === gen) {
+        /**
+         * Never give up silently: surface the failure so the pane shows why
+         * the live stream stopped instead of a torn-down transcript. Callers
+         * own the finalize on a false return (every call site finalizes with
+         * error: true), which refetches the persisted transcript; if the
+         * server turn is still running, the visibility/online recovery path
+         * re-attaches on the next pageshow/visible/online event.
+         */
         setIsReconnecting(false)
+        setError(RECONNECT_TAIL_ERROR)
+        /**
+         * The tab may stay visible (no pageshow/visible/online event will ever
+         * fire) while the server turn keeps running detached. One bounded
+         * recheck re-enters recovery once the transient network condition has
+         * had time to clear; recovery itself no-ops when nothing is active.
+         */
+        if (reconnectExhaustedRecheckTimerRef.current) {
+          clearTimeout(reconnectExhaustedRecheckTimerRef.current)
+        }
+        reconnectExhaustedRecheckTimerRef.current = setTimeout(() => {
+          reconnectExhaustedRecheckTimerRef.current = null
+          void recoverActiveStreamRef.current('exhausted_recheck')
+        }, RECONNECT_EXHAUSTED_RECHECK_MS)
       }
       return false
     },
@@ -3208,7 +3335,7 @@ export function useChat(
   retryReconnectRef.current = retryReconnect
 
   const recoverActiveStreamFromRedis = useCallback(
-    async (reason: 'pageshow' | 'visible' | 'online'): Promise<void> => {
+    async (reason: 'pageshow' | 'visible' | 'online' | 'exhausted_recheck'): Promise<void> => {
       const startingChatId = chatIdRef.current
       const startingSelectedChatId = selectedChatIdRef.current
       const chatId = startingChatId ?? startingSelectedChatId
@@ -3343,6 +3470,7 @@ export function useChat(
     },
     [getActiveStreamIdForChat, queryClient, resumeOrFinalize, setTransportReconnecting]
   )
+  recoverActiveStreamRef.current = recoverActiveStreamFromRedis
 
   useEffect(() => {
     if (typeof window === 'undefined' || typeof document === 'undefined') return
@@ -3374,6 +3502,10 @@ export function useChat(
       document.removeEventListener('visibilitychange', handleVisibilityChange)
       window.removeEventListener('pageshow', handlePageShow)
       window.removeEventListener('online', handleOnline)
+      if (reconnectExhaustedRecheckTimerRef.current) {
+        clearTimeout(reconnectExhaustedRecheckTimerRef.current)
+        reconnectExhaustedRecheckTimerRef.current = null
+      }
     }
   }, [recoverActiveStreamFromRedis])
 
@@ -4164,12 +4296,23 @@ export function useChat(
 
       // An in-flight send drains the queue from `finalize`; a pending stop kicks
       // the dispatcher itself, since nothing else will once the stop settles.
-      if (sendingRef.current || pendingStopPromiseRef.current) {
+      // A non-empty queue forces queueing even on an idle chat: messages
+      // queued while the previous turn streamed must go out first, so a fresh
+      // send lands behind them instead of jumping the line in the drain gap
+      // after a turn ends.
+      const queuedAheadCount = (queueStore.queues[activeChatKey] ?? EMPTY_MESSAGE_QUEUE).length
+      if (
+        shouldQueueOutgoingMessage(
+          Boolean(sendingRef.current),
+          Boolean(pendingStopPromiseRef.current),
+          queuedAheadCount
+        )
+      ) {
         queueStore.enqueue(
           activeChatKey,
           createQueuedMessage(message, fileAttachments, contexts, options?.resumeUserMessageId)
         )
-        if (pendingStopPromiseRef.current) {
+        if (pendingStopPromiseRef.current || (queuedAheadCount > 0 && !sendingRef.current)) {
           void enqueueQueueDispatchRef.current({ type: 'send_head' })
         }
         return
@@ -4518,6 +4661,9 @@ export function useChat(
       abortControllerRef.current?.abort('user_stop:client_stopGeneration')
       abortControllerRef.current = null
       setTransportIdle()
+      // The paced reveal may still hold up to a drain-horizon of buffered text;
+      // after an explicit Stop it must not keep typing itself out.
+      snapAllSmoothText()
 
       try {
         if (activeChatId) {
diff --git a/apps/sim/app/workspace/[workspaceId]/home/types.ts b/apps/sim/app/workspace/[workspaceId]/home/types.ts
index e6d21c2776..9634055b5e 100644
--- a/apps/sim/app/workspace/[workspaceId]/home/types.ts
+++ b/apps/sim/app/workspace/[workspaceId]/home/types.ts
@@ -1,7 +1,7 @@
 import type { ChatContext } from '@/stores/panel'
 import type { BrowserTextSelection, TerminalTextSelection } from '@/stores/panel/types'
 
-const EDIT_CONTENT_TOOL_ID = 'edit_content'
+const EDIT_CONTENT_TOOL_ID = 'apply_file_edit'
 const RUN_SUBAGENT_ID = 'run'
 
 export type {
@@ -114,6 +114,8 @@ export interface ContentBlock {
   type: ContentBlockType
   content?: string
   subagent?: string
+  /** Orchestrator-chosen display name for a `subagent` start block (shown instead of the generic agent label). */
+  subagentName?: string
   toolCall?: ToolCallInfo
   options?: OptionItem[]
   timestamp?: number
@@ -189,9 +191,13 @@ export const SUBAGENT_LABELS: Record<string, string> = {
   custom_tool: 'Custom Tool Agent',
   scout: 'Scout Agent',
   search: 'Search Agent',
+  platform: 'Platform Agent',
   superagent: 'Superagent',
   run: 'Run Agent',
-  agent: 'Tools Agent',
+  // The extensions subagent's wire/scope AgentID stays `agent` (pre-rename);
+  // `extensions` is its current model-facing trigger tool name.
+  agent: 'Extensions Agent',
+  extensions: 'Extensions Agent',
   // `job` retained as a backward-compat alias so historical transcripts still render a label.
   job: 'Job Agent',
   file: 'File Agent',
diff --git a/apps/sim/app/workspace/[workspaceId]/integrations/components/connect-slack-bot-modal/connect-slack-bot-modal.tsx b/apps/sim/app/workspace/[workspaceId]/integrations/components/connect-slack-bot-modal/connect-slack-bot-modal.tsx
index 449e1dbe83..cf0a76bcac 100644
--- a/apps/sim/app/workspace/[workspaceId]/integrations/components/connect-slack-bot-modal/connect-slack-bot-modal.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/integrations/components/connect-slack-bot-modal/connect-slack-bot-modal.tsx
@@ -29,6 +29,7 @@ import {
   SLACK_CAPABILITIES,
   SLACK_MANAGED_USER_AUTHORIZATION_CAPABILITY,
 } from '@/triggers/slack/capabilities'
+import { buildSlackCustomBotRequestUrl } from '@/triggers/webhook-url'
 
 const logger = createLogger('ConnectSlackBotModal')
 
@@ -119,13 +120,9 @@ export function ConnectSlackBotModal({
     }
   }, [open, created, isReconnect, initialDisplayName, initialDescription])
 
-  // NEXT_PUBLIC_APP_URL, not window.location.origin: Slack's servers must be
-  // able to reach this URL, so it has to be the app's public base (e.g. the
-  // tunnel host in dev), not whatever host the browser happens to be on.
-  const requestUrl = useMemo(
-    () => `${getBaseUrl()}/api/webhooks/slack/custom/${credentialId}`,
-    [credentialId]
-  )
+  // Shared server-side derivation: uses the app public base (not
+  // window.location.origin) so Slack's servers can reach it.
+  const requestUrl = useMemo(() => buildSlackCustomBotRequestUrl(credentialId), [credentialId])
 
   const manifestJson = useMemo(() => {
     const managedUserAuthorization = selected.has(SLACK_MANAGED_USER_AUTHORIZATION_CAPABILITY.id)
diff --git a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/document.tsx b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/document.tsx
index 3f2d482dbe..3edc072014 100644
--- a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/document.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/document.tsx
@@ -37,6 +37,7 @@ import {
   EMPTY_CELL_PLACEHOLDER,
   Resource,
   ResourceNotFound,
+  SearchHighlight,
 } from '@/app/workspace/[workspaceId]/components'
 import {
   FOLDERED_RESOURCE_HEADERS,
@@ -55,7 +56,7 @@ import {
   documentParsers,
   documentUrlKeys,
 } from '@/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/search-params'
-import { ActionBar, SearchHighlight } from '@/app/workspace/[workspaceId]/knowledge/[id]/components'
+import { ActionBar } from '@/app/workspace/[workspaceId]/knowledge/[id]/components'
 import { getDocumentIcon } from '@/app/workspace/[workspaceId]/knowledge/components'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import { useContextMenu } from '@/app/workspace/[workspaceId]/w/components/sidebar/hooks'
diff --git a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/base.tsx b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/base.tsx
index 6d61db64ea..95c2e69871 100644
--- a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/base.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/base.tsx
@@ -64,6 +64,7 @@ import {
   isResourceListEmpty,
   Resource,
   ResourceNotFound,
+  SearchHighlight,
 } from '@/app/workspace/[workspaceId]/components'
 import {
   FOLDERED_RESOURCE_HEADERS,
@@ -81,7 +82,6 @@ import {
   ConnectorsSection,
   DocumentContextMenu,
   RenameDocumentModal,
-  SearchHighlight,
 } from '@/app/workspace/[workspaceId]/knowledge/[id]/components'
 import {
   addConnectorParam,
diff --git a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/index.ts b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/index.ts
index 12e32ebf73..d26e85dc9e 100644
--- a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/index.ts
+++ b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/index.ts
@@ -6,4 +6,3 @@ export { ConnectorsSection } from './connectors-section'
 export { DocumentContextMenu } from './document-context-menu'
 export { EditConnectorModal } from './edit-connector-modal'
 export { RenameDocumentModal } from './rename-document-modal'
-export { SearchHighlight } from './search-highlight'
diff --git a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/search-highlight/index.ts b/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/search-highlight/index.ts
deleted file mode 100644
index 1144ed165c..0000000000
--- a/apps/sim/app/workspace/[workspaceId]/knowledge/[id]/components/search-highlight/index.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { SearchHighlight } from './search-highlight'
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.test.tsx b/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.test.tsx
index 327771b3a5..bb3e1a1109 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.test.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.test.tsx
@@ -87,8 +87,22 @@ vi.mock('@sim/emcn', () => ({
     </select>
   ),
   Label: ({ children }: { children: ReactNode }) => <span>{children}</span>,
-  Switch: ({ checked }: { checked: boolean }) => (
-    <button type='button' role='switch' aria-checked={checked} />
+  Switch: ({
+    checked,
+    disabled,
+    onCheckedChange,
+  }: {
+    checked: boolean
+    disabled?: boolean
+    onCheckedChange?: (checked: boolean) => void
+  }) => (
+    <button
+      type='button'
+      role='switch'
+      aria-checked={checked}
+      disabled={disabled}
+      onClick={() => onCheckedChange?.(!checked)}
+    />
   ),
   toast: mockToast,
 }))
@@ -235,6 +249,7 @@ const IMPORTED_BOTH: BrowserChromeImportResult = {
 
 interface BridgeOverrides {
   browserEnabled?: boolean
+  browserSearchSuggestionsEnabled?: boolean
   browserTheme?: 'app' | 'light' | 'dark'
   browserDefaultZoom?: DesktopZoomPercent
   browserDownloadDirectory?: string
@@ -247,6 +262,7 @@ interface BridgeOverrides {
 
 function createBridge({
   browserEnabled = true,
+  browserSearchSuggestionsEnabled = true,
   browserTheme = 'app',
   browserDefaultZoom = 100,
   browserDownloadDirectory = '/Users/sim/Downloads',
@@ -263,6 +279,7 @@ function createBridge({
     launchAtLogin: false,
     autoDownloadUpdates: true,
     browserEnabled,
+    browserSearchSuggestionsEnabled,
     browserTheme,
     browserDefaultZoom,
     browserDownloadDirectory,
@@ -271,6 +288,10 @@ function createBridge({
     settings: {
       getPreferences: vi.fn(async () => preferences),
       setBrowserEnabled: vi.fn(),
+      setBrowserSearchSuggestionsEnabled: vi.fn(async (enabled: boolean) => ({
+        ...preferences,
+        browserSearchSuggestionsEnabled: enabled,
+      })),
       setBrowserTheme: vi.fn(async (theme: 'app' | 'light' | 'dark') => ({
         ...preferences,
         browserTheme: theme,
@@ -343,6 +364,7 @@ describe('Browser settings', () => {
 
     expect(container.textContent).toContain('Let Chat browse the web')
     expect(container.textContent).toContain('Theme')
+    expect(container.textContent).toContain('Search suggestions')
     expect(container.textContent).not.toContain(
       'Pages open in a browser built into Sim, signed in separately from your own.'
     )
@@ -352,6 +374,22 @@ describe('Browser settings', () => {
     expect(container.textContent).not.toContain('Saved passwords are never deleted here')
   })
 
+  it('explains and persists the live-search privacy switch', async () => {
+    const bridge = createBridge({ browserSearchSuggestionsEnabled: true })
+    mockBridge.current = bridge
+    await render()
+
+    expect(container.textContent).toContain(
+      'Send address-bar typing to Google for live completions'
+    )
+    const switches = [...container.querySelectorAll<HTMLButtonElement>('[role="switch"]')]
+    expect(switches[1]).toHaveAttribute('aria-checked', 'true')
+
+    await click(switches[1])
+
+    expect(bridge.settings.setBrowserSearchSuggestionsEnabled).toHaveBeenCalledWith(false)
+  })
+
   it('persists an independent website theme', async () => {
     const bridge = createBridge({ browserTheme: 'app' })
     mockBridge.current = bridge
diff --git a/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.tsx b/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.tsx
index 356d8c12aa..0710de9a7c 100644
--- a/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/settings/components/browser/browser.tsx
@@ -114,6 +114,14 @@ export function Browser() {
     setPreferences
   )
 
+  const { pending: searchSuggestionsPending, mutate: setSearchSuggestionsEnabled } =
+    useDesktopPreferenceMutation(
+      async (bridge, enabled: boolean) =>
+        bridge.settings.setBrowserSearchSuggestionsEnabled?.(enabled),
+      'Could not update browser search suggestions',
+      setPreferences
+    )
+
   const clear = useCallback(async (kinds: readonly BrowserDataKind[]) => {
     const desktop = getDesktopBridge()
     if (!desktop) return
@@ -145,6 +153,9 @@ export function Browser() {
   }
 
   const enabled = preferences.browserEnabled
+  const supportsSearchSuggestions = Boolean(
+    getDesktopBridge()?.settings.setBrowserSearchSuggestionsEnabled
+  )
   const target = confirming === 'all' ? null : confirming
 
   return (
@@ -172,6 +183,23 @@ export function Browser() {
               />
             </div>
 
+            {supportsSearchSuggestions && (
+              <div className='flex items-center justify-between gap-4'>
+                <div className='flex min-w-0 flex-col gap-1'>
+                  <Label htmlFor='browser-search-suggestions'>Search suggestions</Label>
+                  <p className='text-[var(--text-muted)] text-caption'>
+                    Send address-bar typing to Google for live completions
+                  </p>
+                </div>
+                <Switch
+                  id='browser-search-suggestions'
+                  checked={preferences.browserSearchSuggestionsEnabled ?? true}
+                  disabled={searchSuggestionsPending}
+                  onCheckedChange={(checked) => void setSearchSuggestionsEnabled(checked)}
+                />
+              </div>
+            )}
+
             <div className='flex items-center justify-between gap-4'>
               <Label>Theme</Label>
               <AppearanceThemeSelect
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
index f69e052706..379f94465c 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/components/table-grid/table-grid.tsx
@@ -28,6 +28,7 @@ import { columnTypeOf } from '@/lib/table/column-types'
 import { TABLE_LIMITS } from '@/lib/table/constants'
 import { cellValueFilterConditions } from '@/lib/table/query-builder/cell-filter'
 import { SEARCH_DEBOUNCE_MS } from '@/lib/url-state'
+import { FindBar } from '@/app/workspace/[workspaceId]/components'
 import { useUserPermissionsContext } from '@/app/workspace/[workspaceId]/providers/workspace-permissions-provider'
 import type { RemoteTableSelection } from '@/app/workspace/[workspaceId]/tables/[tableId]/hooks/use-table-room'
 import type { BlockedTableAction } from '@/app/workspace/[workspaceId]/tables/[tableId]/lock-copy'
@@ -63,7 +64,6 @@ import { ADD_COL_WIDTH, COL_WIDTH, SELECTION_TINT_BG } from './constants'
 import { DataRow } from './data-row'
 import { ColumnHeaderMenu, WorkflowGroupMetaCell } from './headers'
 import { RemoteSelectionOverlay } from './remote-selection-overlay'
-import { TableFind } from './table-find'
 import { AddRowButton, SelectAllCheckbox, TableColGroup } from './table-primitives'
 import type { DisplayColumn } from './types'
 import {
@@ -4592,7 +4592,8 @@ export function TableGrid({
     <div ref={containerRef} className='flex h-full flex-col overflow-hidden'>
       <div className='relative flex min-h-0 flex-1'>
         {findOpen && (
-          <TableFind
+          <FindBar
+            ariaLabel='Find in table'
             query={findQuery}
             onQueryChange={setFindQuery}
             onNext={handleFindNext}
diff --git a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx
index b94138e438..1dd2e81044 100644
--- a/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx
+++ b/apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx
@@ -125,6 +125,13 @@ interface TableProps {
    * today's Filter/Sort behavior.
    */
   viewsEnabled?: boolean
+  /**
+   * Saved view to adopt on first seed instead of the table's default —
+   * embedded mode only, set when the agent opened this table pinned to a
+   * view. Participates only in the one-time adoption branch, so it never
+   * fights a later user switch.
+   */
+  initialViewId?: string
 }
 
 /**
@@ -191,6 +198,7 @@ interface ViewConfigKeep {
  */
 export function Table({
   embedded,
+  initialViewId,
   workspaceId: propWorkspaceId,
   tableId: propTableId,
   tableLocksEnabled = false,
@@ -585,17 +593,23 @@ export function Table({
       const legacyAllWithDefault = activeViewId === ALL_VIEW_PARAM && defaultView !== null
 
       if (activeViewId === null || inheritedParams || legacyAllWithDefault) {
+        // Embedded mode may pin the view the agent opened this table on
+        // (`initialViewId`); the pin outranks the persisted default for this
+        // first adoption.
+        const pinnedView =
+          embedded && initialViewId ? views.find((view) => view.id === initialViewId) : undefined
+        const viewToApply = pinnedView ?? defaultView
         // `sort` rides the same host URL, so when the view id is inherited the
         // sort beside it is too — not local work, and it must not suppress the
         // default view's own sort.
         const keep = inheritedParams ? { ...localWork(), sort: false } : localWork()
-        if (defaultView) {
-          appliedViewRevisionRef.current = getTableViewRevision(defaultView)
-          setTableParams({ view: defaultView.id })
-          preserveViewState(defaultView.id, keep)
-          applyViewConfig(resolveTableViewConfig(tableData?.metadata, defaultView.config), keep)
-          resolvePendingLayout(defaultView.id)
-          flushPendingViewConfig(defaultView.id)
+        if (viewToApply) {
+          appliedViewRevisionRef.current = getTableViewRevision(viewToApply)
+          setTableParams({ view: viewToApply.id })
+          preserveViewState(viewToApply.id, keep)
+          applyViewConfig(resolveTableViewConfig(tableData?.metadata, viewToApply.config), keep)
+          resolvePendingLayout(viewToApply.id)
+          flushPendingViewConfig(viewToApply.id)
           return
         }
         // No view to adopt. Deliberately does NOT apply an empty config — that
diff --git a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
index 3f888b2e19..4dc59961db 100644
--- a/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
+++ b/apps/sim/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils.ts
@@ -1070,7 +1070,10 @@ export async function executeWorkflowWithFullLogging(
       error: errorMessage,
       httpStatus: response.status,
     })
-    throw new Error(errorMessage)
+    // Keep the status and code on the thrown error. Downgrading to a bare Error
+    // discarded both, so callers could not tell a Copilot binding rejection from
+    // any other 4xx — and the reason never reached the agent that could fix it.
+    throw new ExecutionStreamHttpError(errorMessage, response.status, errorCode)
   }
 
   if (!response.body) {
diff --git a/apps/sim/components/icons/document-icons.tsx b/apps/sim/components/icons/document-icons.tsx
index 6b669a44d6..cd4436318d 100644
--- a/apps/sim/components/icons/document-icons.tsx
+++ b/apps/sim/components/icons/document-icons.tsx
@@ -139,6 +139,26 @@ export function VideoIcon(props: SVGProps<SVGSVGElement>) {
   )
 }
 
+export function ChartFileIcon(props: SVGProps<SVGSVGElement>) {
+  return (
+    <svg
+      viewBox='0 0 24 24'
+      fill='none'
+      stroke='currentColor'
+      strokeWidth='1.5'
+      strokeLinecap='round'
+      strokeLinejoin='round'
+      xmlns='http://www.w3.org/2000/svg'
+      {...props}
+    >
+      <path d='M3 3v17a1 1 0 0 0 1 1h17' />
+      <rect x='7' y='12' width='3' height='6' rx='0.5' />
+      <rect x='12.5' y='8' width='3' height='10' rx='0.5' />
+      <rect x='18' y='5' width='3' height='13' rx='0.5' />
+    </svg>
+  )
+}
+
 export function HtmlIcon(props: SVGProps<SVGSVGElement>) {
   return (
     <svg
@@ -277,6 +297,16 @@ export function getDocumentIcon(
     return PptxIcon
   }
 
+  if (mimeType === 'text/x-sim-chart' || extension === 'chart') {
+    return ChartFileIcon
+  }
+
+  // Sim pages present as plain documents, not as HTML artifacts — the .html
+  // is an implementation detail (legacy pages still carry the extension).
+  if (mimeType === 'text/x-sim-page') {
+    return DefaultFileIcon
+  }
+
   if (mimeType === 'text/html' || extension === 'html' || extension === 'htm') {
     return HtmlIcon
   }
diff --git a/apps/sim/ee/access-control/components/group-detail.tsx b/apps/sim/ee/access-control/components/group-detail.tsx
index 406f04fe44..0fe1deaa51 100644
--- a/apps/sim/ee/access-control/components/group-detail.tsx
+++ b/apps/sim/ee/access-control/components/group-detail.tsx
@@ -30,6 +30,7 @@ import { useQueryState } from 'nuqs'
 import { saveDiscardActions } from '@/components/settings/save-discard-actions'
 import type { ShareAuthType } from '@/lib/api/contracts/public-shares'
 import { isBlockTypeAccessControlExempt } from '@/lib/permission-groups/block-access'
+import { PLATFORM_CATEGORY_ORDER, PLATFORM_FEATURES } from '@/lib/permission-groups/features'
 import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
 import { UnsavedChangesModal } from '@/app/workspace/[workspaceId]/components/credential-detail'
 import {
@@ -174,151 +175,6 @@ function AuthModeField({ label, value, onChange, options, disabled }: AuthModeFi
   )
 }
 
-/** Render order for the platform-feature category sections; unlisted ones follow. */
-const PLATFORM_CATEGORY_ORDER = [
-  'Sidebar',
-  'Deploy Tabs',
-  'Chat',
-  'Collaboration',
-  'Workflow Panel',
-  'Tools',
-  'Features',
-  'Settings Tabs',
-  'Logs',
-  'Files',
-]
-
-const PLATFORM_FEATURES = [
-  {
-    id: 'hide-knowledge-base',
-    label: 'Knowledge Base',
-    category: 'Sidebar',
-    configKey: 'hideKnowledgeBaseTab' as const,
-    hint: 'Hide the Knowledge Base module from the sidebar.',
-  },
-  {
-    id: 'hide-tables',
-    label: 'Tables',
-    category: 'Sidebar',
-    configKey: 'hideTablesTab' as const,
-    hint: 'Hide the Tables module from the sidebar.',
-  },
-  {
-    id: 'hide-copilot',
-    label: 'Chat',
-    category: 'Workflow Panel',
-    configKey: 'hideCopilot' as const,
-    hint: 'Hide the Chat panel so users cannot build or edit with natural language.',
-  },
-  {
-    id: 'hide-integrations',
-    label: 'Integrations',
-    category: 'Settings Tabs',
-    configKey: 'hideIntegrationsTab' as const,
-    hint: 'Hide the Integrations settings tab (OAuth connections).',
-  },
-  {
-    id: 'hide-secrets',
-    label: 'Secrets',
-    category: 'Settings Tabs',
-    configKey: 'hideSecretsTab' as const,
-    hint: 'Hide the Secrets (environment variables) settings tab.',
-  },
-  {
-    id: 'hide-api-keys',
-    label: 'API Keys',
-    category: 'Settings Tabs',
-    configKey: 'hideApiKeysTab' as const,
-    hint: 'Hide the API Keys settings tab.',
-  },
-  {
-    id: 'hide-files',
-    label: 'Files',
-    category: 'Settings Tabs',
-    configKey: 'hideFilesTab' as const,
-    hint: 'Hide the Files settings tab.',
-  },
-  {
-    id: 'hide-deploy-api',
-    label: 'API',
-    category: 'Deploy Tabs',
-    configKey: 'hideDeployApi' as const,
-    hint: 'Hide the API deployment option.',
-  },
-  {
-    id: 'hide-deploy-mcp',
-    label: 'MCP',
-    category: 'Deploy Tabs',
-    configKey: 'hideDeployMcp' as const,
-    hint: 'Hide the MCP server deployment option.',
-  },
-  {
-    id: 'disable-mcp',
-    label: 'MCP Tools',
-    category: 'Tools',
-    configKey: 'disableMcpTools' as const,
-    hint: 'Block agents from calling MCP tools.',
-  },
-  {
-    id: 'disable-custom-tools',
-    label: 'Custom Tools',
-    category: 'Tools',
-    configKey: 'disableCustomTools' as const,
-    hint: 'Block agents from calling user-defined custom tools.',
-  },
-  {
-    id: 'disable-skills',
-    label: 'Skills',
-    category: 'Tools',
-    configKey: 'disableSkills' as const,
-    hint: 'Block agents from loading skills.',
-  },
-  {
-    id: 'hide-trace-spans',
-    label: 'Trace Spans',
-    category: 'Logs',
-    configKey: 'hideTraceSpans' as const,
-    hint: 'Hide per-block trace spans in logs.',
-  },
-  {
-    id: 'disable-invitations',
-    label: 'Invitations',
-    category: 'Collaboration',
-    configKey: 'disableInvitations' as const,
-    hint: 'Prevent users from inviting others to workspaces.',
-  },
-  {
-    id: 'hide-inbox',
-    label: 'Sim Mailer',
-    category: 'Features',
-    configKey: 'hideInboxTab' as const,
-    hint: 'Hide the Sim Mailer inbox.',
-  },
-  {
-    id: 'disable-public-api',
-    label: 'Public API',
-    category: 'Features',
-    configKey: 'disablePublicApi' as const,
-    hint: 'Disable public API access to deployed workflows.',
-  },
-  // Chat and Files get a category of their own so their nested auth-mode
-  // dropdown (see `featureExtras`) reads as part of the toggle it qualifies.
-  {
-    id: 'hide-deploy-chatbot',
-    label: 'Deployment',
-    category: 'Chat',
-    configKey: 'hideDeployChatbot' as const,
-    hint: 'Hide the chat deployment option.',
-  },
-  {
-    id: 'disable-public-file-sharing',
-    label: 'Public Sharing',
-    category: 'Files',
-    configKey: 'disablePublicFileSharing' as const,
-    hint: 'Disable public file-share links.',
-  },
-]
-
 interface OrganizationMemberOption {
   userId: string
   user: {
@@ -963,7 +819,7 @@ export function GroupDetail({
   }, [searchedPlatformFeatures, statusFilter, editingConfig])
 
   const platformCategories = useMemo(() => {
-    const categories: Record<string, typeof PLATFORM_FEATURES> = {}
+    const categories: Record<string, (typeof PLATFORM_FEATURES)[number][]> = {}
     for (const feature of filteredPlatformFeatures) {
       if (!categories[feature.category]) {
         categories[feature.category] = []
diff --git a/apps/sim/ee/access-control/utils/permission-check.test.ts b/apps/sim/ee/access-control/utils/permission-check.test.ts
index 8a9d502c80..b5eaa61049 100644
--- a/apps/sim/ee/access-control/utils/permission-check.test.ts
+++ b/apps/sim/ee/access-control/utils/permission-check.test.ts
@@ -84,6 +84,8 @@ import {
   ModelNotAllowedError,
   ProviderNotAllowedError,
   PublicFileSharingNotAllowedError,
+  resolveUserAccessControlContext,
+  resolveVerifiedUserAccessControlContext,
   SkillsNotAllowedError,
   ToolNotAllowedError,
   validateBlockType,
@@ -229,6 +231,126 @@ describe('getUserPermissionConfig (org + entitlement gating)', () => {
   })
 })
 
+describe('resolveUserAccessControlContext', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    resetDbChainMock()
+    mockGetAllowedIntegrationsFromEnv.mockReturnValue(null)
+  })
+
+  it('describes a personal workspace without changing the config-only result', async () => {
+    mockGetWorkspaceWithOwner.mockResolvedValue({ organizationId: null })
+
+    await expect(resolveUserAccessControlContext('user-123', 'workspace-1')).resolves.toEqual({
+      organizationId: null,
+      entitled: false,
+      permissionGroup: null,
+      config: null,
+    })
+    await expect(getUserPermissionConfig('user-123', 'workspace-1')).resolves.toBeNull()
+  })
+
+  it('returns the explicit governing group and its effective config', async () => {
+    setEnterpriseOrgWorkspace()
+    queueGroupResolution([
+      {
+        id: 'group-explicit',
+        name: 'Engineering',
+        config: { disableMcpTools: true },
+        isMember: true,
+        hasMembers: true,
+      },
+    ])
+
+    await expect(resolveUserAccessControlContext('user-123', 'workspace-1')).resolves.toEqual({
+      organizationId: 'org-1',
+      entitled: true,
+      permissionGroup: {
+        id: 'group-explicit',
+        name: 'Engineering',
+        resolution: 'explicit-member',
+      },
+      config: expect.objectContaining({ disableMcpTools: true }),
+    })
+  })
+
+  it('identifies an all-members governing group', async () => {
+    setEnterpriseOrgWorkspace()
+    queueGroupResolution([
+      {
+        id: 'group-all-members',
+        name: 'All workspace members',
+        config: { disableCustomTools: true },
+        isMember: false,
+        hasMembers: false,
+      },
+    ])
+
+    const context = await resolveUserAccessControlContext('user-123', 'workspace-1')
+
+    expect(context.permissionGroup).toEqual({
+      id: 'group-all-members',
+      name: 'All workspace members',
+      resolution: 'all-members',
+    })
+  })
+
+  it('uses a verified workspace organization without loading the workspace again', async () => {
+    mockIsOrganizationOnEnterprisePlan.mockResolvedValue(true)
+    queueGroupResolution([
+      {
+        id: 'group-verified',
+        name: 'Verified group',
+        config: { disableSkills: true },
+        isMember: true,
+        hasMembers: true,
+      },
+    ])
+
+    const context = await resolveVerifiedUserAccessControlContext(
+      'user-123',
+      'workspace-1',
+      'org-verified'
+    )
+
+    expect(mockGetWorkspaceWithOwner).not.toHaveBeenCalled()
+    expect(mockIsOrganizationOnEnterprisePlan).toHaveBeenCalledWith('org-verified')
+    expect(context).toMatchObject({
+      organizationId: 'org-verified',
+      entitled: true,
+      permissionGroup: {
+        id: 'group-verified',
+        resolution: 'explicit-member',
+      },
+      config: { disableSkills: true },
+    })
+  })
+
+  it('identifies the default group and preserves the environment allowlist', async () => {
+    setEnterpriseOrgWorkspace()
+    mockGetAllowedIntegrationsFromEnv.mockReturnValue(['slack'])
+    queueGroupResolution(
+      [],
+      [
+        {
+          id: 'group-default',
+          name: 'Organization default',
+          config: { allowedIntegrations: ['slack', 'github'] },
+        },
+      ]
+    )
+
+    const context = await resolveUserAccessControlContext('user-123', 'workspace-1')
+
+    expect(context.permissionGroup).toEqual({
+      id: 'group-default',
+      name: 'Organization default',
+      resolution: 'default',
+    })
+    expect(context.config?.allowedIntegrations).toEqual(['slack'])
+  })
+})
+
 describe('getUserPermissionConfig (workspace-group precedence)', () => {
   beforeEach(() => {
     vi.clearAllMocks()
diff --git a/apps/sim/ee/access-control/utils/permission-check.ts b/apps/sim/ee/access-control/utils/permission-check.ts
index d83b16e8f6..0afd24ed46 100644
--- a/apps/sim/ee/access-control/utils/permission-check.ts
+++ b/apps/sim/ee/access-control/utils/permission-check.ts
@@ -141,9 +141,30 @@ function mergeEnvAllowlist(config: PermissionGroupConfig | null): PermissionGrou
 export interface ResolvedPermissionGroup {
   permissionGroupId: string
   groupName: string
+  resolution: 'explicit-member' | 'all-members' | 'default'
   config: PermissionGroupConfig
 }
 
+export interface UserAccessControlContext {
+  organizationId: string | null
+  entitled: boolean
+  permissionGroup: {
+    id: string
+    name: string
+    resolution: ResolvedPermissionGroup['resolution']
+  } | null
+  config: PermissionGroupConfig | null
+}
+
+function inactiveUserAccessControlContext(organizationId: string | null): UserAccessControlContext {
+  return {
+    organizationId,
+    entitled: false,
+    permissionGroup: null,
+    config: mergeEnvAllowlist(null),
+  }
+}
+
 /** The organization's single default group (`isDefault`), or `null`. */
 async function resolveDefaultGroup(
   organizationId: string
@@ -167,6 +188,7 @@ async function resolveDefaultGroup(
   return {
     permissionGroupId: defaultGroup.id,
     groupName: defaultGroup.name,
+    resolution: 'default',
     config: parsePermissionGroupConfig(defaultGroup.config),
   }
 }
@@ -222,12 +244,14 @@ export async function resolveWorkspaceGroup(
     )
     .orderBy(asc(permissionGroup.createdAt), asc(permissionGroup.id))
 
-  const winner = rows.find((row) => row.isMember) ?? rows.find((row) => !row.hasMembers)
+  const explicitMemberGroup = rows.find((row) => row.isMember)
+  const winner = explicitMemberGroup ?? rows.find((row) => !row.hasMembers)
 
   if (winner) {
     return {
       permissionGroupId: winner.id,
       groupName: winner.name,
+      resolution: explicitMemberGroup ? 'explicit-member' : 'all-members',
       config: parsePermissionGroupConfig(winner.config),
     }
   }
@@ -246,26 +270,70 @@ export async function resolveWorkspaceGroup(
  * The env-level integration allowlist is always merged last so self-hosted
  * deployments can constrain integrations without touching the DB.
  */
+async function resolveUserAccessControlContextForOrganization(
+  userId: string,
+  workspaceId: string,
+  organizationId: string | null
+): Promise<UserAccessControlContext> {
+  if (!organizationId) return inactiveUserAccessControlContext(null)
+
+  const isEnterprise = await isOrganizationOnEnterprisePlan(organizationId)
+  if (!isEnterprise) {
+    return inactiveUserAccessControlContext(organizationId)
+  }
+
+  const resolved = await resolveWorkspaceGroup(userId, organizationId, workspaceId)
+  return {
+    organizationId,
+    entitled: true,
+    permissionGroup: resolved
+      ? {
+          id: resolved.permissionGroupId,
+          name: resolved.groupName,
+          resolution: resolved.resolution,
+        }
+      : null,
+    config: mergeEnvAllowlist(resolved?.config ?? null),
+  }
+}
+
+/**
+ * Resolves Access Control from an organization ID obtained from an already
+ * access-checked workspace. This function does not independently authorize the
+ * user for the workspace; callers must establish that boundary first.
+ */
+export async function resolveVerifiedUserAccessControlContext(
+  userId: string,
+  workspaceId: string,
+  organizationId: string | null
+): Promise<UserAccessControlContext> {
+  if (!isHosted && !isAccessControlEnabled) {
+    return inactiveUserAccessControlContext(null)
+  }
+  return resolveUserAccessControlContextForOrganization(userId, workspaceId, organizationId)
+}
+
+export async function resolveUserAccessControlContext(
+  userId: string,
+  workspaceId: string
+): Promise<UserAccessControlContext> {
+  if (!isHosted && !isAccessControlEnabled) {
+    return inactiveUserAccessControlContext(null)
+  }
+
+  const workspace = await getWorkspaceWithOwner(workspaceId, { includeArchived: true })
+  return resolveUserAccessControlContextForOrganization(
+    userId,
+    workspaceId,
+    workspace?.organizationId ?? null
+  )
+}
+
 export async function getUserPermissionConfig(
   userId: string,
   workspaceId: string
 ): Promise<PermissionGroupConfig | null> {
-  if (!isHosted && !isAccessControlEnabled) {
-    return mergeEnvAllowlist(null)
-  }
-
-  const ws = await getWorkspaceWithOwner(workspaceId, { includeArchived: true })
-  if (!ws?.organizationId) {
-    return mergeEnvAllowlist(null)
-  }
-
-  const isEnterprise = await isOrganizationOnEnterprisePlan(ws.organizationId)
-  if (!isEnterprise) {
-    return mergeEnvAllowlist(null)
-  }
-
-  const resolved = await resolveWorkspaceGroup(userId, ws.organizationId, workspaceId)
-  return mergeEnvAllowlist(resolved?.config ?? null)
+  return (await resolveUserAccessControlContext(userId, workspaceId)).config
 }
 
 /**
diff --git a/apps/sim/hooks/queries/tables.ts b/apps/sim/hooks/queries/tables.ts
index 4d54cfb8bb..6ee390af92 100644
--- a/apps/sim/hooks/queries/tables.ts
+++ b/apps/sim/hooks/queries/tables.ts
@@ -501,6 +501,47 @@ export function useFindTableRows({ workspaceId, tableId, q, filter, sort }: Find
   })
 }
 
+/**
+ * Bounded single-page row read for chart files (`.chart` previews): one fetch
+ * of up to `limit` rows with the spec's verbatim filter/sort. Charts accept a
+ * truncated page — they visualize a sample, not a drained table.
+ */
+export function useTableRowsSample({
+  workspaceId,
+  tableId,
+  filter,
+  sort,
+  limit,
+  enabled = true,
+}: {
+  workspaceId?: string
+  tableId?: string
+  /** Passed through verbatim from the chart document; the contract validates. */
+  filter?: unknown
+  sort?: unknown
+  limit: number
+  enabled?: boolean
+}) {
+  const paramsKey = JSON.stringify({ filter: filter ?? null, sort: sort ?? null, limit })
+  return useQuery({
+    // rq-lint-allow: tableId is globally unique; workspaceId is only the authz scope
+    queryKey: tableKeys.sample(tableId ?? '', paramsKey),
+    queryFn: ({ signal }) =>
+      fetchTableRows({
+        workspaceId: workspaceId as string,
+        tableId: tableId as string,
+        limit,
+        filter: (filter ?? null) as TablePredicate | null,
+        sort: (sort ?? null) as SortSpec | null,
+        includeTotal: false,
+        signal,
+      }),
+    enabled: Boolean(workspaceId && tableId) && enabled,
+    staleTime: TABLE_ROWS_STALE_TIME,
+    placeholderData: keepPreviousData,
+  })
+}
+
 export function tableRowsInfiniteOptions({
   workspaceId,
   tableId,
diff --git a/apps/sim/hooks/queries/utils/table-keys.ts b/apps/sim/hooks/queries/utils/table-keys.ts
index 853103b512..5ccf7f3445 100644
--- a/apps/sim/hooks/queries/utils/table-keys.ts
+++ b/apps/sim/hooks/queries/utils/table-keys.ts
@@ -34,6 +34,9 @@ export const tableKeys = {
   infiniteRows: (tableId: string, paramsKey: string) =>
     [...tableKeys.infiniteRowsRoot(tableId), paramsKey] as const,
   rowWrites: (tableId: string) => [...tableKeys.rowsRoot(tableId), 'write'] as const,
+  /** Bounded single-page row read for chart files (`.chart` previews). */
+  sample: (tableId: string, paramsKey: string) =>
+    [...tableKeys.rowsRoot(tableId), 'sample', paramsKey] as const,
   find: (tableId: string, paramsKey: string) =>
     [...tableKeys.rowsRoot(tableId), 'find', paramsKey] as const,
   /** Deliberately NOT under `detail` — the non-exact `invalidateQueries` on that
diff --git a/apps/sim/hooks/use-smooth-text.test.tsx b/apps/sim/hooks/use-smooth-text.test.tsx
index b4fe89d991..c80221ddce 100644
--- a/apps/sim/hooks/use-smooth-text.test.tsx
+++ b/apps/sim/hooks/use-smooth-text.test.tsx
@@ -4,7 +4,7 @@
 import { act } from 'react'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { useSmoothText } from '@/hooks/use-smooth-text'
+import { snapAllSmoothText, useSmoothText } from '@/hooks/use-smooth-text'
 
 interface ProbeProps {
   content: string
@@ -89,3 +89,37 @@ describe('useSmoothText — streaming that begins on an already-open document',
     h.unmount()
   })
 })
+
+describe('snapAllSmoothText — user Stop must end the paced reveal instantly', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('reveals the full backlog immediately when snapped mid-stream', () => {
+    const probe = renderSmoothText({ content: '', isStreaming: true })
+    probe.rerender({ content: 'The quick brown fox jumps over the lazy dog. '.repeat(4) })
+    // Paced reveal has not caught up (fake timers hold the frame loop).
+    expect(probe.value().length).toBeLessThan(180)
+
+    act(() => {
+      snapAllSmoothText()
+    })
+    expect(probe.value()).toBe('The quick brown fox jumps over the lazy dog. '.repeat(4))
+    probe.unmount()
+  })
+
+  it('is one-shot: a later stream paces normally again', () => {
+    const probe = renderSmoothText({ content: '', isStreaming: true })
+    act(() => {
+      snapAllSmoothText()
+    })
+    probe.rerender({
+      content: 'Fresh streaming text that should reveal gradually, not snap. '.repeat(3),
+    })
+    expect(probe.value().length).toBeLessThan(180)
+    probe.unmount()
+  })
+})
diff --git a/apps/sim/hooks/use-smooth-text.ts b/apps/sim/hooks/use-smooth-text.ts
index 0411e8365d..0b38aa11b4 100644
--- a/apps/sim/hooks/use-smooth-text.ts
+++ b/apps/sim/hooks/use-smooth-text.ts
@@ -1,4 +1,29 @@
-import { useEffect, useRef, useState } from 'react'
+import { useEffect, useRef, useState, useSyncExternalStore } from 'react'
+
+/**
+ * Global snap signal: bumping the epoch makes every mounted smooth-text reveal
+ * jump to its full content immediately. Used by the user Stop path — after an
+ * explicit abort, watching the buffered tail keep typing itself out reads as
+ * "my stop didn't work", so the paced reveal must end NOW, not over the drain
+ * horizon. One-shot per bump: subsequent streams pace normally again.
+ */
+let snapEpoch = 0
+const snapListeners = new Set<() => void>()
+
+function subscribeToSnapEpoch(listener: () => void): () => void {
+  snapListeners.add(listener)
+  return () => snapListeners.delete(listener)
+}
+
+function getSnapEpoch(): number {
+  return snapEpoch
+}
+
+/** Snap every mounted smooth-text reveal to its full content immediately. */
+export function snapAllSmoothText(): void {
+  snapEpoch++
+  for (const listener of [...snapListeners]) listener()
+}
 
 /**
  * Time-based paced reveal of a growing string. A per-frame loop earns a
@@ -111,8 +136,22 @@ export function useSmoothText(
   const prevContentRef = useRef(content)
   const prevIsStreamingRef = useRef(isStreaming)
 
+  const currentSnapEpoch = useSyncExternalStore(subscribeToSnapEpoch, getSnapEpoch, getSnapEpoch)
+  const [prevSnapEpoch, setPrevSnapEpoch] = useState(currentSnapEpoch)
+
   let effectiveRevealed = revealed
 
+  // A user Stop bumped the snap epoch: reveal everything now instead of
+  // draining the backlog at the paced cadence.
+  if (prevSnapEpoch !== currentSnapEpoch) {
+    setPrevSnapEpoch(currentSnapEpoch)
+    if (revealed < content.length) {
+      effectiveRevealed = content.length
+      revealedRef.current = content.length
+      setRevealed(content.length)
+    }
+  }
+
   if (
     isStreaming &&
     !prevIsStreamingRef.current &&
diff --git a/apps/sim/instrumentation-node.ts b/apps/sim/instrumentation-node.ts
index 9d536bb527..2b9da2a012 100644
--- a/apps/sim/instrumentation-node.ts
+++ b/apps/sim/instrumentation-node.ts
@@ -83,6 +83,23 @@ function normalizeOtlpMetricsUrl(url: string): string {
   }
 }
 
+// Logs counterpart to `normalizeOtlpMetricsUrl` — same parsed-pathname
+// handling, targeting the /v1/logs signal path.
+function normalizeOtlpLogsUrl(url: string): string {
+  if (!url) return url
+  try {
+    const u = new URL(url)
+    const path = u.pathname.replace(/\/$/, '')
+    if (path.endsWith('/v1/logs')) return url
+    u.pathname = path.endsWith('/v1/traces')
+      ? path.replace(/\/v1\/traces$/, '/v1/logs')
+      : `${path}/v1/logs`
+    return u.toString()
+  } catch {
+    return url
+  }
+}
+
 // deployment.environment in the GO value space (dev | staging | prod) without
 // any new infra env var. Every deployed Sim tier already gets
 // APPCONFIG_ENVIRONMENT = the infra env name (dev | staging | production), so we
@@ -177,6 +194,8 @@ async function initializeOpenTelemetry() {
     const { OTLPTraceExporter } = await import('@opentelemetry/exporter-trace-otlp-http')
     const { OTLPMetricExporter } = await import('@opentelemetry/exporter-metrics-otlp-http')
     const { PeriodicExportingMetricReader } = await import('@opentelemetry/sdk-metrics')
+    const { OTLPLogExporter } = await import('@opentelemetry/exporter-logs-otlp-http')
+    const { BatchLogRecordProcessor } = await import('@opentelemetry/sdk-logs')
     const { BatchSpanProcessor } = await import('@opentelemetry/sdk-trace-node')
     const { TraceIdRatioBasedSampler, SamplingDecision } = await import(
       '@opentelemetry/sdk-trace-base'
@@ -271,6 +290,19 @@ async function initializeOpenTelemetry() {
       exportIntervalMillis: 60000,
     })
 
+    // Logs share the trace endpoint and headers as well (signal path
+    // /v1/logs). Every @sim/logger line fans out through the global Logs API
+    // (see packages/logger), which the NodeSDK wires to this processor — the
+    // stdout JSON lines continue to CloudWatch unchanged.
+    const logRecordProcessor = new BatchLogRecordProcessor(
+      new OTLPLogExporter({
+        url: normalizeOtlpLogsUrl(telemetryConfig.endpoint),
+        headers: otlpHeaders,
+        timeoutMillis: Math.min(telemetryConfig.batchSettings.exportTimeoutMillis, 10000),
+        keepAlive: false,
+      })
+    )
+
     // Must be unique per process: replicas sharing one instance id collapse
     // into a single Prometheus series, so their independent cumulative
     // counters interleave and corrupt rate()/increase(). The slug keeps Sim
@@ -320,6 +352,7 @@ async function initializeOpenTelemetry() {
       spanProcessors,
       sampler,
       metricReader,
+      logRecordProcessors: [logRecordProcessor],
     })
 
     sdk.start()
diff --git a/apps/sim/lib/api/contracts/copilot.ts b/apps/sim/lib/api/contracts/copilot.ts
index bd26d8a4a4..7a46337b03 100644
--- a/apps/sim/lib/api/contracts/copilot.ts
+++ b/apps/sim/lib/api/contracts/copilot.ts
@@ -140,6 +140,28 @@ export const copilotChatAbortBodySchema = z.object({
 })
 export type CopilotChatAbortBody = z.input<typeof copilotChatAbortBodySchema>
 
+export const copilotChatSteerBodySchema = z.object({
+  streamId: z.string().min(1, 'streamId is required'),
+  chatId: z.string().min(1, 'chatId is required'),
+  steeringId: z.string().min(1, 'steeringId is required'),
+  content: z.string().min(1, 'content is required').max(32_768, 'content is too long'),
+})
+export type CopilotChatSteerBody = z.input<typeof copilotChatSteerBodySchema>
+
+export const copilotToolExecuteInternalBodySchema = z.object({
+  toolCallId: z.string().min(1, 'toolCallId is required'),
+  toolName: z.string().min(1, 'toolName is required'),
+  params: z.record(z.string(), z.unknown()).default({}),
+  userId: z.string().min(1, 'userId is required'),
+  workflowId: z.string().optional(),
+  workspaceId: z.string().optional(),
+  chatId: z.string().optional(),
+  messageId: z.string().optional(),
+  parentToolCallId: z.string().optional(),
+  userPermission: z.string().optional(),
+})
+export type CopilotToolExecuteInternalBody = z.input<typeof copilotToolExecuteInternalBodySchema>
+
 export const copilotChatGetQuerySchema = z
   .object({
     workflowId: z.string().optional(),
diff --git a/apps/sim/lib/api/contracts/custom-blocks.ts b/apps/sim/lib/api/contracts/custom-blocks.ts
index 70f40a1132..99ec47a5f0 100644
--- a/apps/sim/lib/api/contracts/custom-blocks.ts
+++ b/apps/sim/lib/api/contracts/custom-blocks.ts
@@ -83,7 +83,7 @@ export const listCustomBlocksQuerySchema = z.object({
  * Icon URLs are rendered as org-wide `<img>` sources, so only https URLs and
  * internal file-serve paths (what the icon upload UI stores) are accepted —
  * never data:/blob:/other schemes an admin could smuggle into shared metadata.
- * Shared with the copilot deploy_custom_block handler's pass-through branch.
+ * Shared with the copilot publish_custom_block handler's pass-through branch.
  */
 export function isAllowedCustomBlockIconUrl(value: string): boolean {
   return value.startsWith('https://') || value.startsWith('/api/files/serve/')
diff --git a/apps/sim/lib/api/contracts/logs.ts b/apps/sim/lib/api/contracts/logs.ts
index b269d8c75f..71677a738c 100644
--- a/apps/sim/lib/api/contracts/logs.ts
+++ b/apps/sim/lib/api/contracts/logs.ts
@@ -38,6 +38,8 @@ export const listLogsQuerySchema = logFilterQuerySchema.extend({
   limit: z.coerce.number().int().min(1).max(200).optional().default(100),
   sortBy: logSortBySchema,
   sortOrder: logSortOrderSchema,
+  /** Also run a COUNT(*) under the same filters and return it as `total`. */
+  includeTotal: z.coerce.boolean().optional(),
 })
 
 export const logDetailQuerySchema = z.object({
@@ -294,6 +296,8 @@ export type WorkflowLogRow = WorkflowLogSummary &
 export const listLogsResponseSchema = z.object({
   data: z.array(workflowLogSummarySchema),
   nextCursor: z.string().nullable(),
+  /** Total rows matching the filters; present only when `includeTotal` was set. */
+  total: z.number().optional(),
 })
 
 export type ListLogsResponse = z.output<typeof listLogsResponseSchema>
diff --git a/apps/sim/lib/api/contracts/organization.ts b/apps/sim/lib/api/contracts/organization.ts
index 1a3ee14895..53d2644b4c 100644
--- a/apps/sim/lib/api/contracts/organization.ts
+++ b/apps/sim/lib/api/contracts/organization.ts
@@ -1,5 +1,6 @@
 import { z } from 'zod'
 import {
+  organizationRoleSchema,
   type PiiRedactionSettings,
   piiRedactionSettingsSchema,
   retentionOverridesSchema,
@@ -15,9 +16,6 @@ const numericResponseSchema = z.preprocess((value) => {
   return Number.isFinite(parsed) ? parsed : value
 }, z.number())
 
-export const organizationRoleSchema = z.enum(['owner', 'admin', 'member'], {
-  error: 'Invalid role',
-})
 export const organizationParamsSchema = z.object({
   id: z.string().min(1),
 })
diff --git a/apps/sim/lib/api/contracts/primitives.test.ts b/apps/sim/lib/api/contracts/primitives.test.ts
index b9a2d79197..280df88de6 100644
--- a/apps/sim/lib/api/contracts/primitives.test.ts
+++ b/apps/sim/lib/api/contracts/primitives.test.ts
@@ -8,6 +8,7 @@ import {
   isCanonicalBase64,
   MAX_ID_LENGTH,
   organizationIdSchema,
+  organizationRoleSchema,
   piiStagePolicySchema,
   piiStagesSchema,
   privateSecretProvenanceBundleSchema,
@@ -19,6 +20,16 @@ import {
   workspaceIdSchema,
 } from '@/lib/api/contracts/primitives'
 
+describe('organizationRoleSchema', () => {
+  it.each(['owner', 'admin', 'member'] as const)('accepts canonical role %s', (role) => {
+    expect(organizationRoleSchema.parse(role)).toBe(role)
+  })
+
+  it.each(['billing-owner', 'viewer', '', null, undefined])('rejects invalid role %j', (role) => {
+    expect(organizationRoleSchema.safeParse(role).success).toBe(false)
+  })
+})
+
 describe('workspaceFileNameSchema', () => {
   it('trims and accepts one bounded file name', () => {
     expect(workspaceFileNameSchema.parse(' report.pdf ')).toBe('report.pdf')
diff --git a/apps/sim/lib/api/contracts/primitives.ts b/apps/sim/lib/api/contracts/primitives.ts
index c2eeec7228..21717e0418 100644
--- a/apps/sim/lib/api/contracts/primitives.ts
+++ b/apps/sim/lib/api/contracts/primitives.ts
@@ -277,6 +277,12 @@ export const workspaceFileNameSchema = z
 /** Non-empty `organizationId` field with a stable, human-readable message. */
 export const organizationIdSchema = requiredFieldSchema('Organization ID is required')
 
+/** Canonical organization membership role shared across API resource families. */
+export const organizationRoleSchema = z.enum(['owner', 'admin', 'member'], {
+  error: 'Invalid role',
+})
+export type OrganizationRole = z.output<typeof organizationRoleSchema>
+
 /** Non-empty `workflowId` field with a stable, human-readable message. */
 export const workflowIdSchema = requiredFieldSchema('Workflow ID is required')
 
diff --git a/apps/sim/lib/api/contracts/workspaces.test.ts b/apps/sim/lib/api/contracts/workspaces.test.ts
new file mode 100644
index 0000000000..8adfeed25e
--- /dev/null
+++ b/apps/sim/lib/api/contracts/workspaces.test.ts
@@ -0,0 +1,32 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { workspaceHostContextSchema } from '@/lib/api/contracts/workspaces'
+
+const viewerSchema = workspaceHostContextSchema.shape.viewer
+const viewer = {
+  permission: 'read' as const,
+  isHostOrganizationMember: false,
+  isHostOrganizationAdmin: false,
+}
+
+describe('workspaceHostContextSchema organizationRole', () => {
+  it.each(['owner', 'admin', 'member'] as const)(
+    'accepts canonical role %s',
+    (organizationRole) => {
+      expect(viewerSchema.safeParse({ ...viewer, organizationRole }).success).toBe(true)
+    }
+  )
+
+  it('retains null and omission for rolling response compatibility', () => {
+    expect(viewerSchema.safeParse({ ...viewer, organizationRole: null }).success).toBe(true)
+    expect(viewerSchema.safeParse(viewer).success).toBe(true)
+  })
+
+  it('rejects non-canonical organization roles', () => {
+    expect(viewerSchema.safeParse({ ...viewer, organizationRole: 'billing-owner' }).success).toBe(
+      false
+    )
+  })
+})
diff --git a/apps/sim/lib/api/contracts/workspaces.ts b/apps/sim/lib/api/contracts/workspaces.ts
index 5c01d3fc62..beac7ce329 100644
--- a/apps/sim/lib/api/contracts/workspaces.ts
+++ b/apps/sim/lib/api/contracts/workspaces.ts
@@ -1,5 +1,9 @@
 import { z } from 'zod'
-import { nonEmptyIdSchema, requiredFieldSchema } from '@/lib/api/contracts/primitives'
+import {
+  nonEmptyIdSchema,
+  organizationRoleSchema,
+  requiredFieldSchema,
+} from '@/lib/api/contracts/primitives'
 import { type ContractJsonResponse, defineRouteContract } from '@/lib/api/contracts/types'
 
 export const workspaceScopeSchema = z.enum(['active', 'archived', 'all'])
@@ -262,6 +266,8 @@ export const workspaceHostContextSchema = z.object({
     permission: workspacePermissionSchema,
     isHostOrganizationMember: z.boolean(),
     isHostOrganizationAdmin: z.boolean(),
+    /** Optional for rolling compatibility with app versions that predate organization-role projection. */
+    organizationRole: organizationRoleSchema.nullable().optional(),
   }),
   features: z
     .object({
diff --git a/apps/sim/lib/auth/sso-trust.test.ts b/apps/sim/lib/auth/sso-trust.test.ts
index 1b620d4529..bedc390b4c 100644
--- a/apps/sim/lib/auth/sso-trust.test.ts
+++ b/apps/sim/lib/auth/sso-trust.test.ts
@@ -10,6 +10,11 @@
 import { resetEnvFlagsMock, setEnvFlags } from '@sim/testing'
 import { afterAll, expect, it, vi } from 'vitest'
 
+// Structurally slow — it imports the entire Better Auth module graph — so under a fully-parallel local run this file
+// blows the default timeout while passing in isolation and on CI. Give it a
+// real budget instead of letting machine load decide the verdict.
+vi.setConfig({ testTimeout: 30_000 })
+
 const { ssoOptions } = vi.hoisted(() => ({
   ssoOptions: { current: undefined as Record<string, unknown> | undefined },
 }))
diff --git a/apps/sim/lib/billing/core/account-billing-snapshot.test.ts b/apps/sim/lib/billing/core/account-billing-snapshot.test.ts
new file mode 100644
index 0000000000..503d01834a
--- /dev/null
+++ b/apps/sim/lib/billing/core/account-billing-snapshot.test.ts
@@ -0,0 +1,100 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  events: [] as string[],
+  getResolvedUserUsageData: vi.fn(),
+  getCreditBalanceForEntity: vi.fn(),
+  isOrgScopedSubscription: vi.fn(),
+}))
+
+vi.mock('@/lib/billing/core/usage', () => ({
+  getResolvedUserUsageData: mocks.getResolvedUserUsageData,
+}))
+
+vi.mock('@/lib/billing/credits/balance', () => ({
+  getCreditBalanceForEntity: mocks.getCreditBalanceForEntity,
+}))
+
+vi.mock('@/lib/billing/subscriptions/utils', () => ({
+  isOrgScopedSubscription: mocks.isOrgScopedSubscription,
+}))
+
+import { getAccountBillingSnapshot } from '@/lib/billing/core/account-billing-snapshot'
+
+const usage = {
+  currentUsage: 18.5,
+  limit: 40,
+  percentUsed: 46.25,
+  isWarning: false,
+  isExceeded: false,
+  billingPeriodStart: new Date('2026-08-01T00:00:00Z'),
+  billingPeriodEnd: new Date('2026-09-01T00:00:00Z'),
+  lastPeriodCost: 31,
+}
+
+describe('getAccountBillingSnapshot', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.events.length = 0
+  })
+
+  it('reuses one resolved subscription for org scope, usage, limits, and credits', async () => {
+    const subscription = {
+      plan: 'team',
+      referenceId: 'org-1',
+    }
+    mocks.getResolvedUserUsageData.mockImplementation(async () => {
+      mocks.events.push('usage-and-subscription')
+      return { usage, subscription, personalCreditBalance: 4 }
+    })
+    mocks.isOrgScopedSubscription.mockReturnValue(true)
+    mocks.getCreditBalanceForEntity.mockImplementation(async () => {
+      mocks.events.push('credits')
+      return 25
+    })
+
+    await expect(getAccountBillingSnapshot('user-1')).resolves.toEqual({
+      plan: 'team',
+      billingScope: 'organization',
+      organizationId: 'org-1',
+      usage: {
+        currentPeriodCost: 18.5,
+        limit: 40,
+        remaining: 21.5,
+        percentUsed: 46.25,
+        isExceeded: false,
+        billingPeriodEnd: new Date('2026-09-01T00:00:00Z'),
+      },
+      credits: { balance: 25, scope: 'organization' },
+    })
+    expect(mocks.getResolvedUserUsageData).toHaveBeenCalledOnce()
+    expect(mocks.getCreditBalanceForEntity).toHaveBeenCalledWith(
+      'organization',
+      'org-1',
+      expect.anything()
+    )
+    expect(mocks.events).toEqual(['usage-and-subscription', 'credits'])
+  })
+
+  it('preserves personal scope and clamps negative remaining usage to zero', async () => {
+    mocks.getResolvedUserUsageData.mockResolvedValue({
+      usage: { ...usage, currentUsage: 45, isExceeded: true },
+      subscription: { plan: 'pro', referenceId: 'user-1' },
+      personalCreditBalance: 0,
+    })
+    mocks.isOrgScopedSubscription.mockReturnValue(false)
+    mocks.getCreditBalanceForEntity.mockResolvedValue(0)
+
+    await expect(getAccountBillingSnapshot('user-1')).resolves.toMatchObject({
+      plan: 'pro',
+      billingScope: 'user',
+      organizationId: null,
+      usage: { remaining: 0, isExceeded: true },
+      credits: { balance: 0, scope: 'user' },
+    })
+    expect(mocks.getCreditBalanceForEntity).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/lib/billing/core/account-billing-snapshot.ts b/apps/sim/lib/billing/core/account-billing-snapshot.ts
new file mode 100644
index 0000000000..a7591357ac
--- /dev/null
+++ b/apps/sim/lib/billing/core/account-billing-snapshot.ts
@@ -0,0 +1,58 @@
+import { db } from '@sim/db'
+import { getResolvedUserUsageData } from '@/lib/billing/core/usage'
+import { getCreditBalanceForEntity } from '@/lib/billing/credits/balance'
+import { isOrgScopedSubscription } from '@/lib/billing/subscriptions/utils'
+import type { DbClient } from '@/lib/db/types'
+
+export interface AccountBillingSnapshot {
+  plan: string
+  billingScope: 'user' | 'organization'
+  organizationId: string | null
+  usage: {
+    currentPeriodCost: number
+    limit: number
+    remaining: number
+    percentUsed: number
+    isExceeded: boolean
+    billingPeriodEnd: Date | null
+  }
+  credits: {
+    balance: number
+    scope: 'user' | 'organization'
+  }
+}
+
+/** Resolves one coherent subscription, usage, limit, and credit snapshot for an account. */
+export async function getAccountBillingSnapshot(
+  userId: string,
+  executor: DbClient = db
+): Promise<AccountBillingSnapshot> {
+  const { usage, subscription, personalCreditBalance } = await getResolvedUserUsageData(
+    userId,
+    executor
+  )
+  const organizationScoped = isOrgScopedSubscription(subscription, userId) && subscription !== null
+  const billingScope = organizationScoped ? 'organization' : 'user'
+  const billingEntityId = organizationScoped ? subscription.referenceId : userId
+  const creditBalance = organizationScoped
+    ? await getCreditBalanceForEntity('organization', billingEntityId, executor)
+    : personalCreditBalance
+
+  return {
+    plan: subscription?.plan || 'free',
+    billingScope,
+    organizationId: organizationScoped ? subscription.referenceId : null,
+    usage: {
+      currentPeriodCost: usage.currentUsage,
+      limit: usage.limit,
+      remaining: Math.max(0, usage.limit - usage.currentUsage),
+      percentUsed: usage.percentUsed,
+      isExceeded: usage.isExceeded,
+      billingPeriodEnd: usage.billingPeriodEnd,
+    },
+    credits: {
+      balance: creditBalance,
+      scope: billingScope,
+    },
+  }
+}
diff --git a/apps/sim/lib/billing/core/subscription.ts b/apps/sim/lib/billing/core/subscription.ts
index d697c9fd7f..a2359d28a2 100644
--- a/apps/sim/lib/billing/core/subscription.ts
+++ b/apps/sim/lib/billing/core/subscription.ts
@@ -713,7 +713,7 @@ export async function hasWorkspaceLiveSyncAccess(workspaceId: string): Promise<b
  * Existing Function execution deliberately does not consult it (see
  * `resolveWorkspaceSandbox`), so a workspace that downgrades keeps running the
  * sandboxes it already built. New Copilot discovery, mutations, attachments,
- * and direct function_execute selections do re-check it.
+ * and direct run_function selections do re-check it.
  */
 export async function hasWorkspaceSandboxAccess(workspaceId: string): Promise<boolean> {
   try {
diff --git a/apps/sim/lib/billing/core/usage.ts b/apps/sim/lib/billing/core/usage.ts
index bdc3af07bb..d001876869 100644
--- a/apps/sim/lib/billing/core/usage.ts
+++ b/apps/sim/lib/billing/core/usage.ts
@@ -14,7 +14,10 @@ import {
 } from '@/components/emails'
 import { getEffectiveBillingStatus } from '@/lib/billing/core/access'
 import { defaultBillingPeriod } from '@/lib/billing/core/billing-period'
-import { getHighestPrioritySubscription } from '@/lib/billing/core/plan'
+import {
+  getHighestPrioritySubscription,
+  type HighestPrioritySubscription,
+} from '@/lib/billing/core/plan'
 import {
   type ResolvedUsagePeriod,
   resolveSubscriptionUsagePeriod,
@@ -197,13 +200,18 @@ export async function ensureUserStatsExists(userId: string): Promise<void> {
     .onConflictDoNothing({ target: userStats.userId })
 }
 
-/**
- * Get comprehensive usage data for a user
- */
-export async function getUserUsageData(
+export interface ResolvedUserUsageData {
+  usage: UsageData
+  subscription: HighestPrioritySubscription
+  /** The personal balance from the same user-stats row used to calculate usage. */
+  personalCreditBalance: number
+}
+
+/** Resolves comprehensive usage and the subscription that determined its billing scope. */
+export async function getResolvedUserUsageData(
   userId: string,
   executor: DbClient = db
-): Promise<UsageData> {
+): Promise<ResolvedUserUsageData> {
   try {
     // Write — always on the primary regardless of executor routing.
     await ensureUserStatsExists(userId)
@@ -344,14 +352,18 @@ export async function getUserUsageData(
     const isExceeded = effectiveUsage >= limit
 
     return {
-      currentUsage: effectiveUsage,
-      limit,
-      percentUsed,
-      isWarning,
-      isExceeded,
-      billingPeriodStart,
-      billingPeriodEnd,
-      lastPeriodCost,
+      usage: {
+        currentUsage: effectiveUsage,
+        limit,
+        percentUsed,
+        isWarning,
+        isExceeded,
+        billingPeriodStart,
+        billingPeriodEnd,
+        lastPeriodCost,
+      },
+      subscription,
+      personalCreditBalance: toNumber(toDecimal(stats.creditBalance)),
     }
   } catch (error) {
     logger.error('Failed to get user usage data', { userId, error })
@@ -359,6 +371,14 @@ export async function getUserUsageData(
   }
 }
 
+/** Get comprehensive usage data for a user. */
+export async function getUserUsageData(
+  userId: string,
+  executor: DbClient = db
+): Promise<UsageData> {
+  return (await getResolvedUserUsageData(userId, executor)).usage
+}
+
 /**
  * Get usage limit information for a user
  */
diff --git a/apps/sim/lib/browser-agent/open-in-panel.ts b/apps/sim/lib/browser-agent/open-in-panel.ts
index 651cfcb82d..bc19973067 100644
--- a/apps/sim/lib/browser-agent/open-in-panel.ts
+++ b/apps/sim/lib/browser-agent/open-in-panel.ts
@@ -1,6 +1,6 @@
 /**
  * "Open this URL in the Sim browser panel" — the desktop-only affordance that
- * routes chat links into the embedded agent browser instead of a new browser
+ * routes chat links into the embedded agent browser instead of a system-browser
  * tab.
  *
  * Rendering components (markdown links, chips) can't reach the chat's
diff --git a/apps/sim/lib/browser-agent/transport.test.ts b/apps/sim/lib/browser-agent/transport.test.ts
index 75701bedfa..b264fc674c 100644
--- a/apps/sim/lib/browser-agent/transport.test.ts
+++ b/apps/sim/lib/browser-agent/transport.test.ts
@@ -153,6 +153,7 @@ import {
   fillBrowserCredential,
   initBrowserAgentTransport,
   loadBrowserFillOptions,
+  loadBrowserSearchSuggestions,
   migrateBrowserScope,
   onBrowserAddToChat,
   onBrowserFillAvailability,
@@ -162,6 +163,7 @@ import {
   onBrowserOmniboxFocus,
   onBrowserToolbarCommand,
   openBrowserTab,
+  openUrlInNewBrowserTab,
   reorderBrowserTab,
   reportBrowserPanelBounds,
   reportBrowserPanelFocused,
@@ -243,6 +245,33 @@ describe('browser panel transport', () => {
     expect(setTabsState).toHaveBeenCalledWith(state)
   })
 
+  it('opens chat URLs in a distinct tab before navigating', async () => {
+    const callOrder: string[] = []
+    openTab.mockImplementation(async () => {
+      callOrder.push('open-tab')
+      return {
+        scopeId: 'chat-test',
+        activeTabId: '2',
+        tabs: [],
+      }
+    })
+    panelAction.mockImplementation(() => {
+      callOrder.push('navigate')
+    })
+
+    await openUrlInNewBrowserTab('https://example.com/docs', 'chat-test')
+
+    expect(callOrder).toEqual(['open-tab', 'navigate'])
+    expect(panelAction).toHaveBeenCalledWith(
+      { action: 'navigate', url: 'https://example.com/docs' },
+      'chat-test'
+    )
+  })
+
+  it('keeps search suggestions local-only on older installed shells', async () => {
+    await expect(loadBrowserSearchSuggestions('sim ai')).resolves.toEqual([])
+  })
+
   it('forwards panel bounds directly to the native view', () => {
     const initialBounds = { x: 10, y: 20, width: 300, height: 200 }
     const updatedBounds = { x: 20, y: 30, width: 320, height: 220 }
diff --git a/apps/sim/lib/browser-agent/transport.ts b/apps/sim/lib/browser-agent/transport.ts
index 51815f9755..46aa80f1e2 100644
--- a/apps/sim/lib/browser-agent/transport.ts
+++ b/apps/sim/lib/browser-agent/transport.ts
@@ -307,6 +307,15 @@ export async function openBrowserTab(
   return state
 }
 
+/** Opens a distinct browser tab and navigates it after the shell accepts it. */
+export async function openUrlInNewBrowserTab(
+  url: string,
+  scopeId = currentBrowserScopeId()
+): Promise<void> {
+  await openBrowserTab(scopeId)
+  sendBrowserPanelAction('navigate', { url }, scopeId)
+}
+
 /** Pins or unpins a live browser tab. */
 export function setBrowserTabPinned(
   tabId: string,
@@ -487,6 +496,19 @@ export async function loadBrowserSuggestionSources(): Promise<{
   return { sessions: known?.sessions ?? [], credentials, sites }
 }
 
+/**
+ * Requests live Google completions through the desktop shell. Older shells and
+ * disabled/offline providers resolve to an empty list, leaving local sites and
+ * ordinary Enter-to-search behavior intact.
+ */
+export function loadBrowserSearchSuggestions(query: string): Promise<string[]> {
+  return (
+    bridge()
+      ?.getSearchSuggestions?.(query)
+      .catch(() => []) ?? Promise.resolve([])
+  )
+}
+
 /** Subscribes to native browser shortcuts that target the renderer omnibox. */
 export function onBrowserOmniboxFocus(
   callback: (mode: BrowserOmniboxFocusMode) => void,
diff --git a/apps/sim/lib/charts/option.ts b/apps/sim/lib/charts/option.ts
new file mode 100644
index 0000000000..d862a89291
--- /dev/null
+++ b/apps/sim/lib/charts/option.ts
@@ -0,0 +1,86 @@
+/**
+ * ECharts option assembly for the `.chart` file viewer. Pure: no React, no
+ * echarts import, JSON-in/JSON-out.
+ *
+ * Chrome layout is Sim-owned, content is spec-owned. Models reliably produce
+ * colliding title/legend placements, so the renderer pins the title top-left
+ * and the legend top-right on one chrome row (scrollable when long),
+ * overriding any spec positions — the same split the pptx renderer makes
+ * between slide chrome and slide content.
+ */
+
+export interface ChartRenderInput {
+  title?: string
+  option: Record<string, unknown>
+  rows?: Array<Record<string, unknown>> | null
+}
+
+export function buildChartRenderOption({
+  title,
+  option: specOption,
+  rows,
+}: ChartRenderInput): Record<string, unknown> {
+  const option = structuredClone(specOption)
+  if (rows && rows.length > 0) {
+    // The resolved rows become the FIRST dataset (id "table", datasetIndex 0).
+    // Spec-declared datasets follow it, so filter/sort transform datasets can
+    // derive from the injected rows (transforms default to fromDatasetIndex 0,
+    // or name it explicitly with fromDatasetId: "table").
+    const injected = { id: 'table', source: rows }
+    if (option.dataset === undefined) {
+      option.dataset = injected
+    } else if (Array.isArray(option.dataset)) {
+      option.dataset = [injected, ...option.dataset]
+    } else {
+      option.dataset = [injected, option.dataset]
+    }
+  }
+  if (option.backgroundColor === undefined) {
+    option.backgroundColor = 'transparent'
+  }
+  if (title && option.title === undefined) {
+    option.title = { text: title }
+  }
+  const hasTitle = option.title !== null && typeof option.title === 'object'
+  if (hasTitle) {
+    const titles = Array.isArray(option.title) ? option.title : [option.title]
+    const primary = titles[0]
+    if (primary !== null && typeof primary === 'object') {
+      const t = primary as Record<string, unknown>
+      t.left = 0
+      t.top = 0
+      t.right = undefined
+      t.bottom = undefined
+    }
+    option.title = titles[0]
+  }
+  let hasLegend = false
+  if (option.legend !== null && typeof option.legend === 'object') {
+    const legends = Array.isArray(option.legend) ? option.legend : [option.legend]
+    for (const entry of legends) {
+      if (entry === null || typeof entry !== 'object') continue
+      hasLegend = true
+      const l = entry as Record<string, unknown>
+      l.top = 2
+      l.right = 0
+      l.left = undefined
+      l.bottom = undefined
+      if (l.type === undefined) l.type = 'scroll'
+    }
+  }
+  // Reserve a chrome row above the plot. Fill only what the spec left unset
+  // inside grid — axis-name insets remain the spec's call.
+  const chromeTop = hasTitle || hasLegend ? 48 : 16
+  if (option.grid === undefined) {
+    option.grid = { top: chromeTop, left: 12, right: 12, bottom: 12, containLabel: true }
+  } else if (
+    option.grid !== null &&
+    typeof option.grid === 'object' &&
+    !Array.isArray(option.grid)
+  ) {
+    const g = option.grid as Record<string, unknown>
+    if (g.top === undefined) g.top = chromeTop
+    if (g.containLabel === undefined) g.containLabel = true
+  }
+  return option
+}
diff --git a/apps/sim/lib/charts/spec.test.ts b/apps/sim/lib/charts/spec.test.ts
new file mode 100644
index 0000000000..da150499d4
--- /dev/null
+++ b/apps/sim/lib/charts/spec.test.ts
@@ -0,0 +1,116 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { parseChartSpec, shapeTableRows } from '@/lib/charts/spec'
+
+const rows = [
+  { month: '2024-01', region: 'NA', revenue: 100, conversion: 4 },
+  { month: '2024-01', region: 'EMEA', revenue: 50, conversion: 2 },
+  { month: '2024-02', region: 'NA', revenue: 200, conversion: 6 },
+  { month: '2024-02', region: 'EMEA', revenue: 80, conversion: 4 },
+]
+
+describe('shapeTableRows', () => {
+  it('passes rows through without groupBy', () => {
+    expect(shapeTableRows(rows, { type: 'table', tableId: 't' })).toBe(rows)
+  })
+
+  it('groups and aggregates, keeping first-seen group order', () => {
+    const shaped = shapeTableRows(rows, {
+      type: 'table',
+      tableId: 't',
+      groupBy: ['month'],
+      aggregate: { revenue: 'sum', conversion: 'avg' },
+    })
+    expect(shaped).toEqual([
+      { month: '2024-01', revenue: 150, conversion: 3 },
+      { month: '2024-02', revenue: 280, conversion: 5 },
+    ])
+  })
+
+  it('pivots a single metric into per-value columns', () => {
+    const shaped = shapeTableRows(rows, {
+      type: 'table',
+      tableId: 't',
+      groupBy: ['month'],
+      aggregate: { revenue: 'sum' },
+      pivot: 'region',
+    })
+    expect(shaped).toEqual([
+      { month: '2024-01', NA: 100, EMEA: 50 },
+      { month: '2024-02', NA: 200, EMEA: 80 },
+    ])
+  })
+
+  it('prefixes pivot columns when several metrics are aggregated', () => {
+    const shaped = shapeTableRows(rows, {
+      type: 'table',
+      tableId: 't',
+      groupBy: ['month'],
+      aggregate: { revenue: 'sum', conversion: 'avg' },
+      pivot: 'region',
+    })
+    expect(shaped[0]).toEqual({
+      month: '2024-01',
+      'NA revenue': 100,
+      'NA conversion': 4,
+      'EMEA revenue': 50,
+      'EMEA conversion': 2,
+    })
+  })
+
+  it('counts rows and ignores non-numeric values in numeric ops', () => {
+    const noisy = [
+      { g: 'a', v: 1 },
+      { g: 'a', v: 'oops' },
+      { g: 'a', v: 3 },
+    ]
+    expect(
+      shapeTableRows(noisy, {
+        type: 'table',
+        tableId: 't',
+        groupBy: ['g'],
+        aggregate: { v: 'count' },
+      })
+    ).toEqual([{ g: 'a', v: 3 }])
+    expect(
+      shapeTableRows(noisy, {
+        type: 'table',
+        tableId: 't',
+        groupBy: ['g'],
+        aggregate: { v: 'avg' },
+      })
+    ).toEqual([{ g: 'a', v: 2 }])
+  })
+})
+
+describe('parseChartSpec table-shaping validation', () => {
+  it('rejects groupBy without aggregate and bad ops', () => {
+    const base = { schema_version: 1, option: {} }
+    expect(
+      parseChartSpec(
+        JSON.stringify({
+          ...base,
+          source: { type: 'table', tableId: 't', groupBy: ['m'] },
+        })
+      ).error
+    ).toMatch(/aggregate/)
+    expect(
+      parseChartSpec(
+        JSON.stringify({
+          ...base,
+          source: { type: 'table', tableId: 't', groupBy: ['m'], aggregate: { v: 'median' } },
+        })
+      ).error
+    ).toMatch(/ops/)
+    expect(
+      parseChartSpec(
+        JSON.stringify({
+          ...base,
+          source: { type: 'table', tableId: 't', pivot: 'region' },
+        })
+      ).error
+    ).toMatch(/pivot/)
+  })
+})
diff --git a/apps/sim/lib/charts/spec.ts b/apps/sim/lib/charts/spec.ts
new file mode 100644
index 0000000000..c406cab607
--- /dev/null
+++ b/apps/sim/lib/charts/spec.ts
@@ -0,0 +1,203 @@
+/**
+ * The `.chart` document contract for the file viewer: parsing/validation and
+ * the table-source shaping (group → aggregate → pivot). Pure JSON-in/JSON-out
+ * — no React, no echarts.
+ */
+
+import { getErrorMessage } from '@sim/utils/errors'
+import { getColumnId } from '@/lib/table/column-keys'
+import type { ColumnDefinition } from '@/lib/table/types'
+
+/** Hard cap on rows a table-backed chart pulls per read; the spec's `limit` clamps under it. */
+export const CHART_ROWS_MAX = 5000
+export const CHART_ROWS_DEFAULT = 1000
+
+export type ChartAggregateOp = 'sum' | 'avg' | 'min' | 'max' | 'count'
+
+export const CHART_AGGREGATE_OPS = new Set<string>(['sum', 'avg', 'min', 'max', 'count'])
+
+export interface ChartTableSource {
+  type: 'table'
+  tableId: string
+  filter?: unknown
+  sort?: unknown
+  limit?: number
+  /** Group rows by these columns; requires `aggregate`. */
+  groupBy?: string[]
+  /** Metric column → op, computed per group. */
+  aggregate?: Record<string, ChartAggregateOp>
+  /** Fan the aggregated metric(s) out into one column per distinct value of this column. */
+  pivot?: string
+}
+
+export interface ChartStaticSource {
+  type: 'static'
+  rows?: Array<Record<string, unknown>>
+}
+
+/**
+ * A `.chart` file (`text/x-sim-chart`): a declarative ECharts document. The
+ * `option` is a plain ECharts option object; `source` optionally supplies the
+ * data — inline rows, or a live read of a Sim table injected as
+ * `option.dataset.source` so the chart stays current with the table.
+ */
+export interface ChartSpec {
+  schema_version: number
+  title?: string
+  source?: ChartStaticSource | ChartTableSource
+  option: Record<string, unknown>
+}
+
+export function parseChartSpec(content: string): { spec?: ChartSpec; error?: string } {
+  let raw: unknown
+  try {
+    raw = JSON.parse(content)
+  } catch (e) {
+    return { error: getErrorMessage(e, 'not valid JSON') }
+  }
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+    return { error: 'chart document must be a JSON object' }
+  }
+  const doc = raw as Record<string, unknown>
+  if (doc.schema_version !== 1) {
+    return { error: 'chart document must declare "schema_version": 1' }
+  }
+  if (doc.option === null || typeof doc.option !== 'object' || Array.isArray(doc.option)) {
+    return { error: 'chart document must declare an "option" object (an ECharts option)' }
+  }
+  const source = doc.source as ChartSpec['source']
+  if (source !== undefined) {
+    if (source === null || typeof source !== 'object') {
+      return { error: '"source" must be an object' }
+    }
+    if (source.type === 'table') {
+      if (typeof source.tableId !== 'string' || source.tableId === '') {
+        return { error: 'a table source must declare "tableId"' }
+      }
+      if (source.groupBy !== undefined) {
+        if (!Array.isArray(source.groupBy) || source.groupBy.some((c) => typeof c !== 'string')) {
+          return { error: '"groupBy" must be an array of column names' }
+        }
+        if (source.aggregate === null || typeof source.aggregate !== 'object') {
+          return { error: '"groupBy" requires an "aggregate" object ({column: op})' }
+        }
+        const ops = Object.values(source.aggregate)
+        if (ops.length === 0 || ops.some((op) => !CHART_AGGREGATE_OPS.has(String(op)))) {
+          return { error: '"aggregate" ops must be sum, avg, min, max, or count' }
+        }
+      }
+      if (source.pivot !== undefined) {
+        if (typeof source.pivot !== 'string') return { error: '"pivot" must be a column name' }
+        if (!source.groupBy) return { error: '"pivot" requires "groupBy" and "aggregate"' }
+      }
+    } else if (source.type === 'static') {
+      if (source.rows !== undefined && !Array.isArray(source.rows)) {
+        return { error: 'a static source\'s "rows" must be an array' }
+      }
+    } else {
+      return { error: '"source.type" must be "static" or "table"' }
+    }
+  }
+  // Built explicitly from the validated fields — no blanket cast, and no
+  // unvalidated extra keys riding along on the parsed spec.
+  return {
+    spec: {
+      schema_version: 1,
+      title: typeof doc.title === 'string' ? doc.title : undefined,
+      source,
+      option: doc.option as Record<string, unknown>,
+    },
+  }
+}
+
+/**
+ * Table rows arrive keyed by column ID (an opaque uuid); chart specs — like
+ * the mothership table tool and the public API — speak column NAMES. Remap so
+ * `encode`/dimension references in the option match what the author sees in
+ * the table UI.
+ */
+export function mapRowsToColumnNames(
+  rows: Array<{ data: Record<string, unknown> }>,
+  columns: Array<Pick<ColumnDefinition, 'id' | 'name'>>
+): Array<Record<string, unknown>> {
+  const nameByStorageKey = new Map<string, string>()
+  for (const col of columns) nameByStorageKey.set(getColumnId(col), col.name)
+  return rows.map((row) => {
+    const out: Record<string, unknown> = {}
+    for (const [key, value] of Object.entries(row.data)) {
+      out[nameByStorageKey.get(key) ?? key] = value
+    }
+    return out
+  })
+}
+
+function aggregateValues(
+  rows: Array<Record<string, unknown>>,
+  column: string,
+  op: ChartAggregateOp
+): number {
+  if (op === 'count') return rows.length
+  const values = rows.map((r) => Number(r[column])).filter((n) => Number.isFinite(n))
+  if (values.length === 0) return 0
+  switch (op) {
+    case 'sum':
+      return values.reduce((a, b) => a + b, 0)
+    case 'avg':
+      return values.reduce((a, b) => a + b, 0) / values.length
+    case 'min':
+      return Math.min(...values)
+    case 'max':
+      return Math.max(...values)
+  }
+}
+
+/**
+ * Client-side shaping for table sources: group → aggregate → optionally pivot
+ * one column's distinct values into per-value columns. Groups keep first-seen
+ * order, so the source's `sort` decides the category order. This is the whole
+ * "query engine" — deliberately tiny; anything fancier belongs in a static
+ * source with precomputed rows.
+ */
+export function shapeTableRows(
+  rows: Array<Record<string, unknown>>,
+  source: ChartTableSource
+): Array<Record<string, unknown>> {
+  const { groupBy, aggregate, pivot } = source
+  if (!groupBy || groupBy.length === 0 || !aggregate) return rows
+
+  const groups = new Map<string, Array<Record<string, unknown>>>()
+  for (const row of rows) {
+    const key = groupBy.map((c) => String(row[c] ?? '')).join('\u0000')
+    const bucket = groups.get(key)
+    if (bucket) bucket.push(row)
+    else groups.set(key, [row])
+  }
+
+  const metrics = Object.entries(aggregate)
+  const out: Array<Record<string, unknown>> = []
+  for (const bucket of groups.values()) {
+    const shaped: Record<string, unknown> = {}
+    for (const c of groupBy) shaped[c] = bucket[0][c]
+    if (pivot) {
+      const byValue = new Map<string, Array<Record<string, unknown>>>()
+      for (const row of bucket) {
+        const value = String(row[pivot] ?? '')
+        const slice = byValue.get(value)
+        if (slice) slice.push(row)
+        else byValue.set(value, [row])
+      }
+      for (const [value, slice] of byValue) {
+        for (const [column, op] of metrics) {
+          const name = metrics.length === 1 ? value : `${value} ${column}`
+          shaped[name] = aggregateValues(slice, column, op)
+        }
+      }
+    } else {
+      for (const [column, op] of metrics) {
+        shaped[column] = aggregateValues(bucket, column, op)
+      }
+    }
+    out.push(shaped)
+  }
+  return out
+}
diff --git a/apps/sim/lib/copilot/application/error.ts b/apps/sim/lib/copilot/application/error.ts
index 966a3233b7..4f5c862616 100644
--- a/apps/sim/lib/copilot/application/error.ts
+++ b/apps/sim/lib/copilot/application/error.ts
@@ -1,13 +1,46 @@
+import { trace } from '@opentelemetry/api'
+import { toError } from '@sim/utils/errors'
 import { asOrchestrationError } from '@/lib/core/orchestration/types'
 
 export const COPILOT_APPLICATION_SYSTEM_ERROR_MESSAGE =
   'The operation failed due to a system error. Please retry.'
 
-/** Projects only caller-actionable application failures into Copilot-visible content. */
+/**
+ * Projects only caller-actionable application failures into Copilot-visible
+ * content. Whenever the real cause is swallowed by the generic fallback, it is
+ * recorded on the active span first — otherwise these failures are
+ * undiagnosable from telemetry (the cause otherwise lives only in stdout logs
+ * that do not ship anywhere queryable).
+ */
 export function messageForCopilotApplicationError(
   error: unknown,
   fallback = COPILOT_APPLICATION_SYSTEM_ERROR_MESSAGE
 ): string {
   const classified = asOrchestrationError(error)
-  return classified && classified.code !== 'internal' ? classified.message : fallback
+  if (classified && classified.code !== 'internal') {
+    return classified.message
+  }
+  trace.getActiveSpan()?.recordException(flattenErrorChain(error))
+  return fallback
+}
+
+/**
+ * Wrapper errors (Drizzle's "Failed query: <sql>") bury the actionable cause —
+ * the Postgres constraint/violation — in `cause`. Join the chain so the span
+ * exception carries the part an investigator actually needs.
+ */
+function flattenErrorChain(error: unknown): Error {
+  const primary = toError(error)
+  const parts = [primary.message]
+  let cursor: unknown = primary.cause
+  let depth = 0
+  while (cursor && depth < 4) {
+    parts.push(toError(cursor).message)
+    cursor = toError(cursor).cause
+    depth += 1
+  }
+  if (parts.length === 1) return primary
+  const flattened = new Error(parts.join(' ← '))
+  flattened.stack = primary.stack
+  return flattened
 }
diff --git a/apps/sim/lib/copilot/application/execute-platform-context-use-case.ts b/apps/sim/lib/copilot/application/execute-platform-context-use-case.ts
new file mode 100644
index 0000000000..b891ea294c
--- /dev/null
+++ b/apps/sim/lib/copilot/application/execute-platform-context-use-case.ts
@@ -0,0 +1,40 @@
+import { createCopilotApplicationAdapter } from '@/lib/copilot/application/application-adapter'
+import { messageForCopilotApplicationError } from '@/lib/copilot/application/error'
+import {
+  COPILOT_APPLICATION_DELEGATION_TTL_MS,
+  type CopilotExecutionContext,
+  InteractiveCopilotExecutionRequiredError,
+  requireInteractiveCopilotExecutionContext,
+} from '@/lib/copilot/auth/application-delegation'
+import type { OperationUseCase } from '@/lib/core/application'
+import { platformContextDelegationPolicy } from '@/lib/platform-context/application/authorization'
+import {
+  type PlatformContextOperation,
+  platformContextOperations,
+} from '@/lib/platform-context/application/operations'
+
+const executePlatformContextUseCase = createCopilotApplicationAdapter({
+  domain: 'platform context',
+  delegation: {
+    audience: platformContextDelegationPolicy.audience,
+    ttlMs: COPILOT_APPLICATION_DELEGATION_TTL_MS,
+    createDelegationId: (context) => `copilot-tool:${context.toolCallId}`,
+  },
+  operations: platformContextOperations,
+})
+
+/** Enters a live platform-context operation only from a trusted interactive Copilot lifecycle. */
+export function executeCopilotPlatformContextUseCase<O extends PlatformContextOperation, I, R>(
+  context: CopilotExecutionContext | undefined,
+  useCase: OperationUseCase<O, I, R>,
+  input: I
+): Promise<R> {
+  const trustedContext = requireInteractiveCopilotExecutionContext(context)
+  return executePlatformContextUseCase(trustedContext, useCase, input)
+}
+
+/** Projects only actionable authorization failures into live platform-context tool output. */
+export function messageForCopilotPlatformContextError(error: unknown): string {
+  if (error instanceof InteractiveCopilotExecutionRequiredError) return error.message
+  return messageForCopilotApplicationError(error)
+}
diff --git a/apps/sim/lib/copilot/application/table-commands.test.ts b/apps/sim/lib/copilot/application/table-commands.test.ts
index 900f8b76df..f1d734dec1 100644
--- a/apps/sim/lib/copilot/application/table-commands.test.ts
+++ b/apps/sim/lib/copilot/application/table-commands.test.ts
@@ -12,7 +12,7 @@ const mocks = vi.hoisted(() => ({
     createFromFile: { operation: { id: 'tables.imports.create_from_workspace_file' } },
     createWorkflowGroup: { operation: { id: 'tables.groups.create' } },
     deleteTables: { operation: { id: 'tables.delete' } },
-    importFile: { operation: { id: 'tables.imports.workspace_file' } },
+    importFile: { operation: { id: 'tables.imports.prepare_file_edit' } },
     replaceProjectedRows: { operation: { id: 'tables.rows.replace' } },
     updateWorkflowGroup: { operation: { id: 'tables.groups.update' } },
   },
diff --git a/apps/sim/lib/copilot/async-runs/repository.test.ts b/apps/sim/lib/copilot/async-runs/repository.test.ts
index fcd9c01a4e..81bdd06198 100644
--- a/apps/sim/lib/copilot/async-runs/repository.test.ts
+++ b/apps/sim/lib/copilot/async-runs/repository.test.ts
@@ -11,6 +11,7 @@ import {
   completeAsyncToolCall,
   detachAsyncToolCall,
   getClaimedWorkflowExecutionId,
+  markAsyncToolRunning,
   recordToolPermissionDecision,
   releaseWorkflowToolExecutionClaim,
   replaceTerminalAsyncToolCallResult,
@@ -162,6 +163,29 @@ describe('async tool repository single-row semantics', () => {
     await expect(claimWorkflowToolExecution('workflow-tool', 'execution-2')).resolves.toBeNull()
   })
 
+  it('overwrites a workflow execution claim once the sim path starts running it', async () => {
+    // The server-side fallback claims `workflow:<id>` and then immediately runs
+    // the tool, whose executor re-marks the row as running under 'sim-stream'.
+    // The claim value is therefore NOT durable identity — only its
+    // `claimedBy IS NULL` precondition is load-bearing, since that is what keeps
+    // a late browser locked out. Pinning this so nobody builds on reading it back.
+    dbChainMockFns.returning.mockResolvedValueOnce([
+      {
+        toolCallId: 'workflow-tool',
+        status: 'running',
+        claimedBy: 'sim-stream',
+      },
+    ])
+
+    const result = await markAsyncToolRunning('workflow-tool', 'sim-stream')
+
+    expect(result).toMatchObject({ claimedBy: 'sim-stream' })
+    expect(dbChainMockFns.set).toHaveBeenCalledWith(
+      expect.objectContaining({ claimedBy: 'sim-stream' })
+    )
+    expect(getClaimedWorkflowExecutionId('sim-stream')).toBeUndefined()
+  })
+
   it('releases a matching pre-start workflow claim without changing its lifecycle status', async () => {
     dbChainMockFns.returning.mockResolvedValueOnce([
       {
@@ -258,7 +282,7 @@ describe('async tool repository single-row semantics', () => {
       const existingRow = {
         runId: 'run-1',
         toolCallId: 'tool-1',
-        toolName: 'function_execute',
+        toolName: 'run_function',
         args: { language: 'javascript', code: 'return {{FIRST_SECRET}}' },
         status,
       }
@@ -267,7 +291,7 @@ describe('async tool repository single-row semantics', () => {
       const result = await upsertAsyncToolCall({
         runId: 'run-1',
         toolCallId: 'tool-1',
-        toolName: 'function_execute',
+        toolName: 'run_function',
         args: { language: 'javascript', code: 'return {{SECOND_SECRET}}' },
         status: 'pending',
       })
diff --git a/apps/sim/lib/copilot/auth/application-delegation.test.ts b/apps/sim/lib/copilot/auth/application-delegation.test.ts
index 1e0bdc5037..655f685fc6 100644
--- a/apps/sim/lib/copilot/auth/application-delegation.test.ts
+++ b/apps/sim/lib/copilot/auth/application-delegation.test.ts
@@ -4,6 +4,7 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import {
   createCopilotApplicationPrincipal,
+  requireInteractiveCopilotExecutionContext,
   requireTrustedCopilotExecutionContext,
 } from '@/lib/copilot/auth/application-delegation'
 
@@ -61,4 +62,25 @@ describe('Copilot application delegation', () => {
       },
     })
   })
+
+  it.each([undefined, 'headless' as const])(
+    'rejects non-interactive live platform context (%s)',
+    (copilotInteractionMode) => {
+      expect(() =>
+        requireInteractiveCopilotExecutionContext({
+          ...trustedContext,
+          copilotInteractionMode,
+        })
+      ).toThrow('only in an interactive Copilot session')
+    }
+  )
+
+  it('accepts a server-classified interactive lifecycle', () => {
+    expect(
+      requireInteractiveCopilotExecutionContext({
+        ...trustedContext,
+        copilotInteractionMode: 'interactive',
+      })
+    ).toMatchObject({ copilotInteractionMode: 'interactive' })
+  })
 })
diff --git a/apps/sim/lib/copilot/auth/application-delegation.ts b/apps/sim/lib/copilot/auth/application-delegation.ts
index d4e91c30bb..4a779e0a02 100644
--- a/apps/sim/lib/copilot/auth/application-delegation.ts
+++ b/apps/sim/lib/copilot/auth/application-delegation.ts
@@ -11,6 +11,7 @@ export interface CopilotExecutionContext {
   executionId?: string
   toolCallId?: string
   copilotToolExecution?: boolean
+  copilotInteractionMode?: 'interactive' | 'headless'
 }
 
 export interface TrustedCopilotExecutionContext extends CopilotExecutionContext {
@@ -20,6 +21,17 @@ export interface TrustedCopilotExecutionContext extends CopilotExecutionContext
   copilotToolExecution: true
 }
 
+export interface TrustedInteractiveCopilotExecutionContext extends TrustedCopilotExecutionContext {
+  copilotInteractionMode: 'interactive'
+}
+
+export class InteractiveCopilotExecutionRequiredError extends Error {
+  constructor() {
+    super('Live platform context is available only in an interactive Copilot session.')
+    this.name = 'InteractiveCopilotExecutionRequiredError'
+  }
+}
+
 export type CopilotResourceScope = Pick<
   NonNullable<DelegatedPrincipal['resourceScope']>,
   'fileId' | 'tableId'
@@ -76,9 +88,23 @@ export function requireTrustedCopilotExecutionContext(
     ...(context.executionId ? { executionId: context.executionId } : {}),
     toolCallId: context.toolCallId,
     copilotToolExecution: true,
+    ...(context.copilotInteractionMode
+      ? { copilotInteractionMode: context.copilotInteractionMode }
+      : {}),
   })
 }
 
+/** Restricts sensitive live platform reads to a server-classified interactive lifecycle. */
+export function requireInteractiveCopilotExecutionContext(
+  context: CopilotExecutionContext | undefined
+): TrustedInteractiveCopilotExecutionContext {
+  const trustedContext = requireTrustedCopilotExecutionContext(context)
+  if (trustedContext.copilotInteractionMode !== 'interactive') {
+    throw new InteractiveCopilotExecutionRequiredError()
+  }
+  return trustedContext as TrustedInteractiveCopilotExecutionContext
+}
+
 /** Creates a bounded Copilot principal from an explicitly trusted server lifecycle. */
 export function createTrustedCopilotPrincipal(
   input: CreateTrustedCopilotPrincipalInput,
diff --git a/apps/sim/lib/copilot/chat/desktop-capabilities.ts b/apps/sim/lib/copilot/chat/desktop-capabilities.ts
new file mode 100644
index 0000000000..b8fb040f92
--- /dev/null
+++ b/apps/sim/lib/copilot/chat/desktop-capabilities.ts
@@ -0,0 +1,3 @@
+/** Wire limits shared by the desktop capability snapshot and its request schema. */
+export const DESKTOP_TERMINAL_HINT_ID_MAX_LENGTH = 64
+export const DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH = 1024
diff --git a/apps/sim/lib/copilot/chat/display-message.ts b/apps/sim/lib/copilot/chat/display-message.ts
index 24df088f59..28a348a583 100644
--- a/apps/sim/lib/copilot/chat/display-message.ts
+++ b/apps/sim/lib/copilot/chat/display-message.ts
@@ -92,7 +92,11 @@ function toDisplayBlockBody(block: PersistedContentBlock): ContentBlock | undefi
       if (block.lifecycle === MothershipStreamV1SpanLifecycleEvent.end) {
         return { type: ContentBlockType.subagent_end }
       }
-      return { type: ContentBlockType.subagent, content: block.content }
+      return {
+        type: ContentBlockType.subagent,
+        content: block.content,
+        ...(block.name ? { subagentName: block.name } : {}),
+      }
     case MothershipStreamV1EventType.complete:
       if (block.status === MothershipStreamV1CompletionStatus.cancelled) {
         return { type: ContentBlockType.stopped }
@@ -138,17 +142,17 @@ function toDisplayContexts(
   }))
 }
 
-const WORKSPACE_FILE_TOOL = 'workspace_file'
-const EDIT_CONTENT_TOOL = 'edit_content'
+const WORKSPACE_FILE_TOOL = 'prepare_file_edit'
+const EDIT_CONTENT_TOOL = 'apply_file_edit'
 const MAIN_SPAN = 'main'
 
 /**
- * Collapses an `edit_content` write into the most-recent `workspace_file` row in
+ * Collapses an `apply_file_edit` write into the most-recent `prepare_file_edit` row in
  * the same subagent span, mirroring the live turn-model fold. The live view
  * folds these in `reduceEvent`, but the persisted transcript stores them as two
  * separate tool blocks; without this a reloaded chat splits the file write into
- * "workspace_file" + "edit_content" rows (and a refresh mid-write leaves the
- * second row spinning). The reopened row inherits the edit_content's final
+ * "prepare_file_edit" + "apply_file_edit" rows (and a refresh mid-write leaves the
+ * second row spinning). The reopened row inherits the apply_file_edit's final
  * status/result, exactly as the live single "writing" row resolves. Every other
  * block is passed through untouched, so this only affects file writes.
  */
diff --git a/apps/sim/lib/copilot/chat/effective-transcript.test.ts b/apps/sim/lib/copilot/chat/effective-transcript.test.ts
index 10c74da054..c525a2cc81 100644
--- a/apps/sim/lib/copilot/chat/effective-transcript.test.ts
+++ b/apps/sim/lib/copilot/chat/effective-transcript.test.ts
@@ -242,7 +242,7 @@ describe('buildEffectiveChatTranscript', () => {
             payload: {
               phase: 'result',
               toolCallId: 'tool-1',
-              toolName: 'workspace_file',
+              toolName: 'prepare_file_edit',
               executor: 'go',
               mode: 'sync',
               success: false,
@@ -262,7 +262,7 @@ describe('buildEffectiveChatTranscript', () => {
         type: MothershipStreamV1EventType.tool,
         toolCall: expect.objectContaining({
           id: 'tool-1',
-          name: 'workspace_file',
+          name: 'prepare_file_edit',
           state: MothershipStreamV1CompletionStatus.cancelled,
         }),
       }),
@@ -473,3 +473,44 @@ describe('tool ownership is call-frame authoritative', () => {
     expect(own.parentToolCallId).toBe('dispatch-1')
   })
 })
+
+describe('user aborts are not rendered as errors', () => {
+  function transcriptWithErrorEvent(code: string) {
+    return buildEffectiveChatTranscript({
+      messages: [buildUserMessage('stream-1', 'Hello')],
+      activeStreamId: 'stream-1',
+      streamSnapshot: {
+        events: [
+          toBatchEvent(1, {
+            v: 1,
+            seq: 1,
+            ts: '2026-04-15T12:00:01.000Z',
+            type: MothershipStreamV1EventType.error,
+            stream: { streamId: 'stream-1' },
+            payload: { code, message: 'Request aborted by user' },
+          }),
+        ],
+        previewSessions: [],
+        status: 'active',
+      },
+    })
+  }
+
+  function renderedContent(messages: ReturnType<typeof buildEffectiveChatTranscript>) {
+    return messages
+      .filter((message) => message.role === 'assistant')
+      .map((message) => message.content ?? '')
+      .join('')
+  }
+
+  it.each(['async_resume_aborted', 'stream_cancelled', 'cancelled'])(
+    'suppresses the inline error tag for %s',
+    (code) => {
+      expect(renderedContent(transcriptWithErrorEvent(code))).not.toContain('mothership-error')
+    }
+  )
+
+  it('still renders a genuine failure', () => {
+    expect(renderedContent(transcriptWithErrorEvent('api_error'))).toContain('mothership-error')
+  })
+})
diff --git a/apps/sim/lib/copilot/chat/effective-transcript.ts b/apps/sim/lib/copilot/chat/effective-transcript.ts
index 6594e0f8c7..97527da2c7 100644
--- a/apps/sim/lib/copilot/chat/effective-transcript.ts
+++ b/apps/sim/lib/copilot/chat/effective-transcript.ts
@@ -60,6 +60,23 @@ function isTerminalStreamStatus(status: string | null | undefined): boolean {
   )
 }
 
+/**
+ * Error codes that describe the USER stopping the turn, not a failure.
+ *
+ * A Stop reaches the client as an `error` event because the server's typed
+ * error channel is the only way a terminating stream leg reports its reason —
+ * `async_resume_aborted` in particular is emitted when Stop lands while an
+ * async tool resume is still starting up. The server already classifies these
+ * as aborts (recording an abort rather than an error, and answering 499 rather
+ * than 5xx); rendering them inline made the user's own Stop look like a
+ * failure, so the transcript honors that classification too.
+ */
+const USER_ABORT_ERROR_CODES = new Set(['async_resume_aborted', 'stream_cancelled', 'cancelled'])
+
+function isUserAbortError(payload: MothershipStreamV1ErrorPayload): boolean {
+  return typeof payload.code === 'string' && USER_ABORT_ERROR_CODES.has(payload.code)
+}
+
 function buildInlineErrorTag(payload: MothershipStreamV1ErrorPayload): string {
   const message =
     (typeof payload.displayMessage === 'string' ? payload.displayMessage : undefined) ||
@@ -468,6 +485,11 @@ function buildLiveAssistantMessage(params: {
         continue
       }
       case MothershipStreamV1EventType.error: {
+        // A Stop is already visible: the stream ends and the composer returns.
+        // Adding a line for it just reports the user's own action back as an error.
+        if (isUserAbortError(parsed.payload)) {
+          continue
+        }
         const tag = buildInlineErrorTag(parsed.payload)
         if (runningText.includes(tag)) {
           continue
diff --git a/apps/sim/lib/copilot/chat/payload.test.ts b/apps/sim/lib/copilot/chat/payload.test.ts
index 2f061cf859..4ec333268b 100644
--- a/apps/sim/lib/copilot/chat/payload.test.ts
+++ b/apps/sim/lib/copilot/chat/payload.test.ts
@@ -368,7 +368,7 @@ describe('buildCopilotRequestPayload', () => {
           content: [
             'File "payroll.xlsx" (application/octet-stream, 1 bytes) uploaded.',
             'Read with: read("uploads/payroll.xlsx")',
-            'To save permanently: materialize_file(fileName: "payroll.xlsx")',
+            'To save permanently: save_upload(fileName: "payroll.xlsx")',
           ].join('\n'),
         },
       ])
@@ -410,7 +410,7 @@ describe('buildCopilotRequestPayload', () => {
           content: [
             'File "photo.png" (image/png, 10 bytes) uploaded.',
             'Read with: read("uploads/photo.png")',
-            'To save permanently: materialize_file(fileName: "photo.png")',
+            'To save permanently: save_upload(fileName: "photo.png")',
           ].join('\n'),
         },
       ])
diff --git a/apps/sim/lib/copilot/chat/payload.ts b/apps/sim/lib/copilot/chat/payload.ts
index ef1ea48d15..5f185b683f 100644
--- a/apps/sim/lib/copilot/chat/payload.ts
+++ b/apps/sim/lib/copilot/chat/payload.ts
@@ -362,7 +362,7 @@ export async function buildCopilotRequestPayload(
           userMessageId
         )
         // Encode the read path per the percent-encoded VFS convention (matches
-        // files/ and the uploads glob output). The materialize_file `fileName`
+        // files/ and the uploads glob output). The save_upload `fileName`
         // arg stays the raw display name — the upload resolver accepts both.
         let encodedUploadName = displayName
         try {
@@ -382,11 +382,11 @@ export async function buildCopilotRequestPayload(
           lines = [
             `File "${displayName}" (${mediaType}, ${f.size} bytes) uploaded.`,
             `Read with: read("uploads/${encodedUploadName}")`,
-            `To save permanently: materialize_file(fileName: "${displayName}")`,
+            `To save permanently: save_upload(fileName: "${displayName}")`,
           ]
           if (displayName.endsWith('.json')) {
             lines.push(
-              `To import as a workflow: materialize_file(fileName: "${displayName}", operation: "import")`
+              `To import as a workflow: save_upload(fileName: "${displayName}", operation: "import")`
             )
           }
         }
diff --git a/apps/sim/lib/copilot/chat/persisted-message.ts b/apps/sim/lib/copilot/chat/persisted-message.ts
index 54b66e90c9..fb8a30ba5b 100644
--- a/apps/sim/lib/copilot/chat/persisted-message.ts
+++ b/apps/sim/lib/copilot/chat/persisted-message.ts
@@ -15,12 +15,12 @@ import {
   MothershipStreamV1ToolOutcome,
   MothershipStreamV1ToolPhase,
 } from '@/lib/copilot/generated/mothership-stream-v1'
-import { BrowserRequestTakeover } from '@/lib/copilot/generated/tool-catalog-v1'
 import type {
   ContentBlock,
   LocalToolCallStatus,
   OrchestratorResult,
 } from '@/lib/copilot/request/types'
+import { RETIRED_BROWSER_REQUEST_TAKEOVER_ID } from '@/lib/copilot/tools/retired-tools'
 import type { BrowserTextSelection, TerminalTextSelection } from '@/stores/panel/types'
 
 export type PersistedToolState = LocalToolCallStatus | MothershipStreamV1ToolOutcome | 'interrupted'
@@ -53,6 +53,8 @@ export interface PersistedContentBlock {
   lifecycle?: MothershipStreamV1SpanLifecycleEvent
   status?: MothershipStreamV1CompletionStatus
   content?: string
+  /** Orchestrator-chosen display name on a subagent start block. */
+  name?: string
   toolCall?: PersistedToolCall
   timestamp?: number
   endedAt?: number
@@ -150,7 +152,7 @@ export function stripToolResultOutput(message: PersistedMessage): PersistedMessa
     if (!toolCall || !result || typeof result !== 'object' || !('output' in result)) return block
     const output = result.output
     const userInstruction =
-      toolCall.name === BrowserRequestTakeover.id && isPlainRecord(output)
+      toolCall.name === RETIRED_BROWSER_REQUEST_TAKEOVER_ID && isPlainRecord(output)
         ? output.userInstruction
         : undefined
     const normalizedInstruction = typeof userInstruction === 'string' ? userInstruction.trim() : ''
@@ -243,6 +245,7 @@ function mapContentBlockBody(block: ContentBlock): PersistedContentBlock {
         kind: MothershipStreamV1SpanPayloadKind.subagent,
         lifecycle: MothershipStreamV1SpanLifecycleEvent.start,
         content: block.content,
+        ...(block.subagentName ? { name: block.subagentName } : {}),
       }
     case 'subagent_text':
       return {
@@ -432,6 +435,9 @@ interface RawBlock {
   type: string
   lane?: string
   agent?: string
+  /** Orchestrator-chosen subagent display name (legacy blocks store it as `subagentName`). */
+  name?: string
+  subagentName?: string
   content?: string
   /** Go persists text blocks with key "text" instead of "content" */
   text?: string
@@ -499,6 +505,7 @@ function normalizeCanonicalBlock(block: RawBlock): PersistedContentBlock {
     result.lane = block.lane
   }
   if (block.agent) result.agent = block.agent
+  if (block.name) result.name = block.name
   const blockContent = block.content ?? block.text
   if (blockContent !== undefined) result.content = blockContent
   if (block.channel) result.channel = block.channel as MothershipStreamV1TextChannel
@@ -580,6 +587,7 @@ function normalizeLegacyBlock(block: RawBlock): PersistedContentBlock {
       kind: MothershipStreamV1SpanPayloadKind.subagent,
       lifecycle: MothershipStreamV1SpanLifecycleEvent.start,
       content: block.content,
+      ...(block.subagentName ? { name: block.subagentName } : {}),
     }
   }
 
diff --git a/apps/sim/lib/copilot/chat/post.test.ts b/apps/sim/lib/copilot/chat/post.test.ts
index 4f8efd5202..f7f71a2473 100644
--- a/apps/sim/lib/copilot/chat/post.test.ts
+++ b/apps/sim/lib/copilot/chat/post.test.ts
@@ -384,7 +384,8 @@ describe('handleUnifiedChatPost', () => {
       'user-1',
       'Hello',
       'ws-1',
-      expect.anything()
+      expect.anything(),
+      expect.any(ResolvedSecretTraceRegistry)
     )
   })
 
@@ -448,7 +449,8 @@ describe('handleUnifiedChatPost', () => {
       'user-1',
       'Explain these selections',
       'ws-1',
-      'chat-1'
+      'chat-1',
+      expect.any(ResolvedSecretTraceRegistry)
     )
   })
 
diff --git a/apps/sim/lib/copilot/chat/post.ts b/apps/sim/lib/copilot/chat/post.ts
index 0bde82a6c4..90b4b3b283 100644
--- a/apps/sim/lib/copilot/chat/post.ts
+++ b/apps/sim/lib/copilot/chat/post.ts
@@ -10,6 +10,10 @@ import { z } from 'zod'
 import { isZodError, validationErrorResponse } from '@/lib/api/server'
 import { getSession } from '@/lib/auth'
 import { resolveBillingAttribution } from '@/lib/billing/core/billing-attribution'
+import {
+  DESKTOP_TERMINAL_HINT_ID_MAX_LENGTH,
+  DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH,
+} from '@/lib/copilot/chat/desktop-capabilities'
 import { type ChatLoadResult, resolveOrCreateChat } from '@/lib/copilot/chat/lifecycle'
 import { appendCopilotChatMessages } from '@/lib/copilot/chat/messages-store'
 import { buildCopilotRequestPayload } from '@/lib/copilot/chat/payload'
@@ -289,9 +293,9 @@ const ChatMessageSchema = z.object({
       terminals: z
         .array(
           z.object({
-            id: z.string().max(64),
-            cwd: z.string().max(1024).optional(),
-            running: z.string().max(1024).optional(),
+            id: z.string().max(DESKTOP_TERMINAL_HINT_ID_MAX_LENGTH),
+            cwd: z.string().max(DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH).optional(),
+            running: z.string().max(DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH).optional(),
             interactive: z.boolean().optional(),
             active: z.boolean().optional(),
           })
@@ -461,9 +465,19 @@ async function resolveAgentContexts(params: {
   message: string
   workspaceId?: string
   chatId?: string
+  resolvedSecretTraceRegistry?: ExecutionContext['resolvedSecretTraceRegistry']
   requestId: string
 }): Promise<Array<{ type: string; content: string; tag?: string; path?: string }>> {
-  const { contexts, resourceAttachments, userId, message, workspaceId, chatId, requestId } = params
+  const {
+    contexts,
+    resourceAttachments,
+    userId,
+    message,
+    workspaceId,
+    chatId,
+    resolvedSecretTraceRegistry,
+    requestId,
+  } = params
 
   let agentContexts: Array<{ type: string; content: string; tag?: string; path?: string }> = []
 
@@ -474,7 +488,8 @@ async function resolveAgentContexts(params: {
         userId,
         message,
         workspaceId,
-        chatId
+        chatId,
+        resolvedSecretTraceRegistry
       )
     } catch (error) {
       logger.error(`[${requestId}] Failed to process contexts`, error)
@@ -1267,7 +1282,7 @@ export async function handleUnifiedChatPost(req: NextRequest) {
           }),
         activeOtelRoot.context
       )
-      const agentContextsPromise = executionContextPromise.then(() => {
+      const agentContextsPromise = executionContextPromise.then((executionContext) => {
         return withCopilotSpan(
           TraceSpan.CopilotChatResolveAgentContexts,
           {
@@ -1282,6 +1297,7 @@ export async function handleUnifiedChatPost(req: NextRequest) {
               message: body.message,
               workspaceId,
               chatId: actualChatId,
+              resolvedSecretTraceRegistry: executionContext.resolvedSecretTraceRegistry,
               requestId,
             }),
           activeOtelRoot.context
diff --git a/apps/sim/lib/copilot/chat/process-contents.test.ts b/apps/sim/lib/copilot/chat/process-contents.test.ts
index 6570628e3b..3e29c8b404 100644
--- a/apps/sim/lib/copilot/chat/process-contents.test.ts
+++ b/apps/sim/lib/copilot/chat/process-contents.test.ts
@@ -10,6 +10,7 @@ import {
   MAX_TABLE_SELECTION_ROWS,
 } from '@/lib/copilot/chat/selection-context'
 import { DelegatedWorkspaceAuthorizationError } from '@/lib/core/application'
+import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 import type { ChatContext } from '@/stores/panel'
 
 const {
@@ -25,6 +26,7 @@ const {
   readKnowledgeBase,
   getBlockVisibilityForCopilot,
   isIntegrationDeploymentAvailable,
+  searchDocsExecute,
 } = vi.hoisted(() => ({
   discoverServerTools: vi.fn(),
   getBlock: vi.fn(),
@@ -38,6 +40,7 @@ const {
   readKnowledgeBase: vi.fn(),
   getBlockVisibilityForCopilot: vi.fn(async () => null),
   isIntegrationDeploymentAvailable: vi.fn(() => true),
+  searchDocsExecute: vi.fn(),
 }))
 
 vi.mock('@/blocks/registry', () => ({ getBlock, getBlockRegistry }))
@@ -57,6 +60,9 @@ vi.mock('@/lib/table/rows/service', () => ({ getRowsByIds }))
 vi.mock('@/lib/knowledge/application/knowledge-bases', () => ({
   readKnowledgeBase: { execute: readKnowledgeBase },
 }))
+vi.mock('@/lib/copilot/tools/server/docs/search-docs', () => ({
+  searchDocsServerTool: { execute: searchDocsExecute },
+}))
 
 /**
  * Overrides the global `@sim/db` mock: the logs-context tests below need
@@ -282,6 +288,121 @@ describe('processContextsServer - skill contexts', () => {
   })
 })
 
+describe('processContextsServer - docs contexts', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('routes @Docs to an unscoped search_docs query', async () => {
+    const resolvedSecretTraceRegistry = new ResolvedSecretTraceRegistry()
+    const results = [
+      {
+        path: 'docs/workflows/loops.mdx',
+        url: 'https://docs.sim.ai/workflows/loops',
+        title: 'Loops',
+        content: 'Use a loop block to iterate.',
+        similarity: 0.9,
+      },
+    ]
+    searchDocsExecute.mockResolvedValue({ results, query: 'how do loops work?', totalResults: 1 })
+
+    const result = await processContextsServer(
+      [{ kind: 'docs', label: 'Docs' }],
+      'user-1',
+      '@Docs how do loops work?',
+      'ws-1',
+      undefined,
+      resolvedSecretTraceRegistry
+    )
+
+    expect(searchDocsExecute).toHaveBeenCalledWith(
+      { query: 'how do loops work?' },
+      {
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+        chatId: undefined,
+        resolvedSecretTraceRegistry,
+      }
+    )
+    expect(result).toEqual([
+      {
+        type: 'docs',
+        tag: '@Docs',
+        content: JSON.stringify({ results }),
+      },
+    ])
+  })
+
+  it('preserves the search note when @Docs has no relevant matches', async () => {
+    const note =
+      'No relevant matches. This does NOT mean the docs lack this topic. Rephrase the query.'
+    searchDocsExecute.mockResolvedValue({ results: [], query: 'new topic', totalResults: 0, note })
+
+    const result = await processContextsServer(
+      [{ kind: 'docs', label: 'Docs' }],
+      'user-1',
+      '@Docs new topic',
+      'ws-1',
+      undefined,
+      new ResolvedSecretTraceRegistry()
+    )
+
+    expect(result).toEqual([
+      {
+        type: 'docs',
+        tag: '@Docs',
+        content: JSON.stringify({ results: [], note }),
+      },
+    ])
+  })
+
+  it('uses the Docs label when the message only contains the mention', async () => {
+    searchDocsExecute.mockResolvedValue({ results: [], query: 'Docs', totalResults: 0 })
+
+    await processContextsServer(
+      [{ kind: 'docs', label: 'Docs' }],
+      'user-1',
+      '@Docs',
+      'ws-1',
+      'chat-1',
+      new ResolvedSecretTraceRegistry()
+    )
+
+    expect(searchDocsExecute).toHaveBeenCalledWith(
+      { query: 'Docs' },
+      expect.objectContaining({ workspaceId: 'ws-1', chatId: 'chat-1' })
+    )
+  })
+
+  it('preserves an explicit unavailable note when docs search fails', async () => {
+    searchDocsExecute.mockRejectedValue(new Error('embedding service unavailable'))
+
+    const result = await processContextsServer(
+      [{ kind: 'docs', label: 'Docs' }],
+      'user-1',
+      '@Docs explain schedules',
+      'ws-1',
+      'chat-1',
+      new ResolvedSecretTraceRegistry()
+    )
+
+    expect(result).toEqual([
+      {
+        type: 'docs',
+        tag: '@Docs',
+        content: JSON.stringify({
+          results: [],
+          note: 'Documentation search is temporarily unavailable. Do not infer that the docs lack this topic; retry search_docs or browse docs/** later.',
+        }),
+      },
+    ])
+    expect(mockProcessContentsLogger.error).toHaveBeenCalledWith(
+      'Failed to process docs context',
+      expect.any(Error)
+    )
+  })
+})
+
 describe('processContextsServer - MCP contexts', () => {
   beforeEach(() => {
     vi.clearAllMocks()
diff --git a/apps/sim/lib/copilot/chat/process-contents.ts b/apps/sim/lib/copilot/chat/process-contents.ts
index 8765e334f1..faa77afa33 100644
--- a/apps/sim/lib/copilot/chat/process-contents.ts
+++ b/apps/sim/lib/copilot/chat/process-contents.ts
@@ -49,6 +49,7 @@ import { readWorkspaceFileMetadata } from '@/lib/workspace-files/application/rea
 import { parseWorkspaceFileFolderDisplayPath } from '@/lib/workspace-files/folder-display-path'
 import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
 import { escapeRegExp } from '@/executor/constants'
+import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 import type { BrowserTextSelection, ChatContext, TerminalTextSelection } from '@/stores/panel'
 
 type AgentContextType =
@@ -124,7 +125,8 @@ export async function processContextsServer(
   userId: string,
   userMessage?: string,
   currentWorkspaceId?: string,
-  chatId?: string
+  chatId?: string,
+  resolvedSecretTraceRegistry?: ResolvedSecretTraceRegistry
 ): Promise<AgentContext[]> {
   if (!Array.isArray(contexts) || contexts.length === 0) return []
   const tasks = contexts.map(async (ctx) => {
@@ -314,17 +316,36 @@ export async function processContextsServer(
       }
       if (ctx.kind === 'docs') {
         try {
-          const { searchDocumentationServerTool } = await import(
-            '@/lib/copilot/tools/server/docs/search-documentation'
+          const { searchDocsServerTool } = await import(
+            '@/lib/copilot/tools/server/docs/search-docs'
           )
           const rawQuery = (userMessage || '').trim() || ctx.label || 'Sim documentation'
-          const query = sanitizeMessageForDocs(rawQuery, contexts)
-          const res = await searchDocumentationServerTool.execute({ query, topK: 10 })
-          const content = JSON.stringify(res?.results || [])
+          const query =
+            sanitizeMessageForDocs(rawQuery, contexts) || ctx.label || 'Sim documentation'
+          const res = await searchDocsServerTool.execute(
+            { query },
+            {
+              userId,
+              workspaceId: currentWorkspaceId,
+              chatId,
+              resolvedSecretTraceRegistry,
+            }
+          )
+          const content = JSON.stringify({
+            results: res?.results || [],
+            ...(res?.note ? { note: res.note } : {}),
+          })
           return { type: 'docs', tag: ctx.label ? `@${ctx.label}` : '@', content }
         } catch (e) {
           logger.error('Failed to process docs context', e)
-          return null
+          return {
+            type: 'docs',
+            tag: ctx.label ? `@${ctx.label}` : '@',
+            content: JSON.stringify({
+              results: [],
+              note: 'Documentation search is temporarily unavailable. Do not infer that the docs lack this topic; retry search_docs or browse docs/** later.',
+            }),
+          }
         }
       }
       return null
diff --git a/apps/sim/lib/copilot/constants.ts b/apps/sim/lib/copilot/constants.ts
index 5102f753d5..1df1be6c40 100644
--- a/apps/sim/lib/copilot/constants.ts
+++ b/apps/sim/lib/copilot/constants.ts
@@ -36,6 +36,19 @@ export const TOOL_WATCHDOG_RESUME_GRACE_MS = 30_000
 /** Timeout for the client-side streaming response handler (60 min). */
 export const STREAM_TIMEOUT_MS = 3_600_000
 
+/**
+ * How long a workflow tool call waits for a browser to pick it up before the
+ * server runs it itself.
+ *
+ * Workflow tools are client-routed, but the only thing that starts one is the
+ * mounted chat view — a call frame that arrives while the user is on a
+ * different chat is never dispatched by anyone, and the turn used to park for
+ * the full STREAM_TIMEOUT_MS. The real pickup path (stream frame -> execute
+ * POST -> claim) lands in ~1-3s, so 30s is an order of magnitude of headroom
+ * and cannot steal work from a live tab.
+ */
+export const COPILOT_WORKFLOW_TOOL_CLIENT_GRACE_MS = 30_000
+
 /** SessionStorage key for persisting active stream metadata across page reloads. */
 export const STREAM_STORAGE_KEY = 'copilot_active_stream'
 
diff --git a/apps/sim/lib/copilot/docs/docs-corpus.test.ts b/apps/sim/lib/copilot/docs/docs-corpus.test.ts
new file mode 100644
index 0000000000..54764c3562
--- /dev/null
+++ b/apps/sim/lib/copilot/docs/docs-corpus.test.ts
@@ -0,0 +1,235 @@
+/**
+ * @vitest-environment node
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockSleep } = vi.hoisted(() => ({
+  mockSleep: vi.fn(() => Promise.resolve()),
+}))
+
+vi.mock('@sim/utils/helpers', () => ({
+  sleep: mockSleep,
+}))
+
+import {
+  couldMatchDocsScope,
+  DocsCorpusError,
+  globDocs,
+  grepDocs,
+  isDocsPath,
+  readDocsPage,
+} from '@/lib/copilot/docs/docs-corpus'
+import { DOCS_MANIFEST } from '@/lib/copilot/generated/docs-manifest'
+
+const SAMPLE_PAGE = DOCS_MANIFEST.find((path) => path === 'workflows/blocks/agent.mdx')
+
+function fetchResponse(status: number, content = '', headers: HeadersInit = {}) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    headers: new Headers(headers),
+    text: async () => content,
+  }
+}
+
+describe('docs corpus scoping', () => {
+  it('recognizes docs paths', () => {
+    expect(isDocsPath('docs/workflows.mdx')).toBe(true)
+    expect(isDocsPath('docs')).toBe(true)
+    expect(isDocsPath('/docs/workflows.mdx')).toBe(true)
+    expect(isDocsPath('workflows.mdx')).toBe(false)
+    expect(isDocsPath('files/report.pdf')).toBe(false)
+    expect(isDocsPath('docsomething/x')).toBe(false)
+    expect(isDocsPath(undefined)).toBe(false)
+  })
+
+  it('is opt-in: only an explicit docs/ pattern can match', () => {
+    expect(couldMatchDocsScope('docs/**')).toBe(true)
+    expect(couldMatchDocsScope('docs/workflows/**')).toBe(true)
+    expect(couldMatchDocsScope('**')).toBe(false)
+    expect(couldMatchDocsScope('**/*.mdx')).toBe(false)
+    expect(couldMatchDocsScope('*')).toBe(false)
+    expect(couldMatchDocsScope(undefined)).toBe(false)
+  })
+})
+
+describe('globDocs', () => {
+  it('lists the whole corpus under docs/**', () => {
+    const files = globDocs('docs/**')
+    expect(files.length).toBeGreaterThan(DOCS_MANIFEST.length)
+    expect(files).toContain('docs/workflows/blocks/agent.mdx')
+    expect(files).toContain('docs/workflows/blocks')
+  })
+
+  it('scopes to a section', () => {
+    const files = globDocs('docs/integrations/*.mdx')
+    expect(files).toContain('docs/integrations/gmail.mdx')
+    expect(files.every((path) => path.startsWith('docs/integrations/'))).toBe(true)
+  })
+
+  it('excludes academy and api-reference', () => {
+    expect(globDocs('docs/academy/**')).toEqual([])
+    expect(globDocs('docs/api-reference/**')).toEqual([])
+  })
+
+  it('maps section index pages onto their parent URL path', () => {
+    expect(globDocs('docs/workflows.mdx')).toEqual(['docs/workflows.mdx'])
+    expect(globDocs('docs/workflows/index.mdx')).toEqual([])
+  })
+
+  it('treats a trailing-slash pattern like the bare directory instead of matching nothing', () => {
+    expect(globDocs('docs/')).toEqual(['docs'])
+    expect(globDocs('docs/integrations/')).toEqual(['docs/integrations'])
+  })
+})
+
+describe('readDocsPage', () => {
+  const fetchMock = vi.fn()
+
+  beforeEach(() => {
+    fetchMock.mockReset()
+    mockSleep.mockReset()
+    mockSleep.mockResolvedValue(undefined)
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('fetches the manifest path verbatim from the docs site', async () => {
+    expect(SAMPLE_PAGE).toBeDefined()
+    fetchMock.mockResolvedValue(fetchResponse(200, '# Agent\n\nbody'))
+
+    const page = await readDocsPage(`docs/${SAMPLE_PAGE}`)
+
+    expect(fetchMock).toHaveBeenCalledOnce()
+    expect(fetchMock.mock.calls[0][0]).toBe(`https://docs.sim.ai/${SAMPLE_PAGE}`)
+    expect(page).toEqual({ content: '# Agent\n\nbody', totalLines: 3 })
+  })
+
+  it('rejects an unknown page without fetching', async () => {
+    await expect(readDocsPage('docs/not-a-real-page.mdx')).rejects.toThrow(DocsCorpusError)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('points a directory read at glob', async () => {
+    await expect(readDocsPage('docs/workflows/blocks')).rejects.toThrow(/is a directory/)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('surfaces a docs-site outage as a retryable error after exhausting retries', async () => {
+    fetchMock.mockResolvedValue(fetchResponse(502))
+    await expect(readDocsPage(`docs/${SAMPLE_PAGE}`)).rejects.toThrow(/could not be reached/)
+    expect(fetchMock).toHaveBeenCalledTimes(3)
+  })
+
+  it('treats a network failure as retryable', async () => {
+    fetchMock.mockRejectedValue(new Error('socket hang up'))
+    await expect(readDocsPage(`docs/${SAMPLE_PAGE}`)).rejects.toThrow(/could not be reached/)
+    expect(fetchMock).toHaveBeenCalledTimes(3)
+  })
+
+  it('recovers when a transient failure clears on retry', async () => {
+    fetchMock
+      .mockRejectedValueOnce(new Error('socket hang up'))
+      .mockResolvedValue(fetchResponse(200, '# Agent\n\nbody'))
+
+    const page = await readDocsPage(`docs/${SAMPLE_PAGE}`)
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    expect(page).toEqual({ content: '# Agent\n\nbody', totalLines: 3 })
+  })
+
+  it('reports a page the site no longer serves as permanent, without retrying', async () => {
+    fetchMock.mockResolvedValue(fetchResponse(404))
+    const error = await readDocsPage(`docs/${SAMPLE_PAGE}`).catch((e) => e)
+    expect(error).toBeInstanceOf(DocsCorpusError)
+    expect(error.message).toMatch(/does not serve it/)
+    expect(error.message).toMatch(/retrying will not help/)
+    expect(error.message).not.toMatch(/could not be reached/)
+    expect(fetchMock).toHaveBeenCalledOnce()
+  })
+
+  it('honors Retry-After while retrying a 429 response', async () => {
+    fetchMock.mockResolvedValue(fetchResponse(429, '', { 'Retry-After': '7' }))
+    await expect(readDocsPage(`docs/${SAMPLE_PAGE}`)).rejects.toThrow(/could not be reached/)
+    expect(fetchMock).toHaveBeenCalledTimes(3)
+    expect(mockSleep).toHaveBeenNthCalledWith(1, 7_000)
+    expect(mockSleep).toHaveBeenNthCalledWith(2, 7_000)
+  })
+
+  it('treats 408 as retryable rather than a missing page', async () => {
+    fetchMock.mockResolvedValue(fetchResponse(408))
+    await expect(readDocsPage(`docs/${SAMPLE_PAGE}`)).rejects.toThrow(/could not be reached/)
+    expect(fetchMock).toHaveBeenCalledTimes(3)
+  })
+
+  it('aborts an in-flight fetch without retrying', async () => {
+    const controller = new AbortController()
+    fetchMock.mockImplementation((_url: string, init: RequestInit) => {
+      const signal = init.signal as AbortSignal
+      return new Promise((_resolve, reject) => {
+        signal.addEventListener('abort', () => reject(signal.reason), { once: true })
+      })
+    })
+
+    const request = readDocsPage(`docs/${SAMPLE_PAGE}`, controller.signal)
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledOnce())
+    controller.abort(new Error('user stopped docs read'))
+
+    await expect(request).rejects.toThrow('user stopped docs read')
+    expect(fetchMock).toHaveBeenCalledOnce()
+    expect(mockSleep).not.toHaveBeenCalled()
+  })
+
+  it('aborts retry backoff before starting another fetch', async () => {
+    const controller = new AbortController()
+    fetchMock.mockResolvedValue(fetchResponse(502))
+    mockSleep.mockImplementationOnce(() => new Promise<void>(() => {}))
+
+    const request = readDocsPage(`docs/${SAMPLE_PAGE}`, controller.signal)
+    await vi.waitFor(() => expect(mockSleep).toHaveBeenCalledOnce())
+    controller.abort(new Error('user stopped docs retry'))
+
+    await expect(request).rejects.toThrow('user stopped docs retry')
+    expect(fetchMock).toHaveBeenCalledOnce()
+  })
+})
+
+describe('grepDocs', () => {
+  const fetchMock = vi.fn()
+  const SECTION_DIR = 'docs/workflows/blocks'
+
+  beforeEach(() => {
+    fetchMock.mockReset()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('greps exactly one page for a page path', async () => {
+    fetchMock.mockResolvedValue(fetchResponse(200, 'intro line\nsystemPrompt matters\ntail'))
+
+    const matches = await grepDocs(`docs/${SAMPLE_PAGE}`, 'systemPrompt')
+
+    expect(fetchMock).toHaveBeenCalledOnce()
+    expect(matches).toEqual([
+      { path: `docs/${SAMPLE_PAGE}`, line: 2, content: 'systemPrompt matters' },
+    ])
+  })
+
+  it('rejects a directory without fetching any pages', async () => {
+    await expect(grepDocs(SECTION_DIR, 'cron marker')).rejects.toThrow(
+      /grep must target one docs page/
+    )
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('rejects a path that is neither a page nor a directory without fetching', async () => {
+    await expect(grepDocs('docs/not-a-real-page.mdx', 'cron')).rejects.toThrow(/not a docs page/)
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/lib/copilot/docs/docs-corpus.ts b/apps/sim/lib/copilot/docs/docs-corpus.ts
new file mode 100644
index 0000000000..e8eca75761
--- /dev/null
+++ b/apps/sim/lib/copilot/docs/docs-corpus.ts
@@ -0,0 +1,251 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { sleep } from '@sim/utils/helpers'
+import { backoffWithJitter, parseRetryAfter } from '@sim/utils/retry'
+import { foldDocsIndexPath } from '@/lib/copilot/docs/docs-path'
+import { DOCS_MANIFEST } from '@/lib/copilot/generated/docs-manifest'
+import type { GrepCountEntry, GrepMatch, GrepOptions } from '@/lib/copilot/vfs/operations'
+import { glob as globPaths, grepReadResult } from '@/lib/copilot/vfs/operations'
+
+const logger = createLogger('DocsCorpus')
+
+/** The public docs site the `docs/` tree is a lazy view of. */
+const DOCS_BASE_URL = 'https://docs.sim.ai'
+
+/** VFS prefix the docs corpus is mounted at. */
+const DOCS_PREFIX = 'docs/'
+
+/** Per-attempt budget — the site is CDN-cached and normally answers in well under a second. */
+const FETCH_ATTEMPT_TIMEOUT_MS = 3_000
+const FETCH_MAX_ATTEMPTS = 3
+
+/**
+ * Thrown for expected, user-facing docs-corpus conditions (unknown page,
+ * directory path, site unreachable). The VFS handlers return the message as the
+ * tool error instead of logging an internal failure.
+ */
+export class DocsCorpusError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'DocsCorpusError'
+  }
+}
+
+/**
+ * Keys-only view of the corpus for glob: every manifest path under `docs/`,
+ * mapped to empty content. `ops.glob` matches keys and derives the virtual
+ * directories from them, so this never touches the network.
+ */
+const docsKeyView: Map<string, string> = new Map(
+  DOCS_MANIFEST.map((path) => [`${DOCS_PREFIX}${path}`, ''])
+)
+
+/**
+ * Normalize a docs path and make `docs/` equivalent to `docs`, avoiding empty
+ * glob results caused only by a trailing slash.
+ */
+export function normalizeDocsPath(path: string): string {
+  return path.trim().replace(/^\/+/, '').replace(/\/+$/, '')
+}
+
+/**
+ * True when a read/grep `path` addresses the docs corpus. Deliberately not a
+ * `path is string` type predicate: the callers chain it ahead of the other
+ * namespace checks, and a predicate would narrow `path` to `never` in every
+ * later branch.
+ */
+export function isDocsPath(path: string | undefined): boolean {
+  if (!path) return false
+  const normalized = normalizeDocsPath(path)
+  return normalized === 'docs' || normalized.startsWith(DOCS_PREFIX)
+}
+
+/**
+ * True when a glob `pattern` could match the docs corpus. Like `uploads/` and
+ * `recently-deleted/`, the corpus is opt-in: only a pattern that explicitly
+ * starts with `docs/` (or is exactly `docs`) sees it, so a broad `**` glob never
+ * drags 300+ doc pages into the result. Same rule as {@link isDocsPath}; the
+ * separate name reads correctly at the glob call site.
+ */
+export function couldMatchDocsScope(pattern: string | undefined): boolean {
+  return isDocsPath(pattern)
+}
+
+/** Manifest paths (and their virtual directories) matching an explicit `docs/` pattern. */
+export function globDocs(pattern: string): string[] {
+  return globPaths(docsKeyView, normalizeDocsPath(pattern))
+}
+
+/** True when `path` is a page in the docs tree. */
+export function isDocsPage(path: string): boolean {
+  return docsKeyView.has(normalizeDocsPath(path))
+}
+
+/**
+ * Map a `docs_embeddings.source_document` (the en-relative mdx file path) back to
+ * its `docs/` VFS path, applying the same index-page fold as the manifest
+ * generator. Returns null when the source has no live VFS path — an unmounted
+ * section (academy, api-reference) or a page deleted since the index was built.
+ */
+export function docsPathForSourceDocument(sourceDocument: string | null): string | null {
+  if (!sourceDocument) return null
+  const path = `${DOCS_PREFIX}${foldDocsIndexPath(sourceDocument.replace(/^\/+/, ''))}`
+  return docsKeyView.has(path) ? path : null
+}
+
+/** True when `path` is a directory in the docs tree rather than a page. */
+export function isDocsDir(path: string): boolean {
+  const dir = `${normalizeDocsPath(path).replace(/\/+$/, '')}/`
+  if (dir === DOCS_PREFIX) return true
+  for (const key of docsKeyView.keys()) {
+    if (key.startsWith(dir)) return true
+  }
+  return false
+}
+
+export interface DocsPage {
+  content: string
+  totalLines: number
+}
+
+/**
+ * Fetch one docs page's raw markdown from the live site. The manifest path IS
+ * the URL path (`docs/workflows/blocks/agent.mdx` →
+ * `https://docs.sim.ai/workflows/blocks/agent.mdx`, which the docs app rewrites
+ * to its raw-markdown route), so no mapping table is needed. Transient failures
+ * (5xx, 429, network error, timeout) are retried with jittered backoff before
+ * being reported as unavailable.
+ */
+type DocsFetchResult =
+  | { outcome: 'ok'; content: string }
+  /** The site will not serve this path however many times we ask. */
+  | { outcome: 'missing' }
+  /** Transient: 5xx, 429, network error, or timeout. */
+  | { outcome: 'unavailable'; retryAfterMs: number | null }
+
+function throwIfAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw toError(signal.reason ?? 'Docs request aborted')
+  }
+}
+
+async function sleepForRetry(delayMs: number, signal?: AbortSignal): Promise<void> {
+  if (!signal) {
+    await sleep(delayMs)
+    return
+  }
+
+  throwIfAborted(signal)
+  let abortListener: (() => void) | undefined
+  const aborted = new Promise<never>((_resolve, reject) => {
+    abortListener = () => reject(toError(signal.reason ?? 'Docs request aborted'))
+    signal.addEventListener('abort', abortListener, { once: true })
+    if (signal.aborted) abortListener()
+  })
+
+  try {
+    await Promise.race([sleep(delayMs), aborted])
+  } finally {
+    if (abortListener) signal.removeEventListener('abort', abortListener)
+  }
+}
+
+async function fetchDocsPageOnce(url: string, signal?: AbortSignal): Promise<DocsFetchResult> {
+  throwIfAborted(signal)
+  const timeoutSignal = AbortSignal.timeout(FETCH_ATTEMPT_TIMEOUT_MS)
+  const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal
+
+  try {
+    const response = await fetch(url, {
+      signal: requestSignal,
+      headers: { Accept: 'text/markdown, text/plain' },
+    })
+    if (!response.ok) {
+      logger.warn('Docs page fetch returned a non-OK status', { url, status: response.status })
+      const permanent =
+        response.status >= 400 &&
+        response.status < 500 &&
+        response.status !== 408 &&
+        response.status !== 429
+      if (permanent) return { outcome: 'missing' }
+      return {
+        outcome: 'unavailable',
+        retryAfterMs: parseRetryAfter(response.headers.get('retry-after')),
+      }
+    }
+    return { outcome: 'ok', content: await response.text() }
+  } catch (err) {
+    throwIfAborted(signal)
+    logger.warn('Docs page fetch failed', { url, error: toError(err).message })
+    return { outcome: 'unavailable', retryAfterMs: null }
+  }
+}
+
+async function fetchDocsPage(path: string, signal?: AbortSignal): Promise<DocsFetchResult> {
+  const key = normalizeDocsPath(path)
+  if (!docsKeyView.has(key)) return { outcome: 'missing' }
+  const url = `${DOCS_BASE_URL}/${key.slice(DOCS_PREFIX.length)}`
+  for (let attempt = 1; ; attempt++) {
+    throwIfAborted(signal)
+    const result = await fetchDocsPageOnce(url, signal)
+    throwIfAborted(signal)
+    if (result.outcome !== 'unavailable' || attempt >= FETCH_MAX_ATTEMPTS) return result
+    await sleepForRetry(backoffWithJitter(attempt, result.retryAfterMs), signal)
+  }
+}
+
+/**
+ * Read one docs page. Throws {@link DocsCorpusError} for the expected user-facing
+ * conditions (directory path, unknown page, site unreachable) so the handler can
+ * surface the message verbatim.
+ */
+export async function readDocsPage(path: string, signal?: AbortSignal): Promise<DocsPage> {
+  const key = normalizeDocsPath(path)
+  if (!docsKeyView.has(key)) {
+    if (isDocsDir(key)) {
+      const dir = key.replace(/\/+$/, '')
+      throw new DocsCorpusError(`${dir} is a directory — glob "${dir}/**" to list its pages.`)
+    }
+    throw new DocsCorpusError(
+      `Docs page not found: ${path}. Use glob("docs/**") to list the docs corpus.`
+    )
+  }
+  const result = await fetchDocsPage(key, signal)
+  if (result.outcome === 'missing') {
+    throw new DocsCorpusError(
+      `${key} is in the docs index but ${DOCS_BASE_URL} does not serve it — the page was likely moved or removed. Use glob("docs/**") to find the current path; retrying will not help.`
+    )
+  }
+  if (result.outcome === 'unavailable') {
+    throw new DocsCorpusError(
+      `Could not load ${key} from ${DOCS_BASE_URL} — the docs site could not be reached. Retry shortly.`
+    )
+  }
+  return { content: result.content, totalLines: result.content.split('\n').length }
+}
+
+/**
+ * Grep one docs page. Directory-wide grep is deliberately unsupported because
+ * each page is a separate network fetch; use `search_docs` for corpus search or
+ * `glob("docs/**")` to find a page first.
+ */
+export async function grepDocs(
+  path: string,
+  pattern: string,
+  options?: GrepOptions,
+  signal?: AbortSignal
+): Promise<GrepMatch[] | string[] | GrepCountEntry[]> {
+  const key = normalizeDocsPath(path)
+  if (!docsKeyView.has(key)) {
+    if (isDocsDir(key)) {
+      throw new DocsCorpusError(
+        `"${path}" is a docs directory; grep must target one docs page. Use search_docs to search the corpus or glob("${key}/**") to list its pages.`
+      )
+    }
+    throw new DocsCorpusError(
+      `"${path}" is not a docs page. Use glob("docs/**") to list the docs corpus.`
+    )
+  }
+  const page = await readDocsPage(key, signal)
+  return grepReadResult(key, page, pattern, key, options)
+}
diff --git a/apps/sim/lib/copilot/docs/docs-path.test.ts b/apps/sim/lib/copilot/docs/docs-path.test.ts
new file mode 100644
index 0000000000..c40ba0a7ab
--- /dev/null
+++ b/apps/sim/lib/copilot/docs/docs-path.test.ts
@@ -0,0 +1,35 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { docsSourceCandidates, foldDocsIndexPath } from '@/lib/copilot/docs/docs-path'
+import { DOCS_MANIFEST } from '@/lib/copilot/generated/docs-manifest'
+
+describe('foldDocsIndexPath', () => {
+  it('folds a section overview onto the section path', () => {
+    expect(foldDocsIndexPath('workflows/index.mdx')).toBe('workflows.mdx')
+    expect(foldDocsIndexPath('platform/enterprise/index.mdx')).toBe('platform/enterprise.mdx')
+  })
+
+  it('leaves a plain page untouched', () => {
+    expect(foldDocsIndexPath('workflows/blocks/agent.mdx')).toBe('workflows/blocks/agent.mdx')
+    expect(foldDocsIndexPath('agents.mdx')).toBe('agents.mdx')
+  })
+
+  it('does not fold a page merely named index', () => {
+    expect(foldDocsIndexPath('index.mdx')).toBe('index.mdx')
+  })
+})
+
+describe('docsSourceCandidates', () => {
+  it('is the inverse of the fold — one candidate always reproduces the input', () => {
+    for (const publicPath of DOCS_MANIFEST) {
+      const candidates = docsSourceCandidates(publicPath)
+      expect(candidates.map(foldDocsIndexPath)).toContain(publicPath)
+    }
+  })
+
+  it('offers both on-disk layouts for a section path', () => {
+    expect(docsSourceCandidates('workflows.mdx')).toEqual(['workflows.mdx', 'workflows/index.mdx'])
+  })
+})
diff --git a/apps/sim/lib/copilot/docs/docs-path.ts b/apps/sim/lib/copilot/docs/docs-path.ts
new file mode 100644
index 0000000000..6178541803
--- /dev/null
+++ b/apps/sim/lib/copilot/docs/docs-path.ts
@@ -0,0 +1,44 @@
+/**
+ * The single definition of how a docs source file maps onto its public path.
+ *
+ * Fumadocs folds a section's `index.mdx` into the section URL itself, so
+ * `workflows/index.mdx` on disk is `/workflows` on the site (and
+ * `/workflows/index.mdx` is a 404). Three places need that rule — the manifest
+ * generator, the `source_document` -> VFS reverse mapping, and the vector
+ * search's scope filter — and hand-syncing it has bitten this repo before, so
+ * it lives here.
+ *
+ * Deliberately dependency-free: `scripts/sync-docs-manifest.ts` imports this by
+ * relative path, and it must not pull in the manifest it generates.
+ */
+
+/** Suffix that marks a section overview page on disk. */
+export const DOCS_INDEX_SUFFIX = '/index.mdx'
+
+/**
+ * Top-level docs sections deliberately left out of the copilot's `docs/` tree.
+ *
+ * The manifest generator and vector search share this list so search cannot
+ * return pages that the VFS cannot read.
+ */
+export const UNMOUNTED_DOCS_SECTIONS = ['academy', 'api-reference'] as const
+
+/**
+ * Fold an `en`-relative mdx file path onto its public path — the value used as
+ * both the `docs/`-relative VFS path and the docs.sim.ai URL path.
+ */
+export function foldDocsIndexPath(mdxPath: string): string {
+  return mdxPath.endsWith(DOCS_INDEX_SUFFIX)
+    ? `${mdxPath.slice(0, -DOCS_INDEX_SUFFIX.length)}.mdx`
+    : mdxPath
+}
+
+/**
+ * The inverse of {@link foldDocsIndexPath}: the on-disk file names a public
+ * path could have come from. A page is stored either as `<stem>.mdx` or, when
+ * it is a section overview, as `<stem>/index.mdx`.
+ */
+export function docsSourceCandidates(publicPath: string): [string, string] {
+  const stem = publicPath.replace(/\.mdx$/, '')
+  return [`${stem}.mdx`, `${stem}${DOCS_INDEX_SUFFIX}`]
+}
diff --git a/apps/sim/lib/copilot/docs/docs-search.test.ts b/apps/sim/lib/copilot/docs/docs-search.test.ts
new file mode 100644
index 0000000000..16d19141f4
--- /dev/null
+++ b/apps/sim/lib/copilot/docs/docs-search.test.ts
@@ -0,0 +1,292 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockGenerateSearchEmbedding, capturedWhere, capturedLimit, mockRows } = vi.hoisted(() => ({
+  mockGenerateSearchEmbedding: vi.fn(),
+  capturedWhere: { value: undefined as unknown },
+  capturedLimit: { value: undefined as number | undefined },
+  mockRows: { value: [] as unknown[] },
+}))
+
+vi.mock('@/lib/knowledge/embeddings', () => ({
+  generateSearchEmbedding: mockGenerateSearchEmbedding,
+}))
+
+/**
+ * Override the global drizzle mock with operators that record their arguments,
+ * so a test can assert on the `source_document` filter the scope produced.
+ */
+vi.mock('drizzle-orm', () => {
+  const op =
+    (name: string) =>
+    (...args: unknown[]) => ({ op: name, args })
+  return {
+    and: op('and'),
+    or: op('or'),
+    eq: op('eq'),
+    ne: op('ne'),
+    like: op('like'),
+    notLike: op('notLike'),
+    sql: (strings: TemplateStringsArray) => ({ op: 'sql', text: strings.join('?') }),
+  }
+})
+
+vi.mock('@sim/db', () => ({
+  db: {
+    select: () => ({
+      from: () => ({
+        where: (condition: unknown) => {
+          capturedWhere.value = condition
+          return {
+            orderBy: () => ({
+              limit: async (n: number) => {
+                capturedLimit.value = n
+                return mockRows.value
+              },
+            }),
+          }
+        },
+      }),
+    }),
+  },
+}))
+
+import { DocsSearchScopeError, searchDocs } from '@/lib/copilot/docs/docs-search'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
+
+/** Render a drizzle condition to comparable SQL-ish text for assertions. */
+function whereText(): string {
+  return JSON.stringify(capturedWhere.value)
+}
+
+describe('searchDocs path scoping', () => {
+  beforeEach(() => {
+    capturedWhere.value = undefined
+    mockRows.value = []
+    mockGenerateSearchEmbedding.mockResolvedValue({ embedding: [0.1, 0.2] })
+  })
+
+  it('excludes unmounted sections when unscoped', async () => {
+    await searchDocs('cron')
+    expect(whereText()).toContain('academy/%')
+    expect(whereText()).toContain('api-reference/%')
+  })
+
+  it('treats a bare docs prefix as unscoped', async () => {
+    await searchDocs('cron', { path: 'docs/' })
+    expect(whereText()).toContain('academy/%')
+  })
+
+  it('excludes the root homepage when unscoped — its chunks have no live docs/ path', async () => {
+    await searchDocs('cron')
+    expect(whereText()).toContain('"op":"ne"')
+    expect(whereText()).toContain('index.mdx')
+  })
+
+  it('scopes a page to both on-disk layouts', async () => {
+    await searchDocs('cron', { path: 'docs/workflows/blocks/agent.mdx' })
+    const text = whereText()
+    expect(text).toContain('workflows/blocks/agent.mdx')
+    expect(text).toContain('workflows/blocks/agent/index.mdx')
+  })
+
+  it('maps a section overview page onto its index file', async () => {
+    await searchDocs('cron', { path: 'docs/workflows.mdx' })
+    const text = whereText()
+    expect(text).toContain('workflows/index.mdx')
+  })
+
+  it('scopes a directory to its subtree', async () => {
+    await searchDocs('cron', { path: 'docs/workflows' })
+    expect(whereText()).toContain('workflows/%')
+  })
+
+  it('includes a section overview stored in either on-disk layout', async () => {
+    await searchDocs('cron', { path: 'docs/workflows' })
+    const text = whereText()
+    expect(text).toContain('workflows/%')
+    expect(text).toContain('workflows.mdx')
+  })
+
+  it('rejects a path outside the docs corpus', async () => {
+    const error = await searchDocs('cron', { path: 'files/report.pdf' }).catch((cause) => cause)
+    expect(error).toBeInstanceOf(DocsSearchScopeError)
+    expect(error).toBeInstanceOf(OrchestrationError)
+    expect(error).toMatchObject({ code: 'validation' })
+  })
+
+  it('rejects a docs path that is neither a page nor a section', async () => {
+    await expect(searchDocs('cron', { path: 'docs/not-a-real-section' })).rejects.toThrow(
+      /not a page or section/
+    )
+  })
+
+  it('rejects unmounted sections that exist on the site but not in the VFS', async () => {
+    await expect(searchDocs('cron', { path: 'docs/academy' })).rejects.toThrow(
+      /not a page or section/
+    )
+  })
+})
+
+describe('searchDocs results', () => {
+  beforeEach(() => {
+    capturedWhere.value = undefined
+    mockGenerateSearchEmbedding.mockResolvedValue({ embedding: [0.1, 0.2] })
+  })
+
+  it('returns the docs/ path to read next, folding index pages', async () => {
+    mockRows.value = [
+      {
+        chunkText: 'body',
+        sourceDocument: 'workflows/index.mdx',
+        sourceLink: 'https://docs.sim.ai/workflows',
+        headerText: 'Overview',
+        similarity: 0.8,
+      },
+    ]
+    const { results } = await searchDocs('cron')
+    expect(results).toEqual([
+      {
+        path: 'docs/workflows.mdx',
+        url: 'https://docs.sim.ai/workflows',
+        title: 'Overview',
+        content: 'body',
+        similarity: 0.8,
+      },
+    ])
+  })
+
+  it('drops chunks whose source has no live docs/ path', async () => {
+    mockRows.value = [
+      {
+        chunkText: 'a',
+        sourceDocument: 'academy/lesson-1.mdx',
+        sourceLink: 'x',
+        headerText: 'h',
+        similarity: 0.9,
+      },
+      {
+        chunkText: 'b',
+        sourceDocument: 'deleted-page.mdx',
+        sourceLink: 'y',
+        headerText: 'h',
+        similarity: 0.9,
+      },
+    ]
+    expect((await searchDocs('cron')).results).toEqual([])
+  })
+
+  it('returns the zero-candidate outcome without querying when the embedding is empty', async () => {
+    mockGenerateSearchEmbedding.mockResolvedValue({ embedding: [] })
+    const outcome = await searchDocs('cron')
+    expect(outcome).toEqual({
+      results: [],
+      candidatesConsidered: 0,
+      droppedBelowThreshold: 0,
+      droppedStale: 0,
+    })
+  })
+
+  it('drops chunks below the similarity threshold', async () => {
+    mockRows.value = [
+      {
+        chunkText: 'a',
+        sourceDocument: 'agents.mdx',
+        sourceLink: 'x',
+        headerText: 'h',
+        similarity: 0.1,
+      },
+    ]
+    expect((await searchDocs('cron')).results).toEqual([])
+  })
+})
+
+describe('searchDocs shortfall reporting', () => {
+  beforeEach(() => {
+    capturedWhere.value = undefined
+    mockGenerateSearchEmbedding.mockResolvedValue({ embedding: [0.1, 0.2] })
+  })
+
+  it('counts why candidates were dropped so an empty set is explainable', async () => {
+    mockRows.value = [
+      {
+        chunkText: 'a',
+        sourceDocument: 'agents.mdx',
+        sourceLink: 'x',
+        headerText: 'h',
+        similarity: 0.1,
+      },
+      {
+        chunkText: 'b',
+        sourceDocument: 'deleted-page.mdx',
+        sourceLink: 'y',
+        headerText: 'h',
+        similarity: 0.9,
+      },
+    ]
+    const outcome = await searchDocs('cron')
+    expect(outcome).toEqual({
+      results: [],
+      candidatesConsidered: 2,
+      droppedBelowThreshold: 1,
+      droppedStale: 1,
+    })
+  })
+
+  it('reports no drops when every candidate survives', async () => {
+    mockRows.value = [
+      {
+        chunkText: 'a',
+        sourceDocument: 'agents.mdx',
+        sourceLink: 'x',
+        headerText: 'h',
+        similarity: 0.9,
+      },
+    ]
+    const outcome = await searchDocs('cron')
+    expect(outcome.droppedBelowThreshold).toBe(0)
+    expect(outcome.droppedStale).toBe(0)
+    expect(outcome.results).toHaveLength(1)
+  })
+})
+
+describe('searchDocs topK clamping', () => {
+  beforeEach(() => {
+    capturedLimit.value = undefined
+    mockRows.value = []
+    mockGenerateSearchEmbedding.mockResolvedValue({ embedding: [0.1, 0.2] })
+  })
+
+  it('defaults to 5 when unspecified', async () => {
+    await searchDocs('cron')
+    expect(capturedLimit.value).toBe(5)
+  })
+
+  it('caps at 25 — the documented max, which the old tool never enforced', async () => {
+    await searchDocs('cron', { topK: 500 })
+    expect(capturedLimit.value).toBe(25)
+  })
+
+  it('floors at 1', async () => {
+    await searchDocs('cron', { topK: 0 })
+    expect(capturedLimit.value).toBe(1)
+    await searchDocs('cron', { topK: -8 })
+    expect(capturedLimit.value).toBe(1)
+  })
+
+  it('truncates a fractional count', async () => {
+    await searchDocs('cron', { topK: 7.9 })
+    expect(capturedLimit.value).toBe(7)
+  })
+
+  it('falls back to the default rather than passing NaN to the query', async () => {
+    await searchDocs('cron', { topK: Number.NaN })
+    expect(capturedLimit.value).toBe(5)
+    await searchDocs('cron', { topK: 'twelve' as unknown as number })
+    expect(capturedLimit.value).toBe(5)
+    await searchDocs('cron', { topK: Number.POSITIVE_INFINITY })
+    expect(capturedLimit.value).toBe(5)
+  })
+})
diff --git a/apps/sim/lib/copilot/docs/docs-search.ts b/apps/sim/lib/copilot/docs/docs-search.ts
new file mode 100644
index 0000000000..e506dff48e
--- /dev/null
+++ b/apps/sim/lib/copilot/docs/docs-search.ts
@@ -0,0 +1,207 @@
+import { db } from '@sim/db'
+import { docsEmbeddings } from '@sim/db/schema'
+import { createLogger } from '@sim/logger'
+import { and, eq, like, ne, notLike, or, sql } from 'drizzle-orm'
+import { escapeLikePattern } from '@/lib/api/list-query'
+import {
+  docsPathForSourceDocument,
+  isDocsDir,
+  isDocsPage,
+  normalizeDocsPath,
+} from '@/lib/copilot/docs/docs-corpus'
+import { docsSourceCandidates, UNMOUNTED_DOCS_SECTIONS } from '@/lib/copilot/docs/docs-path'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
+import { generateSearchEmbedding } from '@/lib/knowledge/embeddings'
+
+const logger = createLogger('DocsSearch')
+
+const SIMILARITY_THRESHOLD = 0.3
+const DEFAULT_TOP_K = 5
+const MAX_TOP_K = 25
+
+export interface DocsSearchResult {
+  /** The `docs/` VFS path this chunk came from — pass it to `read` for the full page. */
+  path: string
+  /** Public docs.sim.ai URL for the section, for citation. */
+  url: string
+  title: string
+  content: string
+  similarity: number
+}
+
+/**
+ * A search result set plus why it may be shorter than `topK`. The SQL LIMIT is
+ * applied before the threshold and liveness filters, so these counts are what
+ * distinguishes "nothing matched" from "matches were filtered out".
+ */
+export interface DocsSearchOutcome {
+  results: DocsSearchResult[]
+  /** Rows the vector search returned before filtering. */
+  candidatesConsidered: number
+  /** Candidates dropped for scoring below the similarity threshold. */
+  droppedBelowThreshold: number
+  /** Candidates dropped because their page is no longer in the docs manifest. */
+  droppedStale: number
+}
+
+/**
+ * Thrown when the caller scopes a search to a `path` that is not a real page or
+ * section in the docs corpus. Surfaced verbatim so the model can correct itself
+ * rather than reading an empty result as "the docs say nothing about this".
+ */
+export class DocsSearchScopeError extends OrchestrationError {
+  constructor(message: string) {
+    super('validation', message)
+    this.name = 'DocsSearchScopeError'
+  }
+}
+
+/**
+ * Translate an optional `docs/` VFS path into a `source_document` filter.
+ *
+ * `source_document` stores the en-relative mdx file path, while VFS paths mirror
+ * the public URL — so a section overview is `docs/workflows.mdx` in the VFS but
+ * `workflows/index.mdx` (or `workflows.mdx`) on disk. A directory scope covers
+ * the whole subtree plus the overview in either layout.
+ *
+ * An unscoped search excludes every {@link UNMOUNTED_DOCS_SECTIONS} section:
+ * they are indexed but not mounted in the VFS, so a hit there would be a chunk
+ * the agent cannot then read. The root homepage (`index.mdx`) is excluded for
+ * the same reason — the manifest generator drops it (its URL is `/`, which
+ * redirects), so its chunks would only ever be counted against topK and then
+ * discarded as stale.
+ */
+function scopeCondition(path?: string) {
+  const normalized = normalizeDocsPath(path ?? '')
+  if (normalized === '' || normalized === 'docs') {
+    return and(
+      ne(docsEmbeddings.sourceDocument, 'index.mdx'),
+      ...UNMOUNTED_DOCS_SECTIONS.map((section) =>
+        notLike(docsEmbeddings.sourceDocument, `${section}/%`)
+      )
+    )
+  }
+
+  if (!normalized.startsWith('docs/')) {
+    throw new DocsSearchScopeError(
+      `path must be a docs/ VFS path (got "${path}"). Use glob("docs/**") to find one, or omit path to search everything.`
+    )
+  }
+
+  const tail = normalized.slice('docs/'.length)
+
+  if (isDocsPage(normalized)) {
+    const [pageFile, indexFile] = docsSourceCandidates(tail)
+    return or(
+      eq(docsEmbeddings.sourceDocument, pageFile),
+      eq(docsEmbeddings.sourceDocument, indexFile)
+    )
+  }
+
+  if (isDocsDir(normalized)) {
+    return or(
+      like(docsEmbeddings.sourceDocument, `${escapeLikePattern(tail)}/%`),
+      eq(docsEmbeddings.sourceDocument, `${tail}.mdx`)
+    )
+  }
+
+  throw new DocsSearchScopeError(
+    `"${path}" is not a page or section in the docs corpus. Use glob("docs/**") to find a valid path, or omit path to search everything.`
+  )
+}
+
+/**
+ * Clamp a caller-supplied result count into [1, {@link MAX_TOP_K}].
+ *
+ * Guards magnitude AND type: `Math.min`/`Math.max` propagate NaN, so a
+ * non-numeric value would otherwise reach the query as `.limit(NaN)`. The
+ * generated tool schema rejects a non-number upstream today, but this function
+ * is also called directly, so it does not rely on that.
+ */
+function clampTopK(requested: number | undefined): number {
+  if (requested === undefined || !Number.isFinite(requested)) return DEFAULT_TOP_K
+  return Math.min(Math.max(Math.trunc(requested), 1), MAX_TOP_K)
+}
+
+/**
+ * Semantic search over the indexed docs corpus (`docs_embeddings`, rebuilt by
+ * `scripts/process-docs.ts` on release). Every result carries the `docs/` path
+ * it came from so the caller can `read` the full page next.
+ *
+ * The index lags the VFS: a page added since the last index rebuild is readable
+ * but not searchable, and a deleted one can still return chunks. Results whose
+ * source no longer maps to a live `docs/` path are dropped.
+ *
+ * Because those drops happen after the SQL LIMIT, a caller can get fewer hits
+ * than it asked for — or none at all when every candidate was filtered. The
+ * returned {@link DocsSearchOutcome} reports that explicitly so an empty result
+ * is never mistaken for "the documentation does not cover this".
+ */
+export async function searchDocs(
+  query: string,
+  options?: { path?: string; topK?: number }
+): Promise<DocsSearchOutcome> {
+  if (!query || typeof query !== 'string') throw new Error('query is required')
+
+  const topK = clampTopK(options?.topK)
+  const where = scopeCondition(options?.path)
+
+  logger.info('Executing docs search', {
+    queryLength: query.length,
+    topK,
+    path: options?.path ?? null,
+  })
+
+  const { embedding: queryEmbedding } = await generateSearchEmbedding(query)
+  if (!queryEmbedding || queryEmbedding.length === 0) {
+    return { results: [], candidatesConsidered: 0, droppedBelowThreshold: 0, droppedStale: 0 }
+  }
+  const queryVector = JSON.stringify(queryEmbedding)
+
+  const rows = await db
+    .select({
+      chunkText: docsEmbeddings.chunkText,
+      sourceDocument: docsEmbeddings.sourceDocument,
+      sourceLink: docsEmbeddings.sourceLink,
+      headerText: docsEmbeddings.headerText,
+      similarity: sql<number>`1 - (${docsEmbeddings.embedding} <=> ${queryVector}::vector)`,
+    })
+    .from(docsEmbeddings)
+    .where(where)
+    .orderBy(sql`${docsEmbeddings.embedding} <=> ${queryVector}::vector`)
+    .limit(topK)
+
+  const results: DocsSearchResult[] = []
+  let droppedBelowThreshold = 0
+  let droppedStale = 0
+  for (const row of rows) {
+    if (row.similarity < SIMILARITY_THRESHOLD) {
+      droppedBelowThreshold++
+      continue
+    }
+    const path = docsPathForSourceDocument(row.sourceDocument)
+    if (!path) {
+      droppedStale++
+      continue
+    }
+    results.push({
+      path,
+      url: row.sourceLink,
+      title: row.headerText,
+      content: row.chunkText,
+      similarity: row.similarity,
+    })
+  }
+
+  logger.info('Docs search complete', {
+    count: results.length,
+    droppedBelowThreshold,
+    droppedStale,
+  })
+  return {
+    results,
+    candidatesConsidered: rows.length,
+    droppedBelowThreshold,
+    droppedStale,
+  }
+}
diff --git a/apps/sim/lib/copilot/entitlements.ts b/apps/sim/lib/copilot/entitlements.ts
index f35e356b8d..99219bc837 100644
--- a/apps/sim/lib/copilot/entitlements.ts
+++ b/apps/sim/lib/copilot/entitlements.ts
@@ -3,6 +3,7 @@ import { getErrorMessage } from '@sim/utils/errors'
 import { LRUCache } from 'lru-cache'
 import { hasWorkspaceSandboxAccess } from '@/lib/billing/core/subscription'
 import { isCustomBlocksEligible } from '@/lib/workflows/custom-blocks/operations'
+import { getWorkspaceWithOwner } from '@/lib/workspaces/permissions/utils'
 
 const logger = createLogger('CopilotEntitlements')
 
@@ -12,6 +13,7 @@ const logger = createLogger('CopilotEntitlements')
  */
 export const CUSTOM_BLOCKS_ENTITLEMENT = 'custom-blocks'
 export const SIM_SANDBOXES_ENTITLEMENT = 'sim-sandboxes'
+export const ORGANIZATION_CONTEXT_ENTITLEMENT = 'organization-context'
 
 /**
  * Workspace entitlements — plan/flag-gated org capabilities sent to the
@@ -36,6 +38,18 @@ const ENTITLEMENT_EVALUATORS: Record<
 > = {
   [CUSTOM_BLOCKS_ENTITLEMENT]: isCustomBlocksEligible,
   [SIM_SANDBOXES_ENTITLEMENT]: hasWorkspaceSandboxAccess,
+  [ORGANIZATION_CONTEXT_ENTITLEMENT]: isOrganizationContextAvailable,
+}
+
+/**
+ * True when this workspace belongs to an organization, which is exactly when
+ * the copilot's `organization/` VFS namespace has anything in it. Advertising
+ * it keeps a personal workspace's agents from ever hearing that org standing,
+ * access-control groups, or fork topology exist.
+ */
+async function isOrganizationContextAvailable(workspaceId: string): Promise<boolean> {
+  const workspace = await getWorkspaceWithOwner(workspaceId)
+  return Boolean(workspace?.organizationId)
 }
 
 const entitlementsCache = new LRUCache<string, Promise<string[]>>({
diff --git a/apps/sim/lib/copilot/generated/docs-manifest.ts b/apps/sim/lib/copilot/generated/docs-manifest.ts
new file mode 100644
index 0000000000..6adc3e3217
--- /dev/null
+++ b/apps/sim/lib/copilot/generated/docs-manifest.ts
@@ -0,0 +1,422 @@
+/**
+ * AUTO-GENERATED FILE. DO NOT EDIT.
+ * Generated from apps/docs/content/docs/en by scripts/sync-docs-manifest.ts.
+ * Run: bun run docs-manifest:generate.
+ *
+ * Every page in the copilot's read-only `docs/` VFS tree, as a path that is
+ * simultaneously the `docs/`-relative VFS path and the docs.sim.ai URL path
+ * (so `docs/workflows/blocks/agent.mdx` reads
+ * `https://docs.sim.ai/workflows/blocks/agent.mdx`). Sorted.
+ */
+export const DOCS_MANIFEST: readonly string[] = [
+  'agents.mdx',
+  'agents/choosing.mdx',
+  'agents/custom-tools.mdx',
+  'agents/mcp.mdx',
+  'agents/skills.mdx',
+  'chat.mdx',
+  'chat/files.mdx',
+  'chat/knowledge.mdx',
+  'chat/mailer.mdx',
+  'chat/research.mdx',
+  'chat/tables.mdx',
+  'chat/tasks.mdx',
+  'chat/workflows.mdx',
+  'cli.mdx',
+  'cli/audit-logs.mdx',
+  'cli/authentication.mdx',
+  'cli/billing.mdx',
+  'cli/commands.mdx',
+  'cli/configuration.mdx',
+  'cli/credentials.mdx',
+  'cli/custom-tools.mdx',
+  'cli/files.mdx',
+  'cli/knowledge.mdx',
+  'cli/logs.mdx',
+  'cli/mcp-servers.mdx',
+  'cli/output.mdx',
+  'cli/reference.mdx',
+  'cli/scripting.mdx',
+  'cli/secrets.mdx',
+  'cli/skills.mdx',
+  'cli/tables.mdx',
+  'cli/troubleshooting.mdx',
+  'cli/workflows.mdx',
+  'cli/workspaces.mdx',
+  'files.mdx',
+  'files/editor.mdx',
+  'files/generating.mdx',
+  'files/passing-files.mdx',
+  'files/using-in-workflows.mdx',
+  'getting-started.mdx',
+  'integrations.mdx',
+  'integrations/a2a.mdx',
+  'integrations/agentmail.mdx',
+  'integrations/agentphone.mdx',
+  'integrations/agiloft.mdx',
+  'integrations/ahrefs.mdx',
+  'integrations/airtable-service-account.mdx',
+  'integrations/airtable.mdx',
+  'integrations/airweave.mdx',
+  'integrations/algolia.mdx',
+  'integrations/amplitude.mdx',
+  'integrations/apify.mdx',
+  'integrations/apollo.mdx',
+  'integrations/appconfig.mdx',
+  'integrations/arxiv.mdx',
+  'integrations/asana-service-account.mdx',
+  'integrations/asana.mdx',
+  'integrations/ashby.mdx',
+  'integrations/athena.mdx',
+  'integrations/atlassian-service-account.mdx',
+  'integrations/attio-service-account.mdx',
+  'integrations/attio.mdx',
+  'integrations/azure_data_explorer.mdx',
+  'integrations/azure_devops.mdx',
+  'integrations/bitbucket.mdx',
+  'integrations/box-service-account.mdx',
+  'integrations/box.mdx',
+  'integrations/brandfetch.mdx',
+  'integrations/brex.mdx',
+  'integrations/brightdata.mdx',
+  'integrations/browser_use.mdx',
+  'integrations/buffer.mdx',
+  'integrations/calcom-service-account.mdx',
+  'integrations/calcom.mdx',
+  'integrations/calendly.mdx',
+  'integrations/cbinsights.mdx',
+  'integrations/circleback.mdx',
+  'integrations/clay.mdx',
+  'integrations/clerk.mdx',
+  'integrations/clickhouse.mdx',
+  'integrations/clickup-service-account.mdx',
+  'integrations/clickup.mdx',
+  'integrations/cloudflare.mdx',
+  'integrations/cloudformation.mdx',
+  'integrations/cloudwatch.mdx',
+  'integrations/codepipeline.mdx',
+  'integrations/confluence.mdx',
+  'integrations/context_dev.mdx',
+  'integrations/convex.mdx',
+  'integrations/crowdstrike.mdx',
+  'integrations/crunchbase.mdx',
+  'integrations/cursor.mdx',
+  'integrations/dagster.mdx',
+  'integrations/databricks.mdx',
+  'integrations/datadog.mdx',
+  'integrations/datagma.mdx',
+  'integrations/daytona.mdx',
+  'integrations/deployments.mdx',
+  'integrations/devin.mdx',
+  'integrations/discord.mdx',
+  'integrations/docusign.mdx',
+  'integrations/downdetector.mdx',
+  'integrations/dropbox.mdx',
+  'integrations/dropcontact.mdx',
+  'integrations/dspy.mdx',
+  'integrations/dub.mdx',
+  'integrations/duckduckgo.mdx',
+  'integrations/dynamodb.mdx',
+  'integrations/dynatrace.mdx',
+  'integrations/elasticsearch.mdx',
+  'integrations/elevenlabs.mdx',
+  'integrations/emailbison.mdx',
+  'integrations/embeddings.mdx',
+  'integrations/enrich.mdx',
+  'integrations/enrichment.mdx',
+  'integrations/enrow.mdx',
+  'integrations/exa.mdx',
+  'integrations/extend.mdx',
+  'integrations/fathom.mdx',
+  'integrations/file.mdx',
+  'integrations/findymail.mdx',
+  'integrations/firecrawl.mdx',
+  'integrations/fireflies.mdx',
+  'integrations/flint.mdx',
+  'integrations/gamma.mdx',
+  'integrations/github.mdx',
+  'integrations/gitlab.mdx',
+  'integrations/gmail.mdx',
+  'integrations/gong.mdx',
+  'integrations/google-service-account.mdx',
+  'integrations/google_ads.mdx',
+  'integrations/google_appsheet.mdx',
+  'integrations/google_bigquery.mdx',
+  'integrations/google_books.mdx',
+  'integrations/google_calendar.mdx',
+  'integrations/google_contacts.mdx',
+  'integrations/google_docs.mdx',
+  'integrations/google_drive.mdx',
+  'integrations/google_forms.mdx',
+  'integrations/google_groups.mdx',
+  'integrations/google_maps.mdx',
+  'integrations/google_meet.mdx',
+  'integrations/google_pagespeed.mdx',
+  'integrations/google_search.mdx',
+  'integrations/google_sheets.mdx',
+  'integrations/google_slides.mdx',
+  'integrations/google_tasks.mdx',
+  'integrations/google_translate.mdx',
+  'integrations/google_vault.mdx',
+  'integrations/grafana.mdx',
+  'integrations/grain.mdx',
+  'integrations/granola.mdx',
+  'integrations/greenhouse.mdx',
+  'integrations/greptile.mdx',
+  'integrations/hex.mdx',
+  'integrations/hubspot-service-account.mdx',
+  'integrations/hubspot-setup.mdx',
+  'integrations/hubspot.mdx',
+  'integrations/huggingface.mdx',
+  'integrations/hunter.mdx',
+  'integrations/iam.mdx',
+  'integrations/icypeas.mdx',
+  'integrations/identity_center.mdx',
+  'integrations/imap.mdx',
+  'integrations/incidentio.mdx',
+  'integrations/infisical.mdx',
+  'integrations/instantly.mdx',
+  'integrations/intercom.mdx',
+  'integrations/jina.mdx',
+  'integrations/jira.mdx',
+  'integrations/jira_service_management.mdx',
+  'integrations/jotform.mdx',
+  'integrations/jupyter.mdx',
+  'integrations/kalshi.mdx',
+  'integrations/ketch.mdx',
+  'integrations/knowledge.mdx',
+  'integrations/langsmith.mdx',
+  'integrations/latex.mdx',
+  'integrations/launchdarkly.mdx',
+  'integrations/leadmagic.mdx',
+  'integrations/lemlist.mdx',
+  'integrations/linear-service-account.mdx',
+  'integrations/linear.mdx',
+  'integrations/linkedin.mdx',
+  'integrations/linkup.mdx',
+  'integrations/linq.mdx',
+  'integrations/logfire.mdx',
+  'integrations/logrocket.mdx',
+  'integrations/logs.mdx',
+  'integrations/loops.mdx',
+  'integrations/luma.mdx',
+  'integrations/mailchimp.mdx',
+  'integrations/mailgun.mdx',
+  'integrations/managed_agent.mdx',
+  'integrations/mem0.mdx',
+  'integrations/memory.mdx',
+  'integrations/microsoft_ad.mdx',
+  'integrations/microsoft_dataverse.mdx',
+  'integrations/microsoft_excel.mdx',
+  'integrations/microsoft_planner.mdx',
+  'integrations/microsoft_teams.mdx',
+  'integrations/millionverifier.mdx',
+  'integrations/mintlify.mdx',
+  'integrations/mistral_parse.mdx',
+  'integrations/modal.mdx',
+  'integrations/monday-service-account.mdx',
+  'integrations/monday.mdx',
+  'integrations/mongodb.mdx',
+  'integrations/mssql.mdx',
+  'integrations/mysql.mdx',
+  'integrations/neo4j.mdx',
+  'integrations/netsuite-service-account.mdx',
+  'integrations/netsuite.mdx',
+  'integrations/neverbounce.mdx',
+  'integrations/new_relic.mdx',
+  'integrations/notion-service-account.mdx',
+  'integrations/notion.mdx',
+  'integrations/obsidian.mdx',
+  'integrations/okta.mdx',
+  'integrations/onedrive.mdx',
+  'integrations/onepassword.mdx',
+  'integrations/openai.mdx',
+  'integrations/outlook.mdx',
+  'integrations/pagerduty.mdx',
+  'integrations/parallel_ai.mdx',
+  'integrations/peopledatalabs.mdx',
+  'integrations/perplexity.mdx',
+  'integrations/persona.mdx',
+  'integrations/pinecone.mdx',
+  'integrations/pipedrive-service-account.mdx',
+  'integrations/pipedrive.mdx',
+  'integrations/pitchbook.mdx',
+  'integrations/polymarket.mdx',
+  'integrations/postgresql.mdx',
+  'integrations/posthog.mdx',
+  'integrations/profound.mdx',
+  'integrations/prospeo.mdx',
+  'integrations/pulse.mdx',
+  'integrations/qdrant.mdx',
+  'integrations/quartr.mdx',
+  'integrations/quiver.mdx',
+  'integrations/rabbitmq.mdx',
+  'integrations/railway.mdx',
+  'integrations/rb2b.mdx',
+  'integrations/rds.mdx',
+  'integrations/reddit.mdx',
+  'integrations/redis.mdx',
+  'integrations/reducto.mdx',
+  'integrations/resend.mdx',
+  'integrations/revenuecat.mdx',
+  'integrations/rippling.mdx',
+  'integrations/rocketlane.mdx',
+  'integrations/rootly.mdx',
+  'integrations/s3.mdx',
+  'integrations/salesforce-service-account.mdx',
+  'integrations/salesforce.mdx',
+  'integrations/sap_concur.mdx',
+  'integrations/sap_s4hana.mdx',
+  'integrations/secrets_manager.mdx',
+  'integrations/sendblue.mdx',
+  'integrations/sendgrid.mdx',
+  'integrations/sentry.mdx',
+  'integrations/serper.mdx',
+  'integrations/servicenow.mdx',
+  'integrations/ses.mdx',
+  'integrations/sftp.mdx',
+  'integrations/sharepoint.mdx',
+  'integrations/shopify-service-account.mdx',
+  'integrations/shopify.mdx',
+  'integrations/similarweb.mdx',
+  'integrations/sixtyfour.mdx',
+  'integrations/slack.mdx',
+  'integrations/smartlead.mdx',
+  'integrations/smtp.mdx',
+  'integrations/snowflake-service-account.mdx',
+  'integrations/snowflake.mdx',
+  'integrations/splunk.mdx',
+  'integrations/sportmonks.mdx',
+  'integrations/sqs.mdx',
+  'integrations/square.mdx',
+  'integrations/ssh.mdx',
+  'integrations/stagehand.mdx',
+  'integrations/stripe.mdx',
+  'integrations/sts.mdx',
+  'integrations/supabase.mdx',
+  'integrations/table.mdx',
+  'integrations/tailscale.mdx',
+  'integrations/tavily.mdx',
+  'integrations/telegram.mdx',
+  'integrations/temporal.mdx',
+  'integrations/textract.mdx',
+  'integrations/thrive.mdx',
+  'integrations/tiktok.mdx',
+  'integrations/tinybird.mdx',
+  'integrations/trello-service-account.mdx',
+  'integrations/trello.mdx',
+  'integrations/trigger_dev.mdx',
+  'integrations/twilio.mdx',
+  'integrations/twilio_sms.mdx',
+  'integrations/twilio_voice.mdx',
+  'integrations/typeform.mdx',
+  'integrations/upstash.mdx',
+  'integrations/uptimerobot.mdx',
+  'integrations/vanta.mdx',
+  'integrations/vercel.mdx',
+  'integrations/wealthbox-service-account.mdx',
+  'integrations/wealthbox.mdx',
+  'integrations/webflow-service-account.mdx',
+  'integrations/webflow.mdx',
+  'integrations/whatsapp.mdx',
+  'integrations/wikipedia.mdx',
+  'integrations/windchill.mdx',
+  'integrations/wiza.mdx',
+  'integrations/wordpress.mdx',
+  'integrations/workday.mdx',
+  'integrations/x.mdx',
+  'integrations/youtube.mdx',
+  'integrations/zendesk.mdx',
+  'integrations/zep.mdx',
+  'integrations/zerobounce.mdx',
+  'integrations/zoho-desk-service-account.mdx',
+  'integrations/zoho_desk.mdx',
+  'integrations/zoom-service-account.mdx',
+  'integrations/zoom.mdx',
+  'integrations/zoominfo.mdx',
+  'introduction.mdx',
+  'keyboard-shortcuts.mdx',
+  'knowledgebase.mdx',
+  'knowledgebase/chunking-strategies.mdx',
+  'knowledgebase/connectors.mdx',
+  'knowledgebase/debugging-retrieval.mdx',
+  'knowledgebase/tags.mdx',
+  'knowledgebase/using-in-workflows.mdx',
+  'logs-debugging.mdx',
+  'logs-debugging/alerts.mdx',
+  'logs-debugging/logging.mdx',
+  'platform/costs.mdx',
+  'platform/credentials.mdx',
+  'platform/enterprise.mdx',
+  'platform/enterprise/access-control.mdx',
+  'platform/enterprise/audit-logs.mdx',
+  'platform/enterprise/custom-blocks.mdx',
+  'platform/enterprise/data-drains.mdx',
+  'platform/enterprise/data-retention.mdx',
+  'platform/enterprise/forks.mdx',
+  'platform/enterprise/self-hosted.mdx',
+  'platform/enterprise/session-policies.mdx',
+  'platform/enterprise/sso.mdx',
+  'platform/enterprise/verified-domains.mdx',
+  'platform/enterprise/whitelabeling.mdx',
+  'platform/organization.mdx',
+  'platform/permissions.mdx',
+  'platform/self-hosting.mdx',
+  'platform/self-hosting/architecture.mdx',
+  'platform/self-hosting/authentication.mdx',
+  'platform/self-hosting/background-jobs.mdx',
+  'platform/self-hosting/docker.mdx',
+  'platform/self-hosting/email.mdx',
+  'platform/self-hosting/environment-variables.mdx',
+  'platform/self-hosting/integrations-oauth.mdx',
+  'platform/self-hosting/kubernetes.mdx',
+  'platform/self-hosting/networking.mdx',
+  'platform/self-hosting/object-storage.mdx',
+  'platform/self-hosting/observability.mdx',
+  'platform/self-hosting/platforms.mdx',
+  'platform/self-hosting/redis.mdx',
+  'platform/self-hosting/scaling.mdx',
+  'platform/self-hosting/security.mdx',
+  'platform/self-hosting/troubleshooting.mdx',
+  'platform/self-hosting/upgrades.mdx',
+  'platform/self-hosting/verify.mdx',
+  'platform/workspaces.mdx',
+  'quick-reference.mdx',
+  'tables.mdx',
+  'tables/using-in-workflows.mdx',
+  'tables/workflow-columns.mdx',
+  'workflows.mdx',
+  'workflows/blocks/agent.mdx',
+  'workflows/blocks/api.mdx',
+  'workflows/blocks/condition.mdx',
+  'workflows/blocks/credential.mdx',
+  'workflows/blocks/evaluator.mdx',
+  'workflows/blocks/function.mdx',
+  'workflows/blocks/guardrails.mdx',
+  'workflows/blocks/human-in-the-loop.mdx',
+  'workflows/blocks/logs.mdx',
+  'workflows/blocks/loop.mdx',
+  'workflows/blocks/parallel.mdx',
+  'workflows/blocks/pi.mdx',
+  'workflows/blocks/response.mdx',
+  'workflows/blocks/router.mdx',
+  'workflows/blocks/variables.mdx',
+  'workflows/blocks/wait.mdx',
+  'workflows/blocks/webhook.mdx',
+  'workflows/blocks/workflow.mdx',
+  'workflows/connections.mdx',
+  'workflows/data-flow.mdx',
+  'workflows/deployment.mdx',
+  'workflows/deployment/agent-events.mdx',
+  'workflows/deployment/api.mdx',
+  'workflows/deployment/chat.mdx',
+  'workflows/deployment/mcp.mdx',
+  'workflows/how-it-runs.mdx',
+  'workflows/triggers/rss.mdx',
+  'workflows/triggers/schedule.mdx',
+  'workflows/triggers/sim.mdx',
+  'workflows/triggers/start.mdx',
+  'workflows/triggers/table.mdx',
+  'workflows/triggers/webhook.mdx',
+  'workflows/variables.mdx',
+]
diff --git a/apps/sim/lib/copilot/generated/metrics-v1.ts b/apps/sim/lib/copilot/generated/metrics-v1.ts
index 06c74839c4..b379803f21 100644
--- a/apps/sim/lib/copilot/generated/metrics-v1.ts
+++ b/apps/sim/lib/copilot/generated/metrics-v1.ts
@@ -19,6 +19,7 @@ export const Metric = {
   CopilotCacheWrite: 'copilot.cache.write',
   CopilotChatBlobBytes: 'copilot.chat.blob.bytes',
   CopilotChatBlobCount: 'copilot.chat.blob.count',
+  CopilotDegradedCount: 'copilot.degraded.count',
   CopilotFileReadDuration: 'copilot.file.read.duration',
   CopilotFileReadSize: 'copilot.file.read.size',
   CopilotMessagesSerializeDuration: 'copilot.messages.serialize.duration',
@@ -48,6 +49,7 @@ export const MetricValues: readonly MetricValue[] = [
   'copilot.cache.write',
   'copilot.chat.blob.bytes',
   'copilot.chat.blob.count',
+  'copilot.degraded.count',
   'copilot.file.read.duration',
   'copilot.file.read.size',
   'copilot.messages.serialize.duration',
diff --git a/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts b/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts
index 76322f7b64..e7440fb3d0 100644
--- a/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts
+++ b/apps/sim/lib/copilot/generated/mothership-stream-v1-schema.ts
@@ -514,7 +514,13 @@ export const MOTHERSHIP_STREAM_V1_SCHEMA: JsonSchema = {
       type: 'object',
     },
     MothershipStreamV1RunKind: {
-      enum: ['checkpoint_pause', 'resumed', 'compaction_start', 'compaction_done'],
+      enum: [
+        'checkpoint_pause',
+        'resumed',
+        'compaction_start',
+        'compaction_done',
+        'steering_applied',
+      ],
       type: 'string',
     },
     MothershipStreamV1RunResumedEventEnvelope: {
@@ -777,6 +783,26 @@ export const MOTHERSHIP_STREAM_V1_SCHEMA: JsonSchema = {
       enum: ['subagent', 'structured_result', 'subagent_result'],
       type: 'string',
     },
+    MothershipStreamV1SteeringAppliedPayload: {
+      additionalProperties: false,
+      properties: {
+        content: {
+          type: 'string',
+        },
+        kind: {
+          $ref: '#/$defs/MothershipStreamV1RunKind',
+        },
+        messageId: {
+          type: 'string',
+        },
+        mode: {
+          enum: ['deferred', 'interrupt'],
+          type: 'string',
+        },
+      },
+      required: ['kind', 'messageId', 'content', 'mode'],
+      type: 'object',
+    },
     MothershipStreamV1StreamCursor: {
       additionalProperties: false,
       properties: {
@@ -1313,6 +1339,9 @@ export const MOTHERSHIP_STREAM_V1_SCHEMA: JsonSchema = {
         hidden: {
           type: 'boolean',
         },
+        inbandOwned: {
+          type: 'boolean',
+        },
         internal: {
           type: 'boolean',
         },
diff --git a/apps/sim/lib/copilot/generated/mothership-stream-v1.ts b/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
index 5cdf7801bf..3b47c736f7 100644
--- a/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
+++ b/apps/sim/lib/copilot/generated/mothership-stream-v1.ts
@@ -160,6 +160,7 @@ export interface MothershipStreamV1AdditionalPropertiesMap {
 export interface MothershipStreamV1ToolUI {
   clientExecutable?: boolean
   hidden?: boolean
+  inbandOwned?: boolean
   internal?: boolean
 }
 export interface MothershipStreamV1ToolArgsDeltaEventEnvelope {
@@ -468,12 +469,14 @@ export type MothershipStreamV1RunKind =
   | 'resumed'
   | 'compaction_start'
   | 'compaction_done'
+  | 'steering_applied'
 
 export const MothershipStreamV1RunKind = {
   checkpoint_pause: 'checkpoint_pause',
   resumed: 'resumed',
   compaction_start: 'compaction_start',
   compaction_done: 'compaction_done',
+  steering_applied: 'steering_applied',
 } as const
 
 export type MothershipStreamV1SessionKind = 'trace' | 'chat' | 'title' | 'start'
diff --git a/apps/sim/lib/copilot/generated/tool-catalog-v1.ts b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
index cd2ca61b5c..ab7556186a 100644
--- a/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
+++ b/apps/sim/lib/copilot/generated/tool-catalog-v1.ts
@@ -7,15 +7,18 @@ export interface ToolCatalogEntry {
   clientExecutable?: boolean
   hidden?: boolean
   id:
-    | 'agent'
+    | 'apply_file_edit'
     | 'auth'
     | 'browser'
     | 'browser_click'
+    | 'browser_click_at'
     | 'browser_close_tab'
+    | 'browser_drag'
     | 'browser_extract'
     | 'browser_go_back'
     | 'browser_go_forward'
     | 'browser_hover'
+    | 'browser_insert_text'
     | 'browser_list_sessions'
     | 'browser_list_tabs'
     | 'browser_navigate'
@@ -23,7 +26,6 @@ export interface ToolCatalogEntry {
     | 'browser_open_url'
     | 'browser_press_key'
     | 'browser_read_text'
-    | 'browser_request_takeover'
     | 'browser_screenshot'
     | 'browser_scroll'
     | 'browser_select_option'
@@ -32,26 +34,23 @@ export interface ToolCatalogEntry {
     | 'browser_type'
     | 'browser_wait_for'
     | 'call_integration_tool'
-    | 'check_deployment_status'
+    | 'connect_slack_bot'
     | 'cp'
-    | 'crawl_website'
-    | 'create_file'
+    | 'create_empty_file'
     | 'create_workflow'
     | 'create_workspace_mcp_server'
     | 'delete_workspace_mcp_server'
     | 'deploy'
-    | 'deploy_api'
-    | 'deploy_chat'
-    | 'deploy_custom_block'
-    | 'deploy_mcp'
+    | 'deploy_as_api'
+    | 'deploy_as_chat'
+    | 'deploy_as_mcp'
     | 'diff_workflows'
-    | 'download_to_workspace_file'
-    | 'edit_content'
+    | 'download_file'
     | 'edit_workflow'
-    | 'enrichment_run'
+    | 'extensions'
+    | 'extract_doc_assets'
     | 'ffmpeg'
     | 'file'
-    | 'function_execute'
     | 'generate_api_key'
     | 'generate_audio'
     | 'generate_image'
@@ -59,34 +58,35 @@ export interface ToolCatalogEntry {
     | 'get_block_outputs'
     | 'get_block_upstream_references'
     | 'get_deployed_workflow_state'
-    | 'get_deployment_log'
-    | 'get_page_contents'
-    | 'get_platform_actions'
+    | 'get_deployment_status'
     | 'get_workflow_data'
     | 'get_workflow_run_options'
     | 'glob'
     | 'grep'
+    | 'interrupt_agent'
     | 'knowledge'
-    | 'knowledge_base'
+    | 'list_deployment_versions'
     | 'list_integration_tools'
-    | 'list_user_workspaces'
     | 'list_workspace_mcp_servers'
     | 'load_deployment'
     | 'load_integration_tool'
     | 'load_skill'
     | 'manage_credential'
     | 'manage_custom_tool'
-    | 'manage_mcp_tool'
+    | 'manage_knowledge_base'
+    | 'manage_mcp_connection'
     | 'manage_sandbox'
     | 'manage_skill'
-    | 'materialize_file'
     | 'media'
     | 'mkdir'
     | 'mv'
     | 'oauth_get_auth_link'
     | 'oauth_request_access'
     | 'open_resource'
+    | 'platform'
+    | 'prepare_file_edit'
     | 'promote_to_live'
+    | 'publish_custom_block'
     | 'query_logs'
     | 'query_user_table'
     | 'read'
@@ -97,41 +97,56 @@ export interface ToolCatalogEntry {
     | 'run'
     | 'run_block'
     | 'run_code'
+    | 'run_enrichment'
     | 'run_from_block'
+    | 'run_function'
     | 'run_workflow'
     | 'run_workflow_until_block'
-    | 'scrape_page'
+    | 'save_upload'
     | 'search'
-    | 'search_documentation'
+    | 'search_docs'
     | 'search_integration_tools'
     | 'search_knowledge_base'
     | 'search_library_docs'
-    | 'search_online'
-    | 'search_patterns'
     | 'set_block_enabled'
     | 'set_environment_variables'
     | 'set_global_workflow_variables'
     | 'share_file'
+    | 'steer_agent'
     | 'table'
+    | 'table_automations'
+    | 'table_columns'
+    | 'table_enrichments'
+    | 'table_manage'
+    | 'table_rows'
+    | 'table_views'
+    | 'tail_agent'
     | 'terminal'
     | 'update_deployment_version'
     | 'update_workspace_mcp_server'
     | 'user_table'
     | 'wait'
+    | 'wait_agents'
+    | 'web_crawl'
+    | 'web_fetch'
+    | 'web_scrape'
+    | 'web_search'
     | 'workflow'
-    | 'workspace_file'
   internal?: boolean
   mode: 'async' | 'sync'
   name:
-    | 'agent'
+    | 'apply_file_edit'
     | 'auth'
     | 'browser'
     | 'browser_click'
+    | 'browser_click_at'
     | 'browser_close_tab'
+    | 'browser_drag'
     | 'browser_extract'
     | 'browser_go_back'
     | 'browser_go_forward'
     | 'browser_hover'
+    | 'browser_insert_text'
     | 'browser_list_sessions'
     | 'browser_list_tabs'
     | 'browser_navigate'
@@ -139,7 +154,6 @@ export interface ToolCatalogEntry {
     | 'browser_open_url'
     | 'browser_press_key'
     | 'browser_read_text'
-    | 'browser_request_takeover'
     | 'browser_screenshot'
     | 'browser_scroll'
     | 'browser_select_option'
@@ -148,26 +162,23 @@ export interface ToolCatalogEntry {
     | 'browser_type'
     | 'browser_wait_for'
     | 'call_integration_tool'
-    | 'check_deployment_status'
+    | 'connect_slack_bot'
     | 'cp'
-    | 'crawl_website'
-    | 'create_file'
+    | 'create_empty_file'
     | 'create_workflow'
     | 'create_workspace_mcp_server'
     | 'delete_workspace_mcp_server'
     | 'deploy'
-    | 'deploy_api'
-    | 'deploy_chat'
-    | 'deploy_custom_block'
-    | 'deploy_mcp'
+    | 'deploy_as_api'
+    | 'deploy_as_chat'
+    | 'deploy_as_mcp'
     | 'diff_workflows'
-    | 'download_to_workspace_file'
-    | 'edit_content'
+    | 'download_file'
     | 'edit_workflow'
-    | 'enrichment_run'
+    | 'extensions'
+    | 'extract_doc_assets'
     | 'ffmpeg'
     | 'file'
-    | 'function_execute'
     | 'generate_api_key'
     | 'generate_audio'
     | 'generate_image'
@@ -175,34 +186,35 @@ export interface ToolCatalogEntry {
     | 'get_block_outputs'
     | 'get_block_upstream_references'
     | 'get_deployed_workflow_state'
-    | 'get_deployment_log'
-    | 'get_page_contents'
-    | 'get_platform_actions'
+    | 'get_deployment_status'
     | 'get_workflow_data'
     | 'get_workflow_run_options'
     | 'glob'
     | 'grep'
+    | 'interrupt_agent'
     | 'knowledge'
-    | 'knowledge_base'
+    | 'list_deployment_versions'
     | 'list_integration_tools'
-    | 'list_user_workspaces'
     | 'list_workspace_mcp_servers'
     | 'load_deployment'
     | 'load_integration_tool'
     | 'load_skill'
     | 'manage_credential'
     | 'manage_custom_tool'
-    | 'manage_mcp_tool'
+    | 'manage_knowledge_base'
+    | 'manage_mcp_connection'
     | 'manage_sandbox'
     | 'manage_skill'
-    | 'materialize_file'
     | 'media'
     | 'mkdir'
     | 'mv'
     | 'oauth_get_auth_link'
     | 'oauth_request_access'
     | 'open_resource'
+    | 'platform'
+    | 'prepare_file_edit'
     | 'promote_to_live'
+    | 'publish_custom_block'
     | 'query_logs'
     | 'query_user_table'
     | 'read'
@@ -213,29 +225,41 @@ export interface ToolCatalogEntry {
     | 'run'
     | 'run_block'
     | 'run_code'
+    | 'run_enrichment'
     | 'run_from_block'
+    | 'run_function'
     | 'run_workflow'
     | 'run_workflow_until_block'
-    | 'scrape_page'
+    | 'save_upload'
     | 'search'
-    | 'search_documentation'
+    | 'search_docs'
     | 'search_integration_tools'
     | 'search_knowledge_base'
     | 'search_library_docs'
-    | 'search_online'
-    | 'search_patterns'
     | 'set_block_enabled'
     | 'set_environment_variables'
     | 'set_global_workflow_variables'
     | 'share_file'
+    | 'steer_agent'
     | 'table'
+    | 'table_automations'
+    | 'table_columns'
+    | 'table_enrichments'
+    | 'table_manage'
+    | 'table_rows'
+    | 'table_views'
+    | 'tail_agent'
     | 'terminal'
     | 'update_deployment_version'
     | 'update_workspace_mcp_server'
     | 'user_table'
     | 'wait'
+    | 'wait_agents'
+    | 'web_crawl'
+    | 'web_fetch'
+    | 'web_scrape'
+    | 'web_search'
     | 'workflow'
-    | 'workspace_file'
   parameters: unknown
   requiredPermission?: 'admin' | 'write'
   requiresApproval?: boolean
@@ -249,26 +273,42 @@ export interface ToolCatalogEntry {
     | 'file'
     | 'knowledge'
     | 'media'
+    | 'platform'
     | 'run'
     | 'search'
     | 'table'
     | 'workflow'
 }
 
-export const Agent: ToolCatalogEntry = {
-  id: 'agent',
-  name: 'agent',
-  route: 'subagent',
+export const ApplyFileEdit: ToolCatalogEntry = {
+  id: 'apply_file_edit',
+  name: 'apply_file_edit',
+  route: 'sim',
   mode: 'async',
   parameters: {
-    properties: {
-      request: { description: 'What tool/skill/MCP action is needed.', type: 'string' },
-    },
-    required: ['request'],
     type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description:
+          'The text content to write. For append: text to append. For update: full replacement text. For patch with search_replace: the replacement text. For patch with anchored: the insert/replacement text.',
+      },
+    },
+    required: ['content'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: {
+        type: 'object',
+        description:
+          'Optional operation metadata such as file id, file name, size, and content type.',
+      },
+      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
+      success: { type: 'boolean', description: 'Whether the content was applied successfully.' },
+    },
+    required: ['success', 'message'],
   },
-  subagentId: 'agent',
-  internal: true,
   requiredPermission: 'write',
 }
 
@@ -425,6 +465,135 @@ export const BrowserClick: ToolCatalogEntry = {
   clientExecutable: true,
 }
 
+export const BrowserClickAt: ToolCatalogEntry = {
+  id: 'browser_click_at',
+  name: 'browser_click_at',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      clickCount: {
+        type: 'number',
+        description: '1 = single click (default), 2 = double-click, 3 = triple-click.',
+      },
+      x: {
+        type: 'number',
+        description:
+          "X in CSS pixels within the current viewport. When read off a browser_screenshot, divide the image pixel value by the screenshot's scale.",
+      },
+      y: {
+        type: 'number',
+        description:
+          'Y in CSS pixels within the current viewport, converted from screenshot pixels the same way as x.',
+      },
+    },
+    required: ['x', 'y'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      activeTab: {
+        type: 'object',
+        description: 'New active tab after a tab-changing click.',
+        properties: {
+          tabId: { type: 'string', description: 'Stable browser tab id.' },
+          url: { type: 'string', description: 'New active tab URL.' },
+        },
+      },
+      clickCount: {
+        type: 'number',
+        description: 'The click count that was dispatched (1, 2, or 3).',
+      },
+      clickedAt: {
+        type: 'object',
+        description: 'The CSS-pixel viewport point that was clicked.',
+        properties: {
+          x: { type: 'number', description: 'Clicked X in CSS viewport pixels.' },
+          y: { type: 'number', description: 'Clicked Y in CSS viewport pixels.' },
+        },
+      },
+      dialogs: {
+        type: 'array',
+        description: 'Visible DOM dialogs remaining after the click.',
+        items: { type: 'string' },
+      },
+      dispatched: {
+        type: 'boolean',
+        description: 'Whether the native pointer click was dispatched at the point.',
+      },
+      effect: {
+        type: 'object',
+        description:
+          'Detailed postcondition signals; generic title/DOM/scroll churn is weak evidence unless the tool documents otherwise.',
+        properties: {
+          dialogChanged: { type: 'boolean', description: 'The visible DOM dialog set changed.' },
+          domChanged: {
+            type: 'boolean',
+            description: 'The DOM mutation revision changed; weak evidence on its own.',
+          },
+          fieldChanged: {
+            type: 'boolean',
+            description: 'The safely inspectable focused-field state changed.',
+          },
+          focusChanged: { type: 'boolean', description: 'The focused element changed.' },
+          popupChanged: { type: 'boolean', description: 'The visible popup/menu set changed.' },
+          scrollChanged: {
+            type: 'boolean',
+            description: 'A tracked scroll offset changed; weak evidence except for scroll keys.',
+          },
+          tabChanged: { type: 'boolean', description: 'The active browser tab changed.' },
+          targetChanged: {
+            type: 'boolean',
+            description: "The requested target's checked/selected/expanded/open state changed.",
+          },
+          titleChanged: {
+            type: 'boolean',
+            description: 'The document title changed; weak evidence on its own.',
+          },
+          urlChanged: { type: 'boolean', description: 'The observed URL changed.' },
+        },
+      },
+      effectObserved: {
+        type: 'boolean',
+        description:
+          'Whether a strong page change (URL/dialog/popup/target, or focus into an editable) followed the click.',
+      },
+      note: {
+        type: 'string',
+        description: 'Caution or follow-up guidance, present when the click needs verification.',
+      },
+      notices: {
+        type: 'array',
+        description:
+          'Pending auto-handled JavaScript alert/confirm/prompt notices since the previous successful browser result.',
+        items: { type: 'string' },
+      },
+      possibleEffectObserved: {
+        type: 'boolean',
+        description: 'Whether only weaker background churn (DOM/title) was observed.',
+      },
+      target: {
+        type: 'string',
+        description:
+          'What the point resolved to before the click (tag/role and accessible name) — confirm it matches the intended target.',
+      },
+      targetCursor: {
+        type: 'string',
+        description:
+          "The CSS cursor at the point (e.g. 'pointer', 'text', 'crosshair') — a hint about what kind of surface was hit.",
+      },
+      trusted: {
+        type: 'boolean',
+        description:
+          'True — coordinate and drag input always use the trusted Chromium pointer pipeline.',
+      },
+    },
+    required: ['dispatched'],
+  },
+  clientExecutable: true,
+}
+
 export const BrowserCloseTab: ToolCatalogEntry = {
   id: 'browser_close_tab',
   name: 'browser_close_tab',
@@ -443,6 +612,130 @@ export const BrowserCloseTab: ToolCatalogEntry = {
   clientExecutable: true,
 }
 
+export const BrowserDrag: ToolCatalogEntry = {
+  id: 'browser_drag',
+  name: 'browser_drag',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      fromElementId: {
+        type: 'number',
+        description: 'Drag source element id from the latest snapshot. Alternative to fromX/fromY.',
+      },
+      fromX: {
+        type: 'number',
+        description:
+          'Drag source X in CSS viewport pixels (paired with fromY) when no source element id is available.',
+      },
+      fromY: { type: 'number', description: 'Drag source Y in CSS viewport pixels.' },
+      toElementId: {
+        type: 'number',
+        description: 'Drop target element id from the latest snapshot. Alternative to toX/toY.',
+      },
+      toX: {
+        type: 'number',
+        description: 'Drop target X in CSS viewport pixels (paired with toY).',
+      },
+      toY: { type: 'number', description: 'Drop target Y in CSS viewport pixels.' },
+    },
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      dialogs: {
+        type: 'array',
+        description: 'Visible DOM dialogs remaining after the click.',
+        items: { type: 'string' },
+      },
+      dispatched: { type: 'boolean', description: 'Whether the full drag gesture was dispatched.' },
+      effect: {
+        type: 'object',
+        description:
+          'Detailed postcondition signals; generic title/DOM/scroll churn is weak evidence unless the tool documents otherwise.',
+        properties: {
+          dialogChanged: { type: 'boolean', description: 'The visible DOM dialog set changed.' },
+          domChanged: {
+            type: 'boolean',
+            description: 'The DOM mutation revision changed; weak evidence on its own.',
+          },
+          fieldChanged: {
+            type: 'boolean',
+            description: 'The safely inspectable focused-field state changed.',
+          },
+          focusChanged: { type: 'boolean', description: 'The focused element changed.' },
+          popupChanged: { type: 'boolean', description: 'The visible popup/menu set changed.' },
+          scrollChanged: {
+            type: 'boolean',
+            description: 'A tracked scroll offset changed; weak evidence except for scroll keys.',
+          },
+          tabChanged: { type: 'boolean', description: 'The active browser tab changed.' },
+          targetChanged: {
+            type: 'boolean',
+            description: "The requested target's checked/selected/expanded/open state changed.",
+          },
+          titleChanged: {
+            type: 'boolean',
+            description: 'The document title changed; weak evidence on its own.',
+          },
+          urlChanged: { type: 'boolean', description: 'The observed URL changed.' },
+        },
+      },
+      effectObserved: {
+        type: 'boolean',
+        description:
+          'Whether an observable page change (DOM/URL/dialog/target/scroll) followed the drag.',
+      },
+      from: {
+        type: 'object',
+        description: 'The resolved drag source.',
+        properties: {
+          element: { type: 'string', description: 'What that endpoint resolved to, when known.' },
+          x: { type: 'number', description: 'Endpoint X in CSS viewport pixels.' },
+          y: { type: 'number', description: 'Endpoint Y in CSS viewport pixels.' },
+        },
+      },
+      nativeHtml5Drag: {
+        type: 'boolean',
+        description:
+          'True when the page started a native HTML5 drag and it was completed as a real drag-and-drop; false for a pointer-sensor drag.',
+      },
+      note: {
+        type: 'string',
+        description:
+          'Caution or follow-up guidance — e.g. verify the drop with a fresh snapshot when no effect was observed.',
+      },
+      notices: {
+        type: 'array',
+        description:
+          'Pending auto-handled JavaScript alert/confirm/prompt notices since the previous successful browser result.',
+        items: { type: 'string' },
+      },
+      possibleEffectObserved: {
+        type: 'boolean',
+        description: 'Whether only weaker background churn (DOM/title) was observed.',
+      },
+      to: {
+        type: 'object',
+        description: 'The resolved drop target.',
+        properties: {
+          element: { type: 'string', description: 'What that endpoint resolved to, when known.' },
+          x: { type: 'number', description: 'Endpoint X in CSS viewport pixels.' },
+          y: { type: 'number', description: 'Endpoint Y in CSS viewport pixels.' },
+        },
+      },
+      trusted: {
+        type: 'boolean',
+        description:
+          'True — coordinate and drag input always use the trusted Chromium pointer pipeline.',
+      },
+    },
+    required: ['dispatched'],
+  },
+  clientExecutable: true,
+}
+
 export const BrowserExtract: ToolCatalogEntry = {
   id: 'browser_extract',
   name: 'browser_extract',
@@ -605,6 +898,116 @@ export const BrowserHover: ToolCatalogEntry = {
   clientExecutable: true,
 }
 
+export const BrowserInsertText: ToolCatalogEntry = {
+  id: 'browser_insert_text',
+  name: 'browser_insert_text',
+  route: 'client',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      submit: { type: 'boolean', description: 'Press Enter after inserting. Default false.' },
+      text: { type: 'string', description: 'The text to insert at the caret. Must be non-empty.' },
+    },
+    required: ['text'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      activeElement: { type: 'string', description: 'Focused element kind after the action.' },
+      dispatched: {
+        type: 'boolean',
+        description: 'Whether the text was inserted through the native IME pipeline.',
+      },
+      effect: {
+        type: 'object',
+        description:
+          'Detailed postcondition signals; generic title/DOM/scroll churn is weak evidence unless the tool documents otherwise.',
+        properties: {
+          dialogChanged: { type: 'boolean', description: 'The visible DOM dialog set changed.' },
+          domChanged: {
+            type: 'boolean',
+            description: 'The DOM mutation revision changed; weak evidence on its own.',
+          },
+          fieldChanged: {
+            type: 'boolean',
+            description: 'The safely inspectable focused-field state changed.',
+          },
+          focusChanged: { type: 'boolean', description: 'The focused element changed.' },
+          popupChanged: { type: 'boolean', description: 'The visible popup/menu set changed.' },
+          scrollChanged: {
+            type: 'boolean',
+            description: 'A tracked scroll offset changed; weak evidence except for scroll keys.',
+          },
+          tabChanged: { type: 'boolean', description: 'The active browser tab changed.' },
+          targetChanged: {
+            type: 'boolean',
+            description: "The requested target's checked/selected/expanded/open state changed.",
+          },
+          titleChanged: {
+            type: 'boolean',
+            description: 'The document title changed; weak evidence on its own.',
+          },
+          urlChanged: { type: 'boolean', description: 'The observed URL changed.' },
+        },
+      },
+      effectObserved: {
+        type: 'boolean',
+        description:
+          'Whether a field or page change confirmed the insertion. Canvas editors cannot echo one — verify visually.',
+      },
+      insertedChars: { type: 'number', description: 'How many characters were inserted.' },
+      kind: {
+        type: 'string',
+        description:
+          'The kind of focused editable that received the text (input:*, textarea, contenteditable, canvas, textbox-role).',
+      },
+      note: {
+        type: 'string',
+        description:
+          'Caution or follow-up guidance, e.g. that a canvas editor needs visual verification.',
+      },
+      notices: {
+        type: 'array',
+        description:
+          'Pending auto-handled JavaScript alert/confirm/prompt notices since the previous successful browser result.',
+        items: { type: 'string' },
+      },
+      possibleEffectObserved: {
+        type: 'boolean',
+        description: 'Whether only weaker background churn was observed.',
+      },
+      redacted: {
+        type: 'boolean',
+        description: 'Whether sensitive focused-field details were withheld.',
+      },
+      selectedChars: {
+        type: 'number',
+        description: 'Number of selected characters when safely inspectable.',
+      },
+      submitDispatched: { type: 'boolean', description: 'Whether Enter was actually dispatched.' },
+      submitRequested: {
+        type: 'boolean',
+        description: 'Whether Enter was requested after insertion.',
+      },
+      trusted: {
+        type: 'boolean',
+        description: 'True — insertion uses the trusted input pipeline.',
+      },
+      valueLength: {
+        type: 'number',
+        description: 'Focused non-secret field length when safely inspectable.',
+      },
+      valuePreview: {
+        type: 'string',
+        description: 'Bounded focused non-secret field preview when safely inspectable.',
+      },
+    },
+    required: ['dispatched'],
+  },
+  clientExecutable: true,
+}
+
 export const BrowserListSessions: ToolCatalogEntry = {
   id: 'browser_list_sessions',
   name: 'browser_list_sessions',
@@ -820,31 +1223,6 @@ export const BrowserReadText: ToolCatalogEntry = {
   clientExecutable: true,
 }
 
-export const BrowserRequestTakeover: ToolCatalogEntry = {
-  id: 'browser_request_takeover',
-  name: 'browser_request_takeover',
-  route: 'client',
-  mode: 'async',
-  parameters: {
-    type: 'object',
-    properties: {
-      purpose: {
-        type: 'string',
-        description:
-          'Why takeover is needed. Set sign_in for a login/password flow so the desktop can remember a privacy-preserving session hint after the user finishes.',
-        enum: ['sign_in', 'captcha', 'payment', 'sensitive_confirmation', 'other'],
-      },
-      reason: {
-        type: 'string',
-        description:
-          "Short explanation shown to the user of what they need to do (e.g. 'Sign in to Notion').",
-      },
-    },
-    required: ['reason'],
-  },
-  clientExecutable: true,
-}
-
 export const BrowserScreenshot: ToolCatalogEntry = {
   id: 'browser_screenshot',
   name: 'browser_screenshot',
@@ -1234,20 +1612,34 @@ export const CallIntegrationTool: ToolCatalogEntry = {
   requiresApproval: true,
 }
 
-export const CheckDeploymentStatus: ToolCatalogEntry = {
-  id: 'check_deployment_status',
-  name: 'check_deployment_status',
+export const ConnectSlackBot: ToolCatalogEntry = {
+  id: 'connect_slack_bot',
+  name: 'connect_slack_bot',
   route: 'sim',
   mode: 'async',
   parameters: {
     type: 'object',
     properties: {
-      workflowId: {
+      botTokenEnvVar: {
         type: 'string',
-        description: 'Workflow ID to check (defaults to current workflow)',
+        description:
+          'NAME of the environment variable holding the bot token (xoxb-..., OAuth & Permissions → Bot User OAuth Token). Pass the variable name, never the token value.',
+      },
+      description: { type: 'string', description: 'Optional description shown on the credential.' },
+      displayName: {
+        type: 'string',
+        description:
+          'Display name for the credential, shown in the credential picker (e.g. "Elder Bot"). Must be unique in the workspace.',
+      },
+      signingSecretEnvVar: {
+        type: 'string',
+        description:
+          "NAME of the environment variable holding the Slack app's signing secret (Basic Information → App Credentials). Pass the variable name, never the secret value.",
       },
     },
+    required: ['displayName', 'signingSecretEnvVar', 'botTokenEnvVar'],
   },
+  requiredPermission: 'write',
 }
 
 export const Cp: ToolCatalogEntry = {
@@ -1280,35 +1672,9 @@ export const Cp: ToolCatalogEntry = {
   requiredPermission: 'write',
 }
 
-export const CrawlWebsite: ToolCatalogEntry = {
-  id: 'crawl_website',
-  name: 'crawl_website',
-  route: 'go',
-  mode: 'sync',
-  parameters: {
-    type: 'object',
-    properties: {
-      exclude_paths: {
-        type: 'array',
-        description: 'Skip URLs matching these patterns',
-        items: { type: 'string' },
-      },
-      include_paths: {
-        type: 'array',
-        description: 'Only crawl URLs matching these patterns',
-        items: { type: 'string' },
-      },
-      limit: { type: 'number', description: 'Maximum pages to crawl (default 10, max 50)' },
-      max_depth: { type: 'number', description: 'How deep to follow links (default 2)' },
-      url: { type: 'string', description: 'Starting URL to crawl from' },
-    },
-    required: ['url'],
-  },
-}
-
-export const CreateFile: ToolCatalogEntry = {
-  id: 'create_file',
-  name: 'create_file',
+export const CreateEmptyFile: ToolCatalogEntry = {
+  id: 'create_empty_file',
+  name: 'create_empty_file',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -1460,9 +1826,9 @@ export const Deploy: ToolCatalogEntry = {
   internal: true,
 }
 
-export const DeployApi: ToolCatalogEntry = {
-  id: 'deploy_api',
-  name: 'deploy_api',
+export const DeployAsApi: ToolCatalogEntry = {
+  id: 'deploy_as_api',
+  name: 'deploy_as_api',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -1511,7 +1877,7 @@ export const DeployApi: ToolCatalogEntry = {
       deploymentType: {
         type: 'string',
         description:
-          'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+          'Deployment surface this result describes. For deploy_as_api and redeploy this is always "api".',
       },
       examples: {
         type: 'object',
@@ -1541,9 +1907,9 @@ export const DeployApi: ToolCatalogEntry = {
   requiresApproval: true,
 }
 
-export const DeployChat: ToolCatalogEntry = {
-  id: 'deploy_chat',
-  name: 'deploy_chat',
+export const DeployAsChat: ToolCatalogEntry = {
+  id: 'deploy_as_chat',
+  name: 'deploy_as_chat',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -1642,7 +2008,7 @@ export const DeployChat: ToolCatalogEntry = {
       deploymentType: {
         type: 'string',
         description:
-          'Deployment surface this result describes. For deploy_chat this is always "chat".',
+          'Deployment surface this result describes. For deploy_as_chat this is always "chat".',
       },
       examples: {
         type: 'object',
@@ -1660,7 +2026,7 @@ export const DeployChat: ToolCatalogEntry = {
       },
       success: {
         type: 'boolean',
-        description: 'Whether the deploy_chat action completed successfully.',
+        description: 'Whether the deploy_as_chat action completed successfully.',
       },
       version: {
         type: 'number',
@@ -1687,121 +2053,9 @@ export const DeployChat: ToolCatalogEntry = {
   requiresApproval: true,
 }
 
-export const DeployCustomBlock: ToolCatalogEntry = {
-  id: 'deploy_custom_block',
-  name: 'deploy_custom_block',
-  route: 'sim',
-  mode: 'async',
-  parameters: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        description: 'Whether to publish (deploy) or unpublish (undeploy) the custom block',
-        enum: ['deploy', 'undeploy'],
-        default: 'deploy',
-      },
-      description: {
-        type: 'string',
-        description: 'Short description shown in the block picker, max 280 characters',
-      },
-      exposedOutputs: {
-        type: 'array',
-        description:
-          "Outputs the block exposes, each mapping a child block output path to a friendly name (use get_block_outputs for valid paths). Omit to expose the terminal block's whole result",
-        items: {
-          type: 'object',
-          properties: {
-            blockId: { type: 'string', description: 'Block UUID inside the workflow' },
-            name: { type: 'string', description: 'Friendly output name shown on the block' },
-            path: {
-              type: 'string',
-              description:
-                "Dot-path into that block's output (from get_block_outputs relativeOutputs)",
-            },
-          },
-          required: ['blockId', 'path', 'name'],
-        },
-      },
-      iconUrl: {
-        type: 'string',
-        description:
-          'Optional icon image for the block: a workspace file VFS path (e.g. "files/icon.png", copied into public icon storage at publish) or an https image URL. Omit to use the organization\'s default icon',
-      },
-      inputs: {
-        type: 'array',
-        description:
-          "Optional per-input placeholder overrides. Input names and types are derived from the workflow's input trigger and cannot be changed here",
-        items: {
-          type: 'object',
-          properties: {
-            id: { type: 'string', description: 'Stable id of the input trigger field' },
-            placeholder: {
-              type: 'string',
-              description: "Placeholder text shown in the block's input field",
-            },
-          },
-          required: ['id'],
-        },
-      },
-      name: {
-        type: 'string',
-        description:
-          'Display name for the block, max 60 characters. REQUIRED the first time a workflow is published. When republishing an existing block, omit it to keep the current name or pass a new one to rename. Ignored for undeploy.',
-      },
-      workflowId: { type: 'string', description: 'Workflow ID (defaults to active workflow)' },
-    },
-  },
-  resultSchema: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        description: 'Action performed by the tool, such as "deploy" or "undeploy".',
-      },
-      blockId: { type: 'string', description: 'Custom block record ID.' },
-      blockType: {
-        type: 'string',
-        description: 'Stable block type slug (custom_block_*) used in workflow state.',
-      },
-      deploymentConfig: {
-        type: 'object',
-        description:
-          "Structured deployment configuration keyed by surface name. Includes the block's type, name, description, icon, derived input fields, and exposed outputs.",
-      },
-      deploymentStatus: {
-        type: 'object',
-        description:
-          'Structured per-surface deployment status keyed by surface name, including customBlock and the underlying api surface when applicable.',
-      },
-      deploymentType: {
-        type: 'string',
-        description:
-          'Deployment surface this result describes. For deploy_custom_block this is always "custom_block".',
-      },
-      isDeployed: {
-        type: 'boolean',
-        description: 'Whether the custom block is published after this tool call.',
-      },
-      name: { type: 'string', description: 'Display name of the custom block.' },
-      removed: {
-        type: 'boolean',
-        description: 'Whether the custom block was unpublished during an undeploy action.',
-      },
-      updated: {
-        type: 'boolean',
-        description: 'Whether an existing custom block was updated instead of created.',
-      },
-      workflowId: { type: 'string', description: 'Workflow ID the custom block is bound to.' },
-    },
-    required: ['deploymentType', 'deploymentStatus'],
-  },
-  requiredPermission: 'admin',
-}
-
-export const DeployMcp: ToolCatalogEntry = {
-  id: 'deploy_mcp',
-  name: 'deploy_mcp',
+export const DeployAsMcp: ToolCatalogEntry = {
+  id: 'deploy_as_mcp',
+  name: 'deploy_as_mcp',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -1863,7 +2117,7 @@ export const DeployMcp: ToolCatalogEntry = {
       deploymentType: {
         type: 'string',
         description:
-          'Deployment surface this result describes. For deploy_mcp this is always "mcp".',
+          'Deployment surface this result describes. For deploy_as_mcp this is always "mcp".',
       },
       examples: {
         type: 'object',
@@ -1925,9 +2179,9 @@ export const DiffWorkflows: ToolCatalogEntry = {
   },
 }
 
-export const DownloadToWorkspaceFile: ToolCatalogEntry = {
-  id: 'download_to_workspace_file',
-  name: 'download_to_workspace_file',
+export const DownloadFile: ToolCatalogEntry = {
+  id: 'download_file',
+  name: 'download_file',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -1980,38 +2234,6 @@ export const DownloadToWorkspaceFile: ToolCatalogEntry = {
   capabilities: ['file_output'],
 }
 
-export const EditContent: ToolCatalogEntry = {
-  id: 'edit_content',
-  name: 'edit_content',
-  route: 'sim',
-  mode: 'async',
-  parameters: {
-    type: 'object',
-    properties: {
-      content: {
-        type: 'string',
-        description:
-          'The text content to write. For append: text to append. For update: full replacement text. For patch with search_replace: the replacement text. For patch with anchored: the insert/replacement text.',
-      },
-    },
-    required: ['content'],
-  },
-  resultSchema: {
-    type: 'object',
-    properties: {
-      data: {
-        type: 'object',
-        description:
-          'Optional operation metadata such as file id, file name, size, and content type.',
-      },
-      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
-      success: { type: 'boolean', description: 'Whether the content was applied successfully.' },
-    },
-    required: ['success', 'message'],
-  },
-  requiredPermission: 'write',
-}
-
 export const EditWorkflow: ToolCatalogEntry = {
   id: 'edit_workflow',
   name: 'edit_workflow',
@@ -2039,7 +2261,7 @@ export const EditWorkflow: ToolCatalogEntry = {
             params: {
               type: 'object',
               description:
-                'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)',
+                'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)\nBlock-level settings (retry, triggerMode, advancedMode) go beside "inputs", never inside it.',
             },
           },
           required: ['operation_type', 'block_id'],
@@ -2056,54 +2278,57 @@ export const EditWorkflow: ToolCatalogEntry = {
   requiredPermission: 'write',
 }
 
-export const EnrichmentRun: ToolCatalogEntry = {
-  id: 'enrichment_run',
-  name: 'enrichment_run',
+export const Extensions: ToolCatalogEntry = {
+  id: 'extensions',
+  name: 'extensions',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      request: { description: 'What tool/skill/MCP action is needed.', type: 'string' },
+      sessionId: {
+        description:
+          'Reusable session ID returned by an earlier extensions call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message. Omit it for a new or independent task.',
+        type: 'string',
+      },
+      title: {
+        description:
+          "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the extensions agent. When resuming with sessionId, copy the registry title unchanged.",
+        maxLength: 120,
+        type: 'string',
+      },
+    },
+    required: ['request', 'title'],
+    type: 'object',
+  },
+  subagentId: 'agent',
+  internal: true,
+  requiredPermission: 'write',
+}
+
+export const ExtractDocAssets: ToolCatalogEntry = {
+  id: 'extract_doc_assets',
+  name: 'extract_doc_assets',
   route: 'sim',
   mode: 'async',
   parameters: {
     type: 'object',
     properties: {
-      enrichmentId: {
+      destination: {
         type: 'string',
         description:
-          "Which enrichment to run. Discover the full set and each one's inputs/outputs via user_table.list_enrichments.",
-        enum: [
-          'work-email',
-          'phone-number',
-          'company-domain',
-          'company-info',
-          'email-verification',
-        ],
+          'Folder to write the extracted set into. Defaults to a "files/<Source Name> assets" folder next to the source.',
       },
-      inputs: {
-        type: 'object',
+      path: {
+        type: 'string',
         description:
-          'Map of the enrichment\'s input id → value, e.g. { "fullName": "Jane Doe", "companyDomain": "acme.com" }. Provide a value for every required input.',
+          'Workspace VFS path of the source document, e.g. files/Brand%20Deck.pptx. Must be an existing .pptx, .docx, or .pdf file.',
       },
     },
-    required: ['enrichmentId', 'inputs'],
-  },
-  resultSchema: {
-    type: 'object',
-    properties: {
-      matched: {
-        type: 'boolean',
-        description: 'True when a provider returned a non-empty result.',
-      },
-      provider: {
-        type: ['string', 'null'],
-        description:
-          'Internal label of the provider that produced the result (billing/diagnostics only — do NOT surface it to the user), or null on no match.',
-      },
-      result: {
-        type: 'object',
-        description: 'Mapped output values from the winning provider (empty object on no match).',
-      },
-    },
-    required: ['matched', 'result'],
+    required: ['path'],
   },
   requiredPermission: 'write',
+  capabilities: ['file_output'],
 }
 
 export const Ffmpeg: ToolCatalogEntry = {
@@ -2285,164 +2510,25 @@ export const File: ToolCatalogEntry = {
           "Optional brief instruction (one short sentence) to scope the task. The agent inherits the full conversation history — do NOT restate or rewrite conversation content, only add scoping the history doesn't convey.",
         type: 'string',
       },
+      sessionId: {
+        description:
+          'Reusable session ID returned by an earlier file call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message — the agent resumes from its saved transcript and receives unseen parent conversation messages. Omit it for a new or independent task.',
+        type: 'string',
+      },
+      title: {
+        description:
+          "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the file agent. When resuming with sessionId, copy the registry title unchanged.",
+        maxLength: 120,
+        type: 'string',
+      },
     },
+    required: ['title'],
     type: 'object',
   },
   subagentId: 'file',
   internal: true,
 }
 
-export const FunctionExecute: ToolCatalogEntry = {
-  id: 'function_execute',
-  name: 'function_execute',
-  route: 'sim',
-  mode: 'async',
-  parameters: {
-    type: 'object',
-    properties: {
-      code: {
-        type: 'string',
-        description:
-          'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with pre-installed CLI tools. Use each needed secret as {{VAR_NAME}}; the reference resolves to the value exactly as stored.',
-      },
-      inputs: {
-        type: 'object',
-        description:
-          'Workspace resources to mount into the sandbox. Copy paths verbatim from glob/read/grep output — they are percent-encoded per segment (spaces are %20, an in-name slash is %2F; parentheses and dots stay literal). Both the encoded path and the plain name resolve, so copy the returned path exactly rather than retyping or decoding it.',
-        properties: {
-          directories: {
-            type: 'array',
-            description:
-              'Workspace folders to mount recursively into the sandbox, including nested files and empty folders.',
-            items: {
-              type: 'object',
-              properties: {
-                path: {
-                  type: 'string',
-                  description:
-                    'Canonical VFS folder path, e.g. "files/Reports". By default this mounts at "/home/user/{path}".',
-                },
-                sandboxPath: {
-                  type: 'string',
-                  description:
-                    'Optional full sandbox directory path override. Omit to mount at /home/user/{path}.',
-                },
-              },
-              required: ['path'],
-            },
-          },
-          files: {
-            type: 'array',
-            description: 'Workspace files to mount into the sandbox.',
-            items: {
-              type: 'object',
-              properties: {
-                path: {
-                  type: 'string',
-                  description:
-                    'Canonical VFS file path, e.g. "files/Reports/sales.csv". By default this mounts at "/home/user/{path}".',
-                },
-                sandboxPath: {
-                  type: 'string',
-                  description:
-                    'Full sandbox path to mount at, e.g. /home/user/inputs/data.csv. STRONGLY RECOMMENDED whenever the file name has spaces or special characters: the default mount path is the percent-ENCODED canonical path (e.g. /home/user/files/Q4%20Sales%20(Final).csv), which code using the human-readable name will not find. Set a simple sandboxPath and read exactly that.',
-                },
-              },
-              required: ['path'],
-            },
-          },
-          tables: {
-            type: 'array',
-            description: 'Workspace tables to mount as CSV files.',
-            items: {
-              type: 'object',
-              properties: {
-                path: { type: 'string', description: 'Canonical VFS table path when available.' },
-                sandboxPath: {
-                  type: 'string',
-                  description: 'Optional full sandbox path for the mounted CSV.',
-                },
-                tableId: { type: 'string', description: 'Workspace table ID.' },
-              },
-            },
-          },
-        },
-      },
-      language: {
-        type: 'string',
-        description: 'Execution language.',
-        enum: ['javascript', 'python', 'shell'],
-      },
-      outputTable: {
-        type: 'string',
-        description:
-          'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
-      },
-      outputs: {
-        type: 'object',
-        description:
-          'Workspace files to create or overwrite from returned code results or sandbox-created files.',
-        properties: {
-          files: {
-            type: 'array',
-            description:
-              'File outputs. Missing parent folders are created automatically for create mode.',
-            items: {
-              type: 'object',
-              properties: {
-                format: {
-                  type: 'string',
-                  description: 'Optional serialization format for returned values.',
-                  enum: ['json', 'csv', 'txt', 'md', 'html'],
-                },
-                mimeType: {
-                  type: 'string',
-                  description: 'Optional MIME type override when inference is not enough.',
-                },
-                mode: {
-                  type: 'string',
-                  description: 'Create a new file or overwrite an existing file at path.',
-                  enum: ['create', 'overwrite'],
-                },
-                path: {
-                  type: 'string',
-                  description: 'Canonical destination VFS path, e.g. "files/Reports/chart.png".',
-                },
-                sandboxPath: {
-                  type: 'string',
-                  description:
-                    'Optional full path to a file created inside the sandbox. Omit to save the code return value.',
-                },
-              },
-              required: ['path', 'mode'],
-            },
-          },
-        },
-      },
-      sandboxId: {
-        type: 'string',
-        description:
-          'Optional Sim sandbox id from agent/sandboxes/{name}.json. DEFAULT-FIRST: omit this whenever the documented default function_execute environment can do the job. Select a ready existing Sim sandbox only when a required third-party dependency, Debian system package, or managed CLI is known to be absent, or a default attempt failed specifically because it was missing. Never guess an id.',
-      },
-      timeout: {
-        type: 'number',
-        description:
-          'Maximum execution time in SECONDS (Sim converts to milliseconds). The sandbox stops execution and returns a timeout error after this duration. Defaults to 10 seconds and is capped at 300 seconds regardless of plan.',
-        default: 10,
-      },
-      title: {
-        type: 'string',
-        description:
-          'Short user-visible label for this execution, e.g. "Clean customer CSV", "Revenue chart", or "Query GitHub issues".',
-      },
-    },
-    required: ['code'],
-  },
-  requiredPermission: 'write',
-  requiresApproval: true,
-  capabilities: ['file_input', 'directory_input', 'file_output', 'table_input', 'table_output'],
-}
-
 export const GenerateApiKey: ToolCatalogEntry = {
   id: 'generate_api_key',
   name: 'generate_api_key',
@@ -2973,9 +3059,9 @@ export const GetDeployedWorkflowState: ToolCatalogEntry = {
   },
 }
 
-export const GetDeploymentLog: ToolCatalogEntry = {
-  id: 'get_deployment_log',
-  name: 'get_deployment_log',
+export const GetDeploymentStatus: ToolCatalogEntry = {
+  id: 'get_deployment_status',
+  name: 'get_deployment_status',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -2983,47 +3069,12 @@ export const GetDeploymentLog: ToolCatalogEntry = {
     properties: {
       workflowId: {
         type: 'string',
-        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
+        description: 'Workflow ID to check (defaults to current workflow)',
       },
     },
   },
 }
 
-export const GetPageContents: ToolCatalogEntry = {
-  id: 'get_page_contents',
-  name: 'get_page_contents',
-  route: 'go',
-  mode: 'sync',
-  parameters: {
-    type: 'object',
-    properties: {
-      include_highlights: {
-        type: 'boolean',
-        description: 'Include key highlights (default false)',
-      },
-      include_summary: {
-        type: 'boolean',
-        description: 'Include AI-generated summary (default false)',
-      },
-      include_text: { type: 'boolean', description: 'Include full page text (default true)' },
-      urls: {
-        type: 'array',
-        description: 'URLs to get content from (max 10)',
-        items: { type: 'string' },
-      },
-    },
-    required: ['urls'],
-  },
-}
-
-export const GetPlatformActions: ToolCatalogEntry = {
-  id: 'get_platform_actions',
-  name: 'get_platform_actions',
-  route: 'sim',
-  mode: 'async',
-  parameters: { type: 'object', properties: {} },
-}
-
 export const GetWorkflowData: ToolCatalogEntry = {
   id: 'get_workflow_data',
   name: 'get_workflow_data',
@@ -3117,12 +3168,12 @@ export const Grep: ToolCatalogEntry = {
       path: {
         type: 'string',
         description:
-          "Optional scope. A prefix (e.g. 'workflows/', 'environment/', 'internal/') searches the VFS map under it. An exact single-file path under files/ or uploads/ (optionally with /content) searches that file's content only; folders and multi-file trees are rejected for content search.",
+          "Optional scope. A prefix (e.g. 'workflows/', 'environment/', 'internal/') searches the VFS map under it. An exact supported single-file path searches that file's content; folders and multi-file trees are rejected for content search.",
       },
       pattern: {
         type: 'string',
         description:
-          "Regex pattern to search for. Searches VFS map entries (workflow JSON, metadata, memories) by default; searches a single file's extracted text when path is one files/ or uploads/ file leaf.",
+          "Regex pattern to search for. Searches VFS map entries (workflow JSON, metadata, memories) by default, or an exact supported file leaf's content when path selects one.",
       },
       toolTitle: {
         type: 'string',
@@ -3134,6 +3185,25 @@ export const Grep: ToolCatalogEntry = {
   },
 }
 
+export const InterruptAgent: ToolCatalogEntry = {
+  id: 'interrupt_agent',
+  name: 'interrupt_agent',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_id: { type: 'string', description: 'The agent id to interrupt.' },
+      reason: {
+        type: 'string',
+        description:
+          "Why you are stopping it, in a few words. Recorded in the agent's final status.",
+      },
+    },
+    required: ['agent_id'],
+  },
+}
+
 export const Knowledge: ToolCatalogEntry = {
   id: 'knowledge',
   name: 'knowledge',
@@ -3142,191 +3212,38 @@ export const Knowledge: ToolCatalogEntry = {
   parameters: {
     properties: {
       request: { description: 'What knowledge base action is needed.', type: 'string' },
+      sessionId: {
+        description:
+          'Reusable session ID returned by an earlier knowledge call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message. Omit it for a new or independent task.',
+        type: 'string',
+      },
+      title: {
+        description:
+          "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the knowledge agent. When resuming with sessionId, copy the registry title unchanged.",
+        maxLength: 120,
+        type: 'string',
+      },
     },
-    required: ['request'],
+    required: ['request', 'title'],
     type: 'object',
   },
   subagentId: 'knowledge',
   internal: true,
 }
 
-export const KnowledgeBase: ToolCatalogEntry = {
-  id: 'knowledge_base',
-  name: 'knowledge_base',
+export const ListDeploymentVersions: ToolCatalogEntry = {
+  id: 'list_deployment_versions',
+  name: 'list_deployment_versions',
   route: 'sim',
   mode: 'async',
   parameters: {
     type: 'object',
     properties: {
-      args: {
-        type: 'object',
-        description: 'Arguments for the operation',
-        properties: {
-          apiKey: {
-            type: 'string',
-            description:
-              'API key for API-key-based connectors (required when connector auth mode is apiKey)',
-          },
-          chunkingConfig: {
-            type: 'object',
-            description: "Chunking configuration (optional for 'create')",
-            properties: {
-              maxSize: {
-                type: 'number',
-                description: 'Maximum chunk size (100-4000, default: 1024)',
-                default: 1024,
-              },
-              minSize: {
-                type: 'number',
-                description: 'Minimum chunk size (1-2000, default: 1)',
-                default: 1,
-              },
-              overlap: {
-                type: 'number',
-                description: 'Overlap between chunks (0-500, default: 200)',
-                default: 200,
-              },
-            },
-          },
-          connectorId: {
-            type: 'string',
-            description:
-              'Connector ID (required for update_connector, delete_connector, sync_connector)',
-          },
-          connectorStatus: {
-            type: 'string',
-            description: 'Connector status (optional for update_connector)',
-            enum: ['active', 'paused'],
-          },
-          connectorType: {
-            type: 'string',
-            description:
-              "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
-          },
-          credentialId: {
-            type: 'string',
-            description:
-              'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
-          },
-          description: {
-            type: 'string',
-            description: "Description of the knowledge base (optional for 'create')",
-          },
-          disabledTagIds: {
-            type: 'array',
-            description:
-              'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
-          },
-          documentId: { type: 'string', description: 'Document ID (required for update_document)' },
-          documentIds: {
-            type: 'array',
-            description: 'Document IDs (for batch delete_document)',
-            items: { type: 'string' },
-          },
-          enabled: {
-            type: 'boolean',
-            description: 'Enable/disable a document (optional for update_document)',
-          },
-          filePaths: {
-            type: 'array',
-            description:
-              'Canonical workspace file VFS paths to add as documents (for add_file), e.g. ["files/Docs/handbook.pdf"].',
-            items: { type: 'string' },
-          },
-          filename: {
-            type: 'string',
-            description: 'New filename for a document (optional for update_document)',
-          },
-          knowledgeBaseId: {
-            type: 'string',
-            description:
-              'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
-          },
-          knowledgeBaseIds: {
-            type: 'array',
-            description: 'Knowledge base IDs (for batch delete)',
-            items: { type: 'string' },
-          },
-          name: {
-            type: 'string',
-            description: "Name of the knowledge base (required for 'create')",
-          },
-          query: { type: 'string', description: "Search query text (required for 'query')" },
-          sourceConfig: {
-            type: 'object',
-            description:
-              'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
-          },
-          syncIntervalMinutes: {
-            type: 'number',
-            description:
-              'Sync interval in minutes. Accepted values: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
-            default: 1440,
-          },
-          tagDefinitionId: {
-            type: 'string',
-            description: 'Tag definition ID (required for update_tag, delete_tag)',
-          },
-          tagDisplayName: {
-            type: 'string',
-            description:
-              'Display name for the tag (required for create_tag, optional for update_tag)',
-          },
-          tagFieldType: {
-            type: 'string',
-            description:
-              'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
-            enum: ['text', 'number', 'date', 'boolean'],
-          },
-          topK: {
-            type: 'number',
-            description: 'Number of results to return (1-50, default: 5)',
-            default: 5,
-          },
-          workspaceId: {
-            type: 'string',
-            description:
-              "Workspace ID. Required for 'create' when there is no workspace in context; otherwise the current workspace context is used.",
-          },
-        },
-      },
-      operation: {
+      workflowId: {
         type: 'string',
-        description: 'The operation to perform',
-        enum: [
-          'create',
-          'get',
-          'query',
-          'add_file',
-          'update',
-          'delete_document',
-          'update_document',
-          'list_tags',
-          'create_tag',
-          'update_tag',
-          'delete_tag',
-          'get_tag_usage',
-          'add_connector',
-          'update_connector',
-          'delete_connector',
-          'sync_connector',
-        ],
+        description: 'Optional workflow ID. If not provided, uses the current workflow in context.',
       },
     },
-    required: ['operation'],
-  },
-  resultSchema: {
-    type: 'object',
-    properties: {
-      data: {
-        type: ['object', 'array'],
-        description:
-          'Operation-specific result payload. An object for most operations; list_tags and get_tag_usage return an array of tag definitions.',
-      },
-      message: { type: 'string', description: 'Human-readable outcome summary.' },
-      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
-    },
-    required: ['success', 'message'],
   },
 }
 
@@ -3348,14 +3265,6 @@ export const ListIntegrationTools: ToolCatalogEntry = {
   },
 }
 
-export const ListUserWorkspaces: ToolCatalogEntry = {
-  id: 'list_user_workspaces',
-  name: 'list_user_workspaces',
-  route: 'sim',
-  mode: 'async',
-  parameters: { type: 'object', properties: {} },
-}
-
 export const ListWorkspaceMcpServers: ToolCatalogEntry = {
   id: 'list_workspace_mcp_servers',
   name: 'list_workspace_mcp_servers',
@@ -3528,9 +3437,209 @@ export const ManageCustomTool: ToolCatalogEntry = {
   requiredPermission: 'write',
 }
 
-export const ManageMcpTool: ToolCatalogEntry = {
-  id: 'manage_mcp_tool',
-  name: 'manage_mcp_tool',
+export const ManageKnowledgeBase: ToolCatalogEntry = {
+  id: 'manage_knowledge_base',
+  name: 'manage_knowledge_base',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          apiKey: {
+            type: 'string',
+            description:
+              'API key for API-key-based connectors (required when connector auth mode is apiKey). Accepts an environment-variable reference — {{NAME}} — resolved server-side from workspace/user environment variables; a raw key also works.',
+          },
+          chunkingConfig: {
+            type: 'object',
+            description: "Chunking configuration (optional for 'create')",
+            properties: {
+              maxSize: {
+                type: 'number',
+                description: 'Maximum chunk size (100-4000, default: 1024)',
+                default: 1024,
+              },
+              minSize: {
+                type: 'number',
+                description: 'Minimum chunk size (1-2000, default: 100)',
+                default: 1,
+              },
+              overlap: {
+                type: 'number',
+                description: 'Overlap between chunks (0-500, default: 200)',
+                default: 200,
+              },
+            },
+          },
+          connectorId: {
+            type: 'string',
+            description:
+              'Connector ID (required for update_connector, delete_connector, sync_connector)',
+          },
+          connectorStatus: {
+            type: 'string',
+            description: 'Connector status (optional for update_connector)',
+            enum: ['active', 'paused'],
+          },
+          connectorType: {
+            type: 'string',
+            description:
+              "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
+          },
+          credentialId: {
+            type: 'string',
+            description:
+              'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
+          },
+          description: {
+            type: 'string',
+            description: "Description of the knowledge base (optional for 'create')",
+          },
+          disabledTagIds: {
+            type: 'array',
+            description:
+              'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
+          },
+          documentId: { type: 'string', description: 'Document ID (required for update_document)' },
+          documentIds: {
+            type: 'array',
+            description: 'Document IDs (for batch delete_document)',
+            items: { type: 'string' },
+          },
+          enabled: {
+            type: 'boolean',
+            description: 'Enable/disable a document (optional for update_document)',
+          },
+          filePaths: {
+            type: 'array',
+            description:
+              'Canonical workspace file VFS paths to add as documents (for add_file), e.g. ["files/Docs/handbook.pdf"].',
+            items: { type: 'string' },
+          },
+          filename: {
+            type: 'string',
+            description: 'New filename for a document (optional for update_document)',
+          },
+          knowledgeBaseId: {
+            type: 'string',
+            description:
+              'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
+          },
+          knowledgeBaseIds: {
+            type: 'array',
+            description: 'Knowledge base IDs (for batch delete)',
+            items: { type: 'string' },
+          },
+          name: {
+            type: 'string',
+            description: "Name of the knowledge base (required for 'create')",
+          },
+          query: { type: 'string', description: "Search query text (required for 'query')" },
+          sourceConfig: {
+            type: 'object',
+            description:
+              'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
+          },
+          syncIntervalMinutes: {
+            type: 'number',
+            description:
+              'Sync interval in minutes. Accepted values: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
+            default: 1440,
+          },
+          tagDefinitionId: {
+            type: 'string',
+            description: 'Tag definition ID (required for update_tag, delete_tag)',
+          },
+          tagDisplayName: {
+            type: 'string',
+            description:
+              'Display name for the tag (required for create_tag, optional for update_tag)',
+          },
+          tagFieldType: {
+            type: 'string',
+            description:
+              'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
+            enum: ['text', 'number', 'date', 'boolean'],
+          },
+          tagValues: {
+            type: 'array',
+            description:
+              'Typed tag values to set on this document (optional for update_document). Resolve tagDefinitionId with list_tags first. Use null to clear a value.',
+            items: {
+              type: 'object',
+              properties: {
+                tagDefinitionId: {
+                  type: 'string',
+                  description: 'Tag definition ID returned by list_tags.',
+                },
+                value: {
+                  type: ['string', 'number', 'boolean', 'null'],
+                  description:
+                    "Value matching the tag definition's field type: string for text, number for number, YYYY-MM-DD string for date, boolean for boolean, or null to clear.",
+                },
+              },
+              required: ['tagDefinitionId', 'value'],
+            },
+          },
+          topK: {
+            type: 'number',
+            description: 'Number of results to return (1-100, default: 5)',
+            default: 5,
+          },
+          workspaceId: {
+            type: 'string',
+            description:
+              "Workspace ID. Required for 'create' when there is no workspace in context; otherwise the current workspace context is used.",
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The operation to perform',
+        enum: [
+          'create',
+          'get',
+          'query',
+          'add_file',
+          'update',
+          'delete_document',
+          'update_document',
+          'list_tags',
+          'create_tag',
+          'update_tag',
+          'delete_tag',
+          'get_tag_usage',
+          'add_connector',
+          'update_connector',
+          'delete_connector',
+          'sync_connector',
+        ],
+      },
+    },
+    required: ['operation'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: {
+        type: ['object', 'array'],
+        description:
+          'Operation-specific result payload. An object for most operations; list_tags and get_tag_usage return an array of tag definitions.',
+      },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const ManageMcpConnection: ToolCatalogEntry = {
+  id: 'manage_mcp_connection',
+  name: 'manage_mcp_connection',
   route: 'sim',
   mode: 'async',
   parameters: {
@@ -3546,7 +3655,8 @@ export const ManageMcpTool: ToolCatalogEntry = {
           },
           headers: {
             type: 'object',
-            description: 'Optional HTTP headers to send with requests (key-value pairs)',
+            description:
+              'Optional HTTP headers to send with requests (key-value pairs). Values accept {{ENV_VAR}} references, resolved per-user at connect time — prefer them over pasting raw tokens.',
           },
           name: { type: 'string', description: 'Display name for the MCP server' },
           timeout: {
@@ -3670,33 +3780,6 @@ export const ManageSkill: ToolCatalogEntry = {
   requiredPermission: 'write',
 }
 
-export const MaterializeFile: ToolCatalogEntry = {
-  id: 'materialize_file',
-  name: 'materialize_file',
-  route: 'sim',
-  mode: 'async',
-  parameters: {
-    type: 'object',
-    properties: {
-      fileNames: {
-        type: 'array',
-        description:
-          'The names of the uploaded files to materialize (e.g. ["report.pdf", "data.csv"])',
-        items: { type: 'string' },
-      },
-      operation: {
-        type: 'string',
-        description:
-          'What to do with the file. "save" promotes it to a permanent files/ path. "import" imports a workflow JSON as a workspace workflow. "extract" decompresses a .zip upload into files/<archive>/. Defaults to "save".',
-        enum: ['save', 'import', 'extract'],
-        default: 'save',
-      },
-    },
-    required: ['fileNames'],
-  },
-  requiredPermission: 'write',
-}
-
 export const Media: ToolCatalogEntry = {
   id: 'media',
   name: 'media',
@@ -3838,6 +3921,11 @@ export const OpenResource: ToolCatalogEntry = {
               description: 'The resource type.',
               enum: ['workflow', 'table', 'knowledgebase', 'file', 'log'],
             },
+            view: {
+              type: 'string',
+              description:
+                'Saved table view to open pinned (type "table" only): a view ID from the table\'s views.json. The panel opens the table with that view\'s filter/sort active. Omit to open the table on its default view.',
+            },
           },
           required: ['type'],
         },
@@ -3847,6 +3935,149 @@ export const OpenResource: ToolCatalogEntry = {
   },
 }
 
+export const Platform: ToolCatalogEntry = {
+  id: 'platform',
+  name: 'platform',
+  route: 'subagent',
+  mode: 'async',
+  parameters: {
+    properties: {
+      task: {
+        description:
+          "A fully self-contained question about Sim — the platform agent sees none of this conversation, so include every name, id, constraint, and prior finding it needs. Example: 'what is the minimum schedule-trigger interval, and does it differ by plan?' or 'does the agent block persist memory across runs?'.",
+        type: 'string',
+      },
+    },
+    required: ['task'],
+    type: 'object',
+  },
+  subagentId: 'platform',
+  internal: true,
+}
+
+export const PrepareFileEdit: ToolCatalogEntry = {
+  id: 'prepare_file_edit',
+  name: 'prepare_file_edit',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      operation: {
+        type: 'string',
+        description: 'The file operation to perform.',
+        enum: ['append', 'update', 'patch'],
+      },
+      target: {
+        type: 'object',
+        description: 'Explicit file target. Use kind=path + path for existing files.',
+        properties: {
+          kind: {
+            type: 'string',
+            description: 'How the file target is identified.',
+            enum: ['path'],
+          },
+          path: {
+            type: 'string',
+            description:
+              'Canonical existing workspace file VFS path, e.g. "files/Reports/report.md". Required when target.kind=path.',
+          },
+        },
+        required: ['kind'],
+      },
+      title: {
+        type: 'string',
+        description:
+          'Required short UI label for this content unit, e.g. "Chapter 1", "Slide 3", or "Fix footer spacing".',
+      },
+      contentType: {
+        type: 'string',
+        description:
+          'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
+        enum: [
+          'text/markdown',
+          'text/html',
+          'text/plain',
+          'application/json',
+          'text/csv',
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+          'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+          'application/pdf',
+        ],
+      },
+      edit: {
+        type: 'object',
+        description:
+          'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. The actual replacement/insert content is provided via the paired apply_file_edit tool call.',
+        properties: {
+          after_anchor: {
+            type: 'string',
+            description:
+              'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
+          },
+          anchor: {
+            type: 'string',
+            description:
+              'Anchor line after which new content is inserted. Required for mode=insert_after.',
+          },
+          before_anchor: {
+            type: 'string',
+            description:
+              'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
+          },
+          end_anchor: {
+            type: 'string',
+            description: 'First line to keep after deletion. Required for mode=delete_between.',
+          },
+          mode: {
+            type: 'string',
+            description: 'Anchored edit mode when strategy=anchored.',
+            enum: ['replace_between', 'insert_after', 'delete_between'],
+          },
+          occurrence: {
+            type: 'number',
+            description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
+          },
+          replaceAll: {
+            type: 'boolean',
+            description:
+              'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
+          },
+          search: {
+            type: 'string',
+            description:
+              'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
+          },
+          start_anchor: {
+            type: 'string',
+            description: 'First line to delete. Required for mode=delete_between.',
+          },
+          strategy: {
+            type: 'string',
+            description: 'Patch strategy.',
+            enum: ['search_replace', 'anchored'],
+          },
+        },
+      },
+    },
+    required: ['operation', 'target', 'title'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: {
+        type: 'object',
+        description:
+          'Optional operation metadata such as file id, file name, size, and content type.',
+      },
+      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
+      success: { type: 'boolean', description: 'Whether the file operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+  requiredPermission: 'write',
+}
+
 export const PromoteToLive: ToolCatalogEntry = {
   id: 'promote_to_live',
   name: 'promote_to_live',
@@ -3871,6 +4102,118 @@ export const PromoteToLive: ToolCatalogEntry = {
   requiresApproval: true,
 }
 
+export const PublishCustomBlock: ToolCatalogEntry = {
+  id: 'publish_custom_block',
+  name: 'publish_custom_block',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Whether to publish (deploy) or unpublish (undeploy) the custom block',
+        enum: ['deploy', 'undeploy'],
+        default: 'deploy',
+      },
+      description: {
+        type: 'string',
+        description: 'Short description shown in the block picker, max 280 characters',
+      },
+      exposedOutputs: {
+        type: 'array',
+        description:
+          "Outputs the block exposes, each mapping a child block output path to a friendly name (use get_block_outputs for valid paths). Omit to expose the terminal block's whole result",
+        items: {
+          type: 'object',
+          properties: {
+            blockId: { type: 'string', description: 'Block UUID inside the workflow' },
+            name: { type: 'string', description: 'Friendly output name shown on the block' },
+            path: {
+              type: 'string',
+              description:
+                "Dot-path into that block's output (from get_block_outputs relativeOutputs)",
+            },
+          },
+          required: ['blockId', 'path', 'name'],
+        },
+      },
+      iconUrl: {
+        type: 'string',
+        description:
+          'Optional icon image for the block: a workspace file VFS path (e.g. "files/icon.png", copied into public icon storage at publish) or an https image URL. Omit to use the organization\'s default icon',
+      },
+      inputs: {
+        type: 'array',
+        description:
+          "Optional per-input placeholder overrides. Input names and types are derived from the workflow's input trigger and cannot be changed here",
+        items: {
+          type: 'object',
+          properties: {
+            id: { type: 'string', description: 'Stable id of the input trigger field' },
+            placeholder: {
+              type: 'string',
+              description: "Placeholder text shown in the block's input field",
+            },
+          },
+          required: ['id'],
+        },
+      },
+      name: {
+        type: 'string',
+        description:
+          'Display name for the block, max 60 characters. REQUIRED the first time a workflow is published. When republishing an existing block, omit it to keep the current name or pass a new one to rename. Ignored for undeploy.',
+      },
+      workflowId: { type: 'string', description: 'Workflow ID (defaults to active workflow)' },
+    },
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      action: {
+        type: 'string',
+        description: 'Action performed by the tool, such as "deploy" or "undeploy".',
+      },
+      blockId: { type: 'string', description: 'Custom block record ID.' },
+      blockType: {
+        type: 'string',
+        description: 'Stable block type slug (custom_block_*) used in workflow state.',
+      },
+      deploymentConfig: {
+        type: 'object',
+        description:
+          "Structured deployment configuration keyed by surface name. Includes the block's type, name, description, icon, derived input fields, and exposed outputs.",
+      },
+      deploymentStatus: {
+        type: 'object',
+        description:
+          'Structured per-surface deployment status keyed by surface name, including customBlock and the underlying api surface when applicable.',
+      },
+      deploymentType: {
+        type: 'string',
+        description:
+          'Deployment surface this result describes. For publish_custom_block this is always "custom_block".',
+      },
+      isDeployed: {
+        type: 'boolean',
+        description: 'Whether the custom block is published after this tool call.',
+      },
+      name: { type: 'string', description: 'Display name of the custom block.' },
+      removed: {
+        type: 'boolean',
+        description: 'Whether the custom block was unpublished during an undeploy action.',
+      },
+      updated: {
+        type: 'boolean',
+        description: 'Whether an existing custom block was updated instead of created.',
+      },
+      workflowId: { type: 'string', description: 'Workflow ID the custom block is bound to.' },
+    },
+    required: ['deploymentType', 'deploymentStatus'],
+  },
+  requiredPermission: 'admin',
+}
+
 export const QueryLogs: ToolCatalogEntry = {
   id: 'query_logs',
   name: 'query_logs',
@@ -3883,10 +4226,22 @@ export const QueryLogs: ToolCatalogEntry = {
         type: 'string',
         description: "Optional (view='full'): only return this block's span subtree.",
       },
+      blockIds: {
+        type: 'array',
+        description:
+          "(view='full') Block ids to drill into, copied from the trace digest's blockId values. Preferred over blockName; several at once is fine.",
+        items: { type: 'string' },
+      },
       blockName: {
         type: 'string',
         description: "Optional (view='full'): only return spans for this block name.",
       },
+      bucket: {
+        type: 'string',
+        description:
+          "(view='stats') Calendar bucketing for the per-workflow series: 'day' or 'hour'. Omit for overall totals only.",
+        enum: ['day', 'hour'],
+      },
       costOperator: {
         type: 'string',
         description: "Filter (view='list'): comparison operator for cost.",
@@ -3909,24 +4264,34 @@ export const QueryLogs: ToolCatalogEntry = {
         type: 'number',
         description: "Filter (view='list'): duration threshold (ms) paired with durationOperator.",
       },
-      endDate: { type: 'string', description: "Filter (view='list'): ISO end of the time range." },
+      endDate: {
+        type: 'string',
+        description: "Filter (view='list'/'stats'): ISO end of the time range.",
+      },
       executionId: {
         type: 'string',
         description:
-          "Required for 'overview'/'full': the execution to read. For 'list', an optional exact-match filter.",
+          "Required for 'trace'/'overview'/'full': the execution to read. For 'list', an optional exact-match filter.",
+      },
+      fields: {
+        type: 'array',
+        description:
+          "(view='full') Only load these payload fields per span: whole keys ('input', 'output', 'error') or dotted paths into them ('output.result.rows', 'input.query'). Dotted selections come back under 'selected' keyed by path. Use this to pull just the field you need instead of a block's entire I/O.",
+        items: { type: 'string' },
       },
       folderIds: {
         type: 'string',
-        description: "Filter (view='list'): comma-separated folder IDs (descendants included).",
+        description:
+          "Filter (view='list'/'stats'): comma-separated folder IDs (descendants included).",
       },
       folderName: {
         type: 'string',
-        description: "Filter (view='list'): substring match on folder name.",
+        description: "Filter (view='list'/'stats'): substring match on folder name.",
       },
       level: {
         type: 'string',
         description:
-          "Filter (view='list'): comma-separated levels: error, info, running, pending. Default all.",
+          "Filter (view='list'/'stats'): comma-separated levels: error, info, running, pending. Default all.",
       },
       limit: { type: 'number', description: "Max results (view='list'), 1-200 (default 100)." },
       pattern: {
@@ -3950,29 +4315,38 @@ export const QueryLogs: ToolCatalogEntry = {
       },
       startDate: {
         type: 'string',
-        description: "Filter (view='list'): ISO start of the time range.",
+        description: "Filter (view='list'/'stats'): ISO start of the time range.",
+      },
+      timezone: {
+        type: 'string',
+        description:
+          '(view=\'stats\') IANA timezone the buckets are computed in, e.g. "America/Los_Angeles". Defaults to UTC. Set this whenever the user\'s question is about "today"/"yesterday" in their local time.',
+      },
+      title: {
+        type: 'string',
+        description:
+          'Short human-readable label for this query, shown as the tool row in the UI, e.g. "Counting Elder failures Aug 12-13" or "Reading the failed enrichment run". Always provide one — it is how the user follows what you are looking for.',
       },
       triggers: {
         type: 'string',
-        description: "Filter (view='list'): comma-separated trigger types.",
+        description: "Filter (view='list'/'stats'): comma-separated trigger types.",
       },
       view: {
         type: 'string',
         description:
-          "Disclosure level: 'list' (summaries), 'overview' (one execution's trace tree, no I/O), or 'full' (one execution's trace spans with I/O).",
-        enum: ['list', 'overview', 'full'],
+          "Disclosure level: 'stats' (aggregate counts), 'list' (summaries), 'trace' (one execution's condensed block digest), 'overview' (trace tree, no I/O), 'full' (spans with I/O). Defaults to 'trace' with executionId, else 'list'.",
+        enum: ['list', 'stats', 'trace', 'overview', 'full'],
       },
       workflowIds: {
         type: 'string',
-        description: "Filter (view='list'): comma-separated workflow IDs.",
+        description: "Filter (view='list'/'stats'): comma-separated workflow IDs.",
       },
       workflowName: {
         type: 'string',
-        description: "Filter (view='list'): substring match on workflow name.",
+        description: "Filter (view='list'/'stats'): substring match on workflow name.",
       },
       workspaceId: { type: 'string', description: 'Workspace ID to scope to.' },
     },
-    required: ['view'],
   },
 }
 
@@ -4001,7 +4375,7 @@ export const QueryUserTable: ToolCatalogEntry = {
           limit: {
             type: 'number',
             description:
-              'Maximum rows per page for query_rows (optional). Omit to fetch the ENTIRE matching result in one response — the call fails if the result exceeds the 5MB budget (narrow with a filter or set a limit). With a limit, a page may end early at the byte budget with more remaining; a non-null nextCursor in the result means more rows exist (continue with cursor).',
+              'Maximum rows per page for query_rows (optional, max 1000). Omitting it uses the 1000-row default page — the ENTIRE result is never returned in one call; a non-null nextCursor in the result means more rows exist (continue with cursor). A page may also end early at the byte budget with more remaining.',
           },
           order: {
             type: 'array',
@@ -4010,6 +4384,11 @@ export const QueryUserTable: ToolCatalogEntry = {
           },
           rowId: { type: 'string', description: 'Row ID (required for get_row)' },
           tableId: { type: 'string', description: 'Table ID (required for all operations)' },
+          view: {
+            type: 'string',
+            description:
+              "Saved view to query through (query_rows only): a view ID from the table's views.json. The view's saved filter ANDs with any filter you pass (query-within-the-view); its saved sort applies only when you pass no order. Layout fields (hidden columns, widths) are ignored — full rows come back. Manage views via the table agent.",
+          },
         },
       },
       operation: {
@@ -4102,7 +4481,7 @@ export const Redeploy: ToolCatalogEntry = {
       deploymentType: {
         type: 'string',
         description:
-          'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+          'Deployment surface this result describes. For deploy_as_api and redeploy this is always "api".',
       },
       examples: {
         type: 'object',
@@ -4173,7 +4552,16 @@ export const RestoreResource: ToolCatalogEntry = {
       type: {
         type: 'string',
         description: 'The resource type to restore.',
-        enum: ['workflow', 'table', 'file', 'knowledgebase', 'folder', 'file_folder'],
+        enum: [
+          'workflow',
+          'table',
+          'file',
+          'knowledgebase',
+          'folder',
+          'file_folder',
+          'table_folder',
+          'knowledge_folder',
+        ],
       },
     },
     required: ['type', 'id'],
@@ -4248,14 +4636,14 @@ export const RunBlock: ToolCatalogEntry = {
       workflowId: {
         type: 'string',
         description:
-          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+          'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
       },
       workflow_input: {
         type: 'object',
         description: 'JSON object with key-value mappings where each key is an input field name',
       },
     },
-    required: ['blockId'],
+    required: ['workflowId', 'blockId'],
   },
   clientExecutable: true,
 }
@@ -4354,6 +4742,56 @@ export const RunCode: ToolCatalogEntry = {
   capabilities: ['file_input', 'directory_input', 'table_input'],
 }
 
+export const RunEnrichment: ToolCatalogEntry = {
+  id: 'run_enrichment',
+  name: 'run_enrichment',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      enrichmentId: {
+        type: 'string',
+        description:
+          "Which enrichment to run. Discover the full set and each one's inputs/outputs via table_enrichments.list_enrichments.",
+        enum: [
+          'work-email',
+          'phone-number',
+          'company-domain',
+          'company-info',
+          'email-verification',
+        ],
+      },
+      inputs: {
+        type: 'object',
+        description:
+          'Map of the enrichment\'s input id → value, e.g. { "fullName": "Jane Doe", "companyDomain": "acme.com" }. Provide a value for every required input.',
+      },
+    },
+    required: ['enrichmentId', 'inputs'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      matched: {
+        type: 'boolean',
+        description: 'True when a provider returned a non-empty result.',
+      },
+      provider: {
+        type: ['string', 'null'],
+        description:
+          'Internal label of the provider that produced the result (billing/diagnostics only — do NOT surface it to the user), or null on no match.',
+      },
+      result: {
+        type: 'object',
+        description: 'Mapped output values from the winning provider (empty object on no match).',
+      },
+    },
+    required: ['matched', 'result'],
+  },
+  requiredPermission: 'write',
+}
+
 export const RunFromBlock: ToolCatalogEntry = {
   id: 'run_from_block',
   name: 'run_from_block',
@@ -4376,18 +4814,169 @@ export const RunFromBlock: ToolCatalogEntry = {
       workflowId: {
         type: 'string',
         description:
-          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+          'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
       },
       workflow_input: {
         type: 'object',
         description: 'JSON object with key-value mappings where each key is an input field name',
       },
     },
-    required: ['startBlockId'],
+    required: ['workflowId', 'startBlockId'],
   },
   clientExecutable: true,
 }
 
+export const RunFunction: ToolCatalogEntry = {
+  id: 'run_function',
+  name: 'run_function',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      code: {
+        type: 'string',
+        description:
+          'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with pre-installed CLI tools. Use each needed secret as {{VAR_NAME}}; the reference resolves to the value exactly as stored.',
+      },
+      inputs: {
+        type: 'object',
+        description:
+          'Workspace resources to mount into the sandbox. Copy paths verbatim from glob/read/grep output — they are percent-encoded per segment (spaces are %20, an in-name slash is %2F; parentheses and dots stay literal). Both the encoded path and the plain name resolve, so copy the returned path exactly rather than retyping or decoding it.',
+        properties: {
+          directories: {
+            type: 'array',
+            description:
+              'Workspace folders to mount recursively into the sandbox, including nested files and empty folders.',
+            items: {
+              type: 'object',
+              properties: {
+                path: {
+                  type: 'string',
+                  description:
+                    'Canonical VFS folder path, e.g. "files/Reports". By default this mounts at "/home/user/{path}".',
+                },
+                sandboxPath: {
+                  type: 'string',
+                  description:
+                    'Optional full sandbox directory path override. Omit to mount at /home/user/{path}.',
+                },
+              },
+              required: ['path'],
+            },
+          },
+          files: {
+            type: 'array',
+            description: 'Workspace files to mount into the sandbox.',
+            items: {
+              type: 'object',
+              properties: {
+                path: {
+                  type: 'string',
+                  description:
+                    'Canonical VFS file path, e.g. "files/Reports/sales.csv". By default this mounts at "/home/user/{path}".',
+                },
+                sandboxPath: {
+                  type: 'string',
+                  description:
+                    'Full sandbox path to mount at, e.g. /home/user/inputs/data.csv. STRONGLY RECOMMENDED whenever the file name has spaces or special characters: the default mount path is the percent-ENCODED canonical path (e.g. /home/user/files/Q4%20Sales%20(Final).csv), which code using the human-readable name will not find. Set a simple sandboxPath and read exactly that.',
+                },
+              },
+              required: ['path'],
+            },
+          },
+          tables: {
+            type: 'array',
+            description: 'Workspace tables to mount as CSV files.',
+            items: {
+              type: 'object',
+              properties: {
+                path: { type: 'string', description: 'Canonical VFS table path when available.' },
+                sandboxPath: {
+                  type: 'string',
+                  description: 'Optional full sandbox path for the mounted CSV.',
+                },
+                tableId: { type: 'string', description: 'Workspace table ID.' },
+              },
+            },
+          },
+        },
+      },
+      language: {
+        type: 'string',
+        description: 'Execution language.',
+        enum: ['javascript', 'python', 'shell'],
+      },
+      outputTable: {
+        type: 'string',
+        description:
+          'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
+      },
+      outputs: {
+        type: 'object',
+        description:
+          'Workspace files to create or overwrite from returned code results or sandbox-created files.',
+        properties: {
+          files: {
+            type: 'array',
+            description:
+              'File outputs. Missing parent folders are created automatically for create mode.',
+            items: {
+              type: 'object',
+              properties: {
+                format: {
+                  type: 'string',
+                  description: 'Optional serialization format for returned values.',
+                  enum: ['json', 'csv', 'txt', 'md', 'html'],
+                },
+                mimeType: {
+                  type: 'string',
+                  description: 'Optional MIME type override when inference is not enough.',
+                },
+                mode: {
+                  type: 'string',
+                  description: 'Create a new file or overwrite an existing file at path.',
+                  enum: ['create', 'overwrite'],
+                },
+                path: {
+                  type: 'string',
+                  description: 'Canonical destination VFS path, e.g. "files/Reports/chart.png".',
+                },
+                sandboxPath: {
+                  type: 'string',
+                  description:
+                    'Optional full path to a file created inside the sandbox. Omit to save the code return value.',
+                },
+              },
+              required: ['path', 'mode'],
+            },
+          },
+        },
+      },
+      sandboxId: {
+        type: 'string',
+        description:
+          'Optional Sim sandbox id from agent/sandboxes/{name}.json. DEFAULT-FIRST: omit this whenever the documented default run_function environment can do the job. Select a ready existing Sim sandbox only when a required third-party dependency, Debian system package, or managed CLI is known to be absent, or a default attempt failed specifically because it was missing. Never guess an id.',
+      },
+      timeout: {
+        type: 'number',
+        description:
+          'Maximum execution time in SECONDS (Sim converts to milliseconds). The sandbox stops execution and returns a timeout error after this duration. Defaults to 10 seconds and is capped at 300 seconds regardless of plan.',
+        default: 10,
+      },
+      title: {
+        type: 'string',
+        description:
+          'Short user-visible label for this execution, e.g. "Clean customer CSV", "Revenue chart", or "Query GitHub issues".',
+      },
+    },
+    required: ['code'],
+  },
+  requiredPermission: 'write',
+  requiresApproval: true,
+  capabilities: ['file_input', 'directory_input', 'file_output', 'table_input', 'table_output'],
+}
+
 export const RunWorkflow: ToolCatalogEntry = {
   id: 'run_workflow',
   name: 'run_workflow',
@@ -4424,7 +5013,7 @@ export const RunWorkflow: ToolCatalogEntry = {
       workflowId: {
         type: 'string',
         description:
-          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+          'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
       },
       workflow_input: {
         type: 'object',
@@ -4432,6 +5021,7 @@ export const RunWorkflow: ToolCatalogEntry = {
           "JSON object matching the target trigger's inputSchema (from get_workflow_run_options). For external/webhook triggers this is the event payload; for API/Input triggers it is the form fields.",
       },
     },
+    required: ['workflowId'],
   },
   clientExecutable: true,
   requiresApproval: true,
@@ -4472,7 +5062,7 @@ export const RunWorkflowUntilBlock: ToolCatalogEntry = {
       workflowId: {
         type: 'string',
         description:
-          'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+          'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
       },
       workflow_input: {
         type: 'object',
@@ -4480,32 +5070,37 @@ export const RunWorkflowUntilBlock: ToolCatalogEntry = {
           "JSON object matching the target trigger's inputSchema (from get_workflow_run_options). For external/webhook triggers this is the event payload; for API/Input triggers it is the form fields.",
       },
     },
-    required: ['stopAfterBlockId'],
+    required: ['workflowId', 'stopAfterBlockId'],
   },
   clientExecutable: true,
   requiresApproval: true,
 }
 
-export const ScrapePage: ToolCatalogEntry = {
-  id: 'scrape_page',
-  name: 'scrape_page',
-  route: 'go',
-  mode: 'sync',
+export const SaveUpload: ToolCatalogEntry = {
+  id: 'save_upload',
+  name: 'save_upload',
+  route: 'sim',
+  mode: 'async',
   parameters: {
     type: 'object',
     properties: {
-      include_links: {
-        type: 'boolean',
-        description: 'Extract all links from the page (default false)',
+      fileNames: {
+        type: 'array',
+        description:
+          'The names of the uploaded files to materialize (e.g. ["report.pdf", "data.csv"])',
+        items: { type: 'string' },
       },
-      url: { type: 'string', description: 'The URL to scrape (must include https://)' },
-      wait_for: {
+      operation: {
         type: 'string',
-        description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+        description:
+          'What to do with the file. "save" promotes it to a permanent files/ path. "import" imports a workflow JSON as a workspace workflow. "extract" decompresses a .zip upload into files/<archive>/. Defaults to "save".',
+        enum: ['save', 'import', 'extract'],
+        default: 'save',
       },
     },
-    required: ['url'],
+    required: ['fileNames'],
   },
+  requiredPermission: 'write',
 }
 
 export const Search: ToolCatalogEntry = {
@@ -4528,21 +5123,21 @@ export const Search: ToolCatalogEntry = {
   internal: true,
 }
 
-export const SearchDocumentation: ToolCatalogEntry = {
-  id: 'search_documentation',
-  name: 'search_documentation',
+export const SearchDocs: ToolCatalogEntry = {
+  id: 'search_docs',
+  name: 'search_docs',
   route: 'sim',
   mode: 'async',
   parameters: {
     type: 'object',
     properties: {
-      query: { type: 'string', description: 'The search query' },
-      topK: {
-        type: 'number',
+      path: {
+        type: 'string',
         description:
-          'Number of results to return (default 10). Not clamped — keep it small, since each result is a full doc chunk.',
-        default: 10,
+          'Optional docs/ VFS path (a page such as docs/workflows/blocks/agent.mdx, or a section such as docs/workflows) that limits the search scope',
       },
+      query: { type: 'string', description: 'The search query' },
+      topK: { type: 'number', description: 'Number of results (default 5, max 25)', default: 5 },
     },
     required: ['query'],
   },
@@ -4649,67 +5244,6 @@ export const SearchLibraryDocs: ToolCatalogEntry = {
   },
 }
 
-export const SearchOnline: ToolCatalogEntry = {
-  id: 'search_online',
-  name: 'search_online',
-  route: 'go',
-  mode: 'sync',
-  parameters: {
-    type: 'object',
-    properties: {
-      category: {
-        type: 'string',
-        description: 'Filter by category',
-        enum: [
-          'news',
-          'tweet',
-          'github',
-          'company',
-          'research paper',
-          'linkedin profile',
-          'pdf',
-          'personal site',
-        ],
-      },
-      include_text: { type: 'boolean', description: 'Include page text content (default true)' },
-      num_results: { type: 'number', description: 'Number of results (default 10, max 25)' },
-      query: { type: 'string', description: 'Natural language search query' },
-      toolTitle: {
-        type: 'string',
-        description:
-          "Required short UI label fragment (e.g. 'Slack integrations'), not a full sentence.",
-      },
-    },
-    required: ['query', 'toolTitle'],
-  },
-}
-
-export const SearchPatterns: ToolCatalogEntry = {
-  id: 'search_patterns',
-  name: 'search_patterns',
-  route: 'go',
-  mode: 'sync',
-  parameters: {
-    type: 'object',
-    properties: {
-      limit: {
-        type: 'integer',
-        description: 'Maximum number of pattern examples to return per query (defaults to 3).',
-      },
-      queries: {
-        type: 'array',
-        description:
-          'Up to 3 descriptive strings explaining the workflow pattern(s) you need. Focus on intent and desired outcomes.',
-        items: {
-          type: 'string',
-          description: 'Example: "how to automate wealthbox meeting notes into follow-up tasks"',
-        },
-      },
-    },
-    required: ['queries'],
-  },
-}
-
 export const SetBlockEnabled: ToolCatalogEntry = {
   id: 'set_block_enabled',
   name: 'set_block_enabled',
@@ -4874,20 +5408,642 @@ export const ShareFile: ToolCatalogEntry = {
   requiredPermission: 'write',
 }
 
+export const SteerAgent: ToolCatalogEntry = {
+  id: 'steer_agent',
+  name: 'steer_agent',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_id: { type: 'string', description: 'The agent id to steer.' },
+      content: {
+        type: 'string',
+        description: 'The instruction to deliver, phrased as you would brief a teammate mid-task.',
+      },
+    },
+    required: ['agent_id', 'content'],
+  },
+}
+
 export const Table: ToolCatalogEntry = {
   id: 'table',
   name: 'table',
   route: 'subagent',
   mode: 'async',
   parameters: {
-    properties: { request: { description: 'What table action is needed.', type: 'string' } },
-    required: ['request'],
+    properties: {
+      request: { description: 'What table action is needed.', type: 'string' },
+      sessionId: {
+        description:
+          'Reusable session ID returned by an earlier table call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message. Omit it for a new or independent task.',
+        type: 'string',
+      },
+      title: {
+        description:
+          "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the table agent. When resuming with sessionId, copy the registry title unchanged.",
+        maxLength: 120,
+        type: 'string',
+      },
+    },
+    required: ['request', 'title'],
     type: 'object',
   },
   subagentId: 'table',
   internal: true,
 }
 
+export const TableAutomations: ToolCatalogEntry = {
+  id: 'table_automations',
+  name: 'table_automations',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          autoRun: {
+            type: 'boolean',
+            description:
+              "On add: true fires dep-satisfied rows immediately (only when the user explicitly asked); default false stages silently. On update: toggles the group's auto-fire on dep satisfaction.",
+          },
+          blockId: {
+            type: 'string',
+            description: 'Source block ID inside the workflow (add_workflow_group_output)',
+          },
+          columnName: {
+            type: 'string',
+            description:
+              'Target column name: required for delete_workflow_group_output (the bound column to drop); optional for add_workflow_group_output (auto-derived from path)',
+          },
+          dependencies: {
+            type: 'object',
+            description:
+              'Dependencies before a row runs: { columns?: string[] } of input column names that must be filled. Output columns of upstream groups are valid; a group cannot depend on its own outputs.',
+            properties: {
+              columns: {
+                type: 'array',
+                description: 'Input column names that must be filled before the group runs a row.',
+                items: { type: 'string' },
+              },
+            },
+          },
+          deploymentMode: {
+            type: 'string',
+            description:
+              'Which workflow version rows execute: "live" (default, editable draft — edits take effect immediately) or "deployed" (latest active deployment; fails if the workflow was never deployed).',
+            enum: ['live', 'deployed'],
+          },
+          groupId: {
+            type: 'string',
+            description:
+              'Workflow group ID (required for update_workflow_group, delete_workflow_group, add_workflow_group_output, delete_workflow_group_output)',
+          },
+          groupIds: {
+            type: 'array',
+            description: 'Workflow group IDs to fire (required for run_column, non-empty)',
+            items: { type: 'string' },
+          },
+          mappingUpdates: {
+            type: 'array',
+            description:
+              'Surgical per-output remap for update_workflow_group: each entry repoints ONE existing output column to a new (blockId, path) without touching the rest. Stale cells clear and backfill from saved execution logs where possible. Discover valid pairs via list_workflow_outputs first.',
+            items: {
+              type: 'object',
+              properties: {
+                blockId: { type: 'string', description: 'New source block ID for this column.' },
+                columnName: {
+                  type: 'string',
+                  description: 'The existing output column to remap (must be bound to this group).',
+                },
+                path: { type: 'string', description: 'New dotted output path on the new block.' },
+              },
+              required: ['columnName', 'blockId', 'path'],
+            },
+          },
+          name: {
+            type: 'string',
+            description: 'Display name for the group (optional on add/update)',
+          },
+          outputPath: {
+            type: 'string',
+            description:
+              'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+          },
+          outputs: {
+            type: 'array',
+            description:
+              'Outputs to surface as columns for add_workflow_group: each { blockId, path, columnName?, columnType? }; columnName auto-derives from path, columnType from the leaf type. Validated against list_workflow_outputs — invalid picks return the valid options. For update_workflow_group prefer add/delete_workflow_group_output and mappingUpdates; pass outputs only to restructure the whole set.',
+            items: {
+              type: 'object',
+              properties: {
+                blockId: { type: 'string', description: 'Source block ID inside the workflow.' },
+                columnName: {
+                  type: 'string',
+                  description:
+                    'Optional target column name; auto-derived from the path when omitted.',
+                },
+                columnType: {
+                  type: 'string',
+                  description: 'Optional column type; defaults from the leaf type when omitted.',
+                  enum: ['string', 'number', 'boolean', 'date', 'json'],
+                },
+                path: { type: 'string', description: 'Dotted output path on the block.' },
+              },
+              required: ['blockId', 'path'],
+            },
+          },
+          path: {
+            type: 'string',
+            description: 'Dotted output path on the block (add_workflow_group_output)',
+          },
+          rowId: { type: 'string', description: 'Row ID for cancel_table_runs with scope "row".' },
+          rowIds: {
+            type: 'array',
+            description:
+              'Optional row scope for run_column: only these rows are candidates (server eligibility still applies); omit for the whole table.',
+            items: { type: 'string' },
+          },
+          runMode: {
+            type: 'string',
+            description:
+              'Run mode for run_column: "incomplete" (default) re-runs only rows with no output or a last failure; "all" re-runs every dep-satisfied row.',
+            enum: ['incomplete', 'all'],
+          },
+          scope: {
+            type: 'string',
+            description:
+              'Cancellation scope for cancel_table_runs: "all" (whole table) or "row" (requires rowId).',
+            enum: ['all', 'row'],
+          },
+          tableId: {
+            type: 'string',
+            description: 'Table ID (required for everything except list_workflow_outputs)',
+          },
+          workflowId: {
+            type: 'string',
+            description: 'Workflow ID (required for add_workflow_group and list_workflow_outputs)',
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The automation operation to perform',
+        enum: [
+          'list_workflow_outputs',
+          'add_workflow_group',
+          'update_workflow_group',
+          'delete_workflow_group',
+          'add_workflow_group_output',
+          'delete_workflow_group_output',
+          'run_column',
+          'cancel_table_runs',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const TableColumns: ToolCatalogEntry = {
+  id: 'table_columns',
+  name: 'table_columns',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          column: {
+            type: 'object',
+            description:
+              'Column definition for add_column: { name, type, unique?, position? }; select (enum) columns also take { options: [names], multiple?: true } — options is required for select.',
+          },
+          columnName: {
+            type: 'string',
+            description:
+              'Column name (required for rename_column and update_column; single-column delete_column)',
+          },
+          columnNames: {
+            type: 'array',
+            description:
+              'Array of column names to delete at once (preferred for multi-column delete_column)',
+          },
+          multiple: {
+            type: 'boolean',
+            description:
+              'Whether a select cell may hold several options (default false). Switching true → false fails if any row has more than one selected.',
+          },
+          newName: { type: 'string', description: 'New column name (required for rename_column)' },
+          newType: {
+            type: 'string',
+            description:
+              'New column type for update_column: string, number, boolean, date, json, select. Converting to select also requires options; conversion fails if an existing cell value matches no option. A multiple select round-trips through text as a comma-separated cell.',
+          },
+          options: {
+            type: 'array',
+            description:
+              'Choices for a select (enum) column as display names, e.g. ["Open", "Closed"]. Required when creating or converting to select. On update_column this REPLACES the whole list, matched BY NAME — send the full list including options you keep; omitting one deletes it and clears its cells. Max 100.',
+            items: { type: 'string' },
+          },
+          outputPath: {
+            type: 'string',
+            description:
+              'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+          },
+          tableId: { type: 'string', description: 'Table ID (required for every operation)' },
+          unique: {
+            type: 'boolean',
+            description:
+              'Set or clear the column unique constraint (update_column; not supported on select columns)',
+          },
+        },
+        required: ['tableId'],
+      },
+      operation: {
+        type: 'string',
+        description: 'The column operation to perform',
+        enum: ['add_column', 'rename_column', 'delete_column', 'update_column'],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const TableEnrichments: ToolCatalogEntry = {
+  id: 'table_enrichments',
+  name: 'table_enrichments',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          autoRun: {
+            type: 'boolean',
+            description:
+              'true fires dep-satisfied rows immediately on add (only when the user explicitly asked); default false stages silently — fire later via table_automations run_column.',
+          },
+          dependencies: {
+            type: 'object',
+            description:
+              'Optional dependency override: { columns?: string[] }; omit to default to the mapped input columns.',
+            properties: {
+              columns: {
+                type: 'array',
+                description:
+                  'Input column names that must be filled before the enrichment runs a row.',
+                items: { type: 'string' },
+              },
+            },
+          },
+          enrichmentId: {
+            type: 'string',
+            description:
+              'Enrichment registry ID for add_enrichment — discover via list_enrichments (e.g. work-email, phone-number, company-domain, company-info).',
+          },
+          inputMappings: {
+            type: 'array',
+            description:
+              'For add_enrichment: binds each enrichment input to an existing table column, as { inputName, columnName } where inputName is the enrichment input id from list_enrichments. Provide one for every required input.',
+            items: {
+              type: 'object',
+              properties: {
+                columnName: {
+                  type: 'string',
+                  description: 'Existing table column that supplies this input.',
+                },
+                inputName: {
+                  type: 'string',
+                  description: 'Enrichment input id to bind (from list_enrichments).',
+                },
+              },
+              required: ['inputName', 'columnName'],
+            },
+          },
+          name: {
+            type: 'string',
+            description:
+              "Optional display name for the enrichment column group; defaults to the enrichment's registry name.",
+          },
+          outputColumnNames: {
+            type: 'object',
+            description:
+              'Optional output column name overrides, as { "<outputId>": "<columnName>" }; omit for defaults.',
+            additionalProperties: {
+              type: 'string',
+              description: 'Target column name for this enrichment output id.',
+            },
+          },
+          outputPath: {
+            type: 'string',
+            description:
+              'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+          },
+          tableId: { type: 'string', description: 'Table ID (required for add_enrichment)' },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The enrichment operation to perform',
+        enum: ['list_enrichments', 'add_enrichment'],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const TableManage: ToolCatalogEntry = {
+  id: 'table_manage',
+  name: 'table_manage',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          description: { type: 'string', description: 'Table description (optional for create)' },
+          filePath: {
+            type: 'string',
+            description:
+              'Canonical workspace file VFS path for create_from_file / import_file, e.g. files/{path}/{name}',
+          },
+          mapping: {
+            type: 'object',
+            description:
+              'Optional explicit CSV-header → table-column mapping for import_file, as { "csvHeader": "columnName" | null }. null skips that header; omit a header to auto-map by sanitized name.',
+            additionalProperties: {
+              type: ['string', 'null'],
+              description: 'Target column name on the table; null skips that CSV header.',
+            },
+          },
+          mode: {
+            type: 'string',
+            description:
+              'Import mode for import_file: append (default) adds rows; replace truncates existing rows in a transaction first.',
+            enum: ['append', 'replace'],
+          },
+          name: { type: 'string', description: 'Table name (required for create)' },
+          newName: { type: 'string', description: 'New table name (required for rename)' },
+          outputPath: {
+            type: 'string',
+            description:
+              'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+          },
+          schema: {
+            type: 'object',
+            description:
+              'Table schema with a columns array (required for create). Each column: { name, type, unique? }; a select (enum) column also requires options (display names) and takes multiple?.',
+          },
+          tableId: {
+            type: 'string',
+            description: 'Table ID (required for import_file and rename)',
+          },
+        },
+      },
+      operation: {
+        type: 'string',
+        description: 'The lifecycle operation to perform',
+        enum: ['create', 'create_from_file', 'import_file', 'rename'],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const TableRows: ToolCatalogEntry = {
+  id: 'table_rows',
+  name: 'table_rows',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          columnName: {
+            type: 'string',
+            description: 'Column to set when using the values map format of batch_update_rows',
+          },
+          data: {
+            type: 'object',
+            description:
+              'Row data as column → value pairs (required for insert_row, update_row; the patch object for update_rows_by_filter). Select (enum) cells take the option NAME.',
+          },
+          filter: {
+            type: 'object',
+            description:
+              'Predicate filter for update_rows_by_filter / delete_rows_by_filter: {"all":[...]} (AND) or {"any":[...]} (OR) of {field, op, value} leaves or nested groups. Ops: eq, ne, gt, gte, lt, lte, in, nin, like, ilike (* wildcard), nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty. in/nin take a non-empty array. Single-select columns match by eq/ne/in/nin; multiple-select by contains/ncontains — values are option NAMES.',
+          },
+          limit: {
+            type: 'number',
+            description:
+              'Optional cap on affected rows for the by-filter operations; omit to act on every match.',
+          },
+          outputPath: {
+            type: 'string',
+            description:
+              'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+          },
+          position: {
+            type: 'integer',
+            description:
+              'Zero-based index at which to insert the row (optional, insert_row only). Rows at and below shift down; omit to append.',
+          },
+          rowId: { type: 'string', description: 'Row ID (required for update_row, delete_row)' },
+          rowIds: {
+            type: 'array',
+            description: 'Array of row IDs to delete (required for batch_delete_rows)',
+            items: { type: 'string' },
+          },
+          rows: {
+            type: 'array',
+            description: 'Array of row data objects (required for batch_insert_rows)',
+          },
+          tableId: { type: 'string', description: 'Table ID (required for every operation)' },
+          updates: {
+            type: 'array',
+            description:
+              'Array of per-row updates: [{ rowId, data: { col: val } }] (batch_update_rows format a)',
+          },
+          values: {
+            type: 'object',
+            description:
+              'Map of rowId → value for single-column batch update (batch_update_rows format b, with columnName)',
+          },
+        },
+        required: ['tableId'],
+      },
+      operation: {
+        type: 'string',
+        description: 'The row operation to perform',
+        enum: [
+          'insert_row',
+          'batch_insert_rows',
+          'update_row',
+          'batch_update_rows',
+          'delete_row',
+          'batch_delete_rows',
+          'update_rows_by_filter',
+          'delete_rows_by_filter',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const TableViews: ToolCatalogEntry = {
+  id: 'table_views',
+  name: 'table_views',
+  route: 'sim',
+  mode: 'async',
+  parameters: {
+    type: 'object',
+    properties: {
+      args: {
+        type: 'object',
+        description: 'Arguments for the operation',
+        properties: {
+          filter: {
+            type: 'object',
+            description:
+              'Saved row predicate, same grammar as query_rows filters: {"all":[...]} / {"any":[...]} of {field, op, value} leaves with exact column NAMES. Omit or null for an unfiltered view.',
+          },
+          hiddenColumns: {
+            type: 'array',
+            description:
+              'Column names to hide in the UI when this view is active. Display-only — queries through the view still return every column.',
+            items: { type: 'string' },
+          },
+          isDefault: {
+            type: 'boolean',
+            description:
+              "Make this view the table's default (at most one per table; setting it clears the previous default).",
+          },
+          name: {
+            type: 'string',
+            description:
+              'View display name (required for create_view; optional rename on update_view). Free-form label; references always use the view ID, so names are purely display.',
+          },
+          sort: {
+            type: 'array',
+            description:
+              'Saved ordered sort spec, e.g. [{"field":"due","direction":"asc"}], column NAMES. Omit or null for default ordering.',
+          },
+          tableId: { type: 'string', description: 'Table ID (required for every operation)' },
+          viewId: {
+            type: 'string',
+            description:
+              'View ID (required for get_view, update_view, delete_view, set_default_view)',
+          },
+        },
+        required: ['tableId'],
+      },
+      operation: {
+        type: 'string',
+        description: 'The view operation to perform',
+        enum: [
+          'list_views',
+          'get_view',
+          'create_view',
+          'update_view',
+          'delete_view',
+          'set_default_view',
+        ],
+      },
+    },
+    required: ['operation', 'args'],
+  },
+  resultSchema: {
+    type: 'object',
+    properties: {
+      data: { type: 'object', description: 'Operation-specific result payload.' },
+      message: { type: 'string', description: 'Human-readable outcome summary.' },
+      success: { type: 'boolean', description: 'Whether the operation succeeded.' },
+    },
+    required: ['success', 'message'],
+  },
+}
+
+export const TailAgent: ToolCatalogEntry = {
+  id: 'tail_agent',
+  name: 'tail_agent',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_id: { type: 'string', description: 'The agent id to inspect.' },
+      max_chars: {
+        type: 'number',
+        description:
+          'Max characters of activity to return. Default 4000; unread activity beyond the budget stays queued for your next tail.',
+      },
+    },
+    required: ['agent_id'],
+  },
+}
+
 export const Terminal: ToolCatalogEntry = {
   id: 'terminal',
   name: 'terminal',
@@ -5027,7 +6183,7 @@ export const UpdateDeploymentVersion: ToolCatalogEntry = {
       version: {
         type: 'number',
         description:
-          'The numeric deployment version number to update (use get_deployment_log to find it).',
+          'The numeric deployment version number to update (use list_deployment_versions to find it).',
       },
       workflowId: {
         type: 'string',
@@ -5421,6 +6577,145 @@ export const Wait: ToolCatalogEntry = {
   },
 }
 
+export const WaitAgents: ToolCatalogEntry = {
+  id: 'wait_agents',
+  name: 'wait_agents',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      agent_ids: {
+        type: 'array',
+        description: 'The agent ids to wait on, as returned by their async launches.',
+        items: { type: 'string' },
+      },
+      mode: {
+        type: 'string',
+        description:
+          '"all" (default) wakes when every listed agent finishes; "any" wakes on the first.',
+        enum: ['all', 'any'],
+      },
+      timeout_seconds: {
+        type: 'number',
+        description:
+          'Max seconds to sleep before waking anyway. Default 120, capped at 600. On timeout you get current statuses and can wait again.',
+      },
+    },
+    required: ['agent_ids'],
+  },
+}
+
+export const WebCrawl: ToolCatalogEntry = {
+  id: 'web_crawl',
+  name: 'web_crawl',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      exclude_paths: {
+        type: 'array',
+        description: 'Skip URLs matching these patterns',
+        items: { type: 'string' },
+      },
+      include_paths: {
+        type: 'array',
+        description: 'Only crawl URLs matching these patterns',
+        items: { type: 'string' },
+      },
+      limit: { type: 'number', description: 'Maximum pages to crawl (default 10, max 50)' },
+      max_depth: { type: 'number', description: 'How deep to follow links (default 2)' },
+      url: { type: 'string', description: 'Starting URL to crawl from' },
+    },
+    required: ['url'],
+  },
+}
+
+export const WebFetch: ToolCatalogEntry = {
+  id: 'web_fetch',
+  name: 'web_fetch',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      include_highlights: {
+        type: 'boolean',
+        description: 'Include key highlights (default false)',
+      },
+      include_summary: {
+        type: 'boolean',
+        description: 'Include AI-generated summary (default false)',
+      },
+      include_text: { type: 'boolean', description: 'Include full page text (default true)' },
+      urls: {
+        type: 'array',
+        description: 'URLs to get content from (max 10)',
+        items: { type: 'string' },
+      },
+    },
+    required: ['urls'],
+  },
+}
+
+export const WebScrape: ToolCatalogEntry = {
+  id: 'web_scrape',
+  name: 'web_scrape',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      include_links: {
+        type: 'boolean',
+        description: 'Extract all links from the page (default false)',
+      },
+      url: { type: 'string', description: 'The URL to scrape (must include https://)' },
+      wait_for: {
+        type: 'string',
+        description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+      },
+    },
+    required: ['url'],
+  },
+}
+
+export const WebSearch: ToolCatalogEntry = {
+  id: 'web_search',
+  name: 'web_search',
+  route: 'go',
+  mode: 'sync',
+  parameters: {
+    type: 'object',
+    properties: {
+      category: {
+        type: 'string',
+        description: 'Filter by category',
+        enum: [
+          'news',
+          'tweet',
+          'github',
+          'company',
+          'research paper',
+          'linkedin profile',
+          'pdf',
+          'personal site',
+        ],
+      },
+      include_text: { type: 'boolean', description: 'Include page text content (default true)' },
+      num_results: { type: 'number', description: 'Number of results (default 10, max 25)' },
+      query: { type: 'string', description: 'Natural language search query' },
+      toolTitle: {
+        type: 'string',
+        description:
+          "Required short UI label fragment (e.g. 'Slack integrations'), not a full sentence.",
+      },
+    },
+    required: ['query', 'toolTitle'],
+  },
+}
+
 export const Workflow: ToolCatalogEntry = {
   id: 'workflow',
   name: 'workflow',
@@ -5453,129 +6748,6 @@ export const Workflow: ToolCatalogEntry = {
   internal: true,
 }
 
-export const WorkspaceFile: ToolCatalogEntry = {
-  id: 'workspace_file',
-  name: 'workspace_file',
-  route: 'sim',
-  mode: 'async',
-  parameters: {
-    type: 'object',
-    properties: {
-      operation: {
-        type: 'string',
-        description: 'The file operation to perform.',
-        enum: ['append', 'update', 'patch'],
-      },
-      target: {
-        type: 'object',
-        description: 'Explicit file target. Use kind=path + path for existing files.',
-        properties: {
-          kind: {
-            type: 'string',
-            description: 'How the file target is identified.',
-            enum: ['path'],
-          },
-          path: {
-            type: 'string',
-            description:
-              'Canonical existing workspace file VFS path, e.g. "files/Reports/report.md". Required when target.kind=path.',
-          },
-        },
-        required: ['kind'],
-      },
-      title: {
-        type: 'string',
-        description:
-          'Required short UI label for this content unit, e.g. "Chapter 1", "Slide 3", or "Fix footer spacing".',
-      },
-      contentType: {
-        type: 'string',
-        description:
-          'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
-        enum: [
-          'text/markdown',
-          'text/html',
-          'text/plain',
-          'application/json',
-          'text/csv',
-          'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-          'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-          'application/pdf',
-        ],
-      },
-      edit: {
-        type: 'object',
-        description:
-          'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. The actual replacement/insert content is provided via the paired edit_content tool call.',
-        properties: {
-          after_anchor: {
-            type: 'string',
-            description:
-              'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
-          },
-          anchor: {
-            type: 'string',
-            description:
-              'Anchor line after which new content is inserted. Required for mode=insert_after.',
-          },
-          before_anchor: {
-            type: 'string',
-            description:
-              'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
-          },
-          end_anchor: {
-            type: 'string',
-            description: 'First line to keep after deletion. Required for mode=delete_between.',
-          },
-          mode: {
-            type: 'string',
-            description: 'Anchored edit mode when strategy=anchored.',
-            enum: ['replace_between', 'insert_after', 'delete_between'],
-          },
-          occurrence: {
-            type: 'number',
-            description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
-          },
-          replaceAll: {
-            type: 'boolean',
-            description:
-              'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
-          },
-          search: {
-            type: 'string',
-            description:
-              'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
-          },
-          start_anchor: {
-            type: 'string',
-            description: 'First line to delete. Required for mode=delete_between.',
-          },
-          strategy: {
-            type: 'string',
-            description: 'Patch strategy.',
-            enum: ['search_replace', 'anchored'],
-          },
-        },
-      },
-    },
-    required: ['operation', 'target', 'title'],
-  },
-  resultSchema: {
-    type: 'object',
-    properties: {
-      data: {
-        type: 'object',
-        description:
-          'Optional operation metadata such as file id, file name, size, and content type.',
-      },
-      message: { type: 'string', description: 'Human-readable summary of the outcome.' },
-      success: { type: 'boolean', description: 'Whether the file operation succeeded.' },
-    },
-    required: ['success', 'message'],
-  },
-  requiredPermission: 'write',
-}
-
 export const FfmpegOperation = {
   overlayAudio: 'overlay_audio',
   mixAudio: 'mix_audio',
@@ -5608,47 +6780,6 @@ export const FfmpegOperationValues = [
   FfmpegOperation.probe,
 ] as const
 
-export const KnowledgeBaseOperation = {
-  create: 'create',
-  get: 'get',
-  query: 'query',
-  addFile: 'add_file',
-  update: 'update',
-  deleteDocument: 'delete_document',
-  updateDocument: 'update_document',
-  listTags: 'list_tags',
-  createTag: 'create_tag',
-  updateTag: 'update_tag',
-  deleteTag: 'delete_tag',
-  getTagUsage: 'get_tag_usage',
-  addConnector: 'add_connector',
-  updateConnector: 'update_connector',
-  deleteConnector: 'delete_connector',
-  syncConnector: 'sync_connector',
-} as const
-
-export type KnowledgeBaseOperation =
-  (typeof KnowledgeBaseOperation)[keyof typeof KnowledgeBaseOperation]
-
-export const KnowledgeBaseOperationValues = [
-  KnowledgeBaseOperation.create,
-  KnowledgeBaseOperation.get,
-  KnowledgeBaseOperation.query,
-  KnowledgeBaseOperation.addFile,
-  KnowledgeBaseOperation.update,
-  KnowledgeBaseOperation.deleteDocument,
-  KnowledgeBaseOperation.updateDocument,
-  KnowledgeBaseOperation.listTags,
-  KnowledgeBaseOperation.createTag,
-  KnowledgeBaseOperation.updateTag,
-  KnowledgeBaseOperation.deleteTag,
-  KnowledgeBaseOperation.getTagUsage,
-  KnowledgeBaseOperation.addConnector,
-  KnowledgeBaseOperation.updateConnector,
-  KnowledgeBaseOperation.deleteConnector,
-  KnowledgeBaseOperation.syncConnector,
-] as const
-
 export const ManageCredentialOperation = {
   rename: 'rename',
   delete: 'delete',
@@ -5679,21 +6810,62 @@ export const ManageCustomToolOperationValues = [
   ManageCustomToolOperation.list,
 ] as const
 
-export const ManageMcpToolOperation = {
+export const ManageKnowledgeBaseOperation = {
+  create: 'create',
+  get: 'get',
+  query: 'query',
+  addFile: 'add_file',
+  update: 'update',
+  deleteDocument: 'delete_document',
+  updateDocument: 'update_document',
+  listTags: 'list_tags',
+  createTag: 'create_tag',
+  updateTag: 'update_tag',
+  deleteTag: 'delete_tag',
+  getTagUsage: 'get_tag_usage',
+  addConnector: 'add_connector',
+  updateConnector: 'update_connector',
+  deleteConnector: 'delete_connector',
+  syncConnector: 'sync_connector',
+} as const
+
+export type ManageKnowledgeBaseOperation =
+  (typeof ManageKnowledgeBaseOperation)[keyof typeof ManageKnowledgeBaseOperation]
+
+export const ManageKnowledgeBaseOperationValues = [
+  ManageKnowledgeBaseOperation.create,
+  ManageKnowledgeBaseOperation.get,
+  ManageKnowledgeBaseOperation.query,
+  ManageKnowledgeBaseOperation.addFile,
+  ManageKnowledgeBaseOperation.update,
+  ManageKnowledgeBaseOperation.deleteDocument,
+  ManageKnowledgeBaseOperation.updateDocument,
+  ManageKnowledgeBaseOperation.listTags,
+  ManageKnowledgeBaseOperation.createTag,
+  ManageKnowledgeBaseOperation.updateTag,
+  ManageKnowledgeBaseOperation.deleteTag,
+  ManageKnowledgeBaseOperation.getTagUsage,
+  ManageKnowledgeBaseOperation.addConnector,
+  ManageKnowledgeBaseOperation.updateConnector,
+  ManageKnowledgeBaseOperation.deleteConnector,
+  ManageKnowledgeBaseOperation.syncConnector,
+] as const
+
+export const ManageMcpConnectionOperation = {
   add: 'add',
   edit: 'edit',
   delete: 'delete',
   list: 'list',
 } as const
 
-export type ManageMcpToolOperation =
-  (typeof ManageMcpToolOperation)[keyof typeof ManageMcpToolOperation]
+export type ManageMcpConnectionOperation =
+  (typeof ManageMcpConnectionOperation)[keyof typeof ManageMcpConnectionOperation]
 
-export const ManageMcpToolOperationValues = [
-  ManageMcpToolOperation.add,
-  ManageMcpToolOperation.edit,
-  ManageMcpToolOperation.delete,
-  ManageMcpToolOperation.list,
+export const ManageMcpConnectionOperationValues = [
+  ManageMcpConnectionOperation.add,
+  ManageMcpConnectionOperation.edit,
+  ManageMcpConnectionOperation.delete,
+  ManageMcpConnectionOperation.list,
 ] as const
 
 export const ManageSandboxOperation = {
@@ -5729,19 +6901,19 @@ export const ManageSkillOperationValues = [
   ManageSkillOperation.list,
 ] as const
 
-export const MaterializeFileOperation = {
-  save: 'save',
-  import: 'import',
-  extract: 'extract',
+export const PrepareFileEditOperation = {
+  append: 'append',
+  update: 'update',
+  patch: 'patch',
 } as const
 
-export type MaterializeFileOperation =
-  (typeof MaterializeFileOperation)[keyof typeof MaterializeFileOperation]
+export type PrepareFileEditOperation =
+  (typeof PrepareFileEditOperation)[keyof typeof PrepareFileEditOperation]
 
-export const MaterializeFileOperationValues = [
-  MaterializeFileOperation.save,
-  MaterializeFileOperation.import,
-  MaterializeFileOperation.extract,
+export const PrepareFileEditOperationValues = [
+  PrepareFileEditOperation.append,
+  PrepareFileEditOperation.update,
+  PrepareFileEditOperation.patch,
 ] as const
 
 export const QueryUserTableOperation = {
@@ -5761,6 +6933,20 @@ export const QueryUserTableOperationValues = [
   QueryUserTableOperation.queryRows,
 ] as const
 
+export const SaveUploadOperation = {
+  save: 'save',
+  import: 'import',
+  extract: 'extract',
+} as const
+
+export type SaveUploadOperation = (typeof SaveUploadOperation)[keyof typeof SaveUploadOperation]
+
+export const SaveUploadOperationValues = [
+  SaveUploadOperation.save,
+  SaveUploadOperation.import,
+  SaveUploadOperation.extract,
+] as const
+
 export const SearchKnowledgeBaseOperation = {
   get: 'get',
   query: 'query',
@@ -5776,6 +6962,121 @@ export const SearchKnowledgeBaseOperationValues = [
   SearchKnowledgeBaseOperation.listTags,
 ] as const
 
+export const TableAutomationsOperation = {
+  listWorkflowOutputs: 'list_workflow_outputs',
+  addWorkflowGroup: 'add_workflow_group',
+  updateWorkflowGroup: 'update_workflow_group',
+  deleteWorkflowGroup: 'delete_workflow_group',
+  addWorkflowGroupOutput: 'add_workflow_group_output',
+  deleteWorkflowGroupOutput: 'delete_workflow_group_output',
+  runColumn: 'run_column',
+  cancelTableRuns: 'cancel_table_runs',
+} as const
+
+export type TableAutomationsOperation =
+  (typeof TableAutomationsOperation)[keyof typeof TableAutomationsOperation]
+
+export const TableAutomationsOperationValues = [
+  TableAutomationsOperation.listWorkflowOutputs,
+  TableAutomationsOperation.addWorkflowGroup,
+  TableAutomationsOperation.updateWorkflowGroup,
+  TableAutomationsOperation.deleteWorkflowGroup,
+  TableAutomationsOperation.addWorkflowGroupOutput,
+  TableAutomationsOperation.deleteWorkflowGroupOutput,
+  TableAutomationsOperation.runColumn,
+  TableAutomationsOperation.cancelTableRuns,
+] as const
+
+export const TableColumnsOperation = {
+  addColumn: 'add_column',
+  renameColumn: 'rename_column',
+  deleteColumn: 'delete_column',
+  updateColumn: 'update_column',
+} as const
+
+export type TableColumnsOperation =
+  (typeof TableColumnsOperation)[keyof typeof TableColumnsOperation]
+
+export const TableColumnsOperationValues = [
+  TableColumnsOperation.addColumn,
+  TableColumnsOperation.renameColumn,
+  TableColumnsOperation.deleteColumn,
+  TableColumnsOperation.updateColumn,
+] as const
+
+export const TableEnrichmentsOperation = {
+  listEnrichments: 'list_enrichments',
+  addEnrichment: 'add_enrichment',
+} as const
+
+export type TableEnrichmentsOperation =
+  (typeof TableEnrichmentsOperation)[keyof typeof TableEnrichmentsOperation]
+
+export const TableEnrichmentsOperationValues = [
+  TableEnrichmentsOperation.listEnrichments,
+  TableEnrichmentsOperation.addEnrichment,
+] as const
+
+export const TableManageOperation = {
+  create: 'create',
+  createFromFile: 'create_from_file',
+  importFile: 'import_file',
+  rename: 'rename',
+} as const
+
+export type TableManageOperation = (typeof TableManageOperation)[keyof typeof TableManageOperation]
+
+export const TableManageOperationValues = [
+  TableManageOperation.create,
+  TableManageOperation.createFromFile,
+  TableManageOperation.importFile,
+  TableManageOperation.rename,
+] as const
+
+export const TableRowsOperation = {
+  insertRow: 'insert_row',
+  batchInsertRows: 'batch_insert_rows',
+  updateRow: 'update_row',
+  batchUpdateRows: 'batch_update_rows',
+  deleteRow: 'delete_row',
+  batchDeleteRows: 'batch_delete_rows',
+  updateRowsByFilter: 'update_rows_by_filter',
+  deleteRowsByFilter: 'delete_rows_by_filter',
+} as const
+
+export type TableRowsOperation = (typeof TableRowsOperation)[keyof typeof TableRowsOperation]
+
+export const TableRowsOperationValues = [
+  TableRowsOperation.insertRow,
+  TableRowsOperation.batchInsertRows,
+  TableRowsOperation.updateRow,
+  TableRowsOperation.batchUpdateRows,
+  TableRowsOperation.deleteRow,
+  TableRowsOperation.batchDeleteRows,
+  TableRowsOperation.updateRowsByFilter,
+  TableRowsOperation.deleteRowsByFilter,
+] as const
+
+export const TableViewsOperation = {
+  listViews: 'list_views',
+  getView: 'get_view',
+  createView: 'create_view',
+  updateView: 'update_view',
+  deleteView: 'delete_view',
+  setDefaultView: 'set_default_view',
+} as const
+
+export type TableViewsOperation = (typeof TableViewsOperation)[keyof typeof TableViewsOperation]
+
+export const TableViewsOperationValues = [
+  TableViewsOperation.listViews,
+  TableViewsOperation.getView,
+  TableViewsOperation.createView,
+  TableViewsOperation.updateView,
+  TableViewsOperation.deleteView,
+  TableViewsOperation.setDefaultView,
+] as const
+
 export const TerminalOperation = {
   run: 'run',
   read: 'read',
@@ -5874,31 +7175,19 @@ export const UserTableOperationValues = [
   UserTableOperation.addEnrichment,
 ] as const
 
-export const WorkspaceFileOperation = {
-  append: 'append',
-  update: 'update',
-  patch: 'patch',
-} as const
-
-export type WorkspaceFileOperation =
-  (typeof WorkspaceFileOperation)[keyof typeof WorkspaceFileOperation]
-
-export const WorkspaceFileOperationValues = [
-  WorkspaceFileOperation.append,
-  WorkspaceFileOperation.update,
-  WorkspaceFileOperation.patch,
-] as const
-
 export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
-  [Agent.id]: Agent,
+  [ApplyFileEdit.id]: ApplyFileEdit,
   [Auth.id]: Auth,
   [Browser.id]: Browser,
   [BrowserClick.id]: BrowserClick,
+  [BrowserClickAt.id]: BrowserClickAt,
   [BrowserCloseTab.id]: BrowserCloseTab,
+  [BrowserDrag.id]: BrowserDrag,
   [BrowserExtract.id]: BrowserExtract,
   [BrowserGoBack.id]: BrowserGoBack,
   [BrowserGoForward.id]: BrowserGoForward,
   [BrowserHover.id]: BrowserHover,
+  [BrowserInsertText.id]: BrowserInsertText,
   [BrowserListSessions.id]: BrowserListSessions,
   [BrowserListTabs.id]: BrowserListTabs,
   [BrowserNavigate.id]: BrowserNavigate,
@@ -5906,7 +7195,6 @@ export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
   [BrowserOpenUrl.id]: BrowserOpenUrl,
   [BrowserPressKey.id]: BrowserPressKey,
   [BrowserReadText.id]: BrowserReadText,
-  [BrowserRequestTakeover.id]: BrowserRequestTakeover,
   [BrowserScreenshot.id]: BrowserScreenshot,
   [BrowserScroll.id]: BrowserScroll,
   [BrowserSelectOption.id]: BrowserSelectOption,
@@ -5915,26 +7203,23 @@ export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
   [BrowserType.id]: BrowserType,
   [BrowserWaitFor.id]: BrowserWaitFor,
   [CallIntegrationTool.id]: CallIntegrationTool,
-  [CheckDeploymentStatus.id]: CheckDeploymentStatus,
+  [ConnectSlackBot.id]: ConnectSlackBot,
   [Cp.id]: Cp,
-  [CrawlWebsite.id]: CrawlWebsite,
-  [CreateFile.id]: CreateFile,
+  [CreateEmptyFile.id]: CreateEmptyFile,
   [CreateWorkflow.id]: CreateWorkflow,
   [CreateWorkspaceMcpServer.id]: CreateWorkspaceMcpServer,
   [DeleteWorkspaceMcpServer.id]: DeleteWorkspaceMcpServer,
   [Deploy.id]: Deploy,
-  [DeployApi.id]: DeployApi,
-  [DeployChat.id]: DeployChat,
-  [DeployCustomBlock.id]: DeployCustomBlock,
-  [DeployMcp.id]: DeployMcp,
+  [DeployAsApi.id]: DeployAsApi,
+  [DeployAsChat.id]: DeployAsChat,
+  [DeployAsMcp.id]: DeployAsMcp,
   [DiffWorkflows.id]: DiffWorkflows,
-  [DownloadToWorkspaceFile.id]: DownloadToWorkspaceFile,
-  [EditContent.id]: EditContent,
+  [DownloadFile.id]: DownloadFile,
   [EditWorkflow.id]: EditWorkflow,
-  [EnrichmentRun.id]: EnrichmentRun,
+  [Extensions.id]: Extensions,
+  [ExtractDocAssets.id]: ExtractDocAssets,
   [Ffmpeg.id]: Ffmpeg,
   [File.id]: File,
-  [FunctionExecute.id]: FunctionExecute,
   [GenerateApiKey.id]: GenerateApiKey,
   [GenerateAudio.id]: GenerateAudio,
   [GenerateImage.id]: GenerateImage,
@@ -5942,34 +7227,35 @@ export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
   [GetBlockOutputs.id]: GetBlockOutputs,
   [GetBlockUpstreamReferences.id]: GetBlockUpstreamReferences,
   [GetDeployedWorkflowState.id]: GetDeployedWorkflowState,
-  [GetDeploymentLog.id]: GetDeploymentLog,
-  [GetPageContents.id]: GetPageContents,
-  [GetPlatformActions.id]: GetPlatformActions,
+  [GetDeploymentStatus.id]: GetDeploymentStatus,
   [GetWorkflowData.id]: GetWorkflowData,
   [GetWorkflowRunOptions.id]: GetWorkflowRunOptions,
   [Glob.id]: Glob,
   [Grep.id]: Grep,
+  [InterruptAgent.id]: InterruptAgent,
   [Knowledge.id]: Knowledge,
-  [KnowledgeBase.id]: KnowledgeBase,
+  [ListDeploymentVersions.id]: ListDeploymentVersions,
   [ListIntegrationTools.id]: ListIntegrationTools,
-  [ListUserWorkspaces.id]: ListUserWorkspaces,
   [ListWorkspaceMcpServers.id]: ListWorkspaceMcpServers,
   [LoadDeployment.id]: LoadDeployment,
   [LoadIntegrationTool.id]: LoadIntegrationTool,
   [LoadSkill.id]: LoadSkill,
   [ManageCredential.id]: ManageCredential,
   [ManageCustomTool.id]: ManageCustomTool,
-  [ManageMcpTool.id]: ManageMcpTool,
+  [ManageKnowledgeBase.id]: ManageKnowledgeBase,
+  [ManageMcpConnection.id]: ManageMcpConnection,
   [ManageSandbox.id]: ManageSandbox,
   [ManageSkill.id]: ManageSkill,
-  [MaterializeFile.id]: MaterializeFile,
   [Media.id]: Media,
   [Mkdir.id]: Mkdir,
   [Mv.id]: Mv,
   [OauthGetAuthLink.id]: OauthGetAuthLink,
   [OauthRequestAccess.id]: OauthRequestAccess,
   [OpenResource.id]: OpenResource,
+  [Platform.id]: Platform,
+  [PrepareFileEdit.id]: PrepareFileEdit,
   [PromoteToLive.id]: PromoteToLive,
+  [PublishCustomBlock.id]: PublishCustomBlock,
   [QueryLogs.id]: QueryLogs,
   [QueryUserTable.id]: QueryUserTable,
   [Read.id]: Read,
@@ -5980,27 +7266,39 @@ export const TOOL_CATALOG: Record<string, ToolCatalogEntry> = {
   [Run.id]: Run,
   [RunBlock.id]: RunBlock,
   [RunCode.id]: RunCode,
+  [RunEnrichment.id]: RunEnrichment,
   [RunFromBlock.id]: RunFromBlock,
+  [RunFunction.id]: RunFunction,
   [RunWorkflow.id]: RunWorkflow,
   [RunWorkflowUntilBlock.id]: RunWorkflowUntilBlock,
-  [ScrapePage.id]: ScrapePage,
+  [SaveUpload.id]: SaveUpload,
   [Search.id]: Search,
-  [SearchDocumentation.id]: SearchDocumentation,
+  [SearchDocs.id]: SearchDocs,
   [SearchIntegrationTools.id]: SearchIntegrationTools,
   [SearchKnowledgeBase.id]: SearchKnowledgeBase,
   [SearchLibraryDocs.id]: SearchLibraryDocs,
-  [SearchOnline.id]: SearchOnline,
-  [SearchPatterns.id]: SearchPatterns,
   [SetBlockEnabled.id]: SetBlockEnabled,
   [SetEnvironmentVariables.id]: SetEnvironmentVariables,
   [SetGlobalWorkflowVariables.id]: SetGlobalWorkflowVariables,
   [ShareFile.id]: ShareFile,
+  [SteerAgent.id]: SteerAgent,
   [Table.id]: Table,
+  [TableAutomations.id]: TableAutomations,
+  [TableColumns.id]: TableColumns,
+  [TableEnrichments.id]: TableEnrichments,
+  [TableManage.id]: TableManage,
+  [TableRows.id]: TableRows,
+  [TableViews.id]: TableViews,
+  [TailAgent.id]: TailAgent,
   [Terminal.id]: Terminal,
   [UpdateDeploymentVersion.id]: UpdateDeploymentVersion,
   [UpdateWorkspaceMcpServer.id]: UpdateWorkspaceMcpServer,
   [UserTable.id]: UserTable,
   [Wait.id]: Wait,
+  [WaitAgents.id]: WaitAgents,
+  [WebCrawl.id]: WebCrawl,
+  [WebFetch.id]: WebFetch,
+  [WebScrape.id]: WebScrape,
+  [WebSearch.id]: WebSearch,
   [Workflow.id]: Workflow,
-  [WorkspaceFile.id]: WorkspaceFile,
 }
diff --git a/apps/sim/lib/copilot/generated/tool-schemas-v1.ts b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
index b2c3c73b66..a6070e7f09 100644
--- a/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
+++ b/apps/sim/lib/copilot/generated/tool-schemas-v1.ts
@@ -10,18 +10,37 @@ export interface ToolRuntimeSchemaEntry {
 }
 
 export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
-  agent: {
+  apply_file_edit: {
     parameters: {
+      type: 'object',
       properties: {
-        request: {
-          description: 'What tool/skill/MCP action is needed.',
+        content: {
           type: 'string',
+          description:
+            'The text content to write. For append: text to append. For update: full replacement text. For patch with search_replace: the replacement text. For patch with anchored: the insert/replacement text.',
         },
       },
-      required: ['request'],
+      required: ['content'],
+    },
+    resultSchema: {
       type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description:
+            'Optional operation metadata such as file id, file name, size, and content type.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable summary of the outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the content was applied successfully.',
+        },
+      },
+      required: ['success', 'message'],
     },
-    resultSchema: undefined,
   },
   auth: {
     parameters: {
@@ -195,6 +214,160 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
       required: ['dispatched'],
     },
   },
+  browser_click_at: {
+    parameters: {
+      type: 'object',
+      properties: {
+        clickCount: {
+          type: 'number',
+          description: '1 = single click (default), 2 = double-click, 3 = triple-click.',
+        },
+        x: {
+          type: 'number',
+          description:
+            "X in CSS pixels within the current viewport. When read off a browser_screenshot, divide the image pixel value by the screenshot's scale.",
+        },
+        y: {
+          type: 'number',
+          description:
+            'Y in CSS pixels within the current viewport, converted from screenshot pixels the same way as x.',
+        },
+      },
+      required: ['x', 'y'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        activeTab: {
+          type: 'object',
+          description: 'New active tab after a tab-changing click.',
+          properties: {
+            tabId: {
+              type: 'string',
+              description: 'Stable browser tab id.',
+            },
+            url: {
+              type: 'string',
+              description: 'New active tab URL.',
+            },
+          },
+        },
+        clickCount: {
+          type: 'number',
+          description: 'The click count that was dispatched (1, 2, or 3).',
+        },
+        clickedAt: {
+          type: 'object',
+          description: 'The CSS-pixel viewport point that was clicked.',
+          properties: {
+            x: {
+              type: 'number',
+              description: 'Clicked X in CSS viewport pixels.',
+            },
+            y: {
+              type: 'number',
+              description: 'Clicked Y in CSS viewport pixels.',
+            },
+          },
+        },
+        dialogs: {
+          type: 'array',
+          description: 'Visible DOM dialogs remaining after the click.',
+          items: {
+            type: 'string',
+          },
+        },
+        dispatched: {
+          type: 'boolean',
+          description: 'Whether the native pointer click was dispatched at the point.',
+        },
+        effect: {
+          type: 'object',
+          description:
+            'Detailed postcondition signals; generic title/DOM/scroll churn is weak evidence unless the tool documents otherwise.',
+          properties: {
+            dialogChanged: {
+              type: 'boolean',
+              description: 'The visible DOM dialog set changed.',
+            },
+            domChanged: {
+              type: 'boolean',
+              description: 'The DOM mutation revision changed; weak evidence on its own.',
+            },
+            fieldChanged: {
+              type: 'boolean',
+              description: 'The safely inspectable focused-field state changed.',
+            },
+            focusChanged: {
+              type: 'boolean',
+              description: 'The focused element changed.',
+            },
+            popupChanged: {
+              type: 'boolean',
+              description: 'The visible popup/menu set changed.',
+            },
+            scrollChanged: {
+              type: 'boolean',
+              description: 'A tracked scroll offset changed; weak evidence except for scroll keys.',
+            },
+            tabChanged: {
+              type: 'boolean',
+              description: 'The active browser tab changed.',
+            },
+            targetChanged: {
+              type: 'boolean',
+              description: "The requested target's checked/selected/expanded/open state changed.",
+            },
+            titleChanged: {
+              type: 'boolean',
+              description: 'The document title changed; weak evidence on its own.',
+            },
+            urlChanged: {
+              type: 'boolean',
+              description: 'The observed URL changed.',
+            },
+          },
+        },
+        effectObserved: {
+          type: 'boolean',
+          description:
+            'Whether a strong page change (URL/dialog/popup/target, or focus into an editable) followed the click.',
+        },
+        note: {
+          type: 'string',
+          description: 'Caution or follow-up guidance, present when the click needs verification.',
+        },
+        notices: {
+          type: 'array',
+          description:
+            'Pending auto-handled JavaScript alert/confirm/prompt notices since the previous successful browser result.',
+          items: {
+            type: 'string',
+          },
+        },
+        possibleEffectObserved: {
+          type: 'boolean',
+          description: 'Whether only weaker background churn (DOM/title) was observed.',
+        },
+        target: {
+          type: 'string',
+          description:
+            'What the point resolved to before the click (tag/role and accessible name) — confirm it matches the intended target.',
+        },
+        targetCursor: {
+          type: 'string',
+          description:
+            "The CSS cursor at the point (e.g. 'pointer', 'text', 'crosshair') — a hint about what kind of surface was hit.",
+        },
+        trusted: {
+          type: 'boolean',
+          description:
+            'True — coordinate and drag input always use the trusted Chromium pointer pipeline.',
+        },
+      },
+      required: ['dispatched'],
+    },
+  },
   browser_close_tab: {
     parameters: {
       type: 'object',
@@ -208,6 +381,171 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  browser_drag: {
+    parameters: {
+      type: 'object',
+      properties: {
+        fromElementId: {
+          type: 'number',
+          description:
+            'Drag source element id from the latest snapshot. Alternative to fromX/fromY.',
+        },
+        fromX: {
+          type: 'number',
+          description:
+            'Drag source X in CSS viewport pixels (paired with fromY) when no source element id is available.',
+        },
+        fromY: {
+          type: 'number',
+          description: 'Drag source Y in CSS viewport pixels.',
+        },
+        toElementId: {
+          type: 'number',
+          description: 'Drop target element id from the latest snapshot. Alternative to toX/toY.',
+        },
+        toX: {
+          type: 'number',
+          description: 'Drop target X in CSS viewport pixels (paired with toY).',
+        },
+        toY: {
+          type: 'number',
+          description: 'Drop target Y in CSS viewport pixels.',
+        },
+      },
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        dialogs: {
+          type: 'array',
+          description: 'Visible DOM dialogs remaining after the click.',
+          items: {
+            type: 'string',
+          },
+        },
+        dispatched: {
+          type: 'boolean',
+          description: 'Whether the full drag gesture was dispatched.',
+        },
+        effect: {
+          type: 'object',
+          description:
+            'Detailed postcondition signals; generic title/DOM/scroll churn is weak evidence unless the tool documents otherwise.',
+          properties: {
+            dialogChanged: {
+              type: 'boolean',
+              description: 'The visible DOM dialog set changed.',
+            },
+            domChanged: {
+              type: 'boolean',
+              description: 'The DOM mutation revision changed; weak evidence on its own.',
+            },
+            fieldChanged: {
+              type: 'boolean',
+              description: 'The safely inspectable focused-field state changed.',
+            },
+            focusChanged: {
+              type: 'boolean',
+              description: 'The focused element changed.',
+            },
+            popupChanged: {
+              type: 'boolean',
+              description: 'The visible popup/menu set changed.',
+            },
+            scrollChanged: {
+              type: 'boolean',
+              description: 'A tracked scroll offset changed; weak evidence except for scroll keys.',
+            },
+            tabChanged: {
+              type: 'boolean',
+              description: 'The active browser tab changed.',
+            },
+            targetChanged: {
+              type: 'boolean',
+              description: "The requested target's checked/selected/expanded/open state changed.",
+            },
+            titleChanged: {
+              type: 'boolean',
+              description: 'The document title changed; weak evidence on its own.',
+            },
+            urlChanged: {
+              type: 'boolean',
+              description: 'The observed URL changed.',
+            },
+          },
+        },
+        effectObserved: {
+          type: 'boolean',
+          description:
+            'Whether an observable page change (DOM/URL/dialog/target/scroll) followed the drag.',
+        },
+        from: {
+          type: 'object',
+          description: 'The resolved drag source.',
+          properties: {
+            element: {
+              type: 'string',
+              description: 'What that endpoint resolved to, when known.',
+            },
+            x: {
+              type: 'number',
+              description: 'Endpoint X in CSS viewport pixels.',
+            },
+            y: {
+              type: 'number',
+              description: 'Endpoint Y in CSS viewport pixels.',
+            },
+          },
+        },
+        nativeHtml5Drag: {
+          type: 'boolean',
+          description:
+            'True when the page started a native HTML5 drag and it was completed as a real drag-and-drop; false for a pointer-sensor drag.',
+        },
+        note: {
+          type: 'string',
+          description:
+            'Caution or follow-up guidance — e.g. verify the drop with a fresh snapshot when no effect was observed.',
+        },
+        notices: {
+          type: 'array',
+          description:
+            'Pending auto-handled JavaScript alert/confirm/prompt notices since the previous successful browser result.',
+          items: {
+            type: 'string',
+          },
+        },
+        possibleEffectObserved: {
+          type: 'boolean',
+          description: 'Whether only weaker background churn (DOM/title) was observed.',
+        },
+        to: {
+          type: 'object',
+          description: 'The resolved drop target.',
+          properties: {
+            element: {
+              type: 'string',
+              description: 'What that endpoint resolved to, when known.',
+            },
+            x: {
+              type: 'number',
+              description: 'Endpoint X in CSS viewport pixels.',
+            },
+            y: {
+              type: 'number',
+              description: 'Endpoint Y in CSS viewport pixels.',
+            },
+          },
+        },
+        trusted: {
+          type: 'boolean',
+          description:
+            'True — coordinate and drag input always use the trusted Chromium pointer pipeline.',
+        },
+      },
+      required: ['dispatched'],
+    },
+  },
   browser_extract: {
     parameters: {
       type: 'object',
@@ -391,6 +729,142 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
       required: ['hovered'],
     },
   },
+  browser_insert_text: {
+    parameters: {
+      type: 'object',
+      properties: {
+        submit: {
+          type: 'boolean',
+          description: 'Press Enter after inserting. Default false.',
+        },
+        text: {
+          type: 'string',
+          description: 'The text to insert at the caret. Must be non-empty.',
+        },
+      },
+      required: ['text'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        activeElement: {
+          type: 'string',
+          description: 'Focused element kind after the action.',
+        },
+        dispatched: {
+          type: 'boolean',
+          description: 'Whether the text was inserted through the native IME pipeline.',
+        },
+        effect: {
+          type: 'object',
+          description:
+            'Detailed postcondition signals; generic title/DOM/scroll churn is weak evidence unless the tool documents otherwise.',
+          properties: {
+            dialogChanged: {
+              type: 'boolean',
+              description: 'The visible DOM dialog set changed.',
+            },
+            domChanged: {
+              type: 'boolean',
+              description: 'The DOM mutation revision changed; weak evidence on its own.',
+            },
+            fieldChanged: {
+              type: 'boolean',
+              description: 'The safely inspectable focused-field state changed.',
+            },
+            focusChanged: {
+              type: 'boolean',
+              description: 'The focused element changed.',
+            },
+            popupChanged: {
+              type: 'boolean',
+              description: 'The visible popup/menu set changed.',
+            },
+            scrollChanged: {
+              type: 'boolean',
+              description: 'A tracked scroll offset changed; weak evidence except for scroll keys.',
+            },
+            tabChanged: {
+              type: 'boolean',
+              description: 'The active browser tab changed.',
+            },
+            targetChanged: {
+              type: 'boolean',
+              description: "The requested target's checked/selected/expanded/open state changed.",
+            },
+            titleChanged: {
+              type: 'boolean',
+              description: 'The document title changed; weak evidence on its own.',
+            },
+            urlChanged: {
+              type: 'boolean',
+              description: 'The observed URL changed.',
+            },
+          },
+        },
+        effectObserved: {
+          type: 'boolean',
+          description:
+            'Whether a field or page change confirmed the insertion. Canvas editors cannot echo one — verify visually.',
+        },
+        insertedChars: {
+          type: 'number',
+          description: 'How many characters were inserted.',
+        },
+        kind: {
+          type: 'string',
+          description:
+            'The kind of focused editable that received the text (input:*, textarea, contenteditable, canvas, textbox-role).',
+        },
+        note: {
+          type: 'string',
+          description:
+            'Caution or follow-up guidance, e.g. that a canvas editor needs visual verification.',
+        },
+        notices: {
+          type: 'array',
+          description:
+            'Pending auto-handled JavaScript alert/confirm/prompt notices since the previous successful browser result.',
+          items: {
+            type: 'string',
+          },
+        },
+        possibleEffectObserved: {
+          type: 'boolean',
+          description: 'Whether only weaker background churn was observed.',
+        },
+        redacted: {
+          type: 'boolean',
+          description: 'Whether sensitive focused-field details were withheld.',
+        },
+        selectedChars: {
+          type: 'number',
+          description: 'Number of selected characters when safely inspectable.',
+        },
+        submitDispatched: {
+          type: 'boolean',
+          description: 'Whether Enter was actually dispatched.',
+        },
+        submitRequested: {
+          type: 'boolean',
+          description: 'Whether Enter was requested after insertion.',
+        },
+        trusted: {
+          type: 'boolean',
+          description: 'True — insertion uses the trusted input pipeline.',
+        },
+        valueLength: {
+          type: 'number',
+          description: 'Focused non-secret field length when safely inspectable.',
+        },
+        valuePreview: {
+          type: 'string',
+          description: 'Bounded focused non-secret field preview when safely inspectable.',
+        },
+      },
+      required: ['dispatched'],
+    },
+  },
   browser_list_sessions: {
     parameters: {
       type: 'object',
@@ -629,26 +1103,6 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
       },
     },
   },
-  browser_request_takeover: {
-    parameters: {
-      type: 'object',
-      properties: {
-        purpose: {
-          type: 'string',
-          description:
-            'Why takeover is needed. Set sign_in for a login/password flow so the desktop can remember a privacy-preserving session hint after the user finishes.',
-          enum: ['sign_in', 'captcha', 'payment', 'sensitive_confirmation', 'other'],
-        },
-        reason: {
-          type: 'string',
-          description:
-            "Short explanation shown to the user of what they need to do (e.g. 'Sign in to Notion').",
-        },
-      },
-      required: ['reason'],
-    },
-    resultSchema: undefined,
-  },
   browser_screenshot: {
     parameters: {
       type: 'object',
@@ -1106,15 +1560,31 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  check_deployment_status: {
+  connect_slack_bot: {
     parameters: {
       type: 'object',
       properties: {
-        workflowId: {
+        botTokenEnvVar: {
           type: 'string',
-          description: 'Workflow ID to check (defaults to current workflow)',
+          description:
+            'NAME of the environment variable holding the bot token (xoxb-..., OAuth & Permissions → Bot User OAuth Token). Pass the variable name, never the token value.',
+        },
+        description: {
+          type: 'string',
+          description: 'Optional description shown on the credential.',
+        },
+        displayName: {
+          type: 'string',
+          description:
+            'Display name for the credential, shown in the credential picker (e.g. "Elder Bot"). Must be unique in the workspace.',
+        },
+        signingSecretEnvVar: {
+          type: 'string',
+          description:
+            "NAME of the environment variable holding the Slack app's signing secret (Basic Information → App Credentials). Pass the variable name, never the secret value.",
         },
       },
+      required: ['displayName', 'signingSecretEnvVar', 'botTokenEnvVar'],
     },
     resultSchema: undefined,
   },
@@ -1145,42 +1615,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  crawl_website: {
-    parameters: {
-      type: 'object',
-      properties: {
-        exclude_paths: {
-          type: 'array',
-          description: 'Skip URLs matching these patterns',
-          items: {
-            type: 'string',
-          },
-        },
-        include_paths: {
-          type: 'array',
-          description: 'Only crawl URLs matching these patterns',
-          items: {
-            type: 'string',
-          },
-        },
-        limit: {
-          type: 'number',
-          description: 'Maximum pages to crawl (default 10, max 50)',
-        },
-        max_depth: {
-          type: 'number',
-          description: 'How deep to follow links (default 2)',
-        },
-        url: {
-          type: 'string',
-          description: 'Starting URL to crawl from',
-        },
-      },
-      required: ['url'],
-    },
-    resultSchema: undefined,
-  },
-  create_file: {
+  create_empty_file: {
     parameters: {
       type: 'object',
       properties: {
@@ -1328,7 +1763,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  deploy_api: {
+  deploy_as_api: {
     parameters: {
       type: 'object',
       properties: {
@@ -1382,7 +1817,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         deploymentType: {
           type: 'string',
           description:
-            'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+            'Deployment surface this result describes. For deploy_as_api and redeploy this is always "api".',
         },
         examples: {
           type: 'object',
@@ -1412,7 +1847,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
       ],
     },
   },
-  deploy_chat: {
+  deploy_as_chat: {
     parameters: {
       type: 'object',
       properties: {
@@ -1526,7 +1961,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         deploymentType: {
           type: 'string',
           description:
-            'Deployment surface this result describes. For deploy_chat this is always "chat".',
+            'Deployment surface this result describes. For deploy_as_chat this is always "chat".',
         },
         examples: {
           type: 'object',
@@ -1547,7 +1982,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         },
         success: {
           type: 'boolean',
-          description: 'Whether the deploy_chat action completed successfully.',
+          description: 'Whether the deploy_as_chat action completed successfully.',
         },
         version: {
           type: 'number',
@@ -1571,134 +2006,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
       ],
     },
   },
-  deploy_custom_block: {
-    parameters: {
-      type: 'object',
-      properties: {
-        action: {
-          type: 'string',
-          description: 'Whether to publish (deploy) or unpublish (undeploy) the custom block',
-          enum: ['deploy', 'undeploy'],
-          default: 'deploy',
-        },
-        description: {
-          type: 'string',
-          description: 'Short description shown in the block picker, max 280 characters',
-        },
-        exposedOutputs: {
-          type: 'array',
-          description:
-            "Outputs the block exposes, each mapping a child block output path to a friendly name (use get_block_outputs for valid paths). Omit to expose the terminal block's whole result",
-          items: {
-            type: 'object',
-            properties: {
-              blockId: {
-                type: 'string',
-                description: 'Block UUID inside the workflow',
-              },
-              name: {
-                type: 'string',
-                description: 'Friendly output name shown on the block',
-              },
-              path: {
-                type: 'string',
-                description:
-                  "Dot-path into that block's output (from get_block_outputs relativeOutputs)",
-              },
-            },
-            required: ['blockId', 'path', 'name'],
-          },
-        },
-        iconUrl: {
-          type: 'string',
-          description:
-            'Optional icon image for the block: a workspace file VFS path (e.g. "files/icon.png", copied into public icon storage at publish) or an https image URL. Omit to use the organization\'s default icon',
-        },
-        inputs: {
-          type: 'array',
-          description:
-            "Optional per-input placeholder overrides. Input names and types are derived from the workflow's input trigger and cannot be changed here",
-          items: {
-            type: 'object',
-            properties: {
-              id: {
-                type: 'string',
-                description: 'Stable id of the input trigger field',
-              },
-              placeholder: {
-                type: 'string',
-                description: "Placeholder text shown in the block's input field",
-              },
-            },
-            required: ['id'],
-          },
-        },
-        name: {
-          type: 'string',
-          description:
-            'Display name for the block, max 60 characters. REQUIRED the first time a workflow is published. When republishing an existing block, omit it to keep the current name or pass a new one to rename. Ignored for undeploy.',
-        },
-        workflowId: {
-          type: 'string',
-          description: 'Workflow ID (defaults to active workflow)',
-        },
-      },
-    },
-    resultSchema: {
-      type: 'object',
-      properties: {
-        action: {
-          type: 'string',
-          description: 'Action performed by the tool, such as "deploy" or "undeploy".',
-        },
-        blockId: {
-          type: 'string',
-          description: 'Custom block record ID.',
-        },
-        blockType: {
-          type: 'string',
-          description: 'Stable block type slug (custom_block_*) used in workflow state.',
-        },
-        deploymentConfig: {
-          type: 'object',
-          description:
-            "Structured deployment configuration keyed by surface name. Includes the block's type, name, description, icon, derived input fields, and exposed outputs.",
-        },
-        deploymentStatus: {
-          type: 'object',
-          description:
-            'Structured per-surface deployment status keyed by surface name, including customBlock and the underlying api surface when applicable.',
-        },
-        deploymentType: {
-          type: 'string',
-          description:
-            'Deployment surface this result describes. For deploy_custom_block this is always "custom_block".',
-        },
-        isDeployed: {
-          type: 'boolean',
-          description: 'Whether the custom block is published after this tool call.',
-        },
-        name: {
-          type: 'string',
-          description: 'Display name of the custom block.',
-        },
-        removed: {
-          type: 'boolean',
-          description: 'Whether the custom block was unpublished during an undeploy action.',
-        },
-        updated: {
-          type: 'boolean',
-          description: 'Whether an existing custom block was updated instead of created.',
-        },
-        workflowId: {
-          type: 'string',
-          description: 'Workflow ID the custom block is bound to.',
-        },
-      },
-      required: ['deploymentType', 'deploymentStatus'],
-    },
-  },
-  deploy_mcp: {
+  deploy_as_mcp: {
     parameters: {
       type: 'object',
       properties: {
@@ -1773,7 +2081,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         deploymentType: {
           type: 'string',
           description:
-            'Deployment surface this result describes. For deploy_mcp this is always "mcp".',
+            'Deployment surface this result describes. For deploy_as_mcp this is always "mcp".',
         },
         examples: {
           type: 'object',
@@ -1844,7 +2152,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  download_to_workspace_file: {
+  download_file: {
     parameters: {
       type: 'object',
       properties: {
@@ -1893,38 +2201,6 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  edit_content: {
-    parameters: {
-      type: 'object',
-      properties: {
-        content: {
-          type: 'string',
-          description:
-            'The text content to write. For append: text to append. For update: full replacement text. For patch with search_replace: the replacement text. For patch with anchored: the insert/replacement text.',
-        },
-      },
-      required: ['content'],
-    },
-    resultSchema: {
-      type: 'object',
-      properties: {
-        data: {
-          type: 'object',
-          description:
-            'Optional operation metadata such as file id, file name, size, and content type.',
-        },
-        message: {
-          type: 'string',
-          description: 'Human-readable summary of the outcome.',
-        },
-        success: {
-          type: 'boolean',
-          description: 'Whether the content was applied successfully.',
-        },
-      },
-      required: ['success', 'message'],
-    },
-  },
   edit_workflow: {
     parameters: {
       type: 'object',
@@ -1948,7 +2224,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
               params: {
                 type: 'object',
                 description:
-                  'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)',
+                  'Parameters for the operation (optional).\nFor edit: {"inputs": {"temperature": 0.5}} NOT {"subBlocks": {"temperature": {"value": 0.5}}}\nFor add: {"type": "agent", "name": "My Agent", "inputs": {"model": "<model-id from agent.json>"}}\nFor delete: omit params entirely (none needed)\nBlock-level settings (retry, triggerMode, advancedMode) go beside "inputs", never inside it.',
               },
             },
             required: ['operation_type', 'block_id'],
@@ -1964,49 +2240,48 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  enrichment_run: {
+  extensions: {
+    parameters: {
+      properties: {
+        request: {
+          description: 'What tool/skill/MCP action is needed.',
+          type: 'string',
+        },
+        sessionId: {
+          description:
+            'Reusable session ID returned by an earlier extensions call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message. Omit it for a new or independent task.',
+          type: 'string',
+        },
+        title: {
+          description:
+            "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the extensions agent. When resuming with sessionId, copy the registry title unchanged.",
+          maxLength: 120,
+          type: 'string',
+        },
+      },
+      required: ['request', 'title'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  extract_doc_assets: {
     parameters: {
       type: 'object',
       properties: {
-        enrichmentId: {
+        destination: {
           type: 'string',
           description:
-            "Which enrichment to run. Discover the full set and each one's inputs/outputs via user_table.list_enrichments.",
-          enum: [
-            'work-email',
-            'phone-number',
-            'company-domain',
-            'company-info',
-            'email-verification',
-          ],
+            'Folder to write the extracted set into. Defaults to a "files/<Source Name> assets" folder next to the source.',
         },
-        inputs: {
-          type: 'object',
+        path: {
+          type: 'string',
           description:
-            'Map of the enrichment\'s input id → value, e.g. { "fullName": "Jane Doe", "companyDomain": "acme.com" }. Provide a value for every required input.',
+            'Workspace VFS path of the source document, e.g. files/Brand%20Deck.pptx. Must be an existing .pptx, .docx, or .pdf file.',
         },
       },
-      required: ['enrichmentId', 'inputs'],
-    },
-    resultSchema: {
-      type: 'object',
-      properties: {
-        matched: {
-          type: 'boolean',
-          description: 'True when a provider returned a non-empty result.',
-        },
-        provider: {
-          type: ['string', 'null'],
-          description:
-            'Internal label of the provider that produced the result (billing/diagnostics only — do NOT surface it to the user), or null on no match.',
-        },
-        result: {
-          type: 'object',
-          description: 'Mapped output values from the winning provider (empty object on no match).',
-        },
-      },
-      required: ['matched', 'result'],
+      required: ['path'],
     },
+    resultSchema: undefined,
   },
   ffmpeg: {
     parameters: {
@@ -2198,158 +2473,20 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             "Optional brief instruction (one short sentence) to scope the task. The agent inherits the full conversation history — do NOT restate or rewrite conversation content, only add scoping the history doesn't convey.",
           type: 'string',
         },
-      },
-      type: 'object',
-    },
-    resultSchema: undefined,
-  },
-  function_execute: {
-    parameters: {
-      type: 'object',
-      properties: {
-        code: {
+        sessionId: {
+          description:
+            'Reusable session ID returned by an earlier file call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message — the agent resumes from its saved transcript and receives unseen parent conversation messages. Omit it for a new or independent task.',
           type: 'string',
-          description:
-            'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with pre-installed CLI tools. Use each needed secret as {{VAR_NAME}}; the reference resolves to the value exactly as stored.',
-        },
-        inputs: {
-          type: 'object',
-          description:
-            'Workspace resources to mount into the sandbox. Copy paths verbatim from glob/read/grep output — they are percent-encoded per segment (spaces are %20, an in-name slash is %2F; parentheses and dots stay literal). Both the encoded path and the plain name resolve, so copy the returned path exactly rather than retyping or decoding it.',
-          properties: {
-            directories: {
-              type: 'array',
-              description:
-                'Workspace folders to mount recursively into the sandbox, including nested files and empty folders.',
-              items: {
-                type: 'object',
-                properties: {
-                  path: {
-                    type: 'string',
-                    description:
-                      'Canonical VFS folder path, e.g. "files/Reports". By default this mounts at "/home/user/{path}".',
-                  },
-                  sandboxPath: {
-                    type: 'string',
-                    description:
-                      'Optional full sandbox directory path override. Omit to mount at /home/user/{path}.',
-                  },
-                },
-                required: ['path'],
-              },
-            },
-            files: {
-              type: 'array',
-              description: 'Workspace files to mount into the sandbox.',
-              items: {
-                type: 'object',
-                properties: {
-                  path: {
-                    type: 'string',
-                    description:
-                      'Canonical VFS file path, e.g. "files/Reports/sales.csv". By default this mounts at "/home/user/{path}".',
-                  },
-                  sandboxPath: {
-                    type: 'string',
-                    description:
-                      'Full sandbox path to mount at, e.g. /home/user/inputs/data.csv. STRONGLY RECOMMENDED whenever the file name has spaces or special characters: the default mount path is the percent-ENCODED canonical path (e.g. /home/user/files/Q4%20Sales%20(Final).csv), which code using the human-readable name will not find. Set a simple sandboxPath and read exactly that.',
-                  },
-                },
-                required: ['path'],
-              },
-            },
-            tables: {
-              type: 'array',
-              description: 'Workspace tables to mount as CSV files.',
-              items: {
-                type: 'object',
-                properties: {
-                  path: {
-                    type: 'string',
-                    description: 'Canonical VFS table path when available.',
-                  },
-                  sandboxPath: {
-                    type: 'string',
-                    description: 'Optional full sandbox path for the mounted CSV.',
-                  },
-                  tableId: {
-                    type: 'string',
-                    description: 'Workspace table ID.',
-                  },
-                },
-              },
-            },
-          },
-        },
-        language: {
-          type: 'string',
-          description: 'Execution language.',
-          enum: ['javascript', 'python', 'shell'],
-        },
-        outputTable: {
-          type: 'string',
-          description:
-            'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
-        },
-        outputs: {
-          type: 'object',
-          description:
-            'Workspace files to create or overwrite from returned code results or sandbox-created files.',
-          properties: {
-            files: {
-              type: 'array',
-              description:
-                'File outputs. Missing parent folders are created automatically for create mode.',
-              items: {
-                type: 'object',
-                properties: {
-                  format: {
-                    type: 'string',
-                    description: 'Optional serialization format for returned values.',
-                    enum: ['json', 'csv', 'txt', 'md', 'html'],
-                  },
-                  mimeType: {
-                    type: 'string',
-                    description: 'Optional MIME type override when inference is not enough.',
-                  },
-                  mode: {
-                    type: 'string',
-                    description: 'Create a new file or overwrite an existing file at path.',
-                    enum: ['create', 'overwrite'],
-                  },
-                  path: {
-                    type: 'string',
-                    description: 'Canonical destination VFS path, e.g. "files/Reports/chart.png".',
-                  },
-                  sandboxPath: {
-                    type: 'string',
-                    description:
-                      'Optional full path to a file created inside the sandbox. Omit to save the code return value.',
-                  },
-                },
-                required: ['path', 'mode'],
-              },
-            },
-          },
-        },
-        sandboxId: {
-          type: 'string',
-          description:
-            'Optional Sim sandbox id from agent/sandboxes/{name}.json. DEFAULT-FIRST: omit this whenever the documented default function_execute environment can do the job. Select a ready existing Sim sandbox only when a required third-party dependency, Debian system package, or managed CLI is known to be absent, or a default attempt failed specifically because it was missing. Never guess an id.',
-        },
-        timeout: {
-          type: 'number',
-          description:
-            'Maximum execution time in SECONDS (Sim converts to milliseconds). The sandbox stops execution and returns a timeout error after this duration. Defaults to 10 seconds and is capped at 300 seconds regardless of plan.',
-          default: 10,
         },
         title: {
-          type: 'string',
           description:
-            'Short user-visible label for this execution, e.g. "Clean customer CSV", "Revenue chart", or "Query GitHub issues".',
+            "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the file agent. When resuming with sessionId, copy the registry title unchanged.",
+          maxLength: 120,
+          type: 'string',
         },
       },
-      required: ['code'],
+      required: ['title'],
+      type: 'object',
     },
     resultSchema: undefined,
   },
@@ -2877,54 +3014,18 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  get_deployment_log: {
+  get_deployment_status: {
     parameters: {
       type: 'object',
       properties: {
         workflowId: {
           type: 'string',
-          description:
-            'Optional workflow ID. If not provided, uses the current workflow in context.',
+          description: 'Workflow ID to check (defaults to current workflow)',
         },
       },
     },
     resultSchema: undefined,
   },
-  get_page_contents: {
-    parameters: {
-      type: 'object',
-      properties: {
-        include_highlights: {
-          type: 'boolean',
-          description: 'Include key highlights (default false)',
-        },
-        include_summary: {
-          type: 'boolean',
-          description: 'Include AI-generated summary (default false)',
-        },
-        include_text: {
-          type: 'boolean',
-          description: 'Include full page text (default true)',
-        },
-        urls: {
-          type: 'array',
-          description: 'URLs to get content from (max 10)',
-          items: {
-            type: 'string',
-          },
-        },
-      },
-      required: ['urls'],
-    },
-    resultSchema: undefined,
-  },
-  get_platform_actions: {
-    parameters: {
-      type: 'object',
-      properties: {},
-    },
-    resultSchema: undefined,
-  },
   get_workflow_data: {
     parameters: {
       type: 'object',
@@ -3007,12 +3108,12 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         path: {
           type: 'string',
           description:
-            "Optional scope. A prefix (e.g. 'workflows/', 'environment/', 'internal/') searches the VFS map under it. An exact single-file path under files/ or uploads/ (optionally with /content) searches that file's content only; folders and multi-file trees are rejected for content search.",
+            "Optional scope. A prefix (e.g. 'workflows/', 'environment/', 'internal/') searches the VFS map under it. An exact supported single-file path searches that file's content; folders and multi-file trees are rejected for content search.",
         },
         pattern: {
           type: 'string',
           description:
-            "Regex pattern to search for. Searches VFS map entries (workflow JSON, metadata, memories) by default; searches a single file's extracted text when path is one files/ or uploads/ file leaf.",
+            "Regex pattern to search for. Searches VFS map entries (workflow JSON, metadata, memories) by default, or an exact supported file leaf's content when path selects one.",
         },
         toolTitle: {
           type: 'string',
@@ -3024,6 +3125,24 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  interrupt_agent: {
+    parameters: {
+      type: 'object',
+      properties: {
+        agent_id: {
+          type: 'string',
+          description: 'The agent id to interrupt.',
+        },
+        reason: {
+          type: 'string',
+          description:
+            "Why you are stopping it, in a few words. Recorded in the agent's final status.",
+        },
+      },
+      required: ['agent_id'],
+    },
+    resultSchema: undefined,
+  },
   knowledge: {
     parameters: {
       properties: {
@@ -3031,204 +3150,35 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
           description: 'What knowledge base action is needed.',
           type: 'string',
         },
+        sessionId: {
+          description:
+            'Reusable session ID returned by an earlier knowledge call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message. Omit it for a new or independent task.',
+          type: 'string',
+        },
+        title: {
+          description:
+            "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the knowledge agent. When resuming with sessionId, copy the registry title unchanged.",
+          maxLength: 120,
+          type: 'string',
+        },
       },
-      required: ['request'],
+      required: ['request', 'title'],
       type: 'object',
     },
     resultSchema: undefined,
   },
-  knowledge_base: {
+  list_deployment_versions: {
     parameters: {
       type: 'object',
       properties: {
-        args: {
-          type: 'object',
-          description: 'Arguments for the operation',
-          properties: {
-            apiKey: {
-              type: 'string',
-              description:
-                'API key for API-key-based connectors (required when connector auth mode is apiKey)',
-            },
-            chunkingConfig: {
-              type: 'object',
-              description: "Chunking configuration (optional for 'create')",
-              properties: {
-                maxSize: {
-                  type: 'number',
-                  description: 'Maximum chunk size (100-4000, default: 1024)',
-                  default: 1024,
-                },
-                minSize: {
-                  type: 'number',
-                  description: 'Minimum chunk size (1-2000, default: 1)',
-                  default: 1,
-                },
-                overlap: {
-                  type: 'number',
-                  description: 'Overlap between chunks (0-500, default: 200)',
-                  default: 200,
-                },
-              },
-            },
-            connectorId: {
-              type: 'string',
-              description:
-                'Connector ID (required for update_connector, delete_connector, sync_connector)',
-            },
-            connectorStatus: {
-              type: 'string',
-              description: 'Connector status (optional for update_connector)',
-              enum: ['active', 'paused'],
-            },
-            connectorType: {
-              type: 'string',
-              description:
-                "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
-            },
-            credentialId: {
-              type: 'string',
-              description:
-                'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
-            },
-            description: {
-              type: 'string',
-              description: "Description of the knowledge base (optional for 'create')",
-            },
-            disabledTagIds: {
-              type: 'array',
-              description:
-                'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
-            },
-            documentId: {
-              type: 'string',
-              description: 'Document ID (required for update_document)',
-            },
-            documentIds: {
-              type: 'array',
-              description: 'Document IDs (for batch delete_document)',
-              items: {
-                type: 'string',
-              },
-            },
-            enabled: {
-              type: 'boolean',
-              description: 'Enable/disable a document (optional for update_document)',
-            },
-            filePaths: {
-              type: 'array',
-              description:
-                'Canonical workspace file VFS paths to add as documents (for add_file), e.g. ["files/Docs/handbook.pdf"].',
-              items: {
-                type: 'string',
-              },
-            },
-            filename: {
-              type: 'string',
-              description: 'New filename for a document (optional for update_document)',
-            },
-            knowledgeBaseId: {
-              type: 'string',
-              description:
-                'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
-            },
-            knowledgeBaseIds: {
-              type: 'array',
-              description: 'Knowledge base IDs (for batch delete)',
-              items: {
-                type: 'string',
-              },
-            },
-            name: {
-              type: 'string',
-              description: "Name of the knowledge base (required for 'create')",
-            },
-            query: {
-              type: 'string',
-              description: "Search query text (required for 'query')",
-            },
-            sourceConfig: {
-              type: 'object',
-              description:
-                'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
-            },
-            syncIntervalMinutes: {
-              type: 'number',
-              description:
-                'Sync interval in minutes. Accepted values: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
-              default: 1440,
-            },
-            tagDefinitionId: {
-              type: 'string',
-              description: 'Tag definition ID (required for update_tag, delete_tag)',
-            },
-            tagDisplayName: {
-              type: 'string',
-              description:
-                'Display name for the tag (required for create_tag, optional for update_tag)',
-            },
-            tagFieldType: {
-              type: 'string',
-              description:
-                'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
-              enum: ['text', 'number', 'date', 'boolean'],
-            },
-            topK: {
-              type: 'number',
-              description: 'Number of results to return (1-50, default: 5)',
-              default: 5,
-            },
-            workspaceId: {
-              type: 'string',
-              description:
-                "Workspace ID. Required for 'create' when there is no workspace in context; otherwise the current workspace context is used.",
-            },
-          },
-        },
-        operation: {
+        workflowId: {
           type: 'string',
-          description: 'The operation to perform',
-          enum: [
-            'create',
-            'get',
-            'query',
-            'add_file',
-            'update',
-            'delete_document',
-            'update_document',
-            'list_tags',
-            'create_tag',
-            'update_tag',
-            'delete_tag',
-            'get_tag_usage',
-            'add_connector',
-            'update_connector',
-            'delete_connector',
-            'sync_connector',
-          ],
-        },
-      },
-      required: ['operation'],
-    },
-    resultSchema: {
-      type: 'object',
-      properties: {
-        data: {
-          type: ['object', 'array'],
           description:
-            'Operation-specific result payload. An object for most operations; list_tags and get_tag_usage return an array of tag definitions.',
-        },
-        message: {
-          type: 'string',
-          description: 'Human-readable outcome summary.',
-        },
-        success: {
-          type: 'boolean',
-          description: 'Whether the operation succeeded.',
+            'Optional workflow ID. If not provided, uses the current workflow in context.',
         },
       },
-      required: ['success', 'message'],
     },
+    resultSchema: undefined,
   },
   list_integration_tools: {
     parameters: {
@@ -3244,13 +3194,6 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  list_user_workspaces: {
-    parameters: {
-      type: 'object',
-      properties: {},
-    },
-    resultSchema: undefined,
-  },
   list_workspace_mcp_servers: {
     parameters: {
       type: 'object',
@@ -3423,7 +3366,220 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  manage_mcp_tool: {
+  manage_knowledge_base: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            apiKey: {
+              type: 'string',
+              description:
+                'API key for API-key-based connectors (required when connector auth mode is apiKey). Accepts an environment-variable reference — {{NAME}} — resolved server-side from workspace/user environment variables; a raw key also works.',
+            },
+            chunkingConfig: {
+              type: 'object',
+              description: "Chunking configuration (optional for 'create')",
+              properties: {
+                maxSize: {
+                  type: 'number',
+                  description: 'Maximum chunk size (100-4000, default: 1024)',
+                  default: 1024,
+                },
+                minSize: {
+                  type: 'number',
+                  description: 'Minimum chunk size (1-2000, default: 100)',
+                  default: 1,
+                },
+                overlap: {
+                  type: 'number',
+                  description: 'Overlap between chunks (0-500, default: 200)',
+                  default: 200,
+                },
+              },
+            },
+            connectorId: {
+              type: 'string',
+              description:
+                'Connector ID (required for update_connector, delete_connector, sync_connector)',
+            },
+            connectorStatus: {
+              type: 'string',
+              description: 'Connector status (optional for update_connector)',
+              enum: ['active', 'paused'],
+            },
+            connectorType: {
+              type: 'string',
+              description:
+                "Connector type from registry, e.g. 'confluence', 'google_drive', 'notion' (required for add_connector). Read knowledgebases/connectors/{type}.json for the config schema.",
+            },
+            credentialId: {
+              type: 'string',
+              description:
+                'OAuth credential ID from environment/credentials.json (required for OAuth connectors)',
+            },
+            description: {
+              type: 'string',
+              description: "Description of the knowledge base (optional for 'create')",
+            },
+            disabledTagIds: {
+              type: 'array',
+              description:
+                'Tag definition IDs to opt out of (optional for add_connector). See tagDefinitions in the connector schema.',
+            },
+            documentId: {
+              type: 'string',
+              description: 'Document ID (required for update_document)',
+            },
+            documentIds: {
+              type: 'array',
+              description: 'Document IDs (for batch delete_document)',
+              items: {
+                type: 'string',
+              },
+            },
+            enabled: {
+              type: 'boolean',
+              description: 'Enable/disable a document (optional for update_document)',
+            },
+            filePaths: {
+              type: 'array',
+              description:
+                'Canonical workspace file VFS paths to add as documents (for add_file), e.g. ["files/Docs/handbook.pdf"].',
+              items: {
+                type: 'string',
+              },
+            },
+            filename: {
+              type: 'string',
+              description: 'New filename for a document (optional for update_document)',
+            },
+            knowledgeBaseId: {
+              type: 'string',
+              description:
+                'Knowledge base ID (required for get, query, add_file, list_tags, create_tag, get_tag_usage)',
+            },
+            knowledgeBaseIds: {
+              type: 'array',
+              description: 'Knowledge base IDs (for batch delete)',
+              items: {
+                type: 'string',
+              },
+            },
+            name: {
+              type: 'string',
+              description: "Name of the knowledge base (required for 'create')",
+            },
+            query: {
+              type: 'string',
+              description: "Search query text (required for 'query')",
+            },
+            sourceConfig: {
+              type: 'object',
+              description:
+                'Connector-specific configuration matching the configFields in knowledgebases/connectors/{type}.json',
+            },
+            syncIntervalMinutes: {
+              type: 'number',
+              description:
+                'Sync interval in minutes. Accepted values: 60 (hourly), 360 (6h), 1440 (daily), 10080 (weekly), 0 (manual only). Default: 1440',
+              default: 1440,
+            },
+            tagDefinitionId: {
+              type: 'string',
+              description: 'Tag definition ID (required for update_tag, delete_tag)',
+            },
+            tagDisplayName: {
+              type: 'string',
+              description:
+                'Display name for the tag (required for create_tag, optional for update_tag)',
+            },
+            tagFieldType: {
+              type: 'string',
+              description:
+                'Field type: text, number, date, boolean (optional for create_tag, defaults to text)',
+              enum: ['text', 'number', 'date', 'boolean'],
+            },
+            tagValues: {
+              type: 'array',
+              description:
+                'Typed tag values to set on this document (optional for update_document). Resolve tagDefinitionId with list_tags first. Use null to clear a value.',
+              items: {
+                type: 'object',
+                properties: {
+                  tagDefinitionId: {
+                    type: 'string',
+                    description: 'Tag definition ID returned by list_tags.',
+                  },
+                  value: {
+                    type: ['string', 'number', 'boolean', 'null'],
+                    description:
+                      "Value matching the tag definition's field type: string for text, number for number, YYYY-MM-DD string for date, boolean for boolean, or null to clear.",
+                  },
+                },
+                required: ['tagDefinitionId', 'value'],
+              },
+            },
+            topK: {
+              type: 'number',
+              description: 'Number of results to return (1-100, default: 5)',
+              default: 5,
+            },
+            workspaceId: {
+              type: 'string',
+              description:
+                "Workspace ID. Required for 'create' when there is no workspace in context; otherwise the current workspace context is used.",
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The operation to perform',
+          enum: [
+            'create',
+            'get',
+            'query',
+            'add_file',
+            'update',
+            'delete_document',
+            'update_document',
+            'list_tags',
+            'create_tag',
+            'update_tag',
+            'delete_tag',
+            'get_tag_usage',
+            'add_connector',
+            'update_connector',
+            'delete_connector',
+            'sync_connector',
+          ],
+        },
+      },
+      required: ['operation'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: ['object', 'array'],
+          description:
+            'Operation-specific result payload. An object for most operations; list_tags and get_tag_usage return an array of tag definitions.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  manage_mcp_connection: {
     parameters: {
       type: 'object',
       properties: {
@@ -3437,7 +3593,8 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             },
             headers: {
               type: 'object',
-              description: 'Optional HTTP headers to send with requests (key-value pairs)',
+              description:
+                'Optional HTTP headers to send with requests (key-value pairs). Values accept {{ENV_VAR}} references, resolved per-user at connect time — prefer them over pasting raw tokens.',
             },
             name: {
               type: 'string',
@@ -3562,30 +3719,6 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  materialize_file: {
-    parameters: {
-      type: 'object',
-      properties: {
-        fileNames: {
-          type: 'array',
-          description:
-            'The names of the uploaded files to materialize (e.g. ["report.pdf", "data.csv"])',
-          items: {
-            type: 'string',
-          },
-        },
-        operation: {
-          type: 'string',
-          description:
-            'What to do with the file. "save" promotes it to a permanent files/ path. "import" imports a workflow JSON as a workspace workflow. "extract" decompresses a .zip upload into files/<archive>/. Defaults to "save".',
-          enum: ['save', 'import', 'extract'],
-          default: 'save',
-        },
-      },
-      required: ['fileNames'],
-    },
-    resultSchema: undefined,
-  },
   media: {
     parameters: {
       properties: {
@@ -3706,6 +3839,11 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
                 description: 'The resource type.',
                 enum: ['workflow', 'table', 'knowledgebase', 'file', 'log'],
               },
+              view: {
+                type: 'string',
+                description:
+                  'Saved table view to open pinned (type "table" only): a view ID from the table\'s views.json. The panel opens the table with that view\'s filter/sort active. Omit to open the table on its default view.',
+              },
             },
             required: ['type'],
           },
@@ -3715,6 +3853,143 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  platform: {
+    parameters: {
+      properties: {
+        task: {
+          description:
+            "A fully self-contained question about Sim — the platform agent sees none of this conversation, so include every name, id, constraint, and prior finding it needs. Example: 'what is the minimum schedule-trigger interval, and does it differ by plan?' or 'does the agent block persist memory across runs?'.",
+          type: 'string',
+        },
+      },
+      required: ['task'],
+      type: 'object',
+    },
+    resultSchema: undefined,
+  },
+  prepare_file_edit: {
+    parameters: {
+      type: 'object',
+      properties: {
+        operation: {
+          type: 'string',
+          description: 'The file operation to perform.',
+          enum: ['append', 'update', 'patch'],
+        },
+        target: {
+          type: 'object',
+          description: 'Explicit file target. Use kind=path + path for existing files.',
+          properties: {
+            kind: {
+              type: 'string',
+              description: 'How the file target is identified.',
+              enum: ['path'],
+            },
+            path: {
+              type: 'string',
+              description:
+                'Canonical existing workspace file VFS path, e.g. "files/Reports/report.md". Required when target.kind=path.',
+            },
+          },
+          required: ['kind'],
+        },
+        title: {
+          type: 'string',
+          description:
+            'Required short UI label for this content unit, e.g. "Chapter 1", "Slide 3", or "Fix footer spacing".',
+        },
+        contentType: {
+          type: 'string',
+          description:
+            'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
+          enum: [
+            'text/markdown',
+            'text/html',
+            'text/plain',
+            'application/json',
+            'text/csv',
+            'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'application/pdf',
+          ],
+        },
+        edit: {
+          type: 'object',
+          description:
+            'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. The actual replacement/insert content is provided via the paired apply_file_edit tool call.',
+          properties: {
+            after_anchor: {
+              type: 'string',
+              description:
+                'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
+            },
+            anchor: {
+              type: 'string',
+              description:
+                'Anchor line after which new content is inserted. Required for mode=insert_after.',
+            },
+            before_anchor: {
+              type: 'string',
+              description:
+                'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
+            },
+            end_anchor: {
+              type: 'string',
+              description: 'First line to keep after deletion. Required for mode=delete_between.',
+            },
+            mode: {
+              type: 'string',
+              description: 'Anchored edit mode when strategy=anchored.',
+              enum: ['replace_between', 'insert_after', 'delete_between'],
+            },
+            occurrence: {
+              type: 'number',
+              description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
+            },
+            replaceAll: {
+              type: 'boolean',
+              description:
+                'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
+            },
+            search: {
+              type: 'string',
+              description:
+                'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
+            },
+            start_anchor: {
+              type: 'string',
+              description: 'First line to delete. Required for mode=delete_between.',
+            },
+            strategy: {
+              type: 'string',
+              description: 'Patch strategy.',
+              enum: ['search_replace', 'anchored'],
+            },
+          },
+        },
+      },
+      required: ['operation', 'target', 'title'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description:
+            'Optional operation metadata such as file id, file name, size, and content type.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable summary of the outcome.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the file operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
   promote_to_live: {
     parameters: {
       type: 'object',
@@ -3734,6 +4009,133 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  publish_custom_block: {
+    parameters: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Whether to publish (deploy) or unpublish (undeploy) the custom block',
+          enum: ['deploy', 'undeploy'],
+          default: 'deploy',
+        },
+        description: {
+          type: 'string',
+          description: 'Short description shown in the block picker, max 280 characters',
+        },
+        exposedOutputs: {
+          type: 'array',
+          description:
+            "Outputs the block exposes, each mapping a child block output path to a friendly name (use get_block_outputs for valid paths). Omit to expose the terminal block's whole result",
+          items: {
+            type: 'object',
+            properties: {
+              blockId: {
+                type: 'string',
+                description: 'Block UUID inside the workflow',
+              },
+              name: {
+                type: 'string',
+                description: 'Friendly output name shown on the block',
+              },
+              path: {
+                type: 'string',
+                description:
+                  "Dot-path into that block's output (from get_block_outputs relativeOutputs)",
+              },
+            },
+            required: ['blockId', 'path', 'name'],
+          },
+        },
+        iconUrl: {
+          type: 'string',
+          description:
+            'Optional icon image for the block: a workspace file VFS path (e.g. "files/icon.png", copied into public icon storage at publish) or an https image URL. Omit to use the organization\'s default icon',
+        },
+        inputs: {
+          type: 'array',
+          description:
+            "Optional per-input placeholder overrides. Input names and types are derived from the workflow's input trigger and cannot be changed here",
+          items: {
+            type: 'object',
+            properties: {
+              id: {
+                type: 'string',
+                description: 'Stable id of the input trigger field',
+              },
+              placeholder: {
+                type: 'string',
+                description: "Placeholder text shown in the block's input field",
+              },
+            },
+            required: ['id'],
+          },
+        },
+        name: {
+          type: 'string',
+          description:
+            'Display name for the block, max 60 characters. REQUIRED the first time a workflow is published. When republishing an existing block, omit it to keep the current name or pass a new one to rename. Ignored for undeploy.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID (defaults to active workflow)',
+        },
+      },
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          description: 'Action performed by the tool, such as "deploy" or "undeploy".',
+        },
+        blockId: {
+          type: 'string',
+          description: 'Custom block record ID.',
+        },
+        blockType: {
+          type: 'string',
+          description: 'Stable block type slug (custom_block_*) used in workflow state.',
+        },
+        deploymentConfig: {
+          type: 'object',
+          description:
+            "Structured deployment configuration keyed by surface name. Includes the block's type, name, description, icon, derived input fields, and exposed outputs.",
+        },
+        deploymentStatus: {
+          type: 'object',
+          description:
+            'Structured per-surface deployment status keyed by surface name, including customBlock and the underlying api surface when applicable.',
+        },
+        deploymentType: {
+          type: 'string',
+          description:
+            'Deployment surface this result describes. For publish_custom_block this is always "custom_block".',
+        },
+        isDeployed: {
+          type: 'boolean',
+          description: 'Whether the custom block is published after this tool call.',
+        },
+        name: {
+          type: 'string',
+          description: 'Display name of the custom block.',
+        },
+        removed: {
+          type: 'boolean',
+          description: 'Whether the custom block was unpublished during an undeploy action.',
+        },
+        updated: {
+          type: 'boolean',
+          description: 'Whether an existing custom block was updated instead of created.',
+        },
+        workflowId: {
+          type: 'string',
+          description: 'Workflow ID the custom block is bound to.',
+        },
+      },
+      required: ['deploymentType', 'deploymentStatus'],
+    },
+  },
   query_logs: {
     parameters: {
       type: 'object',
@@ -3742,10 +4144,24 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
           type: 'string',
           description: "Optional (view='full'): only return this block's span subtree.",
         },
+        blockIds: {
+          type: 'array',
+          description:
+            "(view='full') Block ids to drill into, copied from the trace digest's blockId values. Preferred over blockName; several at once is fine.",
+          items: {
+            type: 'string',
+          },
+        },
         blockName: {
           type: 'string',
           description: "Optional (view='full'): only return spans for this block name.",
         },
+        bucket: {
+          type: 'string',
+          description:
+            "(view='stats') Calendar bucketing for the per-workflow series: 'day' or 'hour'. Omit for overall totals only.",
+          enum: ['day', 'hour'],
+        },
         costOperator: {
           type: 'string',
           description: "Filter (view='list'): comparison operator for cost.",
@@ -3771,25 +4187,34 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         },
         endDate: {
           type: 'string',
-          description: "Filter (view='list'): ISO end of the time range.",
+          description: "Filter (view='list'/'stats'): ISO end of the time range.",
         },
         executionId: {
           type: 'string',
           description:
-            "Required for 'overview'/'full': the execution to read. For 'list', an optional exact-match filter.",
+            "Required for 'trace'/'overview'/'full': the execution to read. For 'list', an optional exact-match filter.",
+        },
+        fields: {
+          type: 'array',
+          description:
+            "(view='full') Only load these payload fields per span: whole keys ('input', 'output', 'error') or dotted paths into them ('output.result.rows', 'input.query'). Dotted selections come back under 'selected' keyed by path. Use this to pull just the field you need instead of a block's entire I/O.",
+          items: {
+            type: 'string',
+          },
         },
         folderIds: {
           type: 'string',
-          description: "Filter (view='list'): comma-separated folder IDs (descendants included).",
+          description:
+            "Filter (view='list'/'stats'): comma-separated folder IDs (descendants included).",
         },
         folderName: {
           type: 'string',
-          description: "Filter (view='list'): substring match on folder name.",
+          description: "Filter (view='list'/'stats'): substring match on folder name.",
         },
         level: {
           type: 'string',
           description:
-            "Filter (view='list'): comma-separated levels: error, info, running, pending. Default all.",
+            "Filter (view='list'/'stats'): comma-separated levels: error, info, running, pending. Default all.",
         },
         limit: {
           type: 'number',
@@ -3816,32 +4241,41 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         },
         startDate: {
           type: 'string',
-          description: "Filter (view='list'): ISO start of the time range.",
+          description: "Filter (view='list'/'stats'): ISO start of the time range.",
+        },
+        timezone: {
+          type: 'string',
+          description:
+            '(view=\'stats\') IANA timezone the buckets are computed in, e.g. "America/Los_Angeles". Defaults to UTC. Set this whenever the user\'s question is about "today"/"yesterday" in their local time.',
+        },
+        title: {
+          type: 'string',
+          description:
+            'Short human-readable label for this query, shown as the tool row in the UI, e.g. "Counting Elder failures Aug 12-13" or "Reading the failed enrichment run". Always provide one — it is how the user follows what you are looking for.',
         },
         triggers: {
           type: 'string',
-          description: "Filter (view='list'): comma-separated trigger types.",
+          description: "Filter (view='list'/'stats'): comma-separated trigger types.",
         },
         view: {
           type: 'string',
           description:
-            "Disclosure level: 'list' (summaries), 'overview' (one execution's trace tree, no I/O), or 'full' (one execution's trace spans with I/O).",
-          enum: ['list', 'overview', 'full'],
+            "Disclosure level: 'stats' (aggregate counts), 'list' (summaries), 'trace' (one execution's condensed block digest), 'overview' (trace tree, no I/O), 'full' (spans with I/O). Defaults to 'trace' with executionId, else 'list'.",
+          enum: ['list', 'stats', 'trace', 'overview', 'full'],
         },
         workflowIds: {
           type: 'string',
-          description: "Filter (view='list'): comma-separated workflow IDs.",
+          description: "Filter (view='list'/'stats'): comma-separated workflow IDs.",
         },
         workflowName: {
           type: 'string',
-          description: "Filter (view='list'): substring match on workflow name.",
+          description: "Filter (view='list'/'stats'): substring match on workflow name.",
         },
         workspaceId: {
           type: 'string',
           description: 'Workspace ID to scope to.',
         },
       },
-      required: ['view'],
     },
     resultSchema: undefined,
   },
@@ -3866,7 +4300,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             limit: {
               type: 'number',
               description:
-                'Maximum rows per page for query_rows (optional). Omit to fetch the ENTIRE matching result in one response — the call fails if the result exceeds the 5MB budget (narrow with a filter or set a limit). With a limit, a page may end early at the byte budget with more remaining; a non-null nextCursor in the result means more rows exist (continue with cursor).',
+                'Maximum rows per page for query_rows (optional, max 1000). Omitting it uses the 1000-row default page — the ENTIRE result is never returned in one call; a non-null nextCursor in the result means more rows exist (continue with cursor). A page may also end early at the byte budget with more remaining.',
             },
             order: {
               type: 'array',
@@ -3881,6 +4315,11 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
               type: 'string',
               description: 'Table ID (required for all operations)',
             },
+            view: {
+              type: 'string',
+              description:
+                "Saved view to query through (query_rows only): a view ID from the table's views.json. The view's saved filter ANDs with any filter you pass (query-within-the-view); its saved sort applies only when you pass no order. Layout fields (hidden columns, widths) are ignored — full rows come back. Manage views via the table agent.",
+            },
           },
         },
         operation: {
@@ -3986,7 +4425,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         deploymentType: {
           type: 'string',
           description:
-            'Deployment surface this result describes. For deploy_api and redeploy this is always "api".',
+            'Deployment surface this result describes. For deploy_as_api and redeploy this is always "api".',
         },
         examples: {
           type: 'object',
@@ -4058,7 +4497,16 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         type: {
           type: 'string',
           description: 'The resource type to restore.',
-          enum: ['workflow', 'table', 'file', 'knowledgebase', 'folder', 'file_folder'],
+          enum: [
+            'workflow',
+            'table',
+            'file',
+            'knowledgebase',
+            'folder',
+            'file_folder',
+            'table_folder',
+            'knowledge_folder',
+          ],
         },
       },
       required: ['type', 'id'],
@@ -4125,14 +4573,14 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         workflowId: {
           type: 'string',
           description:
-            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+            'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
         },
         workflow_input: {
           type: 'object',
           description: 'JSON object with key-value mappings where each key is an input field name',
         },
       },
-      required: ['blockId'],
+      required: ['workflowId', 'blockId'],
     },
     resultSchema: undefined,
   },
@@ -4229,6 +4677,50 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  run_enrichment: {
+    parameters: {
+      type: 'object',
+      properties: {
+        enrichmentId: {
+          type: 'string',
+          description:
+            "Which enrichment to run. Discover the full set and each one's inputs/outputs via table_enrichments.list_enrichments.",
+          enum: [
+            'work-email',
+            'phone-number',
+            'company-domain',
+            'company-info',
+            'email-verification',
+          ],
+        },
+        inputs: {
+          type: 'object',
+          description:
+            'Map of the enrichment\'s input id → value, e.g. { "fullName": "Jane Doe", "companyDomain": "acme.com" }. Provide a value for every required input.',
+        },
+      },
+      required: ['enrichmentId', 'inputs'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        matched: {
+          type: 'boolean',
+          description: 'True when a provider returned a non-empty result.',
+        },
+        provider: {
+          type: ['string', 'null'],
+          description:
+            'Internal label of the provider that produced the result (billing/diagnostics only — do NOT surface it to the user), or null on no match.',
+        },
+        result: {
+          type: 'object',
+          description: 'Mapped output values from the winning provider (empty object on no match).',
+        },
+      },
+      required: ['matched', 'result'],
+    },
+  },
   run_from_block: {
     parameters: {
       type: 'object',
@@ -4250,14 +4742,164 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         workflowId: {
           type: 'string',
           description:
-            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+            'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
         },
         workflow_input: {
           type: 'object',
           description: 'JSON object with key-value mappings where each key is an input field name',
         },
       },
-      required: ['startBlockId'],
+      required: ['workflowId', 'startBlockId'],
+    },
+    resultSchema: undefined,
+  },
+  run_function: {
+    parameters: {
+      type: 'object',
+      properties: {
+        code: {
+          type: 'string',
+          description:
+            'Code to execute. For JS: raw statements auto-wrapped in async context. For Python: full script. For shell: bash script with pre-installed CLI tools. Use each needed secret as {{VAR_NAME}}; the reference resolves to the value exactly as stored.',
+        },
+        inputs: {
+          type: 'object',
+          description:
+            'Workspace resources to mount into the sandbox. Copy paths verbatim from glob/read/grep output — they are percent-encoded per segment (spaces are %20, an in-name slash is %2F; parentheses and dots stay literal). Both the encoded path and the plain name resolve, so copy the returned path exactly rather than retyping or decoding it.',
+          properties: {
+            directories: {
+              type: 'array',
+              description:
+                'Workspace folders to mount recursively into the sandbox, including nested files and empty folders.',
+              items: {
+                type: 'object',
+                properties: {
+                  path: {
+                    type: 'string',
+                    description:
+                      'Canonical VFS folder path, e.g. "files/Reports". By default this mounts at "/home/user/{path}".',
+                  },
+                  sandboxPath: {
+                    type: 'string',
+                    description:
+                      'Optional full sandbox directory path override. Omit to mount at /home/user/{path}.',
+                  },
+                },
+                required: ['path'],
+              },
+            },
+            files: {
+              type: 'array',
+              description: 'Workspace files to mount into the sandbox.',
+              items: {
+                type: 'object',
+                properties: {
+                  path: {
+                    type: 'string',
+                    description:
+                      'Canonical VFS file path, e.g. "files/Reports/sales.csv". By default this mounts at "/home/user/{path}".',
+                  },
+                  sandboxPath: {
+                    type: 'string',
+                    description:
+                      'Full sandbox path to mount at, e.g. /home/user/inputs/data.csv. STRONGLY RECOMMENDED whenever the file name has spaces or special characters: the default mount path is the percent-ENCODED canonical path (e.g. /home/user/files/Q4%20Sales%20(Final).csv), which code using the human-readable name will not find. Set a simple sandboxPath and read exactly that.',
+                  },
+                },
+                required: ['path'],
+              },
+            },
+            tables: {
+              type: 'array',
+              description: 'Workspace tables to mount as CSV files.',
+              items: {
+                type: 'object',
+                properties: {
+                  path: {
+                    type: 'string',
+                    description: 'Canonical VFS table path when available.',
+                  },
+                  sandboxPath: {
+                    type: 'string',
+                    description: 'Optional full sandbox path for the mounted CSV.',
+                  },
+                  tableId: {
+                    type: 'string',
+                    description: 'Workspace table ID.',
+                  },
+                },
+              },
+            },
+          },
+        },
+        language: {
+          type: 'string',
+          description: 'Execution language.',
+          enum: ['javascript', 'python', 'shell'],
+        },
+        outputTable: {
+          type: 'string',
+          description:
+            'Table ID to overwrite with the code\'s return value. Code MUST return an array of objects where keys match column names. All existing rows are replaced. Example: "tbl_abc123"',
+        },
+        outputs: {
+          type: 'object',
+          description:
+            'Workspace files to create or overwrite from returned code results or sandbox-created files.',
+          properties: {
+            files: {
+              type: 'array',
+              description:
+                'File outputs. Missing parent folders are created automatically for create mode.',
+              items: {
+                type: 'object',
+                properties: {
+                  format: {
+                    type: 'string',
+                    description: 'Optional serialization format for returned values.',
+                    enum: ['json', 'csv', 'txt', 'md', 'html'],
+                  },
+                  mimeType: {
+                    type: 'string',
+                    description: 'Optional MIME type override when inference is not enough.',
+                  },
+                  mode: {
+                    type: 'string',
+                    description: 'Create a new file or overwrite an existing file at path.',
+                    enum: ['create', 'overwrite'],
+                  },
+                  path: {
+                    type: 'string',
+                    description: 'Canonical destination VFS path, e.g. "files/Reports/chart.png".',
+                  },
+                  sandboxPath: {
+                    type: 'string',
+                    description:
+                      'Optional full path to a file created inside the sandbox. Omit to save the code return value.',
+                  },
+                },
+                required: ['path', 'mode'],
+              },
+            },
+          },
+        },
+        sandboxId: {
+          type: 'string',
+          description:
+            'Optional Sim sandbox id from agent/sandboxes/{name}.json. DEFAULT-FIRST: omit this whenever the documented default run_function environment can do the job. Select a ready existing Sim sandbox only when a required third-party dependency, Debian system package, or managed CLI is known to be absent, or a default attempt failed specifically because it was missing. Never guess an id.',
+        },
+        timeout: {
+          type: 'number',
+          description:
+            'Maximum execution time in SECONDS (Sim converts to milliseconds). The sandbox stops execution and returns a timeout error after this duration. Defaults to 10 seconds and is capped at 300 seconds regardless of plan.',
+          default: 10,
+        },
+        title: {
+          type: 'string',
+          description:
+            'Short user-visible label for this execution, e.g. "Clean customer CSV", "Revenue chart", or "Query GitHub issues".',
+        },
+      },
+      required: ['code'],
     },
     resultSchema: undefined,
   },
@@ -4293,7 +4935,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         workflowId: {
           type: 'string',
           description:
-            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+            'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
         },
         workflow_input: {
           type: 'object',
@@ -4301,6 +4943,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             "JSON object matching the target trigger's inputSchema (from get_workflow_run_options). For external/webhook triggers this is the event payload; for API/Input triggers it is the form fields.",
         },
       },
+      required: ['workflowId'],
     },
     resultSchema: undefined,
   },
@@ -4335,7 +4978,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         workflowId: {
           type: 'string',
           description:
-            'Optional workflow ID to run. If not provided, uses the current workflow in context.',
+            'ID of the workflow to run. Always pass this explicitly — outside a workflow-scoped chat there is no current workflow to fall back to, and the run is rejected without it.',
         },
         workflow_input: {
           type: 'object',
@@ -4343,28 +4986,31 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
             "JSON object matching the target trigger's inputSchema (from get_workflow_run_options). For external/webhook triggers this is the event payload; for API/Input triggers it is the form fields.",
         },
       },
-      required: ['stopAfterBlockId'],
+      required: ['workflowId', 'stopAfterBlockId'],
     },
     resultSchema: undefined,
   },
-  scrape_page: {
+  save_upload: {
     parameters: {
       type: 'object',
       properties: {
-        include_links: {
-          type: 'boolean',
-          description: 'Extract all links from the page (default false)',
+        fileNames: {
+          type: 'array',
+          description:
+            'The names of the uploaded files to materialize (e.g. ["report.pdf", "data.csv"])',
+          items: {
+            type: 'string',
+          },
         },
-        url: {
+        operation: {
           type: 'string',
-          description: 'The URL to scrape (must include https://)',
-        },
-        wait_for: {
-          type: 'string',
-          description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+          description:
+            'What to do with the file. "save" promotes it to a permanent files/ path. "import" imports a workflow JSON as a workspace workflow. "extract" decompresses a .zip upload into files/<archive>/. Defaults to "save".',
+          enum: ['save', 'import', 'extract'],
+          default: 'save',
         },
       },
-      required: ['url'],
+      required: ['fileNames'],
     },
     resultSchema: undefined,
   },
@@ -4382,19 +5028,23 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  search_documentation: {
+  search_docs: {
     parameters: {
       type: 'object',
       properties: {
+        path: {
+          type: 'string',
+          description:
+            'Optional docs/ VFS path (a page such as docs/workflows/blocks/agent.mdx, or a section such as docs/workflows) that limits the search scope',
+        },
         query: {
           type: 'string',
           description: 'The search query',
         },
         topK: {
           type: 'number',
-          description:
-            'Number of results to return (default 10). Not clamped — keep it small, since each result is a full doc chunk.',
-          default: 10,
+          description: 'Number of results (default 5, max 25)',
+          default: 5,
         },
       },
       required: ['query'],
@@ -4498,68 +5148,6 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  search_online: {
-    parameters: {
-      type: 'object',
-      properties: {
-        category: {
-          type: 'string',
-          description: 'Filter by category',
-          enum: [
-            'news',
-            'tweet',
-            'github',
-            'company',
-            'research paper',
-            'linkedin profile',
-            'pdf',
-            'personal site',
-          ],
-        },
-        include_text: {
-          type: 'boolean',
-          description: 'Include page text content (default true)',
-        },
-        num_results: {
-          type: 'number',
-          description: 'Number of results (default 10, max 25)',
-        },
-        query: {
-          type: 'string',
-          description: 'Natural language search query',
-        },
-        toolTitle: {
-          type: 'string',
-          description:
-            "Required short UI label fragment (e.g. 'Slack integrations'), not a full sentence.",
-        },
-      },
-      required: ['query', 'toolTitle'],
-    },
-    resultSchema: undefined,
-  },
-  search_patterns: {
-    parameters: {
-      type: 'object',
-      properties: {
-        limit: {
-          type: 'integer',
-          description: 'Maximum number of pattern examples to return per query (defaults to 3).',
-        },
-        queries: {
-          type: 'array',
-          description:
-            'Up to 3 descriptive strings explaining the workflow pattern(s) you need. Focus on intent and desired outcomes.',
-          items: {
-            type: 'string',
-            description: 'Example: "how to automate wealthbox meeting notes into follow-up tasks"',
-          },
-        },
-      },
-      required: ['queries'],
-    },
-    resultSchema: undefined,
-  },
   set_block_enabled: {
     parameters: {
       type: 'object',
@@ -4721,6 +5309,24 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
       required: ['success', 'message'],
     },
   },
+  steer_agent: {
+    parameters: {
+      type: 'object',
+      properties: {
+        agent_id: {
+          type: 'string',
+          description: 'The agent id to steer.',
+        },
+        content: {
+          type: 'string',
+          description:
+            'The instruction to deliver, phrased as you would brief a teammate mid-task.',
+        },
+      },
+      required: ['agent_id', 'content'],
+    },
+    resultSchema: undefined,
+  },
   table: {
     parameters: {
       properties: {
@@ -4728,12 +5334,696 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
           description: 'What table action is needed.',
           type: 'string',
         },
+        sessionId: {
+          description:
+            'Reusable session ID returned by an earlier table call in this chat. Supply it only on a later user message that continues the same task, and at most once per user message. Omit it for a new or independent task.',
+          type: 'string',
+        },
+        title: {
+          description:
+            "Required private orchestration label (3–8 words) for this session's stable objective. Stored in the request-local, chat-scoped Subagent Registry supplied only to the main orchestrator; not shown to the table agent. When resuming with sessionId, copy the registry title unchanged.",
+          maxLength: 120,
+          type: 'string',
+        },
       },
-      required: ['request'],
+      required: ['request', 'title'],
       type: 'object',
     },
     resultSchema: undefined,
   },
+  table_automations: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            autoRun: {
+              type: 'boolean',
+              description:
+                "On add: true fires dep-satisfied rows immediately (only when the user explicitly asked); default false stages silently. On update: toggles the group's auto-fire on dep satisfaction.",
+            },
+            blockId: {
+              type: 'string',
+              description: 'Source block ID inside the workflow (add_workflow_group_output)',
+            },
+            columnName: {
+              type: 'string',
+              description:
+                'Target column name: required for delete_workflow_group_output (the bound column to drop); optional for add_workflow_group_output (auto-derived from path)',
+            },
+            dependencies: {
+              type: 'object',
+              description:
+                'Dependencies before a row runs: { columns?: string[] } of input column names that must be filled. Output columns of upstream groups are valid; a group cannot depend on its own outputs.',
+              properties: {
+                columns: {
+                  type: 'array',
+                  description:
+                    'Input column names that must be filled before the group runs a row.',
+                  items: {
+                    type: 'string',
+                  },
+                },
+              },
+            },
+            deploymentMode: {
+              type: 'string',
+              description:
+                'Which workflow version rows execute: "live" (default, editable draft — edits take effect immediately) or "deployed" (latest active deployment; fails if the workflow was never deployed).',
+              enum: ['live', 'deployed'],
+            },
+            groupId: {
+              type: 'string',
+              description:
+                'Workflow group ID (required for update_workflow_group, delete_workflow_group, add_workflow_group_output, delete_workflow_group_output)',
+            },
+            groupIds: {
+              type: 'array',
+              description: 'Workflow group IDs to fire (required for run_column, non-empty)',
+              items: {
+                type: 'string',
+              },
+            },
+            mappingUpdates: {
+              type: 'array',
+              description:
+                'Surgical per-output remap for update_workflow_group: each entry repoints ONE existing output column to a new (blockId, path) without touching the rest. Stale cells clear and backfill from saved execution logs where possible. Discover valid pairs via list_workflow_outputs first.',
+              items: {
+                type: 'object',
+                properties: {
+                  blockId: {
+                    type: 'string',
+                    description: 'New source block ID for this column.',
+                  },
+                  columnName: {
+                    type: 'string',
+                    description:
+                      'The existing output column to remap (must be bound to this group).',
+                  },
+                  path: {
+                    type: 'string',
+                    description: 'New dotted output path on the new block.',
+                  },
+                },
+                required: ['columnName', 'blockId', 'path'],
+              },
+            },
+            name: {
+              type: 'string',
+              description: 'Display name for the group (optional on add/update)',
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+            },
+            outputs: {
+              type: 'array',
+              description:
+                'Outputs to surface as columns for add_workflow_group: each { blockId, path, columnName?, columnType? }; columnName auto-derives from path, columnType from the leaf type. Validated against list_workflow_outputs — invalid picks return the valid options. For update_workflow_group prefer add/delete_workflow_group_output and mappingUpdates; pass outputs only to restructure the whole set.',
+              items: {
+                type: 'object',
+                properties: {
+                  blockId: {
+                    type: 'string',
+                    description: 'Source block ID inside the workflow.',
+                  },
+                  columnName: {
+                    type: 'string',
+                    description:
+                      'Optional target column name; auto-derived from the path when omitted.',
+                  },
+                  columnType: {
+                    type: 'string',
+                    description: 'Optional column type; defaults from the leaf type when omitted.',
+                    enum: ['string', 'number', 'boolean', 'date', 'json'],
+                  },
+                  path: {
+                    type: 'string',
+                    description: 'Dotted output path on the block.',
+                  },
+                },
+                required: ['blockId', 'path'],
+              },
+            },
+            path: {
+              type: 'string',
+              description: 'Dotted output path on the block (add_workflow_group_output)',
+            },
+            rowId: {
+              type: 'string',
+              description: 'Row ID for cancel_table_runs with scope "row".',
+            },
+            rowIds: {
+              type: 'array',
+              description:
+                'Optional row scope for run_column: only these rows are candidates (server eligibility still applies); omit for the whole table.',
+              items: {
+                type: 'string',
+              },
+            },
+            runMode: {
+              type: 'string',
+              description:
+                'Run mode for run_column: "incomplete" (default) re-runs only rows with no output or a last failure; "all" re-runs every dep-satisfied row.',
+              enum: ['incomplete', 'all'],
+            },
+            scope: {
+              type: 'string',
+              description:
+                'Cancellation scope for cancel_table_runs: "all" (whole table) or "row" (requires rowId).',
+              enum: ['all', 'row'],
+            },
+            tableId: {
+              type: 'string',
+              description: 'Table ID (required for everything except list_workflow_outputs)',
+            },
+            workflowId: {
+              type: 'string',
+              description:
+                'Workflow ID (required for add_workflow_group and list_workflow_outputs)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The automation operation to perform',
+          enum: [
+            'list_workflow_outputs',
+            'add_workflow_group',
+            'update_workflow_group',
+            'delete_workflow_group',
+            'add_workflow_group_output',
+            'delete_workflow_group_output',
+            'run_column',
+            'cancel_table_runs',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  table_columns: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            column: {
+              type: 'object',
+              description:
+                'Column definition for add_column: { name, type, unique?, position? }; select (enum) columns also take { options: [names], multiple?: true } — options is required for select.',
+            },
+            columnName: {
+              type: 'string',
+              description:
+                'Column name (required for rename_column and update_column; single-column delete_column)',
+            },
+            columnNames: {
+              type: 'array',
+              description:
+                'Array of column names to delete at once (preferred for multi-column delete_column)',
+            },
+            multiple: {
+              type: 'boolean',
+              description:
+                'Whether a select cell may hold several options (default false). Switching true → false fails if any row has more than one selected.',
+            },
+            newName: {
+              type: 'string',
+              description: 'New column name (required for rename_column)',
+            },
+            newType: {
+              type: 'string',
+              description:
+                'New column type for update_column: string, number, boolean, date, json, select. Converting to select also requires options; conversion fails if an existing cell value matches no option. A multiple select round-trips through text as a comma-separated cell.',
+            },
+            options: {
+              type: 'array',
+              description:
+                'Choices for a select (enum) column as display names, e.g. ["Open", "Closed"]. Required when creating or converting to select. On update_column this REPLACES the whole list, matched BY NAME — send the full list including options you keep; omitting one deletes it and clears its cells. Max 100.',
+              items: {
+                type: 'string',
+              },
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+            },
+            tableId: {
+              type: 'string',
+              description: 'Table ID (required for every operation)',
+            },
+            unique: {
+              type: 'boolean',
+              description:
+                'Set or clear the column unique constraint (update_column; not supported on select columns)',
+            },
+          },
+          required: ['tableId'],
+        },
+        operation: {
+          type: 'string',
+          description: 'The column operation to perform',
+          enum: ['add_column', 'rename_column', 'delete_column', 'update_column'],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  table_enrichments: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            autoRun: {
+              type: 'boolean',
+              description:
+                'true fires dep-satisfied rows immediately on add (only when the user explicitly asked); default false stages silently — fire later via table_automations run_column.',
+            },
+            dependencies: {
+              type: 'object',
+              description:
+                'Optional dependency override: { columns?: string[] }; omit to default to the mapped input columns.',
+              properties: {
+                columns: {
+                  type: 'array',
+                  description:
+                    'Input column names that must be filled before the enrichment runs a row.',
+                  items: {
+                    type: 'string',
+                  },
+                },
+              },
+            },
+            enrichmentId: {
+              type: 'string',
+              description:
+                'Enrichment registry ID for add_enrichment — discover via list_enrichments (e.g. work-email, phone-number, company-domain, company-info).',
+            },
+            inputMappings: {
+              type: 'array',
+              description:
+                'For add_enrichment: binds each enrichment input to an existing table column, as { inputName, columnName } where inputName is the enrichment input id from list_enrichments. Provide one for every required input.',
+              items: {
+                type: 'object',
+                properties: {
+                  columnName: {
+                    type: 'string',
+                    description: 'Existing table column that supplies this input.',
+                  },
+                  inputName: {
+                    type: 'string',
+                    description: 'Enrichment input id to bind (from list_enrichments).',
+                  },
+                },
+                required: ['inputName', 'columnName'],
+              },
+            },
+            name: {
+              type: 'string',
+              description:
+                "Optional display name for the enrichment column group; defaults to the enrichment's registry name.",
+            },
+            outputColumnNames: {
+              type: 'object',
+              description:
+                'Optional output column name overrides, as { "<outputId>": "<columnName>" }; omit for defaults.',
+              additionalProperties: {
+                type: 'string',
+                description: 'Target column name for this enrichment output id.',
+              },
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+            },
+            tableId: {
+              type: 'string',
+              description: 'Table ID (required for add_enrichment)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The enrichment operation to perform',
+          enum: ['list_enrichments', 'add_enrichment'],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  table_manage: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            description: {
+              type: 'string',
+              description: 'Table description (optional for create)',
+            },
+            filePath: {
+              type: 'string',
+              description:
+                'Canonical workspace file VFS path for create_from_file / import_file, e.g. files/{path}/{name}',
+            },
+            mapping: {
+              type: 'object',
+              description:
+                'Optional explicit CSV-header → table-column mapping for import_file, as { "csvHeader": "columnName" | null }. null skips that header; omit a header to auto-map by sanitized name.',
+              additionalProperties: {
+                type: ['string', 'null'],
+                description: 'Target column name on the table; null skips that CSV header.',
+              },
+            },
+            mode: {
+              type: 'string',
+              description:
+                'Import mode for import_file: append (default) adds rows; replace truncates existing rows in a transaction first.',
+              enum: ['append', 'replace'],
+            },
+            name: {
+              type: 'string',
+              description: 'Table name (required for create)',
+            },
+            newName: {
+              type: 'string',
+              description: 'New table name (required for rename)',
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+            },
+            schema: {
+              type: 'object',
+              description:
+                'Table schema with a columns array (required for create). Each column: { name, type, unique? }; a select (enum) column also requires options (display names) and takes multiple?.',
+            },
+            tableId: {
+              type: 'string',
+              description: 'Table ID (required for import_file and rename)',
+            },
+          },
+        },
+        operation: {
+          type: 'string',
+          description: 'The lifecycle operation to perform',
+          enum: ['create', 'create_from_file', 'import_file', 'rename'],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  table_rows: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            columnName: {
+              type: 'string',
+              description: 'Column to set when using the values map format of batch_update_rows',
+            },
+            data: {
+              type: 'object',
+              description:
+                'Row data as column → value pairs (required for insert_row, update_row; the patch object for update_rows_by_filter). Select (enum) cells take the option NAME.',
+            },
+            filter: {
+              type: 'object',
+              description:
+                'Predicate filter for update_rows_by_filter / delete_rows_by_filter: {"all":[...]} (AND) or {"any":[...]} (OR) of {field, op, value} leaves or nested groups. Ops: eq, ne, gt, gte, lt, lte, in, nin, like, ilike (* wildcard), nlike, nilike, contains, ncontains, startsWith, endsWith, isNull, isNotNull, isEmpty, isNotEmpty. in/nin take a non-empty array. Single-select columns match by eq/ne/in/nin; multiple-select by contains/ncontains — values are option NAMES.',
+            },
+            limit: {
+              type: 'number',
+              description:
+                'Optional cap on affected rows for the by-filter operations; omit to act on every match.',
+            },
+            outputPath: {
+              type: 'string',
+              description:
+                'Write this call\'s result to a NEW workspace file instead of returning it (e.g. "files/export.csv"). On success the tool result is REPLACED by a file receipt (fileId, vfsPath, size) — set it only when the file IS the goal. ".csv" serializes rows as a CSV table; ".json"/".txt"/".md"/".html" write pretty-printed JSON of the full result envelope. Missing parent folders are created; an existing path fails.',
+            },
+            position: {
+              type: 'integer',
+              description:
+                'Zero-based index at which to insert the row (optional, insert_row only). Rows at and below shift down; omit to append.',
+            },
+            rowId: {
+              type: 'string',
+              description: 'Row ID (required for update_row, delete_row)',
+            },
+            rowIds: {
+              type: 'array',
+              description: 'Array of row IDs to delete (required for batch_delete_rows)',
+              items: {
+                type: 'string',
+              },
+            },
+            rows: {
+              type: 'array',
+              description: 'Array of row data objects (required for batch_insert_rows)',
+            },
+            tableId: {
+              type: 'string',
+              description: 'Table ID (required for every operation)',
+            },
+            updates: {
+              type: 'array',
+              description:
+                'Array of per-row updates: [{ rowId, data: { col: val } }] (batch_update_rows format a)',
+            },
+            values: {
+              type: 'object',
+              description:
+                'Map of rowId → value for single-column batch update (batch_update_rows format b, with columnName)',
+            },
+          },
+          required: ['tableId'],
+        },
+        operation: {
+          type: 'string',
+          description: 'The row operation to perform',
+          enum: [
+            'insert_row',
+            'batch_insert_rows',
+            'update_row',
+            'batch_update_rows',
+            'delete_row',
+            'batch_delete_rows',
+            'update_rows_by_filter',
+            'delete_rows_by_filter',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  table_views: {
+    parameters: {
+      type: 'object',
+      properties: {
+        args: {
+          type: 'object',
+          description: 'Arguments for the operation',
+          properties: {
+            filter: {
+              type: 'object',
+              description:
+                'Saved row predicate, same grammar as query_rows filters: {"all":[...]} / {"any":[...]} of {field, op, value} leaves with exact column NAMES. Omit or null for an unfiltered view.',
+            },
+            hiddenColumns: {
+              type: 'array',
+              description:
+                'Column names to hide in the UI when this view is active. Display-only — queries through the view still return every column.',
+              items: {
+                type: 'string',
+              },
+            },
+            isDefault: {
+              type: 'boolean',
+              description:
+                "Make this view the table's default (at most one per table; setting it clears the previous default).",
+            },
+            name: {
+              type: 'string',
+              description:
+                'View display name (required for create_view; optional rename on update_view). Free-form label; references always use the view ID, so names are purely display.',
+            },
+            sort: {
+              type: 'array',
+              description:
+                'Saved ordered sort spec, e.g. [{"field":"due","direction":"asc"}], column NAMES. Omit or null for default ordering.',
+            },
+            tableId: {
+              type: 'string',
+              description: 'Table ID (required for every operation)',
+            },
+            viewId: {
+              type: 'string',
+              description:
+                'View ID (required for get_view, update_view, delete_view, set_default_view)',
+            },
+          },
+          required: ['tableId'],
+        },
+        operation: {
+          type: 'string',
+          description: 'The view operation to perform',
+          enum: [
+            'list_views',
+            'get_view',
+            'create_view',
+            'update_view',
+            'delete_view',
+            'set_default_view',
+          ],
+        },
+      },
+      required: ['operation', 'args'],
+    },
+    resultSchema: {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'object',
+          description: 'Operation-specific result payload.',
+        },
+        message: {
+          type: 'string',
+          description: 'Human-readable outcome summary.',
+        },
+        success: {
+          type: 'boolean',
+          description: 'Whether the operation succeeded.',
+        },
+      },
+      required: ['success', 'message'],
+    },
+  },
+  tail_agent: {
+    parameters: {
+      type: 'object',
+      properties: {
+        agent_id: {
+          type: 'string',
+          description: 'The agent id to inspect.',
+        },
+        max_chars: {
+          type: 'number',
+          description:
+            'Max characters of activity to return. Default 4000; unread activity beyond the budget stays queued for your next tail.',
+        },
+      },
+      required: ['agent_id'],
+    },
+    resultSchema: undefined,
+  },
   terminal: {
     parameters: {
       type: 'object',
@@ -4865,7 +6155,7 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
         version: {
           type: 'number',
           description:
-            'The numeric deployment version number to update (use get_deployment_log to find it).',
+            'The numeric deployment version number to update (use list_deployment_versions to find it).',
         },
         workflowId: {
           type: 'string',
@@ -5295,6 +6585,157 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
+  wait_agents: {
+    parameters: {
+      type: 'object',
+      properties: {
+        agent_ids: {
+          type: 'array',
+          description: 'The agent ids to wait on, as returned by their async launches.',
+          items: {
+            type: 'string',
+          },
+        },
+        mode: {
+          type: 'string',
+          description:
+            '"all" (default) wakes when every listed agent finishes; "any" wakes on the first.',
+          enum: ['all', 'any'],
+        },
+        timeout_seconds: {
+          type: 'number',
+          description:
+            'Max seconds to sleep before waking anyway. Default 120, capped at 600. On timeout you get current statuses and can wait again.',
+        },
+      },
+      required: ['agent_ids'],
+    },
+    resultSchema: undefined,
+  },
+  web_crawl: {
+    parameters: {
+      type: 'object',
+      properties: {
+        exclude_paths: {
+          type: 'array',
+          description: 'Skip URLs matching these patterns',
+          items: {
+            type: 'string',
+          },
+        },
+        include_paths: {
+          type: 'array',
+          description: 'Only crawl URLs matching these patterns',
+          items: {
+            type: 'string',
+          },
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum pages to crawl (default 10, max 50)',
+        },
+        max_depth: {
+          type: 'number',
+          description: 'How deep to follow links (default 2)',
+        },
+        url: {
+          type: 'string',
+          description: 'Starting URL to crawl from',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  web_fetch: {
+    parameters: {
+      type: 'object',
+      properties: {
+        include_highlights: {
+          type: 'boolean',
+          description: 'Include key highlights (default false)',
+        },
+        include_summary: {
+          type: 'boolean',
+          description: 'Include AI-generated summary (default false)',
+        },
+        include_text: {
+          type: 'boolean',
+          description: 'Include full page text (default true)',
+        },
+        urls: {
+          type: 'array',
+          description: 'URLs to get content from (max 10)',
+          items: {
+            type: 'string',
+          },
+        },
+      },
+      required: ['urls'],
+    },
+    resultSchema: undefined,
+  },
+  web_scrape: {
+    parameters: {
+      type: 'object',
+      properties: {
+        include_links: {
+          type: 'boolean',
+          description: 'Extract all links from the page (default false)',
+        },
+        url: {
+          type: 'string',
+          description: 'The URL to scrape (must include https://)',
+        },
+        wait_for: {
+          type: 'string',
+          description: 'CSS selector to wait for before scraping (for JS-heavy pages)',
+        },
+      },
+      required: ['url'],
+    },
+    resultSchema: undefined,
+  },
+  web_search: {
+    parameters: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description: 'Filter by category',
+          enum: [
+            'news',
+            'tweet',
+            'github',
+            'company',
+            'research paper',
+            'linkedin profile',
+            'pdf',
+            'personal site',
+          ],
+        },
+        include_text: {
+          type: 'boolean',
+          description: 'Include page text content (default true)',
+        },
+        num_results: {
+          type: 'number',
+          description: 'Number of results (default 10, max 25)',
+        },
+        query: {
+          type: 'string',
+          description: 'Natural language search query',
+        },
+        toolTitle: {
+          type: 'string',
+          description:
+            "Required short UI label fragment (e.g. 'Slack integrations'), not a full sentence.",
+        },
+      },
+      required: ['query', 'toolTitle'],
+    },
+    resultSchema: undefined,
+  },
   workflow: {
     parameters: {
       properties: {
@@ -5321,127 +6762,4 @@ export const TOOL_RUNTIME_SCHEMAS: Record<string, ToolRuntimeSchemaEntry> = {
     },
     resultSchema: undefined,
   },
-  workspace_file: {
-    parameters: {
-      type: 'object',
-      properties: {
-        operation: {
-          type: 'string',
-          description: 'The file operation to perform.',
-          enum: ['append', 'update', 'patch'],
-        },
-        target: {
-          type: 'object',
-          description: 'Explicit file target. Use kind=path + path for existing files.',
-          properties: {
-            kind: {
-              type: 'string',
-              description: 'How the file target is identified.',
-              enum: ['path'],
-            },
-            path: {
-              type: 'string',
-              description:
-                'Canonical existing workspace file VFS path, e.g. "files/Reports/report.md". Required when target.kind=path.',
-            },
-          },
-          required: ['kind'],
-        },
-        title: {
-          type: 'string',
-          description:
-            'Required short UI label for this content unit, e.g. "Chapter 1", "Slide 3", or "Fix footer spacing".',
-        },
-        contentType: {
-          type: 'string',
-          description:
-            'Optional MIME type override. Usually omit and let the system infer from the target file extension.',
-          enum: [
-            'text/markdown',
-            'text/html',
-            'text/plain',
-            'application/json',
-            'text/csv',
-            'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-            'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-            'application/pdf',
-          ],
-        },
-        edit: {
-          type: 'object',
-          description:
-            'Patch metadata. Use strategy=search_replace for exact text replacement, or strategy=anchored for line-based inserts/replacements/deletions. The actual replacement/insert content is provided via the paired edit_content tool call.',
-          properties: {
-            after_anchor: {
-              type: 'string',
-              description:
-                'Boundary line kept after inserted replacement content. Required for mode=replace_between.',
-            },
-            anchor: {
-              type: 'string',
-              description:
-                'Anchor line after which new content is inserted. Required for mode=insert_after.',
-            },
-            before_anchor: {
-              type: 'string',
-              description:
-                'Boundary line kept before inserted replacement content. Required for mode=replace_between.',
-            },
-            end_anchor: {
-              type: 'string',
-              description: 'First line to keep after deletion. Required for mode=delete_between.',
-            },
-            mode: {
-              type: 'string',
-              description: 'Anchored edit mode when strategy=anchored.',
-              enum: ['replace_between', 'insert_after', 'delete_between'],
-            },
-            occurrence: {
-              type: 'number',
-              description: '1-based occurrence for repeated anchor lines. Optional; defaults to 1.',
-            },
-            replaceAll: {
-              type: 'boolean',
-              description:
-                'When true and strategy=search_replace, replace every match instead of requiring a unique single match.',
-            },
-            search: {
-              type: 'string',
-              description:
-                'Exact text to find when strategy=search_replace. Must match exactly once unless replaceAll=true.',
-            },
-            start_anchor: {
-              type: 'string',
-              description: 'First line to delete. Required for mode=delete_between.',
-            },
-            strategy: {
-              type: 'string',
-              description: 'Patch strategy.',
-              enum: ['search_replace', 'anchored'],
-            },
-          },
-        },
-      },
-      required: ['operation', 'target', 'title'],
-    },
-    resultSchema: {
-      type: 'object',
-      properties: {
-        data: {
-          type: 'object',
-          description:
-            'Optional operation metadata such as file id, file name, size, and content type.',
-        },
-        message: {
-          type: 'string',
-          description: 'Human-readable summary of the outcome.',
-        },
-        success: {
-          type: 'boolean',
-          description: 'Whether the file operation succeeded.',
-        },
-      },
-      required: ['success', 'message'],
-    },
-  },
 }
diff --git a/apps/sim/lib/copilot/generated/trace-attribute-values-v1.ts b/apps/sim/lib/copilot/generated/trace-attribute-values-v1.ts
index 1fad4c1132..8968f29522 100644
--- a/apps/sim/lib/copilot/generated/trace-attribute-values-v1.ts
+++ b/apps/sim/lib/copilot/generated/trace-attribute-values-v1.ts
@@ -59,6 +59,14 @@ export const BillingRouteOutcome = {
 export type BillingRouteOutcomeKey = keyof typeof BillingRouteOutcome
 export type BillingRouteOutcomeValue = (typeof BillingRouteOutcome)[BillingRouteOutcomeKey]
 
+export const ContextBudgetSource = {
+  Model: 'model',
+  PricingBoundary: 'pricing_boundary',
+} as const
+
+export type ContextBudgetSourceKey = keyof typeof ContextBudgetSource
+export type ContextBudgetSourceValue = (typeof ContextBudgetSource)[ContextBudgetSourceKey]
+
 export const CopilotAbortOutcome = {
   BadRequest: 'bad_request',
   FallbackPersistFailed: 'fallback_persist_failed',
@@ -117,6 +125,16 @@ export const CopilotConfirmOutcome = {
 export type CopilotConfirmOutcomeKey = keyof typeof CopilotConfirmOutcome
 export type CopilotConfirmOutcomeValue = (typeof CopilotConfirmOutcome)[CopilotConfirmOutcomeKey]
 
+export const CopilotDegradedReason = {
+  BindingRejected: 'binding_rejected',
+  ClientPickupTimeout: 'client_pickup_timeout',
+  MissingToolResult: 'missing_tool_result',
+  StreamDeadBeforeDispatch: 'stream_dead_before_dispatch',
+} as const
+
+export type CopilotDegradedReasonKey = keyof typeof CopilotDegradedReason
+export type CopilotDegradedReasonValue = (typeof CopilotDegradedReason)[CopilotDegradedReasonKey]
+
 export const CopilotFinalizeOutcome = {
   Aborted: 'aborted',
   Error: 'error',
@@ -194,6 +212,18 @@ export const CopilotSseCloseReason = {
 export type CopilotSseCloseReasonKey = keyof typeof CopilotSseCloseReason
 export type CopilotSseCloseReasonValue = (typeof CopilotSseCloseReason)[CopilotSseCloseReasonKey]
 
+export const CopilotSteerOutcome = {
+  BadRequest: 'bad_request',
+  MissingContent: 'missing_content',
+  MissingMessageId: 'missing_message_id',
+  NoActiveTurn: 'no_active_turn',
+  QueueFull: 'queue_full',
+  Queued: 'queued',
+} as const
+
+export type CopilotSteerOutcomeKey = keyof typeof CopilotSteerOutcome
+export type CopilotSteerOutcomeValue = (typeof CopilotSteerOutcome)[CopilotSteerOutcomeKey]
+
 export const CopilotStopOutcome = {
   ChatNotFound: 'chat_not_found',
   InternalError: 'internal_error',
@@ -310,6 +340,40 @@ export const LlmErrorStage = {
 export type LlmErrorStageKey = keyof typeof LlmErrorStage
 export type LlmErrorStageValue = (typeof LlmErrorStage)[LlmErrorStageKey]
 
+export const PromptComponent = {
+  ActiveSkills: 'active_skills',
+  AgentGuidance: 'agent_guidance',
+  Capabilities: 'capabilities',
+  Credentials: 'credentials',
+  DesktopContext: 'desktop_context',
+  ExternalTools: 'external_tools',
+  Files: 'files',
+  History: 'history',
+  Override: 'override',
+  PermissionsContext: 'permissions_context',
+  Persona: 'persona',
+  Policies: 'policies',
+  RuntimeTail: 'runtime_tail',
+  SessionContext: 'session_context',
+  SkillsIndex: 'skills_index',
+  SpawnContext: 'spawn_context',
+  Steering: 'steering',
+  SubagentDocs: 'subagent_docs',
+  SubagentRegistry: 'subagent_registry',
+  TaggedResources: 'tagged_resources',
+  TimeContext: 'time_context',
+  ToolDocs: 'tool_docs',
+  ToolResults: 'tool_results',
+  ToolsWire: 'tools_wire',
+  Vfs: 'vfs',
+  WorkflowContext: 'workflow_context',
+  WorkspaceGuide: 'workspace_guide',
+  WorkspaceInventory: 'workspace_inventory',
+} as const
+
+export type PromptComponentKey = keyof typeof PromptComponent
+export type PromptComponentValue = (typeof PromptComponent)[PromptComponentKey]
+
 export const RateLimitOutcome = {
   Allowed: 'allowed',
   IncrError: 'incr_error',
diff --git a/apps/sim/lib/copilot/generated/trace-attributes-v1.ts b/apps/sim/lib/copilot/generated/trace-attributes-v1.ts
index 6db17a6329..8e8778eb6d 100644
--- a/apps/sim/lib/copilot/generated/trace-attributes-v1.ts
+++ b/apps/sim/lib/copilot/generated/trace-attributes-v1.ts
@@ -69,6 +69,7 @@ export const TraceAttr = {
   BillingInterval: 'billing.interval',
   BillingIsMcp: 'billing.is_mcp',
   BillingLlmCost: 'billing.llm_cost',
+  BillingLongContext: 'billing.long_context',
   BillingNewPlan: 'billing.new_plan',
   BillingOutcome: 'billing.outcome',
   BillingPlan: 'billing.plan',
@@ -153,6 +154,7 @@ export const TraceAttr = {
   ConditionName: 'condition.name',
   ConditionResult: 'condition.result',
   ContextReduceBudgetChars: 'context.reduce.budget_chars',
+  ContextReduceBudgetSource: 'context.reduce.budget_source',
   ContextReduceCaller: 'context.reduce.caller',
   ContextReduceDidReduce: 'context.reduce.did_reduce',
   ContextReduceInputChars: 'context.reduce.input_chars',
@@ -177,6 +179,15 @@ export const TraceAttr = {
   CopilotAbortMarkerWritten: 'copilot.abort.marker_written',
   CopilotAbortOutcome: 'copilot.abort.outcome',
   CopilotAbortUnknownReason: 'copilot.abort.unknown_reason',
+  CopilotAsyncSubagentAgent: 'copilot.async_subagent.agent',
+  CopilotAsyncSubagentCount: 'copilot.async_subagent.count',
+  CopilotAsyncSubagentDeltaChars: 'copilot.async_subagent.delta_chars',
+  CopilotAsyncSubagentId: 'copilot.async_subagent.id',
+  CopilotAsyncSubagentReminders: 'copilot.async_subagent.reminders',
+  CopilotAsyncSubagentSleptMs: 'copilot.async_subagent.slept_ms',
+  CopilotAsyncSubagentStatus: 'copilot.async_subagent.status',
+  CopilotAsyncSubagentWaitMode: 'copilot.async_subagent.wait_mode',
+  CopilotAsyncSubagentWakeReason: 'copilot.async_subagent.wake_reason',
   CopilotAsyncToolClaimedBy: 'copilot.async_tool.claimed_by',
   CopilotAsyncToolHasError: 'copilot.async_tool.has_error',
   CopilotAsyncToolIdsCount: 'copilot.async_tool.ids_count',
@@ -189,6 +200,7 @@ export const TraceAttr = {
   CopilotCommandsCount: 'copilot.commands.count',
   CopilotConfirmOutcome: 'copilot.confirm.outcome',
   CopilotContextsCount: 'copilot.contexts.count',
+  CopilotDegradedReason: 'copilot.degraded.reason',
   CopilotExecutionId: 'copilot.execution.id',
   CopilotFileAttachmentsCount: 'copilot.file_attachments.count',
   CopilotFinalizeOutcome: 'copilot.finalize.outcome',
@@ -257,6 +269,11 @@ export const TraceAttr = {
   CopilotSseTerminalEventMissing: 'copilot.sse.terminal_event_missing',
   CopilotSseTerminalEventSeen: 'copilot.sse.terminal_event_seen',
   CopilotSseTotalDispatchMs: 'copilot.sse.total_dispatch_ms',
+  CopilotSteerOutcome: 'copilot.steer.outcome',
+  CopilotSteeringContentChars: 'copilot.steering.content_chars',
+  CopilotSteeringEntries: 'copilot.steering.entries',
+  CopilotSteeringMode: 'copilot.steering.mode',
+  CopilotSteeringSalvagedChars: 'copilot.steering.salvaged_chars',
   CopilotStopAppendedAssistant: 'copilot.stop.appended_assistant',
   CopilotStopBlocksCount: 'copilot.stop.blocks_count',
   CopilotStopContentLength: 'copilot.stop.content_length',
@@ -451,8 +468,6 @@ export const TraceAttr = {
   HttpUrl: 'http.url',
   HttpUserAgent: 'http.user_agent',
   InvitationRole: 'invitation.role',
-  KnowledgeBaseId: 'knowledge_base.id',
-  KnowledgeBaseName: 'knowledge_base.name',
   LlmBackend: 'llm.backend',
   LlmCompactionPause: 'llm.compaction.pause',
   LlmErrorStage: 'llm.error_stage',
@@ -472,6 +487,8 @@ export const TraceAttr = {
   LoopId: 'loop.id',
   LoopIterations: 'loop.iterations',
   LoopName: 'loop.name',
+  ManageKnowledgeBaseId: 'manage_knowledge_base.id',
+  ManageKnowledgeBaseName: 'manage_knowledge_base.name',
   McpExecutionStatus: 'mcp.execution_status',
   McpServerId: 'mcp.server_id',
   McpServerName: 'mcp.server_name',
@@ -502,9 +519,36 @@ export const TraceAttr = {
   ProcessingChunkSize: 'processing.chunk_size',
   ProcessingRecipe: 'processing.recipe',
   PromptCacheableBlocks: 'prompt.cacheable_blocks',
+  PromptComponent: 'prompt.component',
+  PromptRegionFilesChars: 'prompt.region.files_chars',
+  PromptRegionFilesCount: 'prompt.region.files_count',
+  PromptRegionHistoryChars: 'prompt.region.history_chars',
+  PromptRegionHistoryMessages: 'prompt.region.history_messages',
+  PromptRegionRuntimeTailChars: 'prompt.region.runtime_tail_chars',
+  PromptRegionSteeringChars: 'prompt.region.steering_chars',
+  PromptRegionToolResultsChars: 'prompt.region.tool_results_chars',
+  PromptRegionVfsChars: 'prompt.region.vfs_chars',
+  PromptRegionVfsMessages: 'prompt.region.vfs_messages',
+  PromptRuntimeActiveSkillsChars: 'prompt.runtime.active_skills_chars',
+  PromptRuntimeTaggedResourcesChars: 'prompt.runtime.tagged_resources_chars',
+  PromptSectionAgentGuidanceChars: 'prompt.section.agent_guidance_chars',
+  PromptSectionCapabilitiesChars: 'prompt.section.capabilities_chars',
+  PromptSectionCredentialsChars: 'prompt.section.credentials_chars',
+  PromptSectionOverrideChars: 'prompt.section.override_chars',
+  PromptSectionPersonaChars: 'prompt.section.persona_chars',
+  PromptSectionPoliciesChars: 'prompt.section.policies_chars',
+  PromptSectionSkillsIndexChars: 'prompt.section.skills_index_chars',
+  PromptSectionSpawnContextChars: 'prompt.section.spawn_context_chars',
+  PromptSectionSubagentDocsChars: 'prompt.section.subagent_docs_chars',
+  PromptSectionToolDocsChars: 'prompt.section.tool_docs_chars',
+  PromptSectionWorkspaceGuideChars: 'prompt.section.workspace_guide_chars',
+  PromptSectionWorkspaceInventoryChars: 'prompt.section.workspace_inventory_chars',
   PromptSet: 'prompt.set',
+  PromptSite: 'prompt.site',
   PromptSystemBlocks: 'prompt.system_blocks',
   PromptSystemChars: 'prompt.system_chars',
+  PromptToolsWireChars: 'prompt.tools.wire_chars',
+  PromptToolsWireCount: 'prompt.tools.wire_count',
   ProviderId: 'provider.id',
   RateLimitAttempt: 'rate_limit.attempt',
   RateLimitCount: 'rate_limit.count',
@@ -713,6 +757,7 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'billing.interval',
   'billing.is_mcp',
   'billing.llm_cost',
+  'billing.long_context',
   'billing.new_plan',
   'billing.outcome',
   'billing.plan',
@@ -797,6 +842,7 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'condition.name',
   'condition.result',
   'context.reduce.budget_chars',
+  'context.reduce.budget_source',
   'context.reduce.caller',
   'context.reduce.did_reduce',
   'context.reduce.input_chars',
@@ -821,6 +867,15 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'copilot.abort.marker_written',
   'copilot.abort.outcome',
   'copilot.abort.unknown_reason',
+  'copilot.async_subagent.agent',
+  'copilot.async_subagent.count',
+  'copilot.async_subagent.delta_chars',
+  'copilot.async_subagent.id',
+  'copilot.async_subagent.reminders',
+  'copilot.async_subagent.slept_ms',
+  'copilot.async_subagent.status',
+  'copilot.async_subagent.wait_mode',
+  'copilot.async_subagent.wake_reason',
   'copilot.async_tool.claimed_by',
   'copilot.async_tool.has_error',
   'copilot.async_tool.ids_count',
@@ -833,6 +888,7 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'copilot.commands.count',
   'copilot.confirm.outcome',
   'copilot.contexts.count',
+  'copilot.degraded.reason',
   'copilot.execution.id',
   'copilot.file_attachments.count',
   'copilot.finalize.outcome',
@@ -901,6 +957,11 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'copilot.sse.terminal_event_missing',
   'copilot.sse.terminal_event_seen',
   'copilot.sse.total_dispatch_ms',
+  'copilot.steer.outcome',
+  'copilot.steering.content_chars',
+  'copilot.steering.entries',
+  'copilot.steering.mode',
+  'copilot.steering.salvaged_chars',
   'copilot.stop.appended_assistant',
   'copilot.stop.blocks_count',
   'copilot.stop.content_length',
@@ -1084,8 +1145,6 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'http.url',
   'http.user_agent',
   'invitation.role',
-  'knowledge_base.id',
-  'knowledge_base.name',
   'llm.backend',
   'llm.compaction.pause',
   'llm.error_stage',
@@ -1105,6 +1164,8 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'loop.id',
   'loop.iterations',
   'loop.name',
+  'manage_knowledge_base.id',
+  'manage_knowledge_base.name',
   'mcp.execution_status',
   'mcp.server_id',
   'mcp.server_name',
@@ -1135,9 +1196,36 @@ export const TraceAttrValues: readonly TraceAttrValue[] = [
   'processing.chunk_size',
   'processing.recipe',
   'prompt.cacheable_blocks',
+  'prompt.component',
+  'prompt.region.files_chars',
+  'prompt.region.files_count',
+  'prompt.region.history_chars',
+  'prompt.region.history_messages',
+  'prompt.region.runtime_tail_chars',
+  'prompt.region.steering_chars',
+  'prompt.region.tool_results_chars',
+  'prompt.region.vfs_chars',
+  'prompt.region.vfs_messages',
+  'prompt.runtime.active_skills_chars',
+  'prompt.runtime.tagged_resources_chars',
+  'prompt.section.agent_guidance_chars',
+  'prompt.section.capabilities_chars',
+  'prompt.section.credentials_chars',
+  'prompt.section.override_chars',
+  'prompt.section.persona_chars',
+  'prompt.section.policies_chars',
+  'prompt.section.skills_index_chars',
+  'prompt.section.spawn_context_chars',
+  'prompt.section.subagent_docs_chars',
+  'prompt.section.tool_docs_chars',
+  'prompt.section.workspace_guide_chars',
+  'prompt.section.workspace_inventory_chars',
   'prompt.set',
+  'prompt.site',
   'prompt.system_blocks',
   'prompt.system_chars',
+  'prompt.tools.wire_chars',
+  'prompt.tools.wire_count',
   'provider.id',
   'rate_limit.attempt',
   'rate_limit.count',
diff --git a/apps/sim/lib/copilot/generated/trace-spans-v1.ts b/apps/sim/lib/copilot/generated/trace-spans-v1.ts
index 5048cb2fbf..1dc7cc5930 100644
--- a/apps/sim/lib/copilot/generated/trace-spans-v1.ts
+++ b/apps/sim/lib/copilot/generated/trace-spans-v1.ts
@@ -12,6 +12,9 @@ export const TraceSpan = {
   AsyncToolStoreSet: 'async_tool_store.set',
   AuthRateLimitRecord: 'auth.rate_limit.record',
   AuthValidateKey: 'auth.validate_key',
+  ChatAsyncSubagentRun: 'chat.async_subagent.run',
+  ChatAsyncSubagentShutdown: 'chat.async_subagent.shutdown',
+  ChatAsyncSubagentSpawn: 'chat.async_subagent.spawn',
   ChatContinueWithToolResults: 'chat.continue_with_tool_results',
   ChatExplicitAbortConsume: 'chat.explicit_abort.consume',
   ChatExplicitAbortFlushPausedBilling: 'chat.explicit_abort.flush_paused_billing',
@@ -19,6 +22,10 @@ export const TraceSpan = {
   ChatExplicitAbortMark: 'chat.explicit_abort.mark',
   ChatExplicitAbortPeek: 'chat.explicit_abort.peek',
   ChatGateAcquire: 'chat.gate.acquire',
+  ChatOrchestrateInterrupt: 'chat.orchestrate.interrupt',
+  ChatOrchestrateSteer: 'chat.orchestrate.steer',
+  ChatOrchestrateTail: 'chat.orchestrate.tail',
+  ChatOrchestrateWait: 'chat.orchestrate.wait',
   ChatPersistAfterDone: 'chat.persist_after_done',
   ChatSetup: 'chat.setup',
   ContextReduce: 'context.reduce',
@@ -53,6 +60,7 @@ export const TraceSpan = {
   CopilotChatResolveAgentContexts: 'copilot.chat.resolve_agent_contexts',
   CopilotChatResolveBranch: 'copilot.chat.resolve_branch',
   CopilotChatResolveOrCreateChat: 'copilot.chat.resolve_or_create_chat',
+  CopilotChatSteerStream: 'copilot.chat.steer_stream',
   CopilotChatStopStream: 'copilot.chat.stop_stream',
   CopilotConfirmToolResult: 'copilot.confirm.tool_result',
   CopilotFinalizeStream: 'copilot.finalize_stream',
@@ -63,6 +71,7 @@ export const TraceSpan = {
   CopilotToolWaitForClientResult: 'copilot.tool.wait_for_client_result',
   CopilotToolWaitForPermission: 'copilot.tool.wait_for_permission',
   CopilotToolPermissionDecide: 'copilot.tool_permission.decide',
+  CopilotToolsExecuteInband: 'copilot.tools.execute_inband',
   CopilotToolsHandleResourceSideEffects: 'copilot.tools.handle_resource_side_effects',
   CopilotToolsWriteCsvToTable: 'copilot.tools.write_csv_to_table',
   CopilotToolsWriteOutputFile: 'copilot.tools.write_output_file',
@@ -73,6 +82,7 @@ export const TraceSpan = {
   GenAiAgentExecute: 'gen_ai.agent.execute',
   LlmStream: 'llm.stream',
   ProviderRouterRoute: 'provider.router.route',
+  SimExecuteTool: 'sim.execute_tool',
   SimUpdateCost: 'sim.update_cost',
   SimValidateApiKey: 'sim.validate_api_key',
   ToolAsyncWaiterWait: 'tool.async_waiter.wait',
@@ -87,6 +97,9 @@ export const TraceSpanValues: readonly TraceSpanValue[] = [
   'async_tool_store.set',
   'auth.rate_limit.record',
   'auth.validate_key',
+  'chat.async_subagent.run',
+  'chat.async_subagent.shutdown',
+  'chat.async_subagent.spawn',
   'chat.continue_with_tool_results',
   'chat.explicit_abort.consume',
   'chat.explicit_abort.flush_paused_billing',
@@ -94,6 +107,10 @@ export const TraceSpanValues: readonly TraceSpanValue[] = [
   'chat.explicit_abort.mark',
   'chat.explicit_abort.peek',
   'chat.gate.acquire',
+  'chat.orchestrate.interrupt',
+  'chat.orchestrate.steer',
+  'chat.orchestrate.tail',
+  'chat.orchestrate.wait',
   'chat.persist_after_done',
   'chat.setup',
   'context.reduce',
@@ -128,6 +145,7 @@ export const TraceSpanValues: readonly TraceSpanValue[] = [
   'copilot.chat.resolve_agent_contexts',
   'copilot.chat.resolve_branch',
   'copilot.chat.resolve_or_create_chat',
+  'copilot.chat.steer_stream',
   'copilot.chat.stop_stream',
   'copilot.confirm.tool_result',
   'copilot.finalize_stream',
@@ -138,6 +156,7 @@ export const TraceSpanValues: readonly TraceSpanValue[] = [
   'copilot.tool.wait_for_client_result',
   'copilot.tool.wait_for_permission',
   'copilot.tool_permission.decide',
+  'copilot.tools.execute_inband',
   'copilot.tools.handle_resource_side_effects',
   'copilot.tools.write_csv_to_table',
   'copilot.tools.write_output_file',
@@ -148,6 +167,7 @@ export const TraceSpanValues: readonly TraceSpanValue[] = [
   'gen_ai.agent.execute',
   'llm.stream',
   'provider.router.route',
+  'sim.execute_tool',
   'sim.update_cost',
   'sim.validate_api_key',
   'tool.async_waiter.wait',
diff --git a/apps/sim/lib/copilot/generated/vfs-snapshot-v1.ts b/apps/sim/lib/copilot/generated/vfs-snapshot-v1.ts
index ee8a2dc4f6..6559a690ca 100644
--- a/apps/sim/lib/copilot/generated/vfs-snapshot-v1.ts
+++ b/apps/sim/lib/copilot/generated/vfs-snapshot-v1.ts
@@ -10,7 +10,6 @@ export interface VfsSnapshotV1 {
   envVars?: string[]
   files?: VfsSnapshotV1File[]
   integrations?: VfsSnapshotV1Integration[]
-  jobs?: VfsSnapshotV1Job[]
   knowledgeBases?: VfsSnapshotV1KnowledgeBase[]
   mcpServers?: VfsSnapshotV1McpServer[]
   members?: VfsSnapshotV1Member[]
@@ -59,19 +58,6 @@ export interface VfsSnapshotV1Integration {
   providerId: string
   role?: string
 }
-/**
- * This interface was referenced by `VfsSnapshotV1`'s JSON-Schema
- * via the `definition` "VfsSnapshotV1Job".
- */
-export interface VfsSnapshotV1Job {
-  cronExpression?: string
-  id: string
-  lifecycle?: string
-  prompt?: string
-  sourceTaskName?: string
-  status?: string
-  title?: string
-}
 /**
  * This interface was referenced by `VfsSnapshotV1`'s JSON-Schema
  * via the `definition` "VfsSnapshotV1KnowledgeBase".
diff --git a/apps/sim/lib/copilot/request/context/result.test.ts b/apps/sim/lib/copilot/request/context/result.test.ts
index 1947b63551..b8659cb2d6 100644
--- a/apps/sim/lib/copilot/request/context/result.test.ts
+++ b/apps/sim/lib/copilot/request/context/result.test.ts
@@ -3,7 +3,7 @@
  */
 import { describe, expect, it } from 'vitest'
 import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
-import { FunctionExecute } from '@/lib/copilot/generated/tool-catalog-v1'
+import { RunFunction } from '@/lib/copilot/generated/tool-catalog-v1'
 import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
 import { TraceCollector } from '@/lib/copilot/request/trace'
 import type { StreamingContext } from '@/lib/copilot/request/types'
@@ -44,7 +44,7 @@ describe('buildToolCallSummaries', () => {
     const context = makeContext()
     context.toolCalls.set('tool-1', {
       id: 'tool-1',
-      name: 'download_to_workspace_file',
+      name: 'download_file',
       status: 'pending',
       startTime: 1,
     })
@@ -59,7 +59,7 @@ describe('buildToolCallSummaries', () => {
     const context = makeContext()
     context.toolCalls.set('tool-2', {
       id: 'tool-2',
-      name: FunctionExecute.id,
+      name: RunFunction.id,
       status: 'executing',
       startTime: 1,
     })
@@ -76,7 +76,7 @@ describe('buildToolCallSummaries', () => {
       const context = makeContext()
       context.toolCalls.set('tool-3', {
         id: 'tool-3',
-        name: 'download_to_workspace_file',
+        name: 'download_file',
         status: MothershipStreamV1ToolOutcome.cancelled,
         result: { success: false },
         error: 'Stopped by user',
@@ -89,7 +89,7 @@ describe('buildToolCallSummaries', () => {
       expect(summaries).toHaveLength(1)
       expect(summaries[0]).toEqual({
         id: 'tool-3',
-        name: 'download_to_workspace_file',
+        name: 'download_file',
         status: MothershipStreamV1ToolOutcome.cancelled,
         params: undefined,
         result: undefined,
diff --git a/apps/sim/lib/copilot/request/go/file-preview-adapter.test.ts b/apps/sim/lib/copilot/request/go/file-preview-adapter.test.ts
index 27851eabba..3e14e0bd0e 100644
--- a/apps/sim/lib/copilot/request/go/file-preview-adapter.test.ts
+++ b/apps/sim/lib/copilot/request/go/file-preview-adapter.test.ts
@@ -54,21 +54,21 @@ function toolEvent(payload: Record<string, unknown>): StreamEvent {
   )
 }
 
-/** One args_delta chunk of the streamed `edit_content` JSON, as a driveable StreamEvent. */
+/** One args_delta chunk of the streamed `apply_file_edit` JSON, as a driveable StreamEvent. */
 function editContentDelta(argumentsDelta: string): StreamEvent {
   return toolEvent({
     toolCallId: EDIT_TOOL_CALL_ID,
-    toolName: 'edit_content',
+    toolName: 'apply_file_edit',
     phase: MothershipStreamV1ToolPhase.args_delta,
     argumentsDelta,
   })
 }
 
-/** The authoritative `workspace_file` call frame for a path-targeted update. */
+/** The authoritative `prepare_file_edit` call frame for a path-targeted update. */
 function workspaceFileCall(): StreamEvent {
   return toolEvent({
     toolCallId: WORKSPACE_FILE_TOOL_CALL_ID,
-    toolName: 'workspace_file',
+    toolName: 'prepare_file_edit',
     phase: MothershipStreamV1ToolPhase.call,
     arguments: {
       operation: 'update',
diff --git a/apps/sim/lib/copilot/request/go/file-preview-adapter.ts b/apps/sim/lib/copilot/request/go/file-preview-adapter.ts
index 7810c55ff5..bccc3c01ed 100644
--- a/apps/sim/lib/copilot/request/go/file-preview-adapter.ts
+++ b/apps/sim/lib/copilot/request/go/file-preview-adapter.ts
@@ -381,7 +381,7 @@ export async function processFilePreviewStreamEvent(input: {
 
   // Scope the in-flight intent to the invoking file subagent's channel (its
   // outer tool_use id) so two file agents streaming concurrently never read or
-  // overwrite each other's intent. workspace_file and edit_content from the same
+  // overwrite each other's intent. prepare_file_edit and apply_file_edit from the same
   // file agent share this channel id, so they pair up; siblings stay isolated.
   const channelId = streamEvent.scope?.parentToolCallId ?? ''
   const getIntent = (): FileIntent | null => context.activeFileIntents.get(channelId) ?? null
@@ -392,7 +392,7 @@ export async function processFilePreviewStreamEvent(input: {
     context.activeFileIntents.delete(channelId)
   }
 
-  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'workspace_file') {
+  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'prepare_file_edit') {
     const toolCallId = streamEvent.payload.toolCallId
     const parsedArgs = parseWorkspaceFileArgs(streamEvent.payload.arguments)
     if (toolCallId && parsedArgs) {
@@ -407,7 +407,7 @@ export async function processFilePreviewStreamEvent(input: {
       const { fileId, fileName } = target
 
       const isContentOp = isContentOperation(operation)
-      // Per-channel: a re-declared workspace_file just overwrites THIS channel's
+      // Per-channel: a re-declared prepare_file_edit just overwrites THIS channel's
       // slot. No cross-message intent clearing — that would wipe a concurrent
       // sibling file agent's pending intent.
       const intent: FileIntent = {
@@ -450,12 +450,12 @@ export async function processFilePreviewStreamEvent(input: {
 
         await emitPreviewEvent(streamEvent, options, {
           toolCallId,
-          toolName: 'workspace_file',
+          toolName: 'prepare_file_edit',
           previewPhase: 'file_preview_start',
         })
         await emitPreviewEvent(streamEvent, options, {
           toolCallId,
-          toolName: 'workspace_file',
+          toolName: 'prepare_file_edit',
           previewPhase: 'file_preview_target',
           operation,
           target: {
@@ -468,7 +468,7 @@ export async function processFilePreviewStreamEvent(input: {
         if (edit) {
           await emitPreviewEvent(streamEvent, options, {
             toolCallId,
-            toolName: 'workspace_file',
+            toolName: 'prepare_file_edit',
             previewPhase: 'file_preview_edit_meta',
             edit,
           })
@@ -480,7 +480,7 @@ export async function processFilePreviewStreamEvent(input: {
   const workspaceResultIntent = getIntent()
   if (
     isToolResultStreamEvent(streamEvent) &&
-    streamEvent.payload.toolName === 'workspace_file' &&
+    streamEvent.payload.toolName === 'prepare_file_edit' &&
     workspaceResultIntent &&
     isContentOperation(workspaceResultIntent.operation)
   ) {
@@ -525,12 +525,12 @@ export async function processFilePreviewStreamEvent(input: {
 
       await emitPreviewEvent(streamEvent, options, {
         toolCallId: intent.toolCallId,
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         previewPhase: 'file_preview_start',
       })
       await emitPreviewEvent(streamEvent, options, {
         toolCallId: intent.toolCallId,
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         previewPhase: 'file_preview_target',
         operation: intent.operation,
         target: {
@@ -543,7 +543,7 @@ export async function processFilePreviewStreamEvent(input: {
       if (intent.edit) {
         await emitPreviewEvent(streamEvent, options, {
           toolCallId: intent.toolCallId,
-          toolName: 'workspace_file',
+          toolName: 'prepare_file_edit',
           previewPhase: 'file_preview_edit_meta',
           edit: intent.edit,
         })
@@ -554,7 +554,7 @@ export async function processFilePreviewStreamEvent(input: {
   const patchDeleteIntent = getIntent()
   if (
     isToolResultStreamEvent(streamEvent) &&
-    streamEvent.payload.toolName === 'workspace_file' &&
+    streamEvent.payload.toolName === 'prepare_file_edit' &&
     patchDeleteIntent &&
     isContentOperation(patchDeleteIntent.operation) &&
     patchDeleteIntent.operation === 'patch' &&
@@ -593,7 +593,7 @@ export async function processFilePreviewStreamEvent(input: {
       await persistFilePreviewSession(nextSession)
       await emitPreviewEvent(streamEvent, options, {
         toolCallId: nextSession.toolCallId,
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         previewPhase: 'file_preview_content',
         content: previewText,
         contentMode: 'snapshot',
@@ -607,7 +607,10 @@ export async function processFilePreviewStreamEvent(input: {
     }
   }
 
-  if (isToolArgsDeltaStreamEvent(streamEvent) && streamEvent.payload.toolName === 'edit_content') {
+  if (
+    isToolArgsDeltaStreamEvent(streamEvent) &&
+    streamEvent.payload.toolName === 'apply_file_edit'
+  ) {
     const toolCallId = streamEvent.payload.toolCallId
     const delta = streamEvent.payload.argumentsDelta
     const stateForTool = editContentState.get(toolCallId) ?? { raw: '' }
@@ -684,7 +687,7 @@ export async function processFilePreviewStreamEvent(input: {
           // collaborative editor for this file is open, that client applies the stream to the shared
           // doc as minimal CRDT diffs (see `applyStreamedMarkdownToLiveDoc` in the editor), which
           // renders smoothly locally AND broadcasts to every peer — so a server-side streaming merge
-          // would double-write the shared doc. The final `edit_content` durable write still reconciles
+          // would double-write the shared doc. The final `apply_file_edit` durable write still reconciles
           // the file and seeds any late joiner.
 
           if (
@@ -713,7 +716,7 @@ export async function processFilePreviewStreamEvent(input: {
 
             await emitPreviewEvent(streamEvent, options, {
               toolCallId: nextSession.toolCallId,
-              toolName: 'workspace_file',
+              toolName: 'prepare_file_edit',
               previewPhase: 'file_preview_content',
               content: previewUpdate.content,
               contentMode: previewUpdate.contentMode,
@@ -738,7 +741,7 @@ export async function processFilePreviewStreamEvent(input: {
     editContentState.set(toolCallId, stateForTool)
   }
 
-  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'edit_content') {
+  if (isToolCallStreamEvent(streamEvent) && streamEvent.payload.toolName === 'apply_file_edit') {
     const toolCallId = streamEvent.payload.toolCallId
     if (toolCallId) {
       editContentState.delete(toolCallId)
@@ -748,7 +751,7 @@ export async function processFilePreviewStreamEvent(input: {
   const editResultIntent = getIntent()
   if (
     isToolResultStreamEvent(streamEvent) &&
-    streamEvent.payload.toolName === 'edit_content' &&
+    streamEvent.payload.toolName === 'apply_file_edit' &&
     editResultIntent
   ) {
     const currentPreview = filePreviewState.get(editResultIntent.toolCallId)
@@ -766,7 +769,7 @@ export async function processFilePreviewStreamEvent(input: {
       })
       await emitPreviewEvent(streamEvent, options, {
         toolCallId: currentPreview.session.toolCallId,
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         previewPhase: 'file_preview_content',
         content: currentPreview.session.previewText,
         contentMode: 'snapshot',
@@ -800,7 +803,7 @@ export async function processFilePreviewStreamEvent(input: {
 
     await emitPreviewEvent(streamEvent, options, {
       toolCallId: editResultIntent.toolCallId,
-      toolName: 'workspace_file',
+      toolName: 'prepare_file_edit',
       previewPhase: 'file_preview_complete',
       fileId: editResultIntent.target.fileId,
       output: streamEvent.payload.output,
diff --git a/apps/sim/lib/copilot/request/go/stream.test.ts b/apps/sim/lib/copilot/request/go/stream.test.ts
index 5921c6e89b..991570b134 100644
--- a/apps/sim/lib/copilot/request/go/stream.test.ts
+++ b/apps/sim/lib/copilot/request/go/stream.test.ts
@@ -181,7 +181,7 @@ describe('copilot go stream helpers', () => {
     expect(decodeJsonStringPrefix('partial \\u26')).toBe('partial ')
   })
 
-  it('extracts the streamed edit_content prefix from partial JSON', () => {
+  it('extracts the streamed apply_file_edit prefix from partial JSON', () => {
     expect(extractEditContent('{"content":"hello\\nwor')).toBe('hello\nwor')
     expect(extractEditContent('{"content":"tab\\tvalue"}')).toBe('tab\tvalue')
   })
@@ -216,7 +216,7 @@ describe('copilot go stream helpers', () => {
     })
   })
 
-  it('hydrates path-based workspace_file edits into file preview events before edit_content streams', async () => {
+  it('hydrates path-based prepare_file_edit edits into file preview events before apply_file_edit streams', async () => {
     listAllWorkspaceFilesMock.mockResolvedValue({
       files: [{ id: 'file-1', name: 'notes.md', folderPath: null }],
     })
@@ -229,7 +229,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'workspace-file-path-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.call,
@@ -248,7 +248,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'workspace-file-path-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.result,
@@ -267,7 +267,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'edit-content-path-1',
-        toolName: 'edit_content',
+        toolName: 'apply_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.args_delta,
@@ -282,7 +282,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'edit-content-path-1',
-        toolName: 'edit_content',
+        toolName: 'apply_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.result,
@@ -378,7 +378,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'workspace-file-alias-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.call,
@@ -397,7 +397,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'edit-content-alias-1',
-        toolName: 'edit_content',
+        toolName: 'apply_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.args_delta,
@@ -412,7 +412,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'edit-content-alias-1',
-        toolName: 'edit_content',
+        toolName: 'apply_file_edit',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.result,
@@ -492,7 +492,7 @@ describe('copilot go stream helpers', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'tool-result-dedupe',
-        toolName: 'search_online',
+        toolName: 'web_search',
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.result,
@@ -541,7 +541,7 @@ describe('copilot go stream helpers', () => {
     expect(context.toolCalls.get('tool-result-dedupe')).toEqual(
       expect.objectContaining({
         id: 'tool-result-dedupe',
-        name: 'search_online',
+        name: 'web_search',
         status: MothershipStreamV1ToolOutcome.success,
         result: { success: true, output: { value: 'ok' } },
       })
@@ -936,4 +936,70 @@ describe('copilot go stream helpers', () => {
     expect(subagentBlock?.parentSpanId).toBe('S1')
     expect(subagentBlock?.parentToolCallId).toBe('tc-deploy-inner')
   })
+
+  it('backfills the display name when only the second subagent start carries it', async () => {
+    const scope = {
+      lane: 'subagent' as const,
+      agentId: 'research',
+      parentToolCallId: 'tc-research',
+      spanId: 'S3',
+      parentSpanId: 'S1',
+    }
+    vi.mocked(fetch).mockResolvedValueOnce(
+      createSseResponse([
+        // Dispatch-time start: fires before the trigger args stream, so no name.
+        createEvent({
+          streamId: 'stream-1',
+          cursor: '1',
+          seq: 1,
+          requestId: 'req-1',
+          type: MothershipStreamV1EventType.span,
+          scope,
+          payload: {
+            kind: 'subagent',
+            event: 'start',
+            agent: 'research',
+            data: { tool_call_id: 'tc-research' },
+          },
+        }),
+        // Phase-3 start re-announces the lane WITH the orchestrator-chosen name.
+        createEvent({
+          streamId: 'stream-1',
+          cursor: '2',
+          seq: 2,
+          requestId: 'req-1',
+          type: MothershipStreamV1EventType.span,
+          scope,
+          payload: {
+            kind: 'subagent',
+            event: 'start',
+            agent: 'research',
+            data: { tool_call_id: 'tc-research', name: 'Pricing research' },
+          },
+        }),
+        createEvent({
+          streamId: 'stream-1',
+          cursor: '3',
+          seq: 3,
+          requestId: 'req-1',
+          type: MothershipStreamV1EventType.complete,
+          payload: { status: MothershipStreamV1CompletionStatus.complete },
+        }),
+      ])
+    )
+
+    const context = createStreamingContext()
+    const execContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+    }
+
+    await runStreamLoop('https://example.com/mothership/stream', {}, context, execContext, {
+      timeout: 1000,
+    })
+
+    const subagentBlocks = context.contentBlocks.filter((block) => block.type === 'subagent')
+    expect(subagentBlocks).toHaveLength(1)
+    expect(subagentBlocks[0]?.subagentName).toBe('Pricing research')
+  })
 })
diff --git a/apps/sim/lib/copilot/request/go/stream.ts b/apps/sim/lib/copilot/request/go/stream.ts
index 3377e6bd6b..9608589cb0 100644
--- a/apps/sim/lib/copilot/request/go/stream.ts
+++ b/apps/sim/lib/copilot/request/go/stream.ts
@@ -432,17 +432,36 @@ export async function runStreamLoop(
               context.subAgentToolCalls[toolCallId] ??= []
             }
             if (toolCallId && subagentName) {
+              const payloadData = streamEvent.payload.data
+              const rawName =
+                payloadData && typeof payloadData === 'object' && !Array.isArray(payloadData)
+                  ? (payloadData as Record<string, unknown>).name
+                  : undefined
+              const displayName = typeof rawName === 'string' && rawName ? rawName : undefined
               const openParents = (context.openSubagentParents ??= new Set<string>())
               if (!openParents.has(toolCallId)) {
                 openParents.add(toolCallId)
                 context.contentBlocks.push({
                   type: 'subagent',
                   content: subagentName,
+                  ...(displayName ? { subagentName: displayName } : {}),
                   parentToolCallId: toolCallId,
                   ...(spanId ? { spanId } : {}),
                   ...(parentSpanId ? { parentSpanId } : {}),
                   timestamp: Date.now(),
                 })
+              } else if (displayName) {
+                // The lane was opened by the dispatch-time start, which fires
+                // before the trigger args (and therefore the name) exist. The
+                // phase-3 start re-announces the lane WITH the name; backfill
+                // it instead of dropping the duplicate wholesale.
+                for (let i = context.contentBlocks.length - 1; i >= 0; i--) {
+                  const b = context.contentBlocks[i]
+                  if (b.type === 'subagent' && b.parentToolCallId === toolCallId) {
+                    if (!b.subagentName) b.subagentName = displayName
+                    break
+                  }
+                }
               }
             } else {
               logger.warn('subagent start missing toolCallId or agent name', {
diff --git a/apps/sim/lib/copilot/request/handlers/handlers.test.ts b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
index 9bcf12d9d7..aa4ef86a6a 100644
--- a/apps/sim/lib/copilot/request/handlers/handlers.test.ts
+++ b/apps/sim/lib/copilot/request/handlers/handlers.test.ts
@@ -15,10 +15,16 @@ const { isSimExecuted, executeTool, ensureHandlersRegistered, toolRequiresApprov
   })
 )
 
-const { upsertAsyncToolCall, markAsyncToolRunning, completeAsyncToolCall } = vi.hoisted(() => ({
+const {
+  upsertAsyncToolCall,
+  markAsyncToolRunning,
+  completeAsyncToolCall,
+  claimWorkflowToolExecution,
+} = vi.hoisted(() => ({
   upsertAsyncToolCall: vi.fn(),
   markAsyncToolRunning: vi.fn(),
   completeAsyncToolCall: vi.fn(),
+  claimWorkflowToolExecution: vi.fn().mockResolvedValue(null),
 }))
 
 const { waitForClientToolCompletion, waitForToolCompletion, waitForWorkflowToolCompletion } =
@@ -56,6 +62,7 @@ vi.mock('@/lib/copilot/async-runs/repository', () => ({
   upsertAsyncToolCall,
   markAsyncToolRunning,
   completeAsyncToolCall,
+  claimWorkflowToolExecution,
 }))
 
 vi.mock('@/lib/copilot/request/tools/client', () => ({
@@ -80,7 +87,7 @@ import {
   MothershipStreamV1ToolOutcome,
   MothershipStreamV1ToolPhase,
 } from '@/lib/copilot/generated/mothership-stream-v1'
-import { FunctionExecute, Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { Read as ReadTool, RunFunction } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   prePersistClientExecutableToolCall,
   sseHandlers,
@@ -136,6 +143,57 @@ describe('sse-handlers tool lifecycle', () => {
     }
   })
 
+  it('pins the workflow target into the args it persists and forwards', async () => {
+    // The browser resolved its own target from the open tab while the server
+    // resolved the run's workflow; in a workspace chat those disagreed and every
+    // omitted-argument call was rejected. One stamped field ends that.
+    isSimExecuted.mockReturnValue(false)
+    context.runId = 'run-1'
+    const event = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'run-workflow-1',
+        toolName: 'run_workflow',
+        arguments: {},
+        executor: MothershipStreamV1ToolExecutor.client,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.call,
+      },
+    } satisfies StreamEvent
+
+    await prePersistClientExecutableToolCall(event, context, {}, execContext)
+
+    // Forwarded frame — this is what the browser POSTs back with.
+    expect((event.payload as { arguments?: Record<string, unknown> }).arguments).toEqual({
+      workflowId: 'workflow-1',
+    })
+    expect(upsertAsyncToolCall).toHaveBeenCalledWith(
+      expect.objectContaining({ toolCallId: 'run-workflow-1', args: { workflowId: 'workflow-1' } })
+    )
+  })
+
+  it('leaves an explicit workflow target untouched', async () => {
+    isSimExecuted.mockReturnValue(false)
+    context.runId = 'run-1'
+    const event = {
+      type: MothershipStreamV1EventType.tool,
+      payload: {
+        toolCallId: 'run-workflow-2',
+        toolName: 'run_workflow',
+        arguments: { workflowId: 'workflow-explicit' },
+        executor: MothershipStreamV1ToolExecutor.client,
+        mode: MothershipStreamV1ToolMode.async,
+        phase: MothershipStreamV1ToolPhase.call,
+      },
+    } satisfies StreamEvent
+
+    await prePersistClientExecutableToolCall(event, context, {}, execContext)
+
+    expect(upsertAsyncToolCall).toHaveBeenCalledWith(
+      expect.objectContaining({ args: { workflowId: 'workflow-explicit' } })
+    )
+  })
+
   it('pre-persists browser tools as pending for the desktop authorization claim', async () => {
     isSimExecuted.mockReturnValue(false)
     context.runId = 'run-1'
@@ -186,7 +244,7 @@ describe('sse-handlers tool lifecycle', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'deploy-1',
-        toolName: 'deploy_api',
+        toolName: 'deploy_as_api',
         arguments: { versionName: 'v2' },
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
@@ -201,7 +259,7 @@ describe('sse-handlers tool lifecycle', () => {
     expect(upsertAsyncToolCall).toHaveBeenCalledWith({
       runId: 'run-1',
       toolCallId: 'deploy-1',
-      toolName: 'deploy_api',
+      toolName: 'deploy_as_api',
       args: { versionName: 'v2' },
       status: MothershipStreamV1AsyncToolRecordStatus.pending,
     })
@@ -272,14 +330,14 @@ describe('sse-handlers tool lifecycle', () => {
     context.runId = 'run-1'
     context.toolPermissions = {
       enabled: true,
-      autoAllowed: new Set(['deploy_api']),
+      autoAllowed: new Set(['deploy_as_api']),
     }
 
     const event = {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'deploy-2',
-        toolName: 'deploy_api',
+        toolName: 'deploy_as_api',
         arguments: {},
         executor: MothershipStreamV1ToolExecutor.sim,
         mode: MothershipStreamV1ToolMode.async,
@@ -425,6 +483,33 @@ describe('sse-handlers tool lifecycle', () => {
     )
   })
 
+  it('registers but never dispatches an inband-owned sim tool call', async () => {
+    // Go executes inband-owned calls itself via /api/copilot/tools/execute;
+    // dispatching here too ran the tool twice, racing on mutations.
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-inband',
+          toolName: ReadTool.id,
+          arguments: { path: 'files/a.md' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+          ui: { inbandOwned: true },
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { interactive: true }
+    )
+    await sleep(0)
+
+    expect(context.toolCalls.get('tool-inband')).toBeDefined()
+    expect(executeTool).not.toHaveBeenCalled()
+    expect(context.pendingToolPromises.has('tool-inband')).toBe(false)
+  })
+
   it('preserves primitive tool outputs through async completion persistence', async () => {
     executeTool.mockResolvedValueOnce({ success: true, output: 'done' })
     const onEvent = vi.fn()
@@ -504,7 +589,7 @@ describe('sse-handlers tool lifecycle', () => {
         type: MothershipStreamV1EventType.tool,
         payload: {
           toolCallId: 'tool-function',
-          toolName: FunctionExecute.id,
+          toolName: RunFunction.id,
           arguments: { code: 'return {{SECRET}}' },
           executor: MothershipStreamV1ToolExecutor.sim,
           mode: MothershipStreamV1ToolMode.async,
@@ -578,11 +663,13 @@ describe('sse-handlers tool lifecycle', () => {
     await sleep(0)
     await Promise.allSettled(context.pendingToolPromises.values())
 
+    // The waiter always receives a signal now: the server fallback needs a
+    // handle to cancel its own wait if it ends up running the tool itself.
     expect(waitForWorkflowToolCompletion).toHaveBeenCalledWith({
       toolCallId: 'tool-background',
       workflowId: 'workflow-1',
       timeoutMs: 1000,
-      abortSignal: undefined,
+      abortSignal: expect.any(AbortSignal),
       registry: execContext.resolvedSecretTraceRegistry,
     })
     expect(onEvent).toHaveBeenCalledWith(
@@ -644,6 +731,163 @@ describe('sse-handlers tool lifecycle', () => {
     )
   })
 
+  it('runs a workflow tool server-side when no browser picks it up', async () => {
+    // Nobody claims it, the wait expires, and the server wins the claim.
+    waitForWorkflowToolCompletion.mockResolvedValue(null)
+    claimWorkflowToolExecution.mockResolvedValueOnce({ toolCallId: 'tool-unclaimed' })
+    executeTool.mockResolvedValueOnce({ success: true, output: { ran: 'on-server' } })
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-unclaimed',
+          toolName: 'run_workflow',
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.client,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: true, timeout: 1 }
+    )
+
+    await Promise.allSettled(context.pendingToolPromises.values())
+
+    // Regression guard: the wait sets the call to 'executing' before parking,
+    // and executeToolAndReport short-circuits anything already 'executing'. If
+    // the handoff stops resetting the status, executeTool is never reached and
+    // the workflow silently does not run.
+    expect(executeTool).toHaveBeenCalled()
+    expect(executeTool.mock.calls.at(-1)?.[0]).toBe('run_workflow')
+    // The claimed execution id must reach the handler so the run is attributable.
+    expect(executeTool.mock.calls.at(-1)?.[2]?.boundWorkflowExecutionId).toBeTruthy()
+
+    const workflowResults = onEvent.mock.calls
+      .map(([event]) => event)
+      .filter(
+        (event) =>
+          event?.type === MothershipStreamV1EventType.tool &&
+          event.payload?.toolCallId === 'tool-unclaimed' &&
+          event.payload?.phase === MothershipStreamV1ToolPhase.result
+      )
+    // Exactly one result, from the sim path — no client-flavored duplicate on top.
+    expect(workflowResults).toHaveLength(1)
+    expect(workflowResults[0].payload.executor).toBe(MothershipStreamV1ToolExecutor.sim)
+  })
+
+  it('claims and runs the same workflow when the call omits an explicit workflowId', async () => {
+    // The waiter resolves the target via resolveWorkflowToolTargetId(args, ctx)
+    // while the handler resolves it as params.workflowId || context.workflowId.
+    // If those two ever diverge, the fallback would claim one workflow and run
+    // another.
+    waitForWorkflowToolCompletion.mockResolvedValue(null)
+    claimWorkflowToolExecution.mockResolvedValueOnce({ toolCallId: 'tool-implicit-workflow' })
+    executeTool.mockResolvedValueOnce({ success: true, output: {} })
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-implicit-workflow',
+          toolName: 'run_workflow',
+          arguments: {},
+          executor: MothershipStreamV1ToolExecutor.client,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent: vi.fn(), interactive: true, timeout: 1 }
+    )
+
+    await Promise.allSettled(context.pendingToolPromises.values())
+
+    expect(waitForWorkflowToolCompletion).toHaveBeenCalledWith(
+      expect.objectContaining({ workflowId: 'workflow-1' })
+    )
+    expect(executeTool.mock.calls.at(-1)?.[2]?.workflowId).toBe('workflow-1')
+  })
+
+  it('refuses a workflow tool call with no resolvable workflow target', async () => {
+    // A workspace chat has no run-scoped workflow, so an omitted workflowId
+    // cannot be resolved by anyone on this side. Dispatching would only buy a
+    // rejection the model cannot read, so fail with something it can act on.
+    const workspaceExecContext = { ...execContext, workflowId: '' }
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-unbound-workflow',
+          toolName: 'run_workflow',
+          arguments: {},
+          executor: MothershipStreamV1ToolExecutor.client,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      workspaceExecContext,
+      { onEvent, interactive: true, timeout: 1000 }
+    )
+
+    await Promise.allSettled(context.pendingToolPromises.values())
+
+    // Never handed to a browser, and never claimed server-side.
+    expect(waitForWorkflowToolCompletion).not.toHaveBeenCalled()
+    expect(claimWorkflowToolExecution).not.toHaveBeenCalled()
+
+    const results = onEvent.mock.calls
+      .map(([event]) => event)
+      .filter(
+        (event) =>
+          event?.type === MothershipStreamV1EventType.tool &&
+          event.payload?.toolCallId === 'tool-unbound-workflow' &&
+          event.payload?.phase === MothershipStreamV1ToolPhase.result
+      )
+    expect(results).toHaveLength(1)
+    expect(results[0].payload.status).toBe(MothershipStreamV1ToolOutcome.error)
+    // The message has to name the fix, or the model just retries identically.
+    expect(results[0].payload.output?.error).toContain('workflowId')
+    expect(context.toolCalls.get('tool-unbound-workflow')?.status).toBe(
+      MothershipStreamV1ToolOutcome.error
+    )
+  })
+
+  it('does not run a workflow tool server-side when a browser holds the claim', async () => {
+    waitForWorkflowToolCompletion.mockResolvedValue(null)
+    claimWorkflowToolExecution.mockResolvedValueOnce(null)
+    executeTool.mockClear()
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-claimed-elsewhere',
+          toolName: 'run_workflow',
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.client,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: true, timeout: 1 }
+    )
+
+    await Promise.allSettled(context.pendingToolPromises.values())
+
+    expect(executeTool).not.toHaveBeenCalled()
+  })
+
   it('waits for the desktop client when a static VFS read is explicitly user-local', async () => {
     waitForClientToolCompletion.mockResolvedValueOnce({
       status: 'success',
@@ -880,7 +1124,7 @@ describe('sse-handlers tool lifecycle', () => {
         type: MothershipStreamV1EventType.tool,
         payload: {
           toolCallId: 'function-finalized-args',
-          toolName: FunctionExecute.id,
+          toolName: RunFunction.id,
           arguments: { language: 'javascript', code: 'return {{STALE_SECRET}}' },
           executor: MothershipStreamV1ToolExecutor.sim,
           mode: MothershipStreamV1ToolMode.async,
@@ -898,7 +1142,7 @@ describe('sse-handlers tool lifecycle', () => {
         type: MothershipStreamV1EventType.tool,
         payload: {
           toolCallId: 'function-finalized-args',
-          toolName: FunctionExecute.id,
+          toolName: RunFunction.id,
           arguments: { language: 'javascript', code: 'return 1' },
           executor: MothershipStreamV1ToolExecutor.sim,
           mode: MothershipStreamV1ToolMode.async,
@@ -913,7 +1157,7 @@ describe('sse-handlers tool lifecycle', () => {
     await sleep(0)
 
     expect(executeTool).toHaveBeenCalledWith(
-      FunctionExecute.id,
+      RunFunction.id,
       { language: 'javascript', code: 'return 1' },
       expect.any(Object)
     )
@@ -1369,6 +1613,40 @@ describe('sse-handlers tool lifecycle', () => {
     expect(context.pendingToolPromises.has('tool-inflight')).toBe(false)
   })
 
+  it('leaves a complete terminal state when a tool is cancelled before dispatch', async () => {
+    // A tool cancelled because its stream was already aborted used to get a
+    // status but no `result`. The subagent join requires one, so that single
+    // half-finished tool call was turned into a thrown "missing result" that
+    // killed the entire turn and blamed an unrelated tool.
+    context.wasAborted = true
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-stream-dead',
+          toolName: ReadTool.id,
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.sim,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent: vi.fn(), interactive: false, timeout: 1000 }
+    )
+
+    await sleep(0)
+
+    const toolCall = context.toolCalls.get('tool-stream-dead')
+    expect(executeTool).not.toHaveBeenCalled()
+    expect(toolCall?.status).toBe(MothershipStreamV1ToolOutcome.cancelled)
+    // The part that was missing: a terminal tool must also be complete.
+    expect(toolCall?.result).toEqual({ success: false })
+    expect(toolCall?.error).toBeTruthy()
+  })
+
   it('still executes the tool when async row upsert fails', async () => {
     upsertAsyncToolCall.mockRejectedValueOnce(new Error('db down'))
     executeTool.mockResolvedValueOnce({ success: true, output: { ok: true } })
diff --git a/apps/sim/lib/copilot/request/handlers/span.ts b/apps/sim/lib/copilot/request/handlers/span.ts
index 2ad6dcf338..ba2fba1caa 100644
--- a/apps/sim/lib/copilot/request/handlers/span.ts
+++ b/apps/sim/lib/copilot/request/handlers/span.ts
@@ -3,6 +3,7 @@ import {
   MothershipStreamV1SpanPayloadKind,
 } from '@/lib/copilot/generated/mothership-stream-v1'
 import type { StreamHandler } from './types'
+import { addContentBlock } from './types'
 
 /**
  * Mirror Go-emitted span lifecycle events onto the Sim-side TraceCollector.
@@ -34,6 +35,46 @@ export const handleSpanEvent: StreamHandler = (event, context) => {
     // (e.g. two parallel `research` subagents) get distinct trace spans. Fall
     // back to agent:parentToolCallId for legacy events that predate span ids.
     const traceKey = event.scope?.spanId || `${scopeAgent}:${event.scope?.parentToolCallId || ''}`
+    // Persist the lane's lifecycle markers. Without a `subagent` start block,
+    // the transcript parser falls back to grouping lane content by agent NAME
+    // — so a respawned agent of the same type (a second concurrent `search`)
+    // silently merges into the first one's card and appears "missing" until
+    // that one resolves. Keyed and deduped by spanId, so every invocation —
+    // including same-type concurrent respawns — gets its own group.
+    const startData = payload.data as Record<string, unknown> | undefined
+    if (evt === MothershipStreamV1SpanLifecycleEvent.start) {
+      context.openSubagentSpans ??= new Set()
+      if (!context.openSubagentSpans.has(traceKey)) {
+        context.openSubagentSpans.add(traceKey)
+        addContentBlock(context, {
+          type: 'subagent',
+          content: scopeAgent,
+          ...(event.scope?.parentToolCallId
+            ? { parentToolCallId: event.scope.parentToolCallId }
+            : {}),
+          ...(event.scope?.spanId ? { spanId: event.scope.spanId } : {}),
+          ...(event.scope?.parentSpanId ? { parentSpanId: event.scope.parentSpanId } : {}),
+          ...(typeof startData?.name === 'string' && startData.name
+            ? { subagentName: startData.name }
+            : {}),
+        })
+      }
+    } else if (evt === MothershipStreamV1SpanLifecycleEvent.end) {
+      if (context.openSubagentSpans?.has(traceKey)) {
+        context.openSubagentSpans.delete(traceKey)
+        for (let i = context.contentBlocks.length - 1; i >= 0; i--) {
+          const b = context.contentBlocks[i]
+          if (
+            b.type === 'subagent' &&
+            b.endedAt === undefined &&
+            (b.spanId || '') === (event.scope?.spanId || '')
+          ) {
+            b.endedAt = Date.now()
+            break
+          }
+        }
+      }
+    }
     if (evt === MothershipStreamV1SpanLifecycleEvent.start) {
       const span = context.trace.startSpan(`subagent:${scopeAgent}`, 'go.subagent', {
         agent: scopeAgent,
diff --git a/apps/sim/lib/copilot/request/handlers/tool.ts b/apps/sim/lib/copilot/request/handlers/tool.ts
index 415e7475ee..371fa28894 100644
--- a/apps/sim/lib/copilot/request/handlers/tool.ts
+++ b/apps/sim/lib/copilot/request/handlers/tool.ts
@@ -2,9 +2,12 @@ import { isBrowserToolName } from '@sim/browser-protocol'
 import { createLogger } from '@sim/logger'
 import { isTerminalToolName } from '@sim/terminal-protocol'
 import { getErrorMessage, toError } from '@sim/utils/errors'
-import type { AsyncCompletionSignal } from '@/lib/copilot/async-runs/lifecycle'
+import type {
+  AsyncCompletionSignal,
+  AsyncTerminalCompletionSnapshot,
+} from '@/lib/copilot/async-runs/lifecycle'
 import { upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
-import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
+import { COPILOT_WORKFLOW_TOOL_CLIENT_GRACE_MS, STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
 import {
   MothershipStreamV1AsyncToolRecordStatus,
   type MothershipStreamV1ToolCallDescriptor,
@@ -12,7 +15,6 @@ import {
   MothershipStreamV1ToolOutcome,
   type MothershipStreamV1ToolResultPayload,
 } from '@/lib/copilot/generated/mothership-stream-v1'
-import { BrowserRequestTakeover } from '@/lib/copilot/generated/tool-catalog-v1'
 import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
 import { TraceSpan } from '@/lib/copilot/generated/trace-spans-v1'
 import { withCopilotSpan } from '@/lib/copilot/request/otel'
@@ -24,10 +26,7 @@ import {
 } from '@/lib/copilot/request/session'
 import { markToolResultSeen, wasToolResultSeen } from '@/lib/copilot/request/sse-utils'
 import { setTerminalToolCallState } from '@/lib/copilot/request/tool-call-state'
-import {
-  waitForClientToolCompletion,
-  waitForWorkflowToolCompletion,
-} from '@/lib/copilot/request/tools/client'
+import { waitForClientToolCompletion } from '@/lib/copilot/request/tools/client'
 import { sealClientToolContext } from '@/lib/copilot/request/tools/client-completion-seal.server'
 import { executeToolAndReport } from '@/lib/copilot/request/tools/executor'
 import {
@@ -35,6 +34,7 @@ import {
   TOOL_AWAITING_APPROVAL_STATUS,
   toolCallNeedsApproval,
 } from '@/lib/copilot/request/tools/permission'
+import { raceWorkflowToolClientPickup } from '@/lib/copilot/request/tools/workflow-client-fallback'
 import type {
   ExecutionContext,
   OrchestratorOptions,
@@ -45,6 +45,7 @@ import type {
 import { getToolEntry, isSimExecuted } from '@/lib/copilot/tool-executor'
 import { isToolHiddenInUi } from '@/lib/copilot/tools/client/hidden-tools'
 import { isUserLocalVfsToolCall } from '@/lib/copilot/tools/local-filesystem'
+import { RETIRED_BROWSER_REQUEST_TAKEOVER_ID } from '@/lib/copilot/tools/retired-tools'
 import { extractStreamingStringArgument } from '@/lib/copilot/tools/streaming-args'
 import { getToolDisplayTitle } from '@/lib/copilot/tools/tool-display'
 import { isWorkflowToolName, resolveWorkflowToolTargetId } from '@/lib/copilot/tools/workflow-tools'
@@ -225,6 +226,22 @@ export async function prePersistClientExecutableToolCall(
 
   if (!context.runId) return
 
+  // Pin the workflow target into the arguments before they are sealed, persisted,
+  // and forwarded, so the row, the browser, and the completion waiter all read one
+  // explicit field.
+  //
+  // They used to disagree: the server resolved `args.workflowId ?? run.workflowId`
+  // while the browser resolved `args.workflowId ?? activeWorkflowId`. In a
+  // workspace chat `copilot_runs.workflow_id` is NULL, so every call that omitted
+  // the (optional) argument resolved to nothing server-side and to the open tab
+  // client-side — a guaranteed rejection at the execute endpoint.
+  if (isWorkflowToolName(data.toolName)) {
+    const targetWorkflowId = resolveWorkflowToolTargetId(data.arguments, execContext?.workflowId)
+    if (targetWorkflowId) {
+      data.arguments = { ...(data.arguments ?? {}), workflowId: targetWorkflowId }
+    }
+  }
+
   let sealedContext: Awaited<ReturnType<typeof sealClientToolContext>> | undefined
   if (execContext?.resolvedSecretTraceRegistry) {
     try {
@@ -484,18 +501,23 @@ async function handleCallPhase(
   if (!toolCall) return
 
   // Capture the invoking subagent's channel id so the executor can thread it
-  // into the server tool context — this is what scopes the workspace_file ->
-  // edit_content intent handoff to one file subagent under concurrency.
+  // into the server tool context — this is what scopes the prepare_file_edit ->
+  // apply_file_edit intent handoff to one file subagent under concurrency.
   if (parentToolCallId) toolCall.parentToolCallId = parentToolCallId
 
   const readPath = typeof args?.path === 'string' ? args.path : undefined
   if (toolName === 'read' && readPath?.startsWith('internal/')) return
 
-  const { clientExecutable, simExecutable, internal } = ui
+  const { clientExecutable, simExecutable, internal, inbandOwned } = ui
   const catalogEntry = getToolEntry(toolName)
   const isInternal = internal || catalogEntry?.internal === true
   const staticSimExecuted = isSimExecuted(toolName)
-  const willDispatch = !isInternal && (staticSimExecuted || simExecutable || clientExecutable)
+  // Go executes inband-owned calls itself via /api/copilot/tools/execute
+  // (background lanes, and the main lane while background agents run); the
+  // event exists only to draw the row. Dispatching it here would run the
+  // tool a second time, racing the in-band execution on mutations.
+  const willDispatch =
+    !isInternal && !inbandOwned && (staticSimExecuted || simExecutable || clientExecutable)
   logger.info('Tool call routing decision', {
     toolCallId,
     toolName,
@@ -507,6 +529,7 @@ async function handleCallPhase(
     simExecutable,
     staticSimExecuted,
     internal: isInternal,
+    inbandOwned,
     hasPendingPromise: context.pendingToolPromises.has(toolCallId),
     existingStatus: existing?.status,
     willDispatch,
@@ -671,9 +694,11 @@ async function dispatchToolExecution(
 ): Promise<void> {
   const scopeLabel = scope === 'subagent' ? 'subagent ' : ''
 
-  const fireToolExecution = (): Promise<AsyncCompletionSignal> => {
+  const fireToolExecution = (
+    execContextOverride?: ExecutionContext
+  ): Promise<AsyncCompletionSignal> => {
     return (async () => {
-      return executeToolAndReport(toolCallId, context, execContext, options)
+      return executeToolAndReport(toolCallId, context, execContextOverride ?? execContext, options)
     })().catch((err) => {
       logger.error(`Parallel ${scopeLabel}tool execution failed`, {
         toolCallId,
@@ -688,6 +713,39 @@ async function dispatchToolExecution(
     })
   }
 
+  /**
+   * Refuse a workflow tool call whose target this side cannot name.
+   *
+   * The execute endpoint validates the run against the tool call's bound
+   * workflow, so dispatching an unbound call only buys a rejection the model
+   * cannot interpret. Failing here instead tells it exactly what to send back,
+   * and never guesses a workflow on the user's behalf.
+   */
+  const refuseUnboundWorkflowTool = async (): Promise<AsyncCompletionSignal> => {
+    const error = `${toolName} requires an explicit workflowId. This chat is not scoped to a workflow, so there is no current workflow to fall back to — pass the id of the workflow to run.`
+    logger.warn('Refusing workflow tool call with no resolvable workflow target', {
+      toolCallId,
+      toolName,
+    })
+    setTerminalToolCallState(toolCall, {
+      status: MothershipStreamV1ToolOutcome.error,
+      output: { error },
+      error,
+    })
+    markToolResultSeen(toolCallId)
+    await emitSyntheticToolResult(
+      toolCallId,
+      toolCall.name,
+      {
+        status: MothershipStreamV1ToolOutcome.error,
+        message: error,
+        data: { error },
+      },
+      options
+    )
+    return { status: MothershipStreamV1ToolOutcome.error, message: error, data: { error } }
+  }
+
   // Returns the promise instead of registering it, so the permission gate can
   // wrap the whole thing in one pending promise that stays unsettled until the
   // tool has actually run. Null means nothing was dispatched.
@@ -705,6 +763,12 @@ async function dispatchToolExecution(
         if (abortPendingToolIfStreamDead(toolCall, toolCallId, options, context)) return null
         return fireToolExecution()
       }
+      if (
+        delegateWorkflowRunToClient &&
+        !resolveWorkflowToolTargetId(args, execContext.workflowId)
+      ) {
+        return refuseUnboundWorkflowTool()
+      }
       return waitForClientExecution()
     }
 
@@ -743,7 +807,7 @@ async function dispatchToolExecution(
    */
   function waitForClientExecution(): Promise<AsyncCompletionSignal> {
     toolCall.status = 'executing'
-    const waitsForHuman = toolName === BrowserRequestTakeover.id
+    const waitsForHuman = toolName === RETIRED_BROWSER_REQUEST_TAKEOVER_ID
     const timeoutMs = waitsForHuman ? null : options.timeout || STREAM_TIMEOUT_MS
     return withCopilotSpan(
       TraceSpan.CopilotToolWaitForClientResult,
@@ -754,23 +818,58 @@ async function dispatchToolExecution(
         ...(context.runId ? { [TraceAttr.RunId]: context.runId } : {}),
       },
       async (span) => {
-        const completion = isWorkflowToolName(toolName)
-          ? await waitForWorkflowToolCompletion({
-              toolCallId,
-              workflowId: resolveWorkflowToolTargetId(args, execContext.workflowId),
-              timeoutMs: timeoutMs ?? STREAM_TIMEOUT_MS,
-              abortSignal: options.abortSignal,
-              registry: execContext.resolvedSecretTraceRegistry,
-            })
-          : await waitForClientToolCompletion({
-              toolCallId,
-              runId: context.runId,
-              userId: execContext.userId,
-              timeoutMs,
-              abortSignal: options.abortSignal,
-              registry: execContext.resolvedSecretTraceRegistry,
-            })
-        span.setAttribute(TraceAttr.ToolCompletionReceived, completion !== undefined)
+        let completion: AsyncTerminalCompletionSnapshot | null
+        if (isWorkflowToolName(toolName)) {
+          const race = await raceWorkflowToolClientPickup({
+            toolCallId,
+            workflowId: resolveWorkflowToolTargetId(args, execContext.workflowId),
+            timeoutMs: timeoutMs ?? STREAM_TIMEOUT_MS,
+            graceMs: COPILOT_WORKFLOW_TOOL_CLIENT_GRACE_MS,
+            abortSignal: options.abortSignal,
+            registry: execContext.resolvedSecretTraceRegistry,
+            runOnServer: (boundExecutionId) => {
+              // `executeToolAndReportInner` short-circuits a call that is
+              // already 'executing' — which is exactly what this wait set it to
+              // before parking. Hand it back the state it dispatches from.
+              toolCall.status = 'pending'
+              return fireToolExecution({
+                ...execContext,
+                boundWorkflowExecutionId: boundExecutionId,
+              })
+            },
+          })
+
+          if (race.winner === 'sim') {
+            // `executeToolAndReport` already emitted its own `executor: sim`
+            // result and marked it seen, so the client-completion bookkeeping
+            // below must not run again on top of it.
+            span.setAttribute(TraceAttr.ToolExecutor, MothershipStreamV1ToolExecutor.sim)
+            if (race.signal) {
+              span.setAttribute(TraceAttr.ToolOutcome, race.signal.status)
+            }
+            return (
+              race.signal ?? {
+                status: MothershipStreamV1ToolOutcome.error,
+                message: 'Tool completion missing',
+                data: { error: 'Tool completion missing' },
+              }
+            )
+          }
+          completion = race.completion ?? null
+        } else {
+          completion = await waitForClientToolCompletion({
+            toolCallId,
+            runId: context.runId,
+            userId: execContext.userId,
+            timeoutMs,
+            abortSignal: options.abortSignal,
+            registry: execContext.resolvedSecretTraceRegistry,
+          })
+        }
+        span.setAttribute(TraceAttr.ToolExecutor, MothershipStreamV1ToolExecutor.client)
+        // Both waiters resolve `T | null`, never undefined — comparing against
+        // undefined made this a constant `true` and hid every timeout.
+        span.setAttribute(TraceAttr.ToolCompletionReceived, completion !== null)
         if (completion) {
           span.setAttribute(TraceAttr.ToolOutcome, completion.status)
         }
diff --git a/apps/sim/lib/copilot/request/handlers/types.ts b/apps/sim/lib/copilot/request/handlers/types.ts
index 79338a4b59..6145b264bc 100644
--- a/apps/sim/lib/copilot/request/handlers/types.ts
+++ b/apps/sim/lib/copilot/request/handlers/types.ts
@@ -16,6 +16,8 @@ import {
   MothershipStreamV1ToolPhase,
   type MothershipStreamV1ToolResultPayload,
 } from '@/lib/copilot/generated/mothership-stream-v1'
+import { CopilotDegradedReason } from '@/lib/copilot/generated/trace-attribute-values-v1'
+import { recordDegraded } from '@/lib/copilot/request/metrics'
 import { markToolResultSeen } from '@/lib/copilot/request/sse-utils'
 import { setTerminalToolCallState } from '@/lib/copilot/request/tool-call-state'
 import type {
@@ -149,17 +151,37 @@ export function abortPendingToolIfStreamDead(
   if (!options.abortSignal?.aborted && !context.wasAborted) {
     return false
   }
-  toolCall.status = MothershipStreamV1ToolOutcome.cancelled
-  toolCall.endTime = Date.now()
+  const abortReason = options.abortSignal?.aborted
+    ? String(options.abortSignal.reason ?? 'unknown')
+    : undefined
+  // Go through the canonical terminal helper rather than stamping status by
+  // hand: it also writes `result`, and everything downstream that reads a
+  // finished tool call requires one. Leaving it unset made this call look
+  // terminal-but-incomplete, which the subagent join turned into a thrown
+  // "missing result" error that killed the whole turn.
+  setTerminalToolCallState(toolCall, {
+    status: MothershipStreamV1ToolOutcome.cancelled,
+    error: 'Tool was not dispatched because its stream had already been aborted',
+  })
   markToolResultSeen(toolCallId)
+  // Sim's logs do not reach Loki and the trace span below is collected
+  // in-process but never exported, so the counter is the only signal that
+  // survives to somewhere queryable.
+  recordDegraded(CopilotDegradedReason.StreamDeadBeforeDispatch)
+  logger.warn('Cancelled tool call before dispatch: stream already aborted', {
+    toolCallId,
+    toolName: toolCall.name,
+    reason: 'stream_dead_before_dispatch',
+    abortSignalAborted: options.abortSignal?.aborted ?? false,
+    ...(abortReason ? { abortReason } : {}),
+    wasAborted: context.wasAborted ?? false,
+  })
   const toolSpan = context.trace.startSpan(toolCall.name || 'unknown_tool', 'tool.execute', {
     toolCallId,
     toolName: toolCall.name,
     cancelReason: 'stream_dead_before_dispatch',
     abortSignalAborted: options.abortSignal?.aborted ?? false,
-    abortReason: options.abortSignal?.aborted
-      ? String(options.abortSignal.reason ?? 'unknown')
-      : undefined,
+    abortReason,
     wasAborted: context.wasAborted ?? false,
   })
   context.trace.endSpan(toolSpan, 'cancelled')
@@ -176,6 +198,7 @@ export function getToolCallUI(data: MothershipStreamV1ToolCallDescriptor): {
   simExecutable: boolean
   internal: boolean
   hidden: boolean
+  inbandOwned: boolean
 } {
   const raw = toRecord(data.ui)
   return {
@@ -184,6 +207,7 @@ export function getToolCallUI(data: MothershipStreamV1ToolCallDescriptor): {
     simExecutable: data.executor === MothershipStreamV1ToolExecutor.sim,
     internal: raw.internal === true,
     hidden: raw.hidden === true,
+    inbandOwned: raw.inbandOwned === true,
   }
 }
 
diff --git a/apps/sim/lib/copilot/request/lifecycle/headless.test.ts b/apps/sim/lib/copilot/request/lifecycle/headless.test.ts
index d31751c4ad..42f2fbd9eb 100644
--- a/apps/sim/lib/copilot/request/lifecycle/headless.test.ts
+++ b/apps/sim/lib/copilot/request/lifecycle/headless.test.ts
@@ -98,6 +98,24 @@ describe('runHeadlessCopilotLifecycle', () => {
     expect(result.success).toBe(false)
   })
 
+  it('forces the server-owned headless classification', async () => {
+    runCopilotLifecycle.mockResolvedValueOnce(createLifecycleResult())
+
+    await runHeadlessCopilotLifecycle(
+      { message: 'hello', messageId: 'req-classification' },
+      {
+        userId: 'user-1',
+        workflowId: 'workflow-1',
+        interactive: true,
+      }
+    )
+
+    expect(runCopilotLifecycle).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({ interactive: false })
+    )
+  })
+
   it('prefers an explicit simRequestId over the payload messageId', async () => {
     runCopilotLifecycle.mockResolvedValueOnce(createLifecycleResult())
 
diff --git a/apps/sim/lib/copilot/request/lifecycle/headless.ts b/apps/sim/lib/copilot/request/lifecycle/headless.ts
index 0e5172280a..654c050b2a 100644
--- a/apps/sim/lib/copilot/request/lifecycle/headless.ts
+++ b/apps/sim/lib/copilot/request/lifecycle/headless.ts
@@ -49,6 +49,7 @@ export async function runHeadlessCopilotLifecycle(
       try {
         result = await runCopilotLifecycle(requestPayload, {
           ...options,
+          interactive: false,
           trace,
           simRequestId,
           otelContext,
diff --git a/apps/sim/lib/copilot/request/lifecycle/resume-leg-context.test.ts b/apps/sim/lib/copilot/request/lifecycle/resume-leg-context.test.ts
index 68fb457f07..37fff6f90c 100644
--- a/apps/sim/lib/copilot/request/lifecycle/resume-leg-context.test.ts
+++ b/apps/sim/lib/copilot/request/lifecycle/resume-leg-context.test.ts
@@ -9,6 +9,10 @@ import { makeResumeLegContext, mergeResumeLegOutputs } from '@/lib/copilot/reque
 // all concurrent legs build one chat. This is the regression the inline comment
 // warns about — without per-leg isolation the orchestrator's pre-fanout content
 // gets multiplied by the leg count on merge.
+//
+// `wasAborted` is the one deliberate exception to "reset AND folded back": it is
+// reset per leg but folded back only for a turn-level abort, because a fanout
+// cancelling its own lanes must not mark the shared turn aborted.
 describe('resume leg context isolate/merge contract', () => {
   it('isolates the per-leg scalars while sharing the heavy accumulators by reference', () => {
     const base = createStreamingContext({
@@ -31,6 +35,9 @@ describe('resume leg context isolate/merge contract', () => {
     expect(leg.streamComplete).toBe(false)
     expect(leg.awaitingAsyncContinuation).toBeUndefined()
     expect(leg.completionStatus).toBeUndefined()
+    // A leg must never be born aborted — that is what let one cancelled lane
+    // cancel every tool dispatched on every lane created after it.
+    expect(leg.wasAborted).toBe(false)
 
     // A leg's own errors array is a fresh array (not the shared one) so a leg's
     // retry rollback can't truncate a sibling's errors.
@@ -65,6 +72,34 @@ describe('resume leg context isolate/merge contract', () => {
     expect(base.completionStatus).toBe(MothershipStreamV1CompletionStatus.complete)
   })
 
+  it('does not fold a fanout-induced abort onto the shared turn', () => {
+    // A lane that fails cancels its siblings by design, and each cancelled
+    // sibling returns normally with wasAborted set. Folding that marked the
+    // SHARED context aborted, so every leg created afterwards was born aborted
+    // and every tool it dispatched was cancelled before dispatch — which the
+    // subagent join then reported as a fatal "missing result".
+    const base = createStreamingContext({})
+    const leg = makeResumeLegContext(base)
+    leg.wasAborted = true
+
+    mergeResumeLegOutputs(base, leg, false)
+
+    expect(base.wasAborted).toBe(false)
+  })
+
+  it('folds a turn-level abort onto the shared turn', () => {
+    // The other half: a real Stop (or an observed abort marker) must reach the
+    // shared context, because that is what classifies the request as cancelled
+    // rather than successful.
+    const base = createStreamingContext({})
+    const leg = makeResumeLegContext(base)
+    leg.wasAborted = true
+
+    mergeResumeLegOutputs(base, leg, true)
+
+    expect(base.wasAborted).toBe(true)
+  })
+
   it('leaves the turn unfinished when only child legs fold back', () => {
     const base = createStreamingContext()
 
diff --git a/apps/sim/lib/copilot/request/lifecycle/run.test.ts b/apps/sim/lib/copilot/request/lifecycle/run.test.ts
index 5f535532f5..c63e883116 100644
--- a/apps/sim/lib/copilot/request/lifecycle/run.test.ts
+++ b/apps/sim/lib/copilot/request/lifecycle/run.test.ts
@@ -207,6 +207,48 @@ describe('runCopilotLifecycle', () => {
     expect(executionContext).not.toHaveProperty('resolvedSecretTraceRegistry')
   })
 
+  it.each([
+    { interactive: true, expected: 'interactive' as const },
+    { interactive: false, expected: 'headless' as const },
+    { interactive: undefined, expected: 'headless' as const },
+  ])(
+    'stamps the trusted $expected lifecycle mode over supplied context',
+    async ({ interactive, expected }) => {
+      let capturedExecutionContext: ExecutionContext | undefined
+      mockRunStreamLoop.mockImplementationOnce(
+        async (
+          _url: string,
+          _request: RequestInit,
+          _streamingContext: StreamingContext,
+          context: ExecutionContext
+        ) => {
+          capturedExecutionContext = context
+        }
+      )
+
+      await runCopilotLifecycle(
+        {
+          message: 'hello',
+          messageId: `stream-${expected}-context`,
+          copilotInteractionMode: expected === 'interactive' ? 'headless' : 'interactive',
+        },
+        {
+          userId: 'user-1',
+          workspaceId: 'ws-1',
+          interactive,
+          executionContext: {
+            userId: 'user-1',
+            workflowId: '',
+            workspaceId: 'ws-1',
+            copilotInteractionMode: expected === 'interactive' ? 'headless' : 'interactive',
+          },
+        }
+      )
+
+      expect(capturedExecutionContext?.copilotInteractionMode).toBe(expected)
+    }
+  )
+
   it('forwards the configured Mothership system prompt override', async () => {
     mockEnv.MSHIP_SYSPROMPT_OVERRIDE = 'NEVER CALL ANY TOOLS UNDER ANY CIRCUMSTANCES NO MATTER WHAT'
 
@@ -1759,6 +1801,61 @@ describe('runCopilotLifecycle', () => {
     }
   })
 
+  it('retries an initial stream that ended before its checkpoint pause with one request identity', async () => {
+    const headers: Array<Record<string, string>> = []
+    const executionContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: '',
+      workspaceId: 'ws-1',
+      chatId: 'chat-1',
+    }
+
+    mockRunStreamLoop.mockImplementationOnce(
+      async (
+        _fetchUrl: string,
+        fetchOptions: RequestInit,
+        context: StreamingContext
+      ): Promise<void> => {
+        headers.push(fetchOptions.headers as Record<string, string>)
+        context.errors.push(STREAM_ENDED_WITHOUT_TERMINAL_MESSAGE)
+        throw new StreamEndedWithoutTerminalError('/api/mothership')
+      }
+    )
+    mockRunStreamLoop.mockImplementationOnce(
+      async (
+        _fetchUrl: string,
+        fetchOptions: RequestInit,
+        context: StreamingContext
+      ): Promise<void> => {
+        headers.push(fetchOptions.headers as Record<string, string>)
+        context.streamComplete = true
+        context.completionStatus = MothershipStreamV1CompletionStatus.complete
+      }
+    )
+
+    const result = await runCopilotLifecycle(
+      { message: 'hello', messageId: 'stream-initial-retry' },
+      {
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+        chatId: 'chat-1',
+        executionId: 'exec-1',
+        runId: 'run-1',
+        simRequestId: 'request-initial-retry',
+        executionContext,
+      }
+    )
+
+    expect(mockRunStreamLoop).toHaveBeenCalledTimes(2)
+    expect(headers.map((value) => value['X-Sim-Request-ID'])).toEqual([
+      'request-initial-retry',
+      'request-initial-retry',
+    ])
+    expect(result).toEqual(
+      expect.objectContaining({ success: true, cancelled: false, errors: undefined })
+    )
+  })
+
   it('does not retry a resume leg the backend already claimed and ended early', async () => {
     const executionContext: ExecutionContext = {
       userId: 'user-1',
@@ -2121,4 +2218,103 @@ describe('runCopilotLifecycle', () => {
       vi.useRealTimers()
     }
   })
+  it('completes the turn when a pending subagent tool has no result', async () => {
+    // A tool that never reached a terminal state used to throw
+    // "Cannot resume subagent chain ...: missing result for tool call ...",
+    // which inside a fanout cancelled every sibling lane and reported the whole
+    // request as an error blaming an unrelated tool. Synthesize the failure Go
+    // already writes for itself instead, and let the turn finish.
+    const bodies: Array<Record<string, unknown>> = []
+    mockRunStreamLoop.mockImplementation(
+      async (
+        fetchUrl: string,
+        fetchOptions: RequestInit,
+        context: StreamingContext
+      ): Promise<void> => {
+        if (!fetchUrl.includes('/api/tools/resume')) {
+          context.awaitingAsyncContinuation = {
+            checkpointId: 'cp-root',
+            pendingToolCallIds: [],
+            frames: [
+              {
+                parentToolCallId: 'subagent-file',
+                parentToolName: 'file',
+                pendingToolIds: ['tool-never-dispatched'],
+                checkpointId: 'cp-file',
+              },
+            ],
+          }
+          return
+        }
+        bodies.push(JSON.parse(String(fetchOptions.body)))
+        context.streamComplete = true
+        context.completionStatus = MothershipStreamV1CompletionStatus.complete
+      }
+    )
+
+    const result = await runCopilotLifecycle(
+      { message: 'hello', messageId: 'stream-missing-subagent-result' },
+      { userId: 'user-1', workspaceId: 'ws-1' }
+    )
+
+    expect(bodies).toHaveLength(1)
+    expect(bodies[0].checkpointId).toBe('cp-file')
+    expect(bodies[0].results).toEqual([
+      expect.objectContaining({
+        callId: 'tool-never-dispatched',
+        success: false,
+        data: { error: expect.stringContaining('no result was returned') },
+      }),
+    ])
+    expect(result.success).toBe(true)
+  })
+
+  it('classifies a Stop landing during a subagent fanout as cancelled', async () => {
+    // Guards the trap in the fanout fix: `wasAborted` is now isolated per leg, so
+    // a user Stop must still reach the turn — via the abort signal or the folded
+    // turn-level abort — or a cancelled turn would be reported as a success.
+    const controller = new AbortController()
+    mockRunStreamLoop.mockImplementation(
+      async (
+        fetchUrl: string,
+        _fetchOptions: RequestInit,
+        context: StreamingContext
+      ): Promise<void> => {
+        if (!fetchUrl.includes('/api/tools/resume')) {
+          context.toolCalls.set('tool-done', {
+            id: 'tool-done',
+            name: 'read',
+            status: MothershipStreamV1ToolOutcome.success,
+            result: { success: true },
+            endTime: Date.now(),
+          })
+          context.awaitingAsyncContinuation = {
+            checkpointId: 'cp-root',
+            pendingToolCallIds: [],
+            frames: [
+              {
+                parentToolCallId: 'subagent-file',
+                parentToolName: 'file',
+                pendingToolIds: ['tool-done'],
+                checkpointId: 'cp-file',
+              },
+            ],
+          }
+          return
+        }
+        // The user hits Stop mid-fanout. `wasAborted` is isolated per leg now, so
+        // the turn's own signal is what has to carry the cancellation into the
+        // classification — reading only `context.wasAborted` reports success.
+        controller.abort('user_stop')
+      }
+    )
+
+    const result = await runCopilotLifecycle(
+      { message: 'hello', messageId: 'stream-stop-during-fanout' },
+      { userId: 'user-1', workspaceId: 'ws-1', abortSignal: controller.signal }
+    )
+
+    expect(result.cancelled).toBe(true)
+    expect(result.success).toBe(false)
+  })
 })
diff --git a/apps/sim/lib/copilot/request/lifecycle/run.ts b/apps/sim/lib/copilot/request/lifecycle/run.ts
index 1471eddfba..79df0daddb 100644
--- a/apps/sim/lib/copilot/request/lifecycle/run.ts
+++ b/apps/sim/lib/copilot/request/lifecycle/run.ts
@@ -28,6 +28,7 @@ import {
   MothershipStreamV1RunKind,
   MothershipStreamV1ToolOutcome,
 } from '@/lib/copilot/generated/mothership-stream-v1'
+import { CopilotDegradedReason } from '@/lib/copilot/generated/trace-attribute-values-v1'
 import { getAutoAllowedTools } from '@/lib/copilot/persistence/tool-permission/auto-allow'
 import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
 import { buildToolCallSummaries } from '@/lib/copilot/request/context/result'
@@ -37,6 +38,8 @@ import {
   runStreamLoop,
   StreamEndedWithoutTerminalError,
 } from '@/lib/copilot/request/go/stream'
+import { recordDegraded } from '@/lib/copilot/request/metrics'
+import { AbortReason } from '@/lib/copilot/request/session/abort-reason'
 import {
   getToolCallTerminalData,
   requireToolCallStateResult,
@@ -285,6 +288,8 @@ export async function runCopilotLifecycle(
       secretMountPolicy: lifecycleOptions.secretMountPolicy,
       secretActorUserId: lifecycleOptions.secretActorUserId,
     }))
+  execContext.copilotInteractionMode =
+    lifecycleOptions.interactive === true ? 'interactive' : 'headless'
   if (goRoute && MOTHERSHIP_CODE_TOOL_ROUTES.has(goRoute)) {
     execContext.sandboxProfile = 'mothership'
   } else {
@@ -346,7 +351,13 @@ export async function runCopilotLifecycle(
     // the work the user watched succeed.
     const backendFinishedTurn =
       context.completionStatus === MothershipStreamV1CompletionStatus.complete
-    const succeeded = !context.wasAborted && (backendFinishedTurn || context.errors.length === 0)
+    // Consult the lifecycle signal as well as the flag. `context.wasAborted` is
+    // only reached from a fanout leg through the (deliberately asymmetric) merge
+    // in `mergeResumeLegOutputs`, so a Stop landing mid-fanout could otherwise
+    // classify the turn as a success. Mirrors the check already used below on
+    // the throw path.
+    const turnWasAborted = context.wasAborted || (lifecycleOptions.abortSignal?.aborted ?? false)
+    const succeeded = !turnWasAborted && (backendFinishedTurn || context.errors.length === 0)
 
     const result: OrchestratorResult = {
       success: succeeded,
@@ -359,7 +370,7 @@ export async function runCopilotLifecycle(
       // path, but practically that doesn't happen in the success
       // branch here — if there are errors we never reach a
       // wasAborted-without-errors state.
-      cancelled: context.wasAborted && context.errors.length === 0,
+      cancelled: turnWasAborted && context.errors.length === 0,
       content: resultContent(context, lifecycleOptions),
       contentBlocks: context.contentBlocks,
       toolCalls: buildToolCallSummaries(context),
@@ -461,10 +472,12 @@ function isPerSubagentContinuation(c: AsyncContinuation): boolean {
 // every resume leg), so the auth/source/version headers can't drift between the
 // sequential path and the concurrent per-subagent resume legs.
 function mothershipRequestHeaders(
-  hostedBillingRequest?: AttributedBillingRequestEnvelope
+  hostedBillingRequest?: AttributedBillingRequestEnvelope,
+  simRequestId?: string
 ): Record<string, string> {
   return {
     'Content-Type': 'application/json',
+    ...(simRequestId ? { 'X-Sim-Request-ID': simRequestId } : {}),
     ...(env.COPILOT_API_KEY ? { 'x-api-key': env.COPILOT_API_KEY } : {}),
     ...getMothershipSourceEnvHeaders(),
     'X-Client-Version': SIM_AGENT_VERSION,
@@ -496,6 +509,12 @@ function mothershipRequestHeaders(
 //   - completionStatus: the backend's terminal verdict, set only on the leg that
 //     carries the turn to its end; a stale one from a sibling would speak for a
 //     turn that leg never finished.
+//   - wasAborted: the ONE field with an asymmetric fold. Cancelling a fanout
+//     cancels its siblings by design, and each cancelled sibling returns
+//     normally with wasAborted set — folding that unconditionally marked the
+//     SHARED context aborted, so every later leg was born aborted and every tool
+//     it dispatched was cancelled before dispatch. Reset per leg, and fold back
+//     only for a turn-level abort (see mergeResumeLegOutputs).
 // When adding a per-leg field, update BOTH functions (and the contract test in
 // resume-leg-context.test.ts). Exported only for that test.
 export function makeResumeLegContext(base: StreamingContext): StreamingContext {
@@ -509,19 +528,30 @@ export function makeResumeLegContext(base: StreamingContext): StreamingContext {
     cost: undefined,
     errors: [],
     completionStatus: undefined,
+    wasAborted: false,
   }
 }
 
 // mergeResumeLegOutputs folds a finished leg's isolated scalars back into the
 // shared context. Child (subagent-lane) legs leave the join scalars empty; only
 // the join-carrying leg (which streams the orchestrator continuation) sets them.
-export function mergeResumeLegOutputs(context: StreamingContext, leg: StreamingContext): void {
+//
+// `turnWasAborted` is the caller's answer to "was this abort the turn's, or just
+// this fanout cancelling its own lanes?". Only a turn-level abort belongs on the
+// shared context: it is what `runCopilotLifecycle` reads to classify the request
+// as cancelled, and on the headless path (which never wires `onAbortObserved`)
+// it is the only record that the abort marker was ever observed.
+export function mergeResumeLegOutputs(
+  context: StreamingContext,
+  leg: StreamingContext,
+  turnWasAborted = true
+): void {
   if (leg.accumulatedContent) context.accumulatedContent += leg.accumulatedContent
   if (leg.finalAssistantContent) context.finalAssistantContent += leg.finalAssistantContent
   if (leg.usage) context.usage = leg.usage
   if (leg.cost) context.cost = leg.cost
   if (leg.sawMainToolCall) context.sawMainToolCall = true
-  if (leg.wasAborted) context.wasAborted = true
+  if (leg.wasAborted && turnWasAborted) context.wasAborted = true
   if (leg.errors.length > 0) context.errors.push(...leg.errors)
   if (leg.completionStatus) context.completionStatus = leg.completionStatus
 }
@@ -535,26 +565,61 @@ async function waitForToolIds(context: StreamingContext, toolIds: string[]): Pro
   if (promises.length > 0) await Promise.allSettled(promises)
 }
 
+interface ResumeToolResult {
+  callId: string
+  name: string
+  data: unknown
+  success: boolean
+}
+
+/**
+ * Build the resume payload entry for one pending tool call.
+ *
+ * A tool that never reached a terminal state has no result to send. That used to
+ * throw — which turned one incomplete tool into a dead turn, and inside a
+ * subagent fanout cancelled every sibling lane and reported the whole request as
+ * an error blaming an unrelated tool. Synthesize the same failure Go already
+ * writes for itself when Sim posts nothing for a pending call, so the model sees
+ * one failed tool and the turn carries on. Still logged at error level: getting
+ * here is a bug, it just must not be fatal.
+ */
+function buildResumeToolResult(
+  context: StreamingContext,
+  toolCallId: string,
+  checkpointId: string | undefined
+): ResumeToolResult {
+  const tool = context.toolCalls.get(toolCallId)
+  if (!tool || !tool.result) {
+    recordDegraded(CopilotDegradedReason.MissingToolResult)
+    logger.error('Missing tool result for pending tool call; synthesizing a failure', {
+      toolCallId,
+      checkpointId,
+      hasToolEntry: !!tool,
+      toolName: tool?.name,
+      toolStatus: tool?.status,
+      hasPendingPromise: context.pendingToolPromises.has(toolCallId),
+    })
+    return {
+      callId: toolCallId,
+      name: tool?.name || '',
+      data: { error: `no result was returned for tool call ${toolCallId}` },
+      success: false,
+    }
+  }
+  return {
+    callId: toolCallId,
+    name: tool.name || '',
+    data: getToolCallTerminalData(tool),
+    success: requireToolCallStateResult(tool).success,
+  }
+}
+
 function collectResultsForToolIds(
   context: StreamingContext,
   toolIds: string[],
   checkpointId: string
-): Array<{ callId: string; name: string; data: unknown; success: boolean }> {
-  return toolIds.map((toolCallId) => {
-    const tool = context.toolCalls.get(toolCallId)
-    if (!tool || !tool.result) {
-      throw new Error(
-        `Cannot resume subagent chain ${checkpointId}: missing result for tool call ${toolCallId}`
-      )
-    }
-    const name = tool.name || ''
-    return {
-      callId: toolCallId,
-      name,
-      data: getToolCallTerminalData(tool),
-      success: requireToolCallStateResult(tool).success,
-    }
-  })
+): ResumeToolResult[] {
+  return toolIds.map((toolCallId) => buildResumeToolResult(context, toolCallId, checkpointId))
 }
 
 // runResumeLegWithRetry runs ONE resume POST with the same retryable-error +
@@ -581,7 +646,7 @@ async function runResumeLegWithRetry(
         url,
         {
           method: 'POST',
-          headers: mothershipRequestHeaders(hostedBillingRequest),
+          headers: mothershipRequestHeaders(hostedBillingRequest, options.simRequestId),
           body: JSON.stringify(body),
         },
         leg,
@@ -620,6 +685,12 @@ async function driveOneChildChain(
   execContext: ExecutionContext,
   options: CopilotLifecycleOptions,
   baseURL: string,
+  /**
+   * The turn's own abort signal, NOT the fanout controller in `options`. Used to
+   * tell "the user stopped the turn" from "a lane failed and cancelled its
+   * siblings" when deciding whether a leg's abort belongs on the shared context.
+   */
+  turnAbortSignal: AbortSignal | undefined,
   workspaceId?: string,
   hostedBillingRequest?: AttributedBillingRequestEnvelope
 ): Promise<AsyncContinuation | null> {
@@ -640,6 +711,18 @@ async function driveOneChildChain(
     const results = collectResultsForToolIds(context, toolIds, checkpointId)
 
     const leg = makeResumeLegContext(context)
+    // The abort marker is turn-scoped (keyed on the shared messageId), so a leg
+    // that observes it at body close IS a turn-level abort — and on the headless
+    // path, where `onAbortObserved` is never wired to the turn controller, this
+    // is the only record of it.
+    let markerObserved = false
+    const legOptions: CopilotLifecycleOptions = {
+      ...options,
+      onAbortObserved: (reason) => {
+        if (reason === AbortReason.MarkerObservedAtBodyClose) markerObserved = true
+        options.onAbortObserved?.(reason)
+      },
+    }
     await runResumeLegWithRetry(
       `${baseURL}/api/tools/resume`,
       {
@@ -651,10 +734,10 @@ async function driveOneChildChain(
       },
       leg,
       execContext,
-      options,
+      legOptions,
       hostedBillingRequest
     )
-    mergeResumeLegOutputs(context, leg)
+    mergeResumeLegOutputs(context, leg, markerObserved || (turnAbortSignal?.aborted ?? false))
 
     const cont = leg.awaitingAsyncContinuation
     if (!cont) {
@@ -733,6 +816,7 @@ async function driveSubagentChains(
           execContext,
           legOptions,
           baseURL,
+          parentSignal,
           workspaceId,
           hostedBillingRequest
         ).catch((error) => {
@@ -765,9 +849,14 @@ async function runCheckpointLoop(
   let route = initialRoute
   let payload: Record<string, unknown> = initialPayload
   let resumeAttempt = 0
+  let initialAttempt = 0
   const callerOnEvent = options.onEvent
   const mothershipBaseURL = await getMothershipBaseURL({ userId: options.userId })
   const lifecycleWorkspaceId = nonBlankString(options.workspaceId)
+  const mothershipRequestId = nonBlankString(options.simRequestId) ?? generateId()
+  if (!options.simRequestId) {
+    options = { ...options, simRequestId: mothershipRequestId }
+  }
   const systemPromptOverride = env.MSHIP_SYSPROMPT_OVERRIDE
 
   if (typeof systemPromptOverride === 'string' && systemPromptOverride.trim() !== '') {
@@ -851,7 +940,7 @@ async function runCheckpointLoop(
         `${mothershipBaseURL}${route}`,
         {
           method: 'POST',
-          headers: mothershipRequestHeaders(hostedBillingRequest),
+          headers: mothershipRequestHeaders(hostedBillingRequest, mothershipRequestId),
           body: JSON.stringify(payload),
         },
         context,
@@ -866,6 +955,7 @@ async function runCheckpointLoop(
       context.trace.endSpan(streamSpan, streamStatus)
       context.trace.setActiveSpan(undefined)
       resumeAttempt = 0
+      initialAttempt = 0
     } catch (streamError) {
       context.trace.endSpan(streamSpan, RequestTraceV1SpanStatus.error)
       context.trace.setActiveSpan(undefined)
@@ -873,22 +963,27 @@ async function runCheckpointLoop(
         await handleBillingLimitResponse(streamError.userId, context, execContext, options)
         break
       }
-      if (
-        isResume &&
-        isRetryableStreamError(streamError) &&
-        resumeAttempt < MAX_RESUME_ATTEMPTS - 1
-      ) {
+      const attempt = isResume ? resumeAttempt : initialAttempt
+      const retryable = isResume
+        ? isRetryableStreamError(streamError)
+        : isRetryableInitialStreamError(streamError)
+      if (retryable && attempt < MAX_RESUME_ATTEMPTS - 1) {
         // Discard errors recorded during this failed attempt; we're about to
         // redo this leg and a clean retry must not finalize as `error`.
         context.errors.length = errorsBeforeAttempt
-        resumeAttempt++
-        const backoff = RESUME_BACKOFF_MS[resumeAttempt - 1] ?? 1000
-        logger.warn('Resume stream failed, retrying', {
-          attempt: resumeAttempt + 1,
-          maxAttempts: MAX_RESUME_ATTEMPTS,
-          backoffMs: backoff,
-          error: toError(streamError).message,
-        })
+        if (isResume) resumeAttempt++
+        else initialAttempt++
+        const nextAttempt = isResume ? resumeAttempt : initialAttempt
+        const backoff = RESUME_BACKOFF_MS[nextAttempt - 1] ?? 1000
+        logger.warn(
+          isResume ? 'Resume stream failed, retrying' : 'Initial stream failed, retrying',
+          {
+            attempt: nextAttempt + 1,
+            maxAttempts: MAX_RESUME_ATTEMPTS,
+            backoffMs: backoff,
+            error: toError(streamError).message,
+          }
+        )
         await sleepWithAbort(backoff, options.abortSignal)
         continue
       }
@@ -1043,37 +1138,14 @@ async function runCheckpointLoop(
       break
     }
 
-    const results: Array<{
-      callId: string
-      name: string
-      data: unknown
-      success: boolean
-    }> = []
+    const results: ResumeToolResult[] = []
     for (const toolCallId of continuation.pendingToolCallIds) {
       if (isAborted(options, context)) {
         cancelPendingTools(context)
         context.awaitingAsyncContinuation = undefined
         break
       }
-      const tool = context.toolCalls.get(toolCallId)
-      if (!tool || !tool.result) {
-        logger.error('Missing tool result for pending tool call', {
-          toolCallId,
-          checkpointId: continuation.checkpointId,
-          hasToolEntry: !!tool,
-          toolName: tool?.name,
-          toolStatus: tool?.status,
-          hasPendingPromise: context.pendingToolPromises.has(toolCallId),
-        })
-        throw new Error(`Cannot resume: missing result for pending tool call ${toolCallId}`)
-      }
-      const name = tool.name || ''
-      results.push({
-        callId: toolCallId,
-        name,
-        data: getToolCallTerminalData(tool),
-        success: requireToolCallStateResult(tool).success,
-      })
+      results.push(buildResumeToolResult(context, toolCallId, continuation.checkpointId))
     }
 
     if (isAborted(options, context)) {
@@ -1317,6 +1389,25 @@ function isRetryableStreamError(error: unknown): boolean {
   return false
 }
 
+/**
+ * Initial requests use a durable request identity and the backend's checkpoint
+ * delivery reservation. Reposting a transport-ambiguous initial leg is safe:
+ * Go redelivers an untouched committed pause, starts a request that never
+ * anchored, or fails closed when the accepted leg has no recoverable pause.
+ */
+function isRetryableInitialStreamError(error: unknown): boolean {
+  if (error instanceof DOMException && error.name === 'AbortError') {
+    return false
+  }
+  if (error instanceof StreamEndedWithoutTerminalError) {
+    return true
+  }
+  if (error instanceof CopilotBackendError) {
+    return error.status !== undefined && error.status >= 500
+  }
+  return error instanceof TypeError
+}
+
 function sleepWithAbort(ms: number, abortSignal?: AbortSignal): Promise<void> {
   if (!abortSignal) {
     return sleep(ms)
diff --git a/apps/sim/lib/copilot/request/metrics.ts b/apps/sim/lib/copilot/request/metrics.ts
index d3bfb80438..7ad1ed582a 100644
--- a/apps/sim/lib/copilot/request/metrics.ts
+++ b/apps/sim/lib/copilot/request/metrics.ts
@@ -11,6 +11,7 @@
 import { type Counter, type Histogram, metrics } from '@opentelemetry/api'
 import { Metric } from '@/lib/copilot/generated/metrics-v1'
 import { TOOL_CATALOG } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { CopilotDegradedReasonValue } from '@/lib/copilot/generated/trace-attribute-values-v1'
 import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
 
 // MUST match Go's copilot/internal/telemetry/metrics.go LatencyBucketsMs
@@ -26,6 +27,7 @@ const BYTE_BUCKETS = [1024, 8192, 65536, 262144, 1048576, 4194304, 16777216, 671
 interface CopilotMeterInstruments {
   toolDuration: Histogram
   toolCalls: Counter
+  degradedCount: Counter
   vfsMaterializeDuration: Histogram
   fileReadDuration: Histogram
   fileReadBytes: Histogram
@@ -45,6 +47,7 @@ function instruments(): CopilotMeterInstruments {
       advice: { explicitBucketBoundaries: LATENCY_BUCKETS_MS },
     }),
     toolCalls: meter.createCounter(Metric.CopilotToolCalls),
+    degradedCount: meter.createCounter(Metric.CopilotDegradedCount),
     vfsMaterializeDuration: meter.createHistogram(Metric.CopilotVfsMaterializeDuration, {
       unit: 'ms',
       advice: { explicitBucketBoundaries: LATENCY_BUCKETS_MS },
@@ -97,6 +100,18 @@ export function recordSimToolMetric(
   if (durationMs >= 0) toolDuration.record(durationMs, attrs)
 }
 
+// recordDegraded counts one non-fatal fallback, labelled by the bounded reason
+// it took. Every degradation path reports here so "are we degrading, and why" is
+// one query instead of a per-incident investigation — and so a path that should
+// be impossible can be alerted on at > 0. Sim's own logs do not reach Loki and
+// the in-process TraceCollector is not exported, so without this a fallback is
+// invisible.
+export function recordDegraded(reason: CopilotDegradedReasonValue): void {
+  instruments().degradedCount.add(1, {
+    [TraceAttr.CopilotDegradedReason]: reason,
+  })
+}
+
 // recordVfsMaterialize records VFS materialization time. Call once per phase
 // with that phase's duration and once with phase="total" for the whole op, so
 // the dashboard can show total + per-phase. phase must be a bounded value.
diff --git a/apps/sim/lib/copilot/request/otel.ts b/apps/sim/lib/copilot/request/otel.ts
index 3804eb5ebe..291ea303d8 100644
--- a/apps/sim/lib/copilot/request/otel.ts
+++ b/apps/sim/lib/copilot/request/otel.ts
@@ -10,6 +10,7 @@ import {
   TraceFlags,
   trace,
 } from '@opentelemetry/api'
+import { setRequestTraceId } from '@sim/logger'
 import { describeError, toError } from '@sim/utils/errors'
 import { RequestTraceV1Outcome } from '@/lib/copilot/generated/request-trace-v1'
 import {
@@ -459,6 +460,11 @@ export function startCopilotOtelRoot(
     (spanContext.traceId && spanContext.traceId.length === 32 ? spanContext.traceId : '')
   span.setAttribute(TraceAttr.RequestId, requestId)
   span.setAttribute(TraceAttr.SimRequestId, requestId)
+  // Stamp the trace id onto the route's log context so every sim log line in
+  // this request greps by the same id the Go copilot logs as trace_id.
+  if (spanContext.traceId && spanContext.traceId.length === 32) {
+    setRequestTraceId(spanContext.traceId)
+  }
   const rootContext = trace.setSpan(parentContext, carrierSpan)
 
   let finished = false
@@ -573,6 +579,9 @@ export async function withCopilotOtelContext<T>(
     span.setAttribute(TraceAttr.RequestId, resolvedRequestId)
     span.setAttribute(TraceAttr.SimRequestId, resolvedRequestId)
   }
+  if (spanContext.traceId && spanContext.traceId.length === 32) {
+    setRequestTraceId(spanContext.traceId)
+  }
   const otelContext = trace.setSpan(parentContext, carrierSpan)
   let terminalStatusSet = false
 
diff --git a/apps/sim/lib/copilot/request/session/contract.test.ts b/apps/sim/lib/copilot/request/session/contract.test.ts
index 06661e275d..86dcbc17fb 100644
--- a/apps/sim/lib/copilot/request/session/contract.test.ts
+++ b/apps/sim/lib/copilot/request/session/contract.test.ts
@@ -156,7 +156,7 @@ describe('stream session contract parser', () => {
       type: 'tool' as const,
       payload: {
         toolCallId: 'preview-1',
-        toolName: 'workspace_file' as const,
+        toolName: 'prepare_file_edit' as const,
         previewPhase: 'file_preview_content' as const,
         content: 'draft body',
         contentMode: 'snapshot' as const,
diff --git a/apps/sim/lib/copilot/request/session/contract.ts b/apps/sim/lib/copilot/request/session/contract.ts
index 65b9de6cc9..bf8c3ea88d 100644
--- a/apps/sim/lib/copilot/request/session/contract.ts
+++ b/apps/sim/lib/copilot/request/session/contract.ts
@@ -47,7 +47,7 @@ export interface SyntheticFilePreviewTarget {
 export interface SyntheticFilePreviewStartPayload {
   previewPhase: typeof FILE_PREVIEW_PHASE.start
   toolCallId: string
-  toolName: 'workspace_file'
+  toolName: 'prepare_file_edit'
 }
 
 export interface SyntheticFilePreviewTargetPayload {
@@ -56,14 +56,14 @@ export interface SyntheticFilePreviewTargetPayload {
   target: SyntheticFilePreviewTarget
   title?: string
   toolCallId: string
-  toolName: 'workspace_file'
+  toolName: 'prepare_file_edit'
 }
 
 export interface SyntheticFilePreviewEditMetaPayload {
   edit: JsonRecord
   previewPhase: typeof FILE_PREVIEW_PHASE.editMeta
   toolCallId: string
-  toolName: 'workspace_file'
+  toolName: 'prepare_file_edit'
 }
 
 export interface SyntheticFilePreviewContentPayload {
@@ -77,7 +77,7 @@ export interface SyntheticFilePreviewContentPayload {
   previewVersion: number
   targetKind?: string
   toolCallId: string
-  toolName: 'workspace_file'
+  toolName: 'prepare_file_edit'
 }
 
 export interface SyntheticFilePreviewCompletePayload {
@@ -86,7 +86,7 @@ export interface SyntheticFilePreviewCompletePayload {
   previewPhase: typeof FILE_PREVIEW_PHASE.complete
   previewVersion?: number
   toolCallId: string
-  toolName: 'workspace_file'
+  toolName: 'prepare_file_edit'
 }
 
 export type SyntheticFilePreviewPayload =
@@ -354,7 +354,7 @@ function isSyntheticFilePreviewPayload(value: unknown): value is SyntheticFilePr
     return false
   }
 
-  if (typeof value.toolCallId !== 'string' || value.toolName !== 'workspace_file') {
+  if (typeof value.toolCallId !== 'string' || value.toolName !== 'prepare_file_edit') {
     return false
   }
 
diff --git a/apps/sim/lib/copilot/request/session/event.test.ts b/apps/sim/lib/copilot/request/session/event.test.ts
index 0f0573a24f..29d86146c1 100644
--- a/apps/sim/lib/copilot/request/session/event.test.ts
+++ b/apps/sim/lib/copilot/request/session/event.test.ts
@@ -43,7 +43,7 @@ describe('createEvent', () => {
       payload: {
         previewPhase: 'file_preview_start',
         toolCallId: 'preview-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
       },
     })
 
@@ -56,7 +56,7 @@ describe('createEvent', () => {
       payload: {
         previewPhase: 'file_preview_start',
         toolCallId: 'preview-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
       },
     })
   })
diff --git a/apps/sim/lib/copilot/request/session/steer.ts b/apps/sim/lib/copilot/request/session/steer.ts
new file mode 100644
index 0000000000..4e63afca65
--- /dev/null
+++ b/apps/sim/lib/copilot/request/session/steer.ts
@@ -0,0 +1,79 @@
+import type { Context } from '@opentelemetry/api'
+import {
+  COPILOT_BILLING_PROTOCOL,
+  COPILOT_BILLING_PROTOCOL_HEADER,
+} from '@/lib/billing/core/billing-attribution'
+import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
+import { fetchGo } from '@/lib/copilot/request/go/fetch'
+import { getMothershipBaseURL, getMothershipSourceEnvHeaders } from '@/lib/copilot/server/agent-url'
+import { env } from '@/lib/core/config/env'
+
+export const DEFAULT_STEER_TIMEOUT_MS = 3000
+
+/**
+ * Queues a mid-turn steering message with the Go side (`/api/streams/steer`).
+ *
+ * Acceptance means "queued", not "applied": Go acknowledges application with a
+ * `run`/`steering_applied` stream event carrying the steeringId. A caller that
+ * never sees that ack before the stream ends must re-send the content as an
+ * ordinary message — that contract is what makes delivery loss-free without
+ * this call having to prove stream liveness.
+ */
+export async function requestStreamSteering(params: {
+  streamId: string
+  userId: string
+  chatId: string
+  steeringId: string
+  content: string
+  workspaceId?: string
+  timeoutMs?: number
+  otelContext?: Context
+}): Promise<{ queued: boolean; status: number }> {
+  const {
+    streamId,
+    userId,
+    chatId,
+    steeringId,
+    content,
+    timeoutMs = DEFAULT_STEER_TIMEOUT_MS,
+    otelContext,
+  } = params
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    [COPILOT_BILLING_PROTOCOL_HEADER]: COPILOT_BILLING_PROTOCOL.legacy,
+  }
+  if (env.COPILOT_API_KEY) {
+    headers['x-api-key'] = env.COPILOT_API_KEY
+  }
+  Object.assign(headers, getMothershipSourceEnvHeaders())
+
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort('steer_fetch_timeout'), timeoutMs)
+
+  try {
+    const mothershipBaseURL = await getMothershipBaseURL({ userId })
+    const response = await fetchGo(`${mothershipBaseURL}/api/streams/steer`, {
+      method: 'POST',
+      headers,
+      signal: controller.signal,
+      body: JSON.stringify({
+        messageId: streamId,
+        userId,
+        chatId,
+        steeringId,
+        content,
+      }),
+      otelContext,
+      spanName: 'sim → go /api/streams/steer',
+      operation: 'steer',
+      attributes: {
+        [TraceAttr.StreamId]: streamId,
+        [TraceAttr.ChatId]: chatId,
+      },
+    })
+    return { queued: response.ok, status: response.status }
+  } finally {
+    clearTimeout(timeout)
+  }
+}
diff --git a/apps/sim/lib/copilot/request/session/writer.test.ts b/apps/sim/lib/copilot/request/session/writer.test.ts
index aa3eb5384e..8ff64276df 100644
--- a/apps/sim/lib/copilot/request/session/writer.test.ts
+++ b/apps/sim/lib/copilot/request/session/writer.test.ts
@@ -168,7 +168,7 @@ describe('StreamWriter', () => {
       type: MothershipStreamV1EventType.tool,
       payload: {
         toolCallId: 'preview-1',
-        toolName: 'workspace_file',
+        toolName: 'prepare_file_edit',
         previewPhase: 'file_preview_start',
       },
     } satisfies StreamEvent)
diff --git a/apps/sim/lib/copilot/request/sse-utils.test.ts b/apps/sim/lib/copilot/request/sse-utils.test.ts
index 65b5b4319c..d8da8edc0c 100644
--- a/apps/sim/lib/copilot/request/sse-utils.test.ts
+++ b/apps/sim/lib/copilot/request/sse-utils.test.ts
@@ -36,7 +36,7 @@ describe('shouldSkipToolCallEvent', () => {
   it('keeps non-vfs generating placeholders visible', () => {
     expect(
       shouldSkipToolCallEvent(
-        toolCallEvent('search-generating-placeholder', 'search_online', undefined, true)
+        toolCallEvent('search-generating-placeholder', 'web_search', undefined, true)
       )
     ).toBe(false)
   })
diff --git a/apps/sim/lib/copilot/request/tools/executor.test.ts b/apps/sim/lib/copilot/request/tools/executor.test.ts
index 06c86e224f..4bc032fae6 100644
--- a/apps/sim/lib/copilot/request/tools/executor.test.ts
+++ b/apps/sim/lib/copilot/request/tools/executor.test.ts
@@ -73,7 +73,12 @@ vi.mock('@/lib/copilot/request/tools/workflow-context', () => ({
 }))
 
 import { TOOL_WATCHDOG_DEFAULT_MS, TOOL_WATCHDOG_LONG_RUNNING_MS } from '@/lib/copilot/constants'
-import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import {
+  MothershipStreamV1EventType,
+  MothershipStreamV1ToolOutcome,
+  MothershipStreamV1ToolPhase,
+} from '@/lib/copilot/generated/mothership-stream-v1'
+import { GenerateApiKey } from '@/lib/copilot/generated/tool-catalog-v1'
 import { createStreamingContext } from '@/lib/copilot/request/context/request-context'
 import {
   buildToolExecutionContext,
@@ -110,7 +115,7 @@ describe('toolWatchdogTimeoutMs', () => {
     expect(toolWatchdogTimeoutMs('read')).toBe(TOOL_WATCHDOG_DEFAULT_MS)
   })
 
-  it.each(['deploy_api', 'deploy_chat', 'deploy_mcp', 'redeploy', 'promote_to_live'])(
+  it.each(['deploy_as_api', 'deploy_as_chat', 'deploy_as_mcp', 'redeploy', 'promote_to_live'])(
     'does not undercut deployment tool %s with the default watchdog',
     (toolName) => {
       expect(toolWatchdogTimeoutMs(toolName)).toBe(TOOL_WATCHDOG_LONG_RUNNING_MS)
@@ -330,6 +335,61 @@ describe('executeToolAndReport provenance isolation', () => {
     expect(registry.getActiveMatches()).toEqual([])
     expect(JSON.stringify([completion, onEvent.mock.calls])).not.toContain('secret-value')
   })
+
+  it('reveals a generated API key only in the live client event', async () => {
+    const generatedKey = 'sk-sim-one-time-secret'
+    const statusMessage = 'API key "streaming-test" created.'
+    executeTool.mockResolvedValueOnce({
+      success: true,
+      output: {
+        id: 'key-1',
+        name: 'streaming-test',
+        key: generatedKey,
+        workspaceId: 'workspace-1',
+        message: statusMessage,
+      },
+    })
+    const toolCall: ToolCallState = {
+      id: 'generate-key-call',
+      name: GenerateApiKey.id,
+      status: 'pending',
+      params: { name: 'streaming-test' },
+    }
+
+    const completion = await executeToolAndReport(
+      toolCall.id,
+      buildStreamingContext(toolCall),
+      {
+        userId: 'user-1',
+        workflowId: 'workflow-1',
+        resolvedSecretTraceRegistry: new ResolvedSecretTraceRegistry(),
+      },
+      { onEvent }
+    )
+
+    expect(completion).toEqual({
+      status: MothershipStreamV1ToolOutcome.success,
+      message: 'Tool completed',
+      data: statusMessage,
+    })
+    expect(completeAsyncToolCall).toHaveBeenCalledWith(
+      expect.objectContaining({ result: statusMessage })
+    )
+    expect(JSON.stringify([completion, completeAsyncToolCall.mock.calls])).not.toContain(
+      generatedKey
+    )
+    expect(onEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolName: GenerateApiKey.id,
+          phase: MothershipStreamV1ToolPhase.result,
+          success: true,
+          output: expect.objectContaining({ key: generatedKey }),
+        }),
+      })
+    )
+  })
 })
 
 describe('executeToolAndReport metrics', () => {
diff --git a/apps/sim/lib/copilot/request/tools/executor.ts b/apps/sim/lib/copilot/request/tools/executor.ts
index 693a8c325d..127267555d 100644
--- a/apps/sim/lib/copilot/request/tools/executor.ts
+++ b/apps/sim/lib/copilot/request/tools/executor.ts
@@ -20,35 +20,35 @@ import {
   MothershipStreamV1ToolPhase,
 } from '@/lib/copilot/generated/mothership-stream-v1'
 import {
-  BrowserRequestTakeover,
-  CrawlWebsite,
-  CreateFile,
+  ApplyFileEdit,
+  CreateEmptyFile,
   CreateWorkflow,
-  DeployApi,
-  DeployChat,
-  DeployCustomBlock,
-  DeployMcp,
-  DownloadToWorkspaceFile,
-  EditContent,
+  DeployAsApi,
+  DeployAsChat,
+  DeployAsMcp,
+  DownloadFile,
   Ffmpeg,
-  FunctionExecute,
+  GenerateApiKey,
   GenerateAudio,
   GenerateImage,
   GenerateVideo,
-  KnowledgeBase,
   LoadDeployment,
-  MaterializeFile,
+  ManageKnowledgeBase,
   Media,
+  PrepareFileEdit,
   PromoteToLive,
+  PublishCustomBlock,
   Redeploy,
   Run,
   RunBlock,
   RunCode,
   RunFromBlock,
+  RunFunction,
   RunWorkflow,
   RunWorkflowUntilBlock,
+  SaveUpload,
   Search,
-  WorkspaceFile,
+  WebCrawl,
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
 import { publishToolConfirmation } from '@/lib/copilot/persistence/tool-confirm'
@@ -77,6 +77,7 @@ import {
   type ToolCallState,
 } from '@/lib/copilot/request/types'
 import { ensureHandlersRegistered, executeTool } from '@/lib/copilot/tool-executor'
+import { RETIRED_BROWSER_REQUEST_TAKEOVER_ID } from '@/lib/copilot/tools/retired-tools'
 import { isMcpTool } from '@/executor/constants'
 
 export { waitForToolCompletion } from '@/lib/copilot/request/tools/client'
@@ -216,7 +217,7 @@ const LONG_RUNNING_TOOL_IDS: ReadonlySet<string> = new Set([
   RunFromBlock.id,
   RunWorkflow.id,
   RunWorkflowUntilBlock.id,
-  FunctionExecute.id,
+  RunFunction.id,
   RunCode.id,
   GenerateImage.id,
   GenerateAudio.id,
@@ -224,17 +225,17 @@ const LONG_RUNNING_TOOL_IDS: ReadonlySet<string> = new Set([
   Ffmpeg.id,
   Media.id,
   Search.id,
-  CrawlWebsite.id,
-  KnowledgeBase.id,
-  DownloadToWorkspaceFile.id,
-  CreateFile.id,
-  EditContent.id,
-  MaterializeFile.id,
-  WorkspaceFile.id,
-  DeployApi.id,
-  DeployChat.id,
-  DeployCustomBlock.id,
-  DeployMcp.id,
+  WebCrawl.id,
+  ManageKnowledgeBase.id,
+  DownloadFile.id,
+  CreateEmptyFile.id,
+  ApplyFileEdit.id,
+  SaveUpload.id,
+  PrepareFileEdit.id,
+  DeployAsApi.id,
+  DeployAsChat.id,
+  PublishCustomBlock.id,
+  DeployAsMcp.id,
   Redeploy.id,
   LoadDeployment.id,
   PromoteToLive.id,
@@ -258,7 +259,7 @@ export function toolWatchdogTimeoutMs(toolName: string | undefined): number {
 export function pendingToolWaitBudgetMs(
   toolCall: Pick<ToolCallState, 'name' | 'status'> | undefined
 ): number | null {
-  if (toolCall?.name === BrowserRequestTakeover.id && toolCall.status === 'executing') {
+  if (toolCall?.name === RETIRED_BROWSER_REQUEST_TAKEOVER_ID && toolCall?.status === 'executing') {
     return null
   }
   if (toolCall?.status === 'awaiting_approval') return TOOL_WATCHDOG_LONG_RUNNING_MS
@@ -609,7 +610,8 @@ async function executeToolAndReportInner(
     if (abortRequested(context, execContext, options)) {
       const copilotResult = inspectToolResultForCopilot(
         result,
-        toolExecutionContext.resolvedSecretTraceRegistry
+        toolExecutionContext.resolvedSecretTraceRegistry,
+        toolCall.name
       ).result
       markToolCallCancelled('Request aborted during tool execution')
       markToolResultSeen(toolCall.id)
@@ -725,7 +727,8 @@ async function executeToolAndReportInner(
     }
     const projection = inspectToolResultForCopilot(
       result,
-      toolExecutionContext.resolvedSecretTraceRegistry
+      toolExecutionContext.resolvedSecretTraceRegistry,
+      toolCall.name
     )
     const copilotResult = projection.result
     mergeToolRegistry(projection.safe)
@@ -734,6 +737,16 @@ async function executeToolAndReportInner(
     toolSpan.attributes = {
       ...toolSpan.attributes,
       ...summarizeToolResultForSpan(copilotResult),
+      ...(projection.safe ? {} : { resultWithheld: true }),
+    }
+    if (!projection.safe) {
+      // A withheld SUCCESS otherwise leaves no trace anywhere: the span reads
+      // ok and the model just sees a bare `{success: true}` with no output.
+      logger.warn('Tool result withheld by egress projection', {
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        runtimeSucceeded: result.success,
+      })
     }
 
     setTerminalToolCallState(toolCall, {
@@ -807,8 +820,12 @@ async function executeToolAndReportInner(
       return cancelledCompletion('Request aborted before tool result delivery')
     }
 
-    // Fire-and-forget: notify the copilot backend that the tool completed.
-    // IMPORTANT: We must NOT await this — the Go backend may block on the
+    // A newly generated API key is intentionally included only in this
+    // live/replay client event. Model-facing results and long-term chat records stay redacted.
+    const clientEventOutput =
+      toolCall.name === GenerateApiKey.id && modelSucceeded && hasOutputValue(copilotResult)
+        ? copilotResult.output
+        : terminalData
     const resultEvent: StreamEvent = {
       type: MothershipStreamV1EventType.tool,
       payload: {
@@ -818,7 +835,7 @@ async function executeToolAndReportInner(
         mode: MothershipStreamV1ToolMode.async,
         phase: MothershipStreamV1ToolPhase.result,
         success: modelSucceeded,
-        output: terminalData,
+        output: clientEventOutput,
         ...(modelSucceeded
           ? { status: MothershipStreamV1ToolOutcome.success }
           : { status: MothershipStreamV1ToolOutcome.error, error: terminalMessage }),
@@ -856,7 +873,8 @@ async function executeToolAndReportInner(
     const thrownMessage = toError(error).message
     const projection = inspectToolResultForCopilot(
       { success: false, error: thrownMessage },
-      toolExecutionContext.resolvedSecretTraceRegistry
+      toolExecutionContext.resolvedSecretTraceRegistry,
+      toolCall.name
     )
     const copilotError = projection.result
     mergeToolRegistry(projection.safe)
diff --git a/apps/sim/lib/copilot/request/tools/files.test.ts b/apps/sim/lib/copilot/request/tools/files.test.ts
index 19c04e383e..7a6b94dbe8 100644
--- a/apps/sim/lib/copilot/request/tools/files.test.ts
+++ b/apps/sim/lib/copilot/request/tools/files.test.ts
@@ -24,7 +24,7 @@ vi.mock('@/lib/copilot/request/otel', () => ({
   ) => fn({ setAttribute: vi.fn(), setAttributes: vi.fn(), addEvent: vi.fn() }),
 }))
 
-import { FunctionExecute } from '@/lib/copilot/generated/tool-catalog-v1'
+import { RunFunction } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   extractTabularData,
   maybeWriteOutputToFile,
@@ -37,7 +37,7 @@ import { MAX_INLINE_MATERIALIZATION_BYTES } from '@/lib/execution/payloads/limit
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
 describe('unwrapFunctionExecuteOutput', () => {
-  it('unwraps the function_execute envelope { result, stdout }', () => {
+  it('unwraps the run_function envelope { result, stdout }', () => {
     expect(unwrapFunctionExecuteOutput({ result: 'name,age\nAlice,30', stdout: '' })).toBe(
       'name,age\nAlice,30'
     )
@@ -56,7 +56,7 @@ describe('unwrapFunctionExecuteOutput', () => {
 })
 
 describe('serializeOutputForFile (csv)', () => {
-  it('returns raw CSV text when function_execute result is already a CSV string', () => {
+  it('returns raw CSV text when run_function result is already a CSV string', () => {
     const output = {
       result: 'name,age\nAlice,30\nBob,40',
       stdout: '(2 rows)',
@@ -139,7 +139,7 @@ describe('maybeWriteOutputToFile', () => {
 
   it('denies a read-only principal without writing the file', async () => {
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
       { success: true, output: { result: 'name,age\nAlice,30', stdout: '' } },
       buildContext({ userPermission: 'read' })
@@ -152,7 +152,7 @@ describe('maybeWriteOutputToFile', () => {
 
   it('does not deny a read-only principal when no workspace write occurs (sandbox export active)', async () => {
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
       { success: true, output: { result: { files: [{ path: 'report.csv' }] }, stdout: '' } },
       buildContext({ userPermission: 'read' })
@@ -164,7 +164,7 @@ describe('maybeWriteOutputToFile', () => {
 
   it('writes the output file for a write principal', async () => {
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
       { success: true, output: { result: 'name,age\nAlice,30', stdout: '' } },
       buildContext()
@@ -201,7 +201,7 @@ describe('maybeWriteOutputToFile', () => {
     }))
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.json', mode: 'overwrite' }] } },
       { success: true, output: { result: rows, stdout: '' } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -239,7 +239,7 @@ describe('maybeWriteOutputToFile', () => {
     registry.recordResolved('TOKEN', 'secret-value')
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.txt', mode: 'overwrite' }] } },
       {
         success: true,
@@ -280,7 +280,7 @@ describe('maybeWriteOutputToFile', () => {
     }
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.json', mode: 'overwrite' }] } },
       { success: true, output: runtimeOutput },
       buildContext({ resolvedSecretTraceRegistry: toolRegistry })
@@ -317,7 +317,7 @@ describe('maybeWriteOutputToFile', () => {
     registry.recordResolved('CSV_SECRET', secret)
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
       { success: true, output: { result: [{ value: secret }], stdout: '' } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -356,7 +356,7 @@ describe('maybeWriteOutputToFile', () => {
     const rows = Array.from({ length: 10_000 }, () => ({ first: secret, second: secret }))
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
       { success: true, output: { result: rows, stdout: '' } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -377,7 +377,7 @@ describe('maybeWriteOutputToFile', () => {
     registry.recordResolved('CSV_SECRET', secret)
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       {
         outputs: {
           files: [
@@ -402,7 +402,7 @@ describe('maybeWriteOutputToFile', () => {
     }))
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files } },
       { success: true, output: { result: 'content', stdout: '' } },
       buildContext()
@@ -420,7 +420,7 @@ describe('maybeWriteOutputToFile', () => {
     registry.recordResolved('API_KEY', 'secret-value')
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.txt', mode: 'overwrite' }] } },
       { success: true, output: { result: '__var_API_KEY', stdout: '' } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -457,7 +457,7 @@ describe('maybeWriteOutputToFile', () => {
     } as unknown as ResolvedSecretTraceRegistry
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.txt', mode: 'overwrite' }] } },
       { success: true, output: { result: 'anonymous-secret', stdout: '' } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -495,7 +495,7 @@ describe('maybeWriteOutputToFile', () => {
     registry.recordResolved('OUTPUT_SECRET', 'secret-value')
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.txt', mode: 'overwrite' }] } },
       { success: true, output: { result: 'secret-value', stdout: '' } },
       buildContext({ userId: 'billing-actor', resolvedSecretTraceRegistry: registry })
@@ -534,7 +534,7 @@ describe('maybeWriteOutputToFile', () => {
     registry.recordResolved('OUTPUT_SECRET', 'secret-value')
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.txt', mode: 'overwrite' }] } },
       { success: true, output: { result: 'secret-value', stdout: '' } },
       buildContext({ userId: 'billing-actor', resolvedSecretTraceRegistry: registry })
@@ -557,7 +557,7 @@ describe('maybeWriteOutputToFile', () => {
     } as unknown as ResolvedSecretTraceRegistry
 
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       {
         outputs: {
           files: [
@@ -580,7 +580,7 @@ describe('maybeWriteOutputToFile', () => {
 
   it('preserves legacy writes without a registry and marks their provenance unknown', async () => {
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.json', mode: 'overwrite' }] } },
       { success: true, output: { result: { token: 'unknown' }, stdout: '' } },
       buildContext({ resolvedSecretTraceRegistry: undefined })
@@ -595,7 +595,7 @@ describe('maybeWriteOutputToFile', () => {
 
   it('fails loudly instead of silently skipping declared outputs when workspace context is missing', async () => {
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputs: { files: [{ path: 'files/report.csv', mode: 'overwrite' }] } },
       { success: true, output: { result: 'name,age\nAlice,30', stdout: '' } },
       buildContext({ workspaceId: undefined })
@@ -611,7 +611,7 @@ describe('maybeWriteOutputToFile', () => {
   it('still passes results through untouched when no outputs are declared, even without workspace context', async () => {
     const original = { success: true, output: { result: 42, stdout: '' } }
     const result = await maybeWriteOutputToFile(
-      FunctionExecute.id,
+      RunFunction.id,
       {},
       original,
       buildContext({ workspaceId: undefined })
@@ -627,7 +627,7 @@ describe('extractTabularData', () => {
     expect(extractTabularData([{ a: 1 }, { a: 2 }])).toEqual([{ a: 1 }, { a: 2 }])
   })
 
-  it('does NOT unwrap function_execute envelopes on its own (callers must pre-unwrap)', () => {
+  it('does NOT unwrap run_function envelopes on its own (callers must pre-unwrap)', () => {
     // Caller is responsible for unwrapping { result, stdout } envelopes first.
     // Keeping that concern out of this function prevents a double unwrap when
     // the user's payload itself happens to have matching keys.
diff --git a/apps/sim/lib/copilot/request/tools/files.ts b/apps/sim/lib/copilot/request/tools/files.ts
index e1248c0381..3a944910d3 100644
--- a/apps/sim/lib/copilot/request/tools/files.ts
+++ b/apps/sim/lib/copilot/request/tools/files.ts
@@ -1,7 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { isRecordLike } from '@sim/utils/object'
-import { FunctionExecute, UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
+import { RunFunction, UserTable } from '@/lib/copilot/generated/tool-catalog-v1'
 import { CopilotOutputFileOutcome } from '@/lib/copilot/generated/trace-attribute-values-v1'
 import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
 import { TraceEvent } from '@/lib/copilot/generated/trace-events-v1'
@@ -27,7 +27,7 @@ import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secr
 const logger = createLogger('CopilotToolResultFiles')
 const MAX_OUTPUT_FILE_PROVENANCE_REPRESENTATIONS = 10_000
 
-export const OUTPUT_PATH_TOOLS: Set<string> = new Set([FunctionExecute.id, UserTable.id])
+export const OUTPUT_PATH_TOOLS: Set<string> = new Set([RunFunction.id, UserTable.id])
 
 export type OutputFormat = 'json' | 'csv' | 'txt' | 'md' | 'html'
 
@@ -48,12 +48,12 @@ export const FORMAT_TO_CONTENT_TYPE: Record<OutputFormat, string> = {
 }
 
 /**
- * Unwraps the `function_execute` response envelope `{ result, stdout }` so the
+ * Unwraps the `run_function` response envelope `{ result, stdout }` so the
  * rest of the serialization code works on the user's actual payload (a string,
  * array, object, etc.) instead of JSON-stringifying the envelope itself.
  *
  * Only unwraps when both keys are present — that's the unique shape of
- * `function_execute` (see `apps/sim/tools/function/types.ts` `CodeExecutionOutput`).
+ * `run_function` (see `apps/sim/tools/function/types.ts` `CodeExecutionOutput`).
  * `user_table` returns `{ data, message, success }` which is left alone.
  */
 export function unwrapFunctionExecuteOutput(output: unknown): unknown {
@@ -67,7 +67,7 @@ export function unwrapFunctionExecuteOutput(output: unknown): unknown {
 
 /**
  * Try to pull a flat array of row-objects out of an already-unwrapped tool
- * payload. Callers are responsible for stripping any `function_execute`
+ * payload. Callers are responsible for stripping any `run_function`
  * envelope first (via {@link unwrapFunctionExecuteOutput}) — this function
  * does not re-unwrap, so a user payload that coincidentally has `result` and
  * `stdout` keys is not mistaken for another envelope.
diff --git a/apps/sim/lib/copilot/request/tools/permission.test.ts b/apps/sim/lib/copilot/request/tools/permission.test.ts
index 5c75b64573..58a6e6c811 100644
--- a/apps/sim/lib/copilot/request/tools/permission.test.ts
+++ b/apps/sim/lib/copilot/request/tools/permission.test.ts
@@ -94,7 +94,7 @@ describe('toolCallNeedsApproval', () => {
     expect(toolCallNeedsApproval('terminal', context, {}, false, runCall)).toBe(false)
   })
 
-  it.each(['deploy_api', 'deploy_chat', 'deploy_mcp'])(
+  it.each(['deploy_as_api', 'deploy_as_chat', 'deploy_as_mcp'])(
     'honors the saved permission for a %s undeploy',
     (toolName) => {
       const context = makeContext()
@@ -108,10 +108,10 @@ describe('toolCallNeedsApproval', () => {
 
   it('applies the normal saved permission to code with a secret reference', () => {
     const context = makeContext()
-    context.toolPermissions.autoAllowed.add('function_execute')
+    context.toolPermissions.autoAllowed.add('run_function')
 
     expect(
-      toolCallNeedsApproval('function_execute', context, {}, false, {
+      toolCallNeedsApproval('run_function', context, {}, false, {
         language: 'javascript',
         code: 'return {{API_KEY}}',
       })
@@ -135,7 +135,7 @@ describe('toolCallNeedsApproval', () => {
     context.toolPermissions.enabled = false
 
     expect(
-      toolCallNeedsApproval('function_execute', context, {}, false, {
+      toolCallNeedsApproval('run_function', context, {}, false, {
         language: 'javascript',
         code: 'return {{API_KEY}}',
       })
@@ -214,13 +214,13 @@ describe('gated tools are askable', () => {
     ).toEqual([
       'call_integration_tool',
       'delete_workspace_mcp_server',
-      'deploy_api',
-      'deploy_chat',
-      'deploy_mcp',
-      'function_execute',
+      'deploy_as_api',
+      'deploy_as_chat',
+      'deploy_as_mcp',
       'promote_to_live',
       'redeploy',
       'run_code',
+      'run_function',
       'run_workflow',
       'run_workflow_until_block',
       'terminal',
@@ -323,7 +323,7 @@ describe('runGatedToolExecution', () => {
   it('accepts the normal chat-level decision for code with a secret reference', async () => {
     const context = makeContext()
     const toolCall = makeToolCall()
-    toolCall.name = 'function_execute'
+    toolCall.name = 'run_function'
     toolCall.params = { language: 'javascript', code: 'return {{API_KEY}}' }
     const execute = vi.fn().mockResolvedValue({ status: 'success' })
     waitForToolPermissionDecision.mockResolvedValue({
@@ -334,7 +334,7 @@ describe('runGatedToolExecution', () => {
     await gate(context, toolCall, execute, [])
 
     expect(execute).toHaveBeenCalledTimes(1)
-    expect(context.toolPermissions.autoAllowed.has('function_execute')).toBe(true)
+    expect(context.toolPermissions.autoAllowed.has('run_function')).toBe(true)
   })
 
   it('does not suppress later prompts for a one-off allow', async () => {
diff --git a/apps/sim/lib/copilot/request/tools/permissions.ts b/apps/sim/lib/copilot/request/tools/permissions.ts
index 2d12c12ab1..fcd1e8d934 100644
--- a/apps/sim/lib/copilot/request/tools/permissions.ts
+++ b/apps/sim/lib/copilot/request/tools/permissions.ts
@@ -4,7 +4,7 @@ import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/typ
 /**
  * Guards a post-tool output-redirection sink against read-only principals.
  *
- * `function_execute`, `user_table`, and `read` are read-allowed for execution
+ * `run_function`, `user_table`, and `read` are read-allowed for execution
  * (they don't mutate the workspace themselves), so the router's `WRITE_ACTIONS`
  * gate in `tools/server/router.ts` lets read-only collaborators run them. But
  * their output-redirection declarations (`outputs.files`, `outputTable`)
@@ -12,7 +12,7 @@ import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/typ
  * Those writes must satisfy the same write gate as the dedicated mutation tools.
  *
  * Returns a denial `ToolCallResult` when the caller lacks write access (so the
- * agent surfaces the same `Permission denied` outcome it gets from `create_file`
+ * agent surfaces the same `Permission denied` outcome it gets from `create_empty_file`
  * / `user_table` writes), or `null` when the write may proceed.
  */
 export function denyOutputWriteWithoutWritePermission(
diff --git a/apps/sim/lib/copilot/request/tools/resolved-secret-result.test.ts b/apps/sim/lib/copilot/request/tools/resolved-secret-result.test.ts
index 26bff98ec4..26285b0d7d 100644
--- a/apps/sim/lib/copilot/request/tools/resolved-secret-result.test.ts
+++ b/apps/sim/lib/copilot/request/tools/resolved-secret-result.test.ts
@@ -2,10 +2,12 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { FunctionExecute, RunCode } from '@/lib/copilot/generated/tool-catalog-v1'
+import { RunCode, RunFunction } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   projectToolResultForCopilot,
+  READ_TOOL_RESULT_UNAVAILABLE_ERROR,
   TOOL_RESULT_UNAVAILABLE_ERROR,
+  toolResultUnavailableError,
 } from '@/lib/copilot/request/tools/resolved-secret-result'
 import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
 
@@ -20,7 +22,7 @@ function createRegistry(): ResolvedSecretTraceRegistry {
 }
 
 describe('projectToolResultForCopilot', () => {
-  it.each([FunctionExecute.id, RunCode.id])(
+  it.each([RunFunction.id, RunCode.id])(
     'projects active exact and embedded secrets for %s without mutating runtime output',
     (toolName) => {
       const registry = createRegistry()
@@ -430,4 +432,28 @@ describe('projectToolResultForCopilot', () => {
       projectToolResultForCopilot({ success: true, output: 'possibly-secret' }, undefined)
     ).toEqual({ success: true })
   })
+
+  it.each(['read', 'glob', 'grep'])(
+    'withholds a read-only %s failure without the mutation-retry warning',
+    (toolId) => {
+      const projected = projectToolResultForCopilot(
+        { success: false, error: 'anything' },
+        undefined,
+        toolId
+      )
+      expect(projected).toEqual({ success: false, error: READ_TOOL_RESULT_UNAVAILABLE_ERROR })
+      expect(projected.error).not.toContain('mutation')
+    }
+  )
+
+  it('keeps the mutation-retry warning for withheld mutating-tool failures', () => {
+    expect(
+      projectToolResultForCopilot(
+        { success: false, error: 'anything' },
+        undefined,
+        'apply_file_edit'
+      )
+    ).toEqual({ success: false, error: TOOL_RESULT_UNAVAILABLE_ERROR })
+    expect(toolResultUnavailableError(undefined)).toBe(TOOL_RESULT_UNAVAILABLE_ERROR)
+  })
 })
diff --git a/apps/sim/lib/copilot/request/tools/resolved-secret-result.ts b/apps/sim/lib/copilot/request/tools/resolved-secret-result.ts
index fdd4584fd1..f6785f60a8 100644
--- a/apps/sim/lib/copilot/request/tools/resolved-secret-result.ts
+++ b/apps/sim/lib/copilot/request/tools/resolved-secret-result.ts
@@ -5,13 +5,30 @@ import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secr
 export const TOOL_RESULT_UNAVAILABLE_ERROR =
   'Tool execution settled, but its result could not be returned safely. Do not retry a mutation automatically.'
 
+/**
+ * Read-only tools carry no mutation-retry hazard, so their withheld results
+ * must not warn against retrying — that wording makes the model abandon
+ * harmless reads it could simply try again or work around.
+ */
+export const READ_TOOL_RESULT_UNAVAILABLE_ERROR =
+  'Tool executed, but its result could not be returned safely. The call was read-only, so you may retry it or continue without the result.'
+
+const READ_ONLY_RESULT_TOOLS = new Set(['read', 'glob', 'grep'])
+
+/** Chooses the withheld-result message a tool's caller should surface. */
+export function toolResultUnavailableError(toolId?: string): string {
+  return toolId && READ_ONLY_RESULT_TOOLS.has(toolId)
+    ? READ_TOOL_RESULT_UNAVAILABLE_ERROR
+    : TOOL_RESULT_UNAVAILABLE_ERROR
+}
+
 function structuralResult(result: ToolExecutionResult): ToolExecutionResult {
   return { success: result.success === true }
 }
 
-function omittedResult(result: ToolExecutionResult): ToolExecutionResult {
+function omittedResult(result: ToolExecutionResult, toolId?: string): ToolExecutionResult {
   if (result.success) return { success: true }
-  return { success: false, error: TOOL_RESULT_UNAVAILABLE_ERROR }
+  return { success: false, error: toolResultUnavailableError(toolId) }
 }
 
 export type CopilotToolResultProjection =
@@ -26,7 +43,8 @@ export type CopilotToolResultProjection =
  */
 export function inspectToolResultForCopilot(
   result: ToolExecutionResult,
-  registry: ResolvedSecretTraceRegistry | undefined
+  registry: ResolvedSecretTraceRegistry | undefined,
+  toolId?: string
 ): CopilotToolResultProjection {
   try {
     const resultRegistry = registry?.forkForPropagatedEntries()
@@ -36,7 +54,7 @@ export function inspectToolResultForCopilot(
     if (Object.hasOwn(result, 'error')) content.error = result.error
     const projection = projectResolvedSecretModelJsonContent(content, resultRegistry)
     if (!projection.safe || !projection.value || typeof projection.value !== 'object') {
-      return { safe: false, result: omittedResult(result) }
+      return { safe: false, result: omittedResult(result, toolId) }
     }
 
     const projectedContent = projection.value as Record<string, unknown>
@@ -44,7 +62,7 @@ export function inspectToolResultForCopilot(
     if (Object.hasOwn(projectedContent, 'output')) projected.output = projectedContent.output
     if (Object.hasOwn(projectedContent, 'error')) {
       if (typeof projectedContent.error !== 'string') {
-        return { safe: false, result: omittedResult(result) }
+        return { safe: false, result: omittedResult(result, toolId) }
       }
       projected.error = projectedContent.error
     }
@@ -52,11 +70,11 @@ export function inspectToolResultForCopilot(
       projected.resources = resources
     }
     if (!projected.success && !projected.error) {
-      projected.error = TOOL_RESULT_UNAVAILABLE_ERROR
+      projected.error = toolResultUnavailableError(toolId)
     }
     return { safe: true, result: projected }
   } catch {
-    return { safe: false, result: omittedResult(result) }
+    return { safe: false, result: omittedResult(result, toolId) }
   }
 }
 
@@ -66,15 +84,17 @@ export function inspectToolResultForCopilot(
  */
 export function projectToolResultForCopilot(
   result: ToolExecutionResult,
-  registry: ResolvedSecretTraceRegistry | undefined
+  registry: ResolvedSecretTraceRegistry | undefined,
+  toolId?: string
 ): ToolExecutionResult {
-  return inspectToolResultForCopilot(result, registry).result
+  return inspectToolResultForCopilot(result, registry, toolId).result
 }
 
 /** Projects an error before post-processing can attach it to application logs or OTel events. */
 export function projectToolErrorMessageForCopilot(
   error: string,
-  registry: ResolvedSecretTraceRegistry | undefined
+  registry: ResolvedSecretTraceRegistry | undefined,
+  toolId?: string
 ): string {
-  return projectToolResultForCopilot({ success: false, error }, registry).error ?? ''
+  return projectToolResultForCopilot({ success: false, error }, registry, toolId).error ?? ''
 }
diff --git a/apps/sim/lib/copilot/request/tools/tables.test.ts b/apps/sim/lib/copilot/request/tools/tables.test.ts
index 57347739a4..ba68f10f7c 100644
--- a/apps/sim/lib/copilot/request/tools/tables.test.ts
+++ b/apps/sim/lib/copilot/request/tools/tables.test.ts
@@ -30,7 +30,7 @@ vi.mock('@/lib/table/application/rows', () => ({
   ProjectedWireRowsValidationError: class ProjectedWireRowsValidationError extends Error {},
 }))
 
-import { FunctionExecute, Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { Read as ReadTool, RunFunction } from '@/lib/copilot/generated/tool-catalog-v1'
 import { projectToolResultForCopilot } from '@/lib/copilot/request/tools/resolved-secret-result'
 import {
   maybeWriteOutputToTable,
@@ -94,7 +94,7 @@ describe('automatic Copilot tool-output table persistence', () => {
     ]
 
     const result = await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: rows } },
       context
@@ -129,7 +129,7 @@ describe('automatic Copilot tool-output table persistence', () => {
     const runtimeRows = [{ name: 'secret-value', status: 'literal' }]
 
     const result = await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: runtimeRows } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -159,7 +159,7 @@ describe('automatic Copilot tool-output table persistence', () => {
     registry.markIncomplete('unspecified')
 
     await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: [{ name: 'unknown' }] } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -179,7 +179,7 @@ describe('automatic Copilot tool-output table persistence', () => {
     )
 
     const result = await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: [{ wrong: true }] } },
       buildContext()
@@ -199,7 +199,7 @@ describe('automatic Copilot tool-output table persistence', () => {
     mocks.executeReplace.mockRejectedValueOnce(new Error('database duplicate: secret-value'))
 
     const result = await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: [{ name: 'secret-value' }] } },
       buildContext({ resolvedSecretTraceRegistry: registry })
@@ -217,7 +217,7 @@ describe('automatic Copilot tool-output table persistence', () => {
 
   it('rejects read-only Copilot execution before any application command', async () => {
     const result = await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: [{ name: 'Ada' }] } },
       buildContext({ userPermission: 'read' })
@@ -232,7 +232,7 @@ describe('automatic Copilot tool-output table persistence', () => {
     mocks.executeReplace.mockResolvedValueOnce({ table, deletedCount: 1, insertedCount: 1 })
 
     const result = await maybeWriteOutputToTable(
-      FunctionExecute.id,
+      RunFunction.id,
       { outputTable: 'table-1' },
       { success: true, output: { result: [{ name: 'Ada' }, { name: 'Grace' }] } },
       buildContext()
diff --git a/apps/sim/lib/copilot/request/tools/tables.ts b/apps/sim/lib/copilot/request/tools/tables.ts
index 46d4d598e6..36eecdc220 100644
--- a/apps/sim/lib/copilot/request/tools/tables.ts
+++ b/apps/sim/lib/copilot/request/tools/tables.ts
@@ -2,7 +2,7 @@ import { createLogger } from '@sim/logger'
 import { parse as csvParse } from 'csv-parse/sync'
 import { executeCopilotReplaceProjectedWireRows } from '@/lib/copilot/application/table-commands'
 import { messageForCopilotTableError } from '@/lib/copilot/auth/table-delegation'
-import { FunctionExecute, Read as ReadTool } from '@/lib/copilot/generated/tool-catalog-v1'
+import { Read as ReadTool, RunFunction } from '@/lib/copilot/generated/tool-catalog-v1'
 import { CopilotTableOutcome } from '@/lib/copilot/generated/trace-attribute-values-v1'
 import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
 import { TraceEvent } from '@/lib/copilot/generated/trace-events-v1'
@@ -68,7 +68,7 @@ export async function maybeWriteOutputToTable(
   result: ToolCallResult,
   context: ExecutionContext
 ): Promise<ToolCallResult> {
-  if (toolName !== FunctionExecute.id) return result
+  if (toolName !== RunFunction.id) return result
   if (!result.success || !result.output) return result
   const outputTable = params?.outputTable as string | undefined
   if (!outputTable) return result
diff --git a/apps/sim/lib/copilot/request/tools/workflow-client-fallback.test.ts b/apps/sim/lib/copilot/request/tools/workflow-client-fallback.test.ts
new file mode 100644
index 0000000000..d786190a33
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/workflow-client-fallback.test.ts
@@ -0,0 +1,177 @@
+/**
+ * @vitest-environment node
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { waitForWorkflowToolCompletion, claimWorkflowToolExecution, recordDegraded } = vi.hoisted(
+  () => ({
+    waitForWorkflowToolCompletion: vi.fn(),
+    claimWorkflowToolExecution: vi.fn(),
+    recordDegraded: vi.fn(),
+  })
+)
+
+vi.mock('@/lib/copilot/request/metrics', () => ({ recordDegraded }))
+
+vi.mock('@/lib/copilot/request/tools/client', () => ({
+  waitForWorkflowToolCompletion,
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  claimWorkflowToolExecution,
+}))
+
+import { raceWorkflowToolClientPickup } from '@/lib/copilot/request/tools/workflow-client-fallback'
+
+const GRACE_MS = 30_000
+const TIMEOUT_MS = 3_600_000
+
+/** Captures the abort signal the waiter was handed so tests can assert teardown. */
+let waiterSignals: (AbortSignal | undefined)[] = []
+
+/** Models the real waiter: pends until aborted, then resolves null. */
+function pendingUntilAborted() {
+  waitForWorkflowToolCompletion.mockImplementation(({ abortSignal }) => {
+    waiterSignals.push(abortSignal)
+    return new Promise((resolve) => {
+      if (abortSignal?.aborted) {
+        resolve(null)
+        return
+      }
+      abortSignal?.addEventListener('abort', () => resolve(null), { once: true })
+    })
+  })
+}
+
+function baseParams(overrides: Record<string, unknown> = {}) {
+  return {
+    toolCallId: 'tool-1',
+    workflowId: 'workflow-1',
+    timeoutMs: TIMEOUT_MS,
+    graceMs: GRACE_MS,
+    runOnServer: vi.fn().mockResolvedValue({ status: 'success' }),
+    ...overrides,
+  }
+}
+
+describe('raceWorkflowToolClientPickup', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.useFakeTimers()
+    waiterSignals = []
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('lets the client win without ever attempting a claim', async () => {
+    waitForWorkflowToolCompletion.mockResolvedValue({ status: 'success', data: { ok: true } })
+    const params = baseParams()
+
+    const outcome = await raceWorkflowToolClientPickup(params as never)
+
+    expect(outcome.winner).toBe('client')
+    expect(outcome.completion).toEqual({ status: 'success', data: { ok: true } })
+    expect(claimWorkflowToolExecution).not.toHaveBeenCalled()
+    expect(params.runOnServer).not.toHaveBeenCalled()
+  })
+
+  it('runs the tool server-side when the grace elapses and the claim is won', async () => {
+    pendingUntilAborted()
+    claimWorkflowToolExecution.mockResolvedValue({ toolCallId: 'tool-1' })
+    const params = baseParams()
+
+    const promise = raceWorkflowToolClientPickup(params as never)
+    await vi.advanceTimersByTimeAsync(GRACE_MS)
+    const outcome = await promise
+
+    expect(outcome.winner).toBe('sim')
+    expect(outcome.signal).toEqual({ status: 'success' })
+    // Falling back is non-fatal, so it has to be countable — Sim logs do not
+    // reach Loki and this path emits no exported span.
+    expect(recordDegraded).toHaveBeenCalledWith('client_pickup_timeout')
+    expect(claimWorkflowToolExecution).toHaveBeenCalledTimes(1)
+    expect(params.runOnServer).toHaveBeenCalledTimes(1)
+    // The claimed id is what the server run must bind to.
+    expect(params.runOnServer).toHaveBeenCalledWith(outcome.boundExecutionId)
+    expect(outcome.boundExecutionId).toBeTruthy()
+    // The client waiter must be torn down before the server runs, or the sim
+    // path's own confirmation would wake it and emit a duplicate result.
+    expect(waiterSignals.at(0)?.aborted).toBe(true)
+  })
+
+  it('keeps waiting on the browser when the claim is lost', async () => {
+    // The waiter stays pending until the "browser" reports, so we can assert the
+    // helper went back to waiting on the same promise rather than running.
+    let reportFromBrowser!: (value: unknown) => void
+    waitForWorkflowToolCompletion.mockImplementation(({ abortSignal }) => {
+      waiterSignals.push(abortSignal)
+      return new Promise((resolve) => {
+        reportFromBrowser = resolve
+      })
+    })
+    claimWorkflowToolExecution.mockResolvedValue(null)
+    const params = baseParams()
+
+    const promise = raceWorkflowToolClientPickup(params as never)
+    await vi.advanceTimersByTimeAsync(GRACE_MS)
+
+    expect(claimWorkflowToolExecution).toHaveBeenCalledTimes(1)
+    expect(params.runOnServer).not.toHaveBeenCalled()
+    // The waiter must NOT have been torn down — a browser owns this call.
+    expect(waiterSignals.at(0)?.aborted).toBe(false)
+
+    reportFromBrowser({ status: 'success', data: { ranInBrowser: true } })
+    const outcome = await promise
+
+    expect(outcome.winner).toBe('client')
+    expect(outcome.completion).toEqual({ status: 'success', data: { ranInBrowser: true } })
+    expect(waitForWorkflowToolCompletion).toHaveBeenCalledTimes(1)
+  })
+
+  it('never claims work on a turn the user already stopped', async () => {
+    pendingUntilAborted()
+    const abortController = new AbortController()
+    const params = baseParams({ abortSignal: abortController.signal })
+
+    const promise = raceWorkflowToolClientPickup(params as never)
+    abortController.abort()
+    await vi.advanceTimersByTimeAsync(GRACE_MS)
+    const outcome = await promise
+
+    expect(outcome.winner).toBe('client')
+    expect(claimWorkflowToolExecution).not.toHaveBeenCalled()
+    expect(params.runOnServer).not.toHaveBeenCalled()
+  })
+
+  it('still falls back when the wait expires before the grace window', async () => {
+    // A caller-supplied timeout shorter than the grace makes the waiter resolve
+    // null first; that is an expired wait, not a missing completion.
+    waitForWorkflowToolCompletion.mockResolvedValue(null)
+    claimWorkflowToolExecution.mockResolvedValue({ toolCallId: 'tool-1' })
+    const params = baseParams({ timeoutMs: 1_000 })
+
+    const promise = raceWorkflowToolClientPickup(params as never)
+    await vi.advanceTimersByTimeAsync(1_000)
+    const outcome = await promise
+
+    expect(outcome.winner).toBe('sim')
+    expect(params.runOnServer).toHaveBeenCalledTimes(1)
+  })
+
+  it('keeps waiting on the browser when the claim itself errors', async () => {
+    waitForWorkflowToolCompletion.mockResolvedValue(null)
+    claimWorkflowToolExecution.mockRejectedValue(new Error('db down'))
+    const params = baseParams({ timeoutMs: 1_000 })
+
+    const promise = raceWorkflowToolClientPickup(params as never)
+    await vi.advanceTimersByTimeAsync(1_000)
+    const outcome = await promise
+
+    // Losing the claim to an error must never become a second execution.
+    expect(outcome.winner).toBe('client')
+    expect(params.runOnServer).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/lib/copilot/request/tools/workflow-client-fallback.ts b/apps/sim/lib/copilot/request/tools/workflow-client-fallback.ts
new file mode 100644
index 0000000000..6a5a2df4c0
--- /dev/null
+++ b/apps/sim/lib/copilot/request/tools/workflow-client-fallback.ts
@@ -0,0 +1,143 @@
+import { createLogger } from '@sim/logger'
+import { toError } from '@sim/utils/errors'
+import { sleep } from '@sim/utils/helpers'
+import { generateId } from '@sim/utils/id'
+import type {
+  AsyncCompletionSignal,
+  AsyncTerminalCompletionSnapshot,
+} from '@/lib/copilot/async-runs/lifecycle'
+import { claimWorkflowToolExecution } from '@/lib/copilot/async-runs/repository'
+import { CopilotDegradedReason } from '@/lib/copilot/generated/trace-attribute-values-v1'
+import { recordDegraded } from '@/lib/copilot/request/metrics'
+import { waitForWorkflowToolCompletion } from '@/lib/copilot/request/tools/client'
+import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
+
+const logger = createLogger('CopilotWorkflowClientFallback')
+
+/** Which side actually ran the workflow for this tool call. */
+export type WorkflowToolWinner = 'client' | 'sim'
+
+export interface WorkflowToolRaceOutcome {
+  winner: WorkflowToolWinner
+  /** Set when `winner === 'client'`; null means the client wait timed out. */
+  completion?: AsyncTerminalCompletionSnapshot | null
+  /** Set when `winner === 'sim'`. */
+  signal?: AsyncCompletionSignal
+  /** The execution id the server claimed, when it won. */
+  boundExecutionId?: string
+}
+
+interface RaceWorkflowToolClientPickupParams {
+  toolCallId: string
+  workflowId?: string
+  timeoutMs: number
+  graceMs: number
+  abortSignal?: AbortSignal
+  registry?: ResolvedSecretTraceRegistry
+  /** Runs the tool in-process; only invoked after the execution claim is won. */
+  runOnServer: (boundExecutionId: string) => Promise<AsyncCompletionSignal>
+}
+
+/**
+ * Wait for a browser to run a workflow tool call, and run it here if none does.
+ *
+ * Workflow tools are client-routed, but the only thing that dispatches one is
+ * the mounted chat view. A call frame that arrives while the user sits on a
+ * different chat is picked up by nobody, and the turn used to park for the full
+ * `timeoutMs` (an hour) before failing.
+ *
+ * After `graceMs` with no result, this competes for the same single-winner
+ * execution claim that `/api/workflows/[id]/execute` takes on the browser's
+ * behalf. Losing the claim means a browser really is running it, so we go back
+ * to waiting; winning it means nobody was there, so we run it in-process.
+ * Because both sides contend on `claimedBy IS NULL`, the workflow can never run
+ * twice — a browser arriving late gets a 409 it already treats as benign.
+ */
+export async function raceWorkflowToolClientPickup(
+  params: RaceWorkflowToolClientPickupParams
+): Promise<WorkflowToolRaceOutcome> {
+  const { toolCallId, workflowId, timeoutMs, graceMs, abortSignal, registry, runOnServer } = params
+
+  // Cancels only OUR client waiter once the server takes over, without
+  // disturbing the caller's turn-level abort signal.
+  const cancelClientWait = new AbortController()
+  const clientWaitSignal = abortSignal
+    ? AbortSignal.any([abortSignal, cancelClientWait.signal])
+    : cancelClientWait.signal
+
+  // Exactly one waiter for the whole race — a second one would double-consume
+  // the confirmation and emit a duplicate tool result.
+  const clientWait = waitForWorkflowToolCompletion({
+    toolCallId,
+    workflowId,
+    timeoutMs,
+    abortSignal: clientWaitSignal,
+    registry,
+  })
+
+  // A caller-supplied timeout shorter than the grace must win, or the grace
+  // would outlive the wait it is supposed to bound.
+  const effectiveGraceMs = Math.min(graceMs, timeoutMs)
+
+  const first = await Promise.race([
+    clientWait.then((completion) => ({ kind: 'client' as const, completion })),
+    sleep(effectiveGraceMs).then(() => ({ kind: 'grace' as const })),
+  ])
+
+  // A non-null client result inside the grace window is the normal path.
+  // A null one means the wait itself already expired (timeoutMs <= graceMs), so
+  // fall through and try the claim rather than reporting a missing completion.
+  if (first.kind === 'client' && first.completion !== null) {
+    return { winner: 'client', completion: first.completion }
+  }
+
+  // Never claim work on a turn the user already stopped.
+  if (abortSignal?.aborted) {
+    return { winner: 'client', completion: await clientWait }
+  }
+
+  const boundExecutionId = generateId()
+  // The repository returns `row ?? null`, but with no `noUncheckedIndexedAccess`
+  // the destructured row types as non-optional and the null collapses away.
+  // It is genuinely null when the claim is lost, so widen it back — the same
+  // reality `/api/workflows/[id]/execute` leans on for its `if (!boundToolCall)`.
+  let claimed: Awaited<ReturnType<typeof claimWorkflowToolExecution>> | null = null
+  try {
+    claimed = await claimWorkflowToolExecution(toolCallId, boundExecutionId)
+  } catch (error) {
+    // Losing the claim to an error is not a reason to run the workflow twice;
+    // fall back to waiting on the browser exactly as before.
+    logger.warn('Failed to claim workflow tool execution for server fallback', {
+      toolCallId,
+      workflowId,
+      error: toError(error).message,
+    })
+    return { winner: 'client', completion: await clientWait }
+  }
+
+  if (!claimed) {
+    logger.info('Workflow tool already claimed by a client; continuing to wait', {
+      toolCallId,
+      workflowId,
+    })
+    return { winner: 'client', completion: await clientWait }
+  }
+
+  recordDegraded(CopilotDegradedReason.ClientPickupTimeout)
+  logger.info('No client picked up workflow tool within grace; running it server-side', {
+    toolCallId,
+    workflowId,
+    boundExecutionId,
+    graceMs: effectiveGraceMs,
+  })
+
+  // Tear the waiter down BEFORE running in-process. The server path publishes
+  // its own terminal confirmation on the same channel this waiter subscribes
+  // to, so a live waiter would resolve with our own result and emit a second,
+  // client-flavored tool result on top of it. Awaiting is what guarantees the
+  // subscription is gone, not just signalled.
+  cancelClientWait.abort()
+  await clientWait
+
+  return { winner: 'sim', signal: await runOnServer(boundExecutionId), boundExecutionId }
+}
diff --git a/apps/sim/lib/copilot/request/types.ts b/apps/sim/lib/copilot/request/types.ts
index ed76e5cd50..f11a9b15a4 100644
--- a/apps/sim/lib/copilot/request/types.ts
+++ b/apps/sim/lib/copilot/request/types.ts
@@ -41,7 +41,7 @@ export interface ToolCallState {
    * For a subagent-scoped tool call, the invoking subagent's channel id (its
    * outer tool_use id, = event.scope.parentToolCallId). Captured at dispatch so
    * the executor can thread it into the server tool context and scope the
-   * workspace_file -> edit_content intent handoff per file subagent. Undefined
+   * prepare_file_edit -> apply_file_edit intent handoff per file subagent. Undefined
    * for main-lane tool calls.
    */
   parentToolCallId?: string
@@ -80,6 +80,8 @@ export interface ContentBlock {
    * `subagent` start block is missing (resume legs re-emit text without start).
    */
   subagent?: string
+  /** Orchestrator-chosen display name for a `subagent` start block. */
+  subagentName?: string
   /**
    * Deterministic agent-run identity. `spanId` is the stable per-invocation id
    * of the subagent that produced the block; `parentSpanId` links it to the run
@@ -146,6 +148,8 @@ export interface StreamingContext {
    * block. Per-lane keying keeps each subagent's reasoning intact.
    */
   subagentThinkingBlocks: Map<string, ContentBlock>
+  /** Span ids whose lane start block has been persisted (dedupe across replays). */
+  openSubagentSpans?: Set<string>
   isInThinkingBlock: boolean
   subAgentContent: Record<string, string>
   subAgentToolCalls: Record<string, ToolCallState[]>
diff --git a/apps/sim/lib/copilot/resources/extraction.test.ts b/apps/sim/lib/copilot/resources/extraction.test.ts
index 65e8d40bc6..c47413711f 100644
--- a/apps/sim/lib/copilot/resources/extraction.test.ts
+++ b/apps/sim/lib/copilot/resources/extraction.test.ts
@@ -5,9 +5,9 @@ import { describe, expect, it } from 'vitest'
 import { extractDeletedResourcesFromToolResult, extractResourcesFromToolResult } from './extraction'
 
 describe('extractResourcesFromToolResult', () => {
-  it('extracts file resources from create_file results', () => {
+  it('extracts file resources from create_empty_file results', () => {
     const resources = extractResourcesFromToolResult(
-      'create_file',
+      'create_empty_file',
       {
         fileName: 'notes.md',
       },
@@ -31,9 +31,9 @@ describe('extractResourcesFromToolResult', () => {
     ])
   })
 
-  it('uses the knowledge base id for knowledge_base tag mutations', () => {
+  it('uses the knowledge base id for manage_knowledge_base tag mutations', () => {
     const resources = extractResourcesFromToolResult(
-      'knowledge_base',
+      'manage_knowledge_base',
       {
         operation: 'update_tag',
         args: {
@@ -63,7 +63,7 @@ describe('extractResourcesFromToolResult', () => {
 
   it('uses knowledgeBaseId from the tool result when update_tag args omit it', () => {
     const resources = extractResourcesFromToolResult(
-      'knowledge_base',
+      'manage_knowledge_base',
       {
         operation: 'update_tag',
         args: {
@@ -93,7 +93,7 @@ describe('extractResourcesFromToolResult', () => {
 
   it('does not create resources for read-only knowledge base tag operations', () => {
     const resources = extractResourcesFromToolResult(
-      'knowledge_base',
+      'manage_knowledge_base',
       {
         operation: 'list_tags',
         args: {
@@ -156,7 +156,7 @@ describe('extractDeletedResourcesFromToolResult', () => {
             { from: 'workflows/Lead%20Router', kind: 'workflow', id: 'wf-1' },
             { from: 'workflows/Old%20Projects', kind: 'workflow_folder', id: 'wfolder-1' },
             { from: 'tables/Leads', kind: 'table', id: 'tbl-1' },
-            { from: 'knowledgebases/support-docs', kind: 'knowledge_base', id: 'kb-1' },
+            { from: 'knowledgebases/support-docs', kind: 'manage_knowledge_base', id: 'kb-1' },
             { from: 'files/missing.md', kind: 'file', error: 'Not found: files/missing.md' },
           ],
         }
@@ -181,10 +181,10 @@ describe('extractDeletedResourcesFromToolResult', () => {
     ).toEqual([{ type: 'table', id: 'table-1', title: 'Table' }])
   })
 
-  it('extracts deleted knowledge bases from knowledge_base result data', () => {
+  it('extracts deleted knowledge bases from manage_knowledge_base result data', () => {
     expect(
       extractDeletedResourcesFromToolResult(
-        'knowledge_base',
+        'manage_knowledge_base',
         { operation: 'delete', args: { knowledgeBaseIds: ['kb-1'] } },
         {
           success: true,
diff --git a/apps/sim/lib/copilot/resources/extraction.ts b/apps/sim/lib/copilot/resources/extraction.ts
index fc2fd57e96..2f47680dfa 100644
--- a/apps/sim/lib/copilot/resources/extraction.ts
+++ b/apps/sim/lib/copilot/resources/extraction.ts
@@ -1,19 +1,19 @@
 import { toRecord } from '@sim/utils/object'
 import {
-  CreateFile,
+  CreateEmptyFile,
   CreateWorkflow,
-  DownloadToWorkspaceFile,
+  DownloadFile,
   EditWorkflow,
   Ffmpeg,
-  FunctionExecute,
   GenerateAudio,
   GenerateImage,
   GenerateVideo,
   Knowledge,
-  KnowledgeBase,
+  ManageKnowledgeBase,
+  PrepareFileEdit,
   Rm,
+  RunFunction,
   UserTable,
-  WorkspaceFile,
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { MothershipResource, MothershipResourceType } from './types'
 
@@ -22,13 +22,13 @@ type ResourceType = MothershipResourceType
 
 const RESOURCE_TOOL_NAMES: Set<string> = new Set([
   UserTable.id,
-  CreateFile.id,
-  WorkspaceFile.id,
-  DownloadToWorkspaceFile.id,
+  CreateEmptyFile.id,
+  PrepareFileEdit.id,
+  DownloadFile.id,
   CreateWorkflow.id,
   EditWorkflow.id,
-  FunctionExecute.id,
-  KnowledgeBase.id,
+  RunFunction.id,
+  ManageKnowledgeBase.id,
   Knowledge.id,
   GenerateImage.id,
   GenerateVideo.id,
@@ -107,8 +107,8 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case CreateFile.id:
-    case WorkspaceFile.id: {
+    case CreateEmptyFile.id:
+    case PrepareFileEdit.id: {
       const file = toRecord(data.file)
       if (file.id) {
         return [{ type: 'file', id: file.id as string, title: (file.name as string) || 'File' }]
@@ -121,7 +121,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case FunctionExecute.id: {
+    case RunFunction.id: {
       if (result.tableId) {
         return [
           {
@@ -143,7 +143,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case DownloadToWorkspaceFile.id:
+    case DownloadFile.id:
     case GenerateImage.id:
     case GenerateVideo.id:
     case GenerateAudio.id:
@@ -178,7 +178,7 @@ export function extractResourcesFromToolResult(
       return []
     }
 
-    case KnowledgeBase.id: {
+    case ManageKnowledgeBase.id: {
       if (READ_ONLY_KB_OPS.has(getOperation(params) ?? '')) return []
 
       const args = toRecord(params?.args)
@@ -222,9 +222,9 @@ export function extractResourcesFromToolResult(
 }
 
 const DELETE_CAPABLE_TOOL_RESOURCE_TYPE: Record<string, ResourceType> = {
-  [WorkspaceFile.id]: 'file',
+  [PrepareFileEdit.id]: 'file',
   [UserTable.id]: 'table',
-  [KnowledgeBase.id]: 'knowledgebase',
+  [ManageKnowledgeBase.id]: 'knowledgebase',
   // rm spans categories, so unlike every other entry its resource type comes
   // from each outcome's kind rather than from this map. The entry exists so
   // hasDeleteCapability(rm) holds; the rm case below ignores this value.
@@ -238,7 +238,7 @@ const RM_KIND_RESOURCE_TYPE: Record<string, ResourceType> = {
   workflow: 'workflow',
   workflow_folder: 'folder',
   table: 'table',
-  knowledge_base: 'knowledgebase',
+  manage_knowledge_base: 'knowledgebase',
 }
 
 export function hasDeleteCapability(toolName: string): boolean {
@@ -278,7 +278,7 @@ export function extractDeletedResourcesFromToolResult(
         return [{ type, id, title: leaf ? decodeURIComponent(leaf) : 'Deleted resource' }]
       })
     }
-    case WorkspaceFile.id: {
+    case PrepareFileEdit.id: {
       if (operation !== 'delete') return []
       const target = getWorkspaceFileTarget(params)
       const fileId = (data.id as string) ?? (target.fileId as string) ?? (args.fileId as string)
@@ -303,7 +303,7 @@ export function extractDeletedResourcesFromToolResult(
       return []
     }
 
-    case KnowledgeBase.id: {
+    case ManageKnowledgeBase.id: {
       if (operation !== 'delete') return []
       const deleted = Array.isArray(data.deleted) ? data.deleted : []
       const resources = deleted.flatMap((entry): ChatResource[] => {
diff --git a/apps/sim/lib/copilot/resources/types.ts b/apps/sim/lib/copilot/resources/types.ts
index 7edc630d19..bc25956d3d 100644
--- a/apps/sim/lib/copilot/resources/types.ts
+++ b/apps/sim/lib/copilot/resources/types.ts
@@ -20,6 +20,8 @@ export interface MothershipResource {
   id: string
   title: string
   path?: string
+  /** Saved table view to open pinned (type "table" only). */
+  viewId?: string
 }
 
 /**
diff --git a/apps/sim/lib/copilot/tool-executor/executor.test.ts b/apps/sim/lib/copilot/tool-executor/executor.test.ts
index 1a6848d1e5..dff1fc1c42 100644
--- a/apps/sim/lib/copilot/tool-executor/executor.test.ts
+++ b/apps/sim/lib/copilot/tool-executor/executor.test.ts
@@ -51,25 +51,23 @@ describe('copilot tool executor fallback', () => {
     isSimExecuted.mockReturnValue(true)
     isClientExecuted.mockReturnValue(false)
     const handler = vi.fn().mockResolvedValue({ success: true })
-    registerHandler('function_execute', handler)
+    registerHandler('run_function', handler)
 
     await expect(
-      executeTool('function_execute', { code: 'return 1' }, { userId: 'user-1', workflowId: '' })
+      executeTool('run_function', { code: 'return 1' }, { userId: 'user-1', workflowId: '' })
     ).resolves.toEqual({
       success: false,
-      error:
-        "Permission denied: function_execute requires write access. You have 'none' permission.",
+      error: "Permission denied: run_function requires write access. You have 'none' permission.",
     })
     await expect(
       executeTool(
-        'function_execute',
+        'run_function',
         { code: 'return 1' },
         { userId: 'user-1', workflowId: '', userPermission: 'read' }
       )
     ).resolves.toEqual({
       success: false,
-      error:
-        "Permission denied: function_execute requires write access. You have 'read' permission.",
+      error: "Permission denied: run_function requires write access. You have 'read' permission.",
     })
     expect(handler).not.toHaveBeenCalled()
   })
@@ -80,11 +78,11 @@ describe('copilot tool executor fallback', () => {
     isSimExecuted.mockReturnValue(true)
     isClientExecuted.mockReturnValue(false)
     const handler = vi.fn().mockResolvedValue({ success: true, output: 'ok' })
-    registerHandler('function_execute', handler)
+    registerHandler('run_function', handler)
 
     await expect(
       executeTool(
-        'function_execute',
+        'run_function',
         { code: 'return 1' },
         { userId: 'user-1', workflowId: '', userPermission: 'write' }
       )
@@ -266,13 +264,13 @@ describe('copilot tool executor fallback', () => {
     expect(executeAppTool).toHaveBeenCalledWith('unknown_client_tool', expect.any(Object))
   })
 
-  it('converts function_execute timeout from seconds to milliseconds for copilot calls', async () => {
+  it('converts run_function timeout from seconds to milliseconds for copilot calls', async () => {
     isKnownTool.mockReturnValue(false)
     isSimExecuted.mockReturnValue(false)
     executeAppTool.mockResolvedValue({ success: true, output: { result: 'ok' } })
 
     await executeTool(
-      'function_execute',
+      'run_function',
       { code: 'return 1', timeout: 7 },
       {
         userId: 'user-1',
@@ -283,7 +281,7 @@ describe('copilot tool executor fallback', () => {
     )
 
     expect(executeAppTool).toHaveBeenCalledWith(
-      'function_execute',
+      'run_function',
       expect.objectContaining({
         timeout: 7000,
         _context: expect.objectContaining({
@@ -299,12 +297,12 @@ describe('copilot tool executor fallback', () => {
     )
   })
 
-  it('converts function_execute timeout before invoking its registered Sim handler', async () => {
+  it('converts run_function timeout before invoking its registered Sim handler', async () => {
     isKnownTool.mockReturnValue(true)
     isSimExecuted.mockReturnValue(true)
     isClientExecuted.mockReturnValue(false)
     const handler = vi.fn().mockResolvedValue({ success: true, output: { result: 'ok' } })
-    registerHandler('function_execute', handler)
+    registerHandler('run_function', handler)
 
     const context = {
       userId: 'user-1',
@@ -312,7 +310,7 @@ describe('copilot tool executor fallback', () => {
       workspaceId: 'ws-1',
       copilotToolExecution: true,
     }
-    await executeTool('function_execute', { code: 'return 1', timeout: 7 }, context)
+    await executeTool('run_function', { code: 'return 1', timeout: 7 }, context)
 
     expect(handler).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -324,13 +322,13 @@ describe('copilot tool executor fallback', () => {
     expect(executeAppTool).not.toHaveBeenCalled()
   })
 
-  it('defaults copilot function_execute timeout to 10 seconds when omitted', async () => {
+  it('defaults copilot run_function timeout to 10 seconds when omitted', async () => {
     isKnownTool.mockReturnValue(false)
     isSimExecuted.mockReturnValue(false)
     executeAppTool.mockResolvedValue({ success: true, output: { result: 'ok' } })
 
     await executeTool(
-      'function_execute',
+      'run_function',
       { code: 'return 1' },
       {
         userId: 'user-1',
@@ -341,7 +339,7 @@ describe('copilot tool executor fallback', () => {
     )
 
     expect(executeAppTool).toHaveBeenCalledWith(
-      'function_execute',
+      'run_function',
       expect.objectContaining({
         timeout: 10_000,
       }),
@@ -354,13 +352,13 @@ describe('copilot tool executor fallback', () => {
     )
   })
 
-  it('defaults copilot function_execute timeout to 10 seconds when invalid', async () => {
+  it('defaults copilot run_function timeout to 10 seconds when invalid', async () => {
     isKnownTool.mockReturnValue(false)
     isSimExecuted.mockReturnValue(false)
     executeAppTool.mockResolvedValue({ success: true, output: { result: 'ok' } })
 
     await executeTool(
-      'function_execute',
+      'run_function',
       { code: 'return 1', timeout: 0 },
       {
         userId: 'user-1',
@@ -371,7 +369,7 @@ describe('copilot tool executor fallback', () => {
     )
 
     expect(executeAppTool).toHaveBeenCalledWith(
-      'function_execute',
+      'run_function',
       expect.objectContaining({
         timeout: 10_000,
       }),
@@ -384,13 +382,13 @@ describe('copilot tool executor fallback', () => {
     )
   })
 
-  it('does not let copilot function_execute timeout exceed the default execution limit', async () => {
+  it('does not let copilot run_function timeout exceed the default execution limit', async () => {
     isKnownTool.mockReturnValue(false)
     isSimExecuted.mockReturnValue(false)
     executeAppTool.mockResolvedValue({ success: true, output: { result: 'ok' } })
 
     await executeTool(
-      'function_execute',
+      'run_function',
       { code: 'return 1', timeout: 10_000 },
       {
         userId: 'user-1',
@@ -401,7 +399,7 @@ describe('copilot tool executor fallback', () => {
     )
 
     expect(executeAppTool).toHaveBeenCalledWith(
-      'function_execute',
+      'run_function',
       expect.objectContaining({
         timeout: DEFAULT_EXECUTION_TIMEOUT_MS,
       }),
diff --git a/apps/sim/lib/copilot/tool-executor/executor.ts b/apps/sim/lib/copilot/tool-executor/executor.ts
index 81ce68b3dd..e934803dcf 100644
--- a/apps/sim/lib/copilot/tool-executor/executor.ts
+++ b/apps/sim/lib/copilot/tool-executor/executor.ts
@@ -9,7 +9,7 @@ import { getToolEntry, isClientExecuted, isKnownTool, isSimExecuted } from './ro
 import type { ToolExecutionContext, ToolExecutionResult, ToolHandler } from './types'
 
 const logger = createLogger('ToolExecutor')
-const FUNCTION_EXECUTE_TOOL_ID = 'function_execute'
+const FUNCTION_EXECUTE_TOOL_ID = 'run_function'
 const DEFAULT_FUNCTION_EXECUTE_TIMEOUT_SECONDS = 10
 const MILLISECONDS_PER_SECOND = 1000
 
diff --git a/apps/sim/lib/copilot/tool-executor/register-handlers.ts b/apps/sim/lib/copilot/tool-executor/register-handlers.ts
index f2f9eb6d30..a598d4135e 100644
--- a/apps/sim/lib/copilot/tool-executor/register-handlers.ts
+++ b/apps/sim/lib/copilot/tool-executor/register-handlers.ts
@@ -1,42 +1,39 @@
 import { createLogger } from '@sim/logger'
 import {
-  CheckDeploymentStatus,
+  ConnectSlackBot,
   Cp as CpTool,
   CreateWorkflow,
   CreateWorkspaceMcpServer,
   DeleteWorkspaceMcpServer,
-  DeployApi,
-  DeployChat,
-  DeployCustomBlock,
-  DeployMcp,
+  DeployAsApi,
+  DeployAsChat,
+  DeployAsMcp,
   DiffWorkflows,
-  FunctionExecute,
   GenerateApiKey,
   GetBlockOutputs,
   GetBlockUpstreamReferences,
   GetDeployedWorkflowState,
-  GetDeploymentLog,
-  GetPlatformActions,
+  GetDeploymentStatus,
   GetWorkflowData,
   GetWorkflowRunOptions,
   Glob as GlobTool,
   Grep as GrepTool,
+  ListDeploymentVersions,
   ListIntegrationTools,
-  ListUserWorkspaces,
   ListWorkspaceMcpServers,
   LoadDeployment,
   ManageCredential,
   ManageCustomTool,
-  ManageMcpTool,
+  ManageMcpConnection,
   ManageSandbox,
   ManageSkill,
-  MaterializeFile,
   Mkdir as MkdirTool,
   Mv as MvTool,
   OauthGetAuthLink,
   OauthRequestAccess,
   OpenResource,
   PromoteToLive,
+  PublishCustomBlock,
   Read as ReadTool,
   Redeploy,
   RestoreResource,
@@ -44,8 +41,10 @@ import {
   RunBlock,
   RunCode,
   RunFromBlock,
+  RunFunction,
   RunWorkflow,
   RunWorkflowUntilBlock,
+  SaveUpload,
   SetBlockEnabled,
   SetGlobalWorkflowVariables,
   UpdateDeploymentVersion,
@@ -74,6 +73,7 @@ import {
 } from '../tools/handlers/deployment/manage'
 import { executeFunctionExecute } from '../tools/handlers/function-execute'
 import { executeListIntegrationTools } from '../tools/handlers/integration-tools'
+import { executeConnectSlackBot } from '../tools/handlers/management/connect-slack-bot'
 import { executeManageCredential } from '../tools/handlers/management/manage-credential'
 import { executeManageCustomTool } from '../tools/handlers/management/manage-custom-tool'
 import { executeManageMcpTool } from '../tools/handlers/management/manage-mcp-tool'
@@ -81,7 +81,6 @@ import { executeManageSandbox } from '../tools/handlers/management/manage-sandbo
 import { executeManageSkill } from '../tools/handlers/management/manage-skill'
 import { executeMaterializeFile } from '../tools/handlers/materialize-file'
 import { executeOAuthGetAuthLink, executeOAuthRequestAccess } from '../tools/handlers/oauth'
-import { executeGetPlatformActions } from '../tools/handlers/platform'
 import { executeOpenResource } from '../tools/handlers/resources'
 import { executeRestoreResource } from '../tools/handlers/restore-resource'
 import { executeRunCode } from '../tools/handlers/run-code'
@@ -110,7 +109,6 @@ import {
   executeGetDeployedWorkflowState,
   executeGetWorkflowData,
   executeGetWorkflowRunOptions,
-  executeListUserWorkspaces,
 } from '../tools/handlers/workflow/queries'
 import { registerHandlers } from './executor'
 import type { ToolHandler } from './types'
@@ -135,7 +133,6 @@ function h(fn: (params: any, context: any) => Promise<any>): ToolHandler {
 
 function buildHandlerMap(): Record<string, ToolHandler> {
   return {
-    [ListUserWorkspaces.id]: h((_p, c) => executeListUserWorkspaces(c)),
     [GetWorkflowData.id]: h(executeGetWorkflowData),
     [GetWorkflowRunOptions.id]: h(executeGetWorkflowRunOptions),
     [GetBlockOutputs.id]: h(executeGetBlockOutputs),
@@ -156,17 +153,17 @@ function buildHandlerMap(): Record<string, ToolHandler> {
     [GenerateApiKey.id]: h(executeGenerateApiKey),
     [SetGlobalWorkflowVariables.id]: h(executeSetGlobalWorkflowVariables),
 
-    [DeployApi.id]: h(executeDeployApi),
-    [DeployChat.id]: h(executeDeployChat),
-    [DeployMcp.id]: h(executeDeployMcp),
-    [DeployCustomBlock.id]: h(executeDeployCustomBlock),
+    [DeployAsApi.id]: h(executeDeployApi),
+    [DeployAsChat.id]: h(executeDeployChat),
+    [DeployAsMcp.id]: h(executeDeployMcp),
+    [PublishCustomBlock.id]: h(executeDeployCustomBlock),
     [Redeploy.id]: h(executeRedeploy),
-    [CheckDeploymentStatus.id]: h(executeCheckDeploymentStatus),
+    [GetDeploymentStatus.id]: h(executeCheckDeploymentStatus),
     [ListWorkspaceMcpServers.id]: h(executeListWorkspaceMcpServers),
     [CreateWorkspaceMcpServer.id]: h(executeCreateWorkspaceMcpServer),
     [UpdateWorkspaceMcpServer.id]: h(executeUpdateWorkspaceMcpServer),
     [DeleteWorkspaceMcpServer.id]: h(executeDeleteWorkspaceMcpServer),
-    [GetDeploymentLog.id]: h(executeGetDeploymentLog),
+    [ListDeploymentVersions.id]: h(executeGetDeploymentLog),
     [DiffWorkflows.id]: h(executeDiffWorkflows),
     [LoadDeployment.id]: h(executeLoadDeployment),
     [PromoteToLive.id]: h(executePromoteToLive),
@@ -181,10 +178,11 @@ function buildHandlerMap(): Record<string, ToolHandler> {
     [RmTool.id]: h(executeVfsRm),
 
     [ManageCustomTool.id]: h(executeManageCustomTool),
-    [ManageMcpTool.id]: h(executeManageMcpTool),
+    [ManageMcpConnection.id]: h(executeManageMcpTool),
     [ManageSandbox.id]: h(executeManageSandbox),
     [ManageSkill.id]: h(executeManageSkill),
     [ManageCredential.id]: h(executeManageCredential),
+    [ConnectSlackBot.id]: h(executeConnectSlackBot),
     [OauthGetAuthLink.id]: h(executeOAuthGetAuthLink),
     // Rolling-deploy compatibility for calls/checkpoints created before OAuth
     // moved into terminal credential cards. New agents no longer receive this
@@ -192,10 +190,9 @@ function buildHandlerMap(): Record<string, ToolHandler> {
     [OauthRequestAccess.id]: h(executeOAuthRequestAccess),
     [OpenResource.id]: h(executeOpenResource),
     [RestoreResource.id]: h(executeRestoreResource),
-    [GetPlatformActions.id]: h(executeGetPlatformActions),
     [ListIntegrationTools.id]: h(executeListIntegrationTools),
-    [MaterializeFile.id]: h(executeMaterializeFile),
-    [FunctionExecute.id]: h(executeFunctionExecute),
+    [SaveUpload.id]: h(executeMaterializeFile),
+    [RunFunction.id]: h(executeFunctionExecute),
     [RunCode.id]: h(executeRunCode),
 
     ...buildServerToolHandlers(),
diff --git a/apps/sim/lib/copilot/tool-executor/types.ts b/apps/sim/lib/copilot/tool-executor/types.ts
index 17c233e255..d774ca0999 100644
--- a/apps/sim/lib/copilot/tool-executor/types.ts
+++ b/apps/sim/lib/copilot/tool-executor/types.ts
@@ -13,8 +13,18 @@ export interface ToolExecutionContext {
   runId?: string
   /** Stable identity of the individual tool call being executed. */
   toolCallId?: string
+  /**
+   * Workflow execution id this tool call is already bound to, set only by the
+   * copilot request handler when it wins the workflow-tool execution claim and
+   * runs the tool server-side instead of waiting for a browser. Distinct from
+   * `executionId`, which is the copilot run's own identity and is re-emitted
+   * into the principal by `requireTrustedCopilotExecutionContext`.
+   */
+  boundWorkflowExecutionId?: string
   billingAttribution?: BillingAttributionSnapshot
   copilotToolExecution?: boolean
+  /** Trusted lifecycle classification stamped by the server, never from model parameters. */
+  copilotInteractionMode?: 'interactive' | 'headless'
   /** Server-owned base image selected from the fixed Go route for this turn. */
   sandboxProfile?: 'mothership'
   requestMode?: string
diff --git a/apps/sim/lib/copilot/tools/client/browser-tool-execution.test.ts b/apps/sim/lib/copilot/tools/client/browser-tool-execution.test.ts
index 8731aafeed..82b9cc74da 100644
--- a/apps/sim/lib/copilot/tools/client/browser-tool-execution.test.ts
+++ b/apps/sim/lib/copilot/tools/client/browser-tool-execution.test.ts
@@ -436,3 +436,38 @@ describe('executeBrowserToolOnClient', () => {
     })
   })
 })
+
+describe('pre-dispatch drops still resolve the waiter', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockReportCompletion.mockResolvedValue(undefined)
+  })
+
+  it('reports an error confirmation for a stale event instead of hanging the turn', async () => {
+    const staleTs = new Date(Date.now() - 10 * 60 * 1000).toISOString()
+    executeBrowserToolOnClient('stale-call-1', 'browser_list_sessions', {}, 'chat-scope-1', staleTs)
+    await sleep(0)
+
+    expect(mockExecuteBrowserTool).not.toHaveBeenCalled()
+    expect(mockReportCompletion).toHaveBeenCalledWith(
+      'stale-call-1',
+      'error',
+      expect.stringContaining('too late'),
+      expect.objectContaining({ staleEvent: true })
+    )
+  })
+
+  it('reports an error confirmation when no chat scope exists', async () => {
+    useBrowserSessionStore.setState({ activeScopeId: null })
+    executeBrowserToolOnClient('no-scope-1', 'browser_list_sessions', {}, undefined)
+    await sleep(0)
+
+    expect(mockExecuteBrowserTool).not.toHaveBeenCalled()
+    expect(mockReportCompletion).toHaveBeenCalledWith(
+      'no-scope-1',
+      'error',
+      expect.stringContaining('no active browser session'),
+      expect.anything()
+    )
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/client/browser-tool-execution.ts b/apps/sim/lib/copilot/tools/client/browser-tool-execution.ts
index e0a13d0812..4e1f447682 100644
--- a/apps/sim/lib/copilot/tools/client/browser-tool-execution.ts
+++ b/apps/sim/lib/copilot/tools/client/browser-tool-execution.ts
@@ -175,15 +175,45 @@ export function executeBrowserToolOnClient(
 ): void {
   if (!scopeId) {
     logger.error('Cannot execute browser tool without a chat scope', { toolCallId, toolName })
+    // Tell the waiter, or the turn hangs forever on a tool that never ran.
+    const message = 'This browser action could not run: no active browser session for this chat.'
+    void reportClientToolCompletion(toolCallId, ASYNC_TOOL_CONFIRMATION_STATUS.error, message, {
+      error: message,
+    }).catch((reportErr) => {
+      logger.error('Failed to report missing-scope browser tool error', {
+        toolCallId,
+        error: toError(reportErr).message,
+      })
+    })
     return
   }
   if (hasAlreadyExecuted(toolCallId)) {
+    // Same-page re-delivery: the original dispatch is in flight (or done) and
+    // owns the result. Reporting here would race it — the server claims each
+    // resume exactly once, so an error now would discard the genuine result.
     logger.info('Skipping already-executed browser tool (replay)', { toolCallId, toolName })
     return
   }
   const age = eventAgeMs(eventTs)
   if (age !== null && age > MAX_EVENT_AGE_MS) {
     logger.info('Skipping stale browser tool event', { toolCallId, toolName, age })
+    // Usually a replay of an action that already ran and resumed in a previous
+    // page lifetime — the server claims each resume exactly once, so this
+    // duplicate confirmation is simply discarded. When it is NOT a replay
+    // (the event was delivered late, e.g. a backgrounded tab with throttled
+    // timers), this error unblocks the turn instead of leaving it hanging
+    // forever on a tool that will never execute.
+    const message =
+      'This browser action was delivered too late to run safely. Ask again to retry it.'
+    void reportClientToolCompletion(toolCallId, ASYNC_TOOL_CONFIRMATION_STATUS.error, message, {
+      error: message,
+      staleEvent: true,
+    }).catch((reportErr) => {
+      logger.error('Failed to report stale browser tool error', {
+        toolCallId,
+        error: toError(reportErr).message,
+      })
+    })
     return
   }
   markExecuted(toolCallId)
diff --git a/apps/sim/lib/copilot/tools/client/completion.ts b/apps/sim/lib/copilot/tools/client/completion.ts
index b99cb55cf9..691cb1699f 100644
--- a/apps/sim/lib/copilot/tools/client/completion.ts
+++ b/apps/sim/lib/copilot/tools/client/completion.ts
@@ -2,6 +2,7 @@ import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { sleep } from '@sim/utils/helpers'
 import { isRecordLike } from '@sim/utils/object'
+import { backoffWithJitter } from '@sim/utils/retry'
 import type {
   AsyncCompletionData,
   AsyncConfirmationStatus,
@@ -48,7 +49,13 @@ export async function reportClientToolCompletion(
   const bodySize = new Blob([body]).size
   let lastError: Error | null = null
 
-  for (let attempt = 1; attempt <= 2; attempt++) {
+  // A lost confirmation strands the server-side waiter forever (the turn shows
+  // the tool as running indefinitely), so ride out multi-second network blips:
+  // 5 attempts with jittered exponential backoff (~15s total) instead of a
+  // sub-second give-up. The confirm endpoint claims each resume exactly once,
+  // so duplicate deliveries from retries are discarded server-side.
+  const maxAttempts = 5
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
       const response = await send(body)
       if (response.ok) return
@@ -78,8 +85,8 @@ export async function reportClientToolCompletion(
       lastError = toError(error)
     }
 
-    if (attempt < 2) {
-      await sleep(250)
+    if (attempt < maxAttempts) {
+      await sleep(backoffWithJitter(attempt, null))
     }
   }
 
diff --git a/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts b/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
index d0299ac419..95e58fa464 100644
--- a/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
+++ b/apps/sim/lib/copilot/tools/client/run-tool-execution.test.ts
@@ -57,6 +57,11 @@ const setCurrentExecutionId = vi.fn()
 const getCurrentExecutionId = vi.fn()
 const getWorkflowExecution = vi.fn(() => ({ isExecuting: false }))
 
+// Neutralize the confirm-retry backoff so exhaustion tests stay fast.
+vi.mock('@sim/utils/retry', () => ({
+  backoffWithJitter: () => 0,
+}))
+
 vi.mock('@/app/workspace/[workspaceId]/w/[workflowId]/utils/workflow-execution-utils', () => ({
   executeWorkflowWithFullLogging,
 }))
@@ -265,6 +270,9 @@ describe('run tool execution cancellation', () => {
       })
       .mockResolvedValueOnce({ ok: false, status: 503 })
       .mockResolvedValueOnce({ ok: false, status: 503 })
+      .mockResolvedValueOnce({ ok: false, status: 503 })
+      .mockResolvedValueOnce({ ok: false, status: 503 })
+      .mockResolvedValueOnce({ ok: false, status: 503 })
       .mockResolvedValue({ ok: true })
     vi.stubGlobal('fetch', fetchMock)
 
@@ -273,7 +281,7 @@ describe('run tool execution cancellation', () => {
       async: true,
     })
 
-    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(3))
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(6))
     await vi.waitFor(() => expect(isRunToolActiveForId('tool-recover-async')).toBe(false))
     loadExecutionPointer.mockResolvedValueOnce({
       workflowId: 'wf-1',
@@ -283,10 +291,10 @@ describe('run tool execution cancellation', () => {
 
     await expect(bindRunToolToExecution('tool-recover-async', 'wf-1')).resolves.toBe(true)
 
-    expect(fetchMock).toHaveBeenCalledTimes(4)
-    expect(fetchMock.mock.calls[3][0]).toBe('/api/copilot/confirm')
-    expect(fetchMock.mock.calls[3][1]?.body).toContain('"status":"background"')
-    expect(fetchMock.mock.calls[3][1]?.body).toContain('"executionId":"exec-recover-async"')
+    expect(fetchMock).toHaveBeenCalledTimes(7)
+    expect(fetchMock.mock.calls[6][0]).toBe('/api/copilot/confirm')
+    expect(fetchMock.mock.calls[6][1]?.body).toContain('"status":"background"')
+    expect(fetchMock.mock.calls[6][1]?.body).toContain('"executionId":"exec-recover-async"')
     expect(
       fetchMock.mock.calls.filter(([url]) => url === '/api/workflows/wf-1/execute')
     ).toHaveLength(1)
@@ -451,6 +459,64 @@ describe('run tool execution cancellation', () => {
     )
   })
 
+  it('reports the real failure reason so the agent can correct its arguments', async () => {
+    // A generic "Workflow execution failed." told the model nothing, so it could
+    // not fix a rejected binding or an undeployed workflow on retry.
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true })
+    vi.stubGlobal('fetch', fetchMock)
+    executeWorkflowWithFullLogging.mockRejectedValueOnce(
+      new MockExecutionStreamHttpError(
+        'This Copilot workflow tool call is bound to a different workflow',
+        403,
+        'COPILOT_WORKFLOW_TOOL_BINDING_WORKFLOW_MISMATCH'
+      )
+    )
+
+    executeRunToolOnClient('tool-binding-rejected', 'run_workflow', { workflowId: 'wf-1' })
+
+    await vi.waitFor(() => {
+      expect(fetchMock).toHaveBeenCalledWith(
+        '/api/copilot/confirm',
+        expect.objectContaining({
+          body: expect.stringContaining('COPILOT_WORKFLOW_TOOL_BINDING_WORKFLOW_MISMATCH'),
+        })
+      )
+    })
+    const confirmBody = JSON.parse(
+      fetchMock.mock.calls.find(([url]) => url === '/api/copilot/confirm')?.[1]?.body as string
+    )
+    expect(confirmBody.message).toBe(
+      'This Copilot workflow tool call is bound to a different workflow'
+    )
+    expect(confirmBody.status).toBe('error')
+  })
+
+  it('drops a duplicate async launch without confirming or surfacing an error', async () => {
+    // The server fallback (or another tab) already claimed this tool call.
+    // Reporting an error here would overwrite a run that is in flight.
+    const fetchMock = vi.fn().mockResolvedValueOnce({
+      ok: false,
+      status: 409,
+      json: vi.fn().mockResolvedValue({
+        error: 'Copilot workflow tool is already bound to another execution',
+        code: 'COPILOT_WORKFLOW_EXECUTION_CONFLICT',
+      }),
+    })
+    vi.stubGlobal('fetch', fetchMock)
+
+    executeRunToolOnClient('tool-async-duplicate', 'run_workflow', {
+      workflowId: 'wf-1',
+      async: true,
+    })
+
+    await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1))
+
+    // Only the execute attempt — never a /api/copilot/confirm report.
+    expect(fetchMock).toHaveBeenCalledTimes(1)
+    expect(fetchMock.mock.calls[0][0]).toBe('/api/workflows/wf-1/execute')
+    expect(saveExecutionPointer).not.toHaveBeenCalled()
+  })
+
   it('drops a duplicate client runner without confirming or surfacing an error', async () => {
     const fetchMock = vi.fn().mockResolvedValue({ ok: true })
     vi.stubGlobal('fetch', fetchMock)
diff --git a/apps/sim/lib/copilot/tools/client/run-tool-execution.ts b/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
index 4e7e6e2340..ac2ead7670 100644
--- a/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
+++ b/apps/sim/lib/copilot/tools/client/run-tool-execution.ts
@@ -69,6 +69,13 @@ function resolveTriggerBlockId(params: Record<string, unknown>): string | undefi
     : undefined
 }
 
+/** The execute endpoint's "this tool call is already bound to another run" body. */
+function isWorkflowExecutionConflict(responseBody: unknown): boolean {
+  return (
+    isPlainRecord(responseBody) && responseBody.code === COPILOT_WORKFLOW_EXECUTION_CONFLICT_CODE
+  )
+}
+
 async function enqueueAsyncWorkflowRun(
   toolCallId: string,
   workflowId: string,
@@ -120,6 +127,18 @@ async function enqueueAsyncWorkflowRun(
     acceptanceIsAmbiguous =
       isPlainRecord(responseBody) && responseBody.code === 'ASYNC_ENQUEUE_AMBIGUOUS'
 
+    // Someone else — another tab, or the server's own fallback — already owns
+    // this tool call. Stay silent so the winner reports the result; reporting
+    // an error here would overwrite a run that is happily in flight. Mirrors
+    // the streamed path's handling of the same conflict.
+    if (response.status === 409 && isWorkflowExecutionConflict(responseBody)) {
+      logger.info('[RunTool] Ignoring duplicate async workflow launch', {
+        toolCallId,
+        workflowId,
+      })
+      return
+    }
+
     if (!response.ok && !acceptanceIsAmbiguous) {
       const responseError =
         deploymentError?.message ??
@@ -662,11 +681,20 @@ async function doExecuteRunTool(
       logger.error('[RunTool] Workflow execution threw', { toolCallId, toolName, error: msg })
       const failedExecutionId =
         useExecutionStore.getState().getCurrentExecutionId(targetWorkflowId) ?? executionId
+      // Carry the real failure through instead of the generic "Workflow execution
+      // failed." — the agent can only correct a bad request (a rejected binding,
+      // an undeployed workflow) if it is told what was wrong.
+      const failureCode = isExecutionStreamHttpError(err) ? err.code : undefined
       await reportCompletion(
         toolCallId,
         MothershipStreamV1ToolOutcome.error,
-        getWorkflowToolCompletionMessage(MothershipStreamV1ToolOutcome.error),
-        undefined,
+        msg,
+        {
+          success: false,
+          workflowId: targetWorkflowId,
+          error: msg,
+          ...(failureCode ? { code: failureCode } : {}),
+        },
         failedExecutionId
       )
     }
diff --git a/apps/sim/lib/copilot/tools/client/store-utils.test.ts b/apps/sim/lib/copilot/tools/client/store-utils.test.ts
index 7a84982189..f5040b3002 100644
--- a/apps/sim/lib/copilot/tools/client/store-utils.test.ts
+++ b/apps/sim/lib/copilot/tools/client/store-utils.test.ts
@@ -40,7 +40,7 @@ describe('resolveToolDisplay', () => {
       resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
         path: 'workflows/My Workflow/meta.json',
       })?.text
-    ).toBe('Read My Workflow')
+    ).toBe('Read metadata for My Workflow')
 
     expect(
       resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
@@ -49,6 +49,54 @@ describe('resolveToolDisplay', () => {
     ).toBe('Read RET XYZ')
   })
 
+  it('labels resource artifact reads distinctly instead of repeating the resource name', () => {
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'workflows/Elder v2/The Elder/state.json',
+      })?.text
+    ).toBe('Read The Elder')
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'workflows/Elder v2/The Elder/deployment.json',
+      })?.text
+    ).toBe('Read deployment status for The Elder')
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.error, {
+        path: 'workflows/Elder v2/The Elder/lint.json',
+      })?.text
+    ).toBe('Attempted to validate The Elder')
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'tables/CRM/Leads/views.json',
+      })?.text
+    ).toBe('Read views of Leads')
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'knowledgebases/Contracts/documents.json',
+      })?.text
+    ).toBe('Read documents in Contracts')
+  })
+
+  it('formats docs corpus reads as section/page', () => {
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
+        path: 'docs/workflows/blocks/agent.mdx',
+      })?.text
+    ).toBe('Read workflows/agent')
+
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
+        path: 'docs/integrations/gmail.mdx',
+      })?.text
+    ).toBe('Reading integrations/gmail')
+
+    expect(
+      resolveToolDisplay(ReadTool.id, ClientToolCallState.error, {
+        path: 'docs/getting-started.mdx',
+      })?.text
+    ).toBe('Attempted to read getting-started')
+  })
+
   it('decodes percent-encoded VFS path segments for display', () => {
     expect(
       resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
@@ -60,7 +108,7 @@ describe('resolveToolDisplay', () => {
       resolveToolDisplay(ReadTool.id, ClientToolCallState.success, {
         path: 'workflows/My%20Workflow/meta.json',
       })?.text
-    ).toBe('Read My Workflow')
+    ).toBe('Read metadata for My Workflow')
 
     expect(
       resolveToolDisplay(ReadTool.id, ClientToolCallState.executing, {
@@ -173,8 +221,8 @@ describe('resolveToolDisplay', () => {
   })
 
   it('falls back to a humanized tool label for generic tools', () => {
-    expect(resolveToolDisplay('deploy_api', ClientToolCallState.success)?.text).toBe(
-      'Executed Deploy API'
+    expect(resolveToolDisplay('deploy_as_api', ClientToolCallState.success)?.text).toBe(
+      'Executed Deploy As API'
     )
     expect(resolveToolDisplay('oauth-integrations', ClientToolCallState.success)?.text).toBe(
       'Executed OAuth Integrations'
@@ -185,3 +233,24 @@ describe('resolveToolDisplay', () => {
     expect(resolveToolDisplay('load_custom_tool', ClientToolCallState.executing)).toBeUndefined()
   })
 })
+
+describe('lint reads render as validation', () => {
+  it.each([
+    [ClientToolCallState.generating, 'Validating The Elder'],
+    [ClientToolCallState.success, 'Validated The Elder'],
+    [ClientToolCallState.error, 'Attempted to validate The Elder'],
+    [ClientToolCallState.aborted, 'Skipped validating The Elder'],
+  ])('state %s -> %s', (state, expected) => {
+    expect(
+      resolveToolDisplay('read', state, { path: 'workflows/Elder v2/The Elder/lint.json' })?.text
+    ).toBe(expected)
+  })
+
+  it('only workflow lint artifacts get the verb; other reads keep Reading', () => {
+    expect(
+      resolveToolDisplay('read', ClientToolCallState.success, {
+        path: 'workflows/Elder v2/The Elder/meta.json',
+      })?.text
+    ).toBe('Read metadata for The Elder')
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/client/store-utils.ts b/apps/sim/lib/copilot/tools/client/store-utils.ts
index 343c9e2712..e101236c8e 100644
--- a/apps/sim/lib/copilot/tools/client/store-utils.ts
+++ b/apps/sim/lib/copilot/tools/client/store-utils.ts
@@ -45,7 +45,15 @@ function specialToolDisplay(
   }
 
   if (toolName === ReadTool.id) {
-    const target = describeReadTarget(readStringParam(params, 'path'))
+    const path = readStringParam(params, 'path')
+    // lint.json is computed at read time, so reading it IS running the checks —
+    // "Validating X" describes the outcome where "Reading issues in X" would
+    // describe the mechanism.
+    const validated = describeValidationReadTarget(path)
+    if (validated) {
+      return { text: formatValidatingLabel(validated, state), icon: FileText }
+    }
+    const target = describeReadTarget(path)
     return {
       text: formatReadingLabel(target, state),
       icon: FileText,
@@ -83,6 +91,33 @@ function formatReadingLabel(target: string | undefined, state: ClientToolCallSta
   }
 }
 
+/** The workflow name when `path` is a lint artifact; undefined otherwise. */
+function describeValidationReadTarget(path: string | undefined): string | undefined {
+  if (!path) return undefined
+  const segments = path
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean)
+    .map(decodeVfsSegmentSafe)
+  if (segments.length < 2 || segments[segments.length - 1] !== 'lint.json') return undefined
+  if (VFS_DIR_TO_RESOURCE[segments[0]] !== 'workflow') return undefined
+  return stripExtension(getLeafResourceSegment(segments))
+}
+
+function formatValidatingLabel(target: string, state: ClientToolCallState): string {
+  switch (state) {
+    case ClientToolCallState.success:
+      return `Validated ${target}`
+    case ClientToolCallState.error:
+      return `Attempted to validate ${target}`
+    case ClientToolCallState.rejected:
+    case ClientToolCallState.aborted:
+      return `Skipped validating ${target}`
+    default:
+      return `Validating ${target}`
+  }
+}
+
 function describeReadTarget(path: string | undefined): string | undefined {
   if (!path) return undefined
 
@@ -97,6 +132,10 @@ function describeReadTarget(path: string | undefined): string | undefined {
 
   if (segments.length === 0) return undefined
 
+  if (segments[0] === 'docs') {
+    return describeDocsReadTarget(segments)
+  }
+
   const resourceType = VFS_DIR_TO_RESOURCE[segments[0]]
   if (!resourceType) {
     return humanizeDisplayIdentifier(stripExtension(segments[segments.length - 1]), 'sentence')
@@ -107,11 +146,38 @@ function describeReadTarget(path: string | undefined): string | undefined {
   }
 
   if (resourceType === 'workflow') {
-    return stripExtension(getLeafResourceSegment(segments))
+    return describeResourceArtifactTarget(segments)
   }
 
-  const resourceName = segments[1] || segments[segments.length - 1]
-  return stripExtension(resourceName)
+  return describeResourceArtifactTarget(segments)
+}
+
+/**
+ * Resource-scoped artifact files, labeled the same prefix way as
+ * FILE_FACET_LABELS. `state.json` is the empty facet — reading a workflow means
+ * reading its state — so "Read The Elder", "Read metadata for The Elder", and
+ * "Read deployment status for The Elder" render as three distinct rows instead
+ * of three identical "Read The Elder" lines.
+ */
+const RESOURCE_ARTIFACT_LABELS: Record<string, string> = {
+  'state.json': '',
+  'meta.json': 'metadata for',
+  'deployment.json': 'deployment status for',
+  'versions.json': 'versions of',
+  'executions.json': 'runs of',
+  'views.json': 'views of',
+  'documents.json': 'documents in',
+  'connectors.json': 'connectors of',
+}
+
+function describeResourceArtifactTarget(segments: string[]): string {
+  const lastSegment = segments[segments.length - 1] || ''
+  const resourceName = stripExtension(getLeafResourceSegment(segments))
+  const artifactLabel = RESOURCE_ARTIFACT_LABELS[lastSegment]
+  if (artifactLabel !== undefined && segments.length > 1) {
+    return artifactLabel ? `${artifactLabel} ${resourceName}` : resourceName
+  }
+  return resourceName
 }
 
 // A workspace file is addressed as a directory of facets in the VFS
@@ -140,6 +206,19 @@ function describeFileReadTarget(segments: string[]): string {
   return lastSegment
 }
 
+/**
+ * Labels a docs/ corpus read as `<section>/<page>` (e.g. `workflows/agent` for
+ * docs/workflows/blocks/agent.mdx). Top-level pages show just their name (e.g.
+ * `getting-started` for docs/getting-started.mdx).
+ */
+function describeDocsReadTarget(segments: string[]): string {
+  const rest = segments.slice(1)
+  if (rest.length === 0) return 'docs'
+  const leaf = stripExtension(rest[rest.length - 1])
+  if (rest.length === 1) return leaf
+  return `${rest[0]}/${leaf}`
+}
+
 function getLeafResourceSegment(segments: string[]): string {
   const lastSegment = segments[segments.length - 1] || ''
   if (hasFileExtension(lastSegment) && segments.length > 1) {
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/context.test.ts b/apps/sim/lib/copilot/tools/handlers/deployment/context.test.ts
index 9a877e3416..178d403603 100644
--- a/apps/sim/lib/copilot/tools/handlers/deployment/context.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/context.test.ts
@@ -33,7 +33,7 @@ describe('getCopilotDeploymentIdempotencyKey', () => {
   it('separates deployment intents within the same execution', () => {
     const context = { executionId: 'execution-1', toolCallId: 'call-1' }
 
-    expect(getCopilotDeploymentIdempotencyKey(context, 'deploy_api')).not.toBe(
+    expect(getCopilotDeploymentIdempotencyKey(context, 'deploy_as_api')).not.toBe(
       getCopilotDeploymentIdempotencyKey(context, 'redeploy')
     )
   })
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.test.ts b/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.test.ts
index e37f623a23..1be8a3f514 100644
--- a/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.test.ts
@@ -192,7 +192,7 @@ describe('executeDeployCustomBlock', () => {
     const result = await executeDeployCustomBlock({ name: 'Enrich Lead' }, context)
 
     expect(result.success).toBe(false)
-    expect(result.error).toContain('deploy_api')
+    expect(result.error).toContain('deploy_as_api')
     expect(publishCustomBlockMock).not.toHaveBeenCalled()
   })
 
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.ts b/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.ts
index a7ddfb7272..ed8f8ebdc1 100644
--- a/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/custom-block.ts
@@ -262,7 +262,7 @@ export async function executeDeployCustomBlock(
       return {
         success: false,
         error:
-          'Workflow must be deployed before publishing as a custom block. Use deploy_api first.',
+          'Workflow must be deployed before publishing as a custom block. Use deploy_as_api first.',
       }
     }
     // Curation is required on publish: every consumer-visible field must be one
@@ -303,6 +303,10 @@ export async function executeDeployCustomBlock(
       return { success: false, error: error.message }
     }
     logger.error('Custom block deployment failed', { error })
-    return { success: false, error: 'Custom block deployment failed due to a system error' }
+    return {
+      success: false,
+      error:
+        'Publishing the custom block failed inside Sim; assume it was NOT published. Call get_deployment_status to confirm, retry once, and report the failure if it repeats instead of retrying further.',
+    }
   }
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/deploy.test.ts b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.test.ts
index 01727a9c9d..cd5b1ec5cd 100644
--- a/apps/sim/lib/copilot/tools/handlers/deployment/deploy.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.test.ts
@@ -134,7 +134,7 @@ describe('deployment handlers', () => {
       expect.any(Object),
       expect.objectContaining({ operation: expect.objectContaining({ id: 'workflows.deploy' }) }),
       expect.objectContaining({
-        idempotencyKey: 'copilot:execution-1:operation:deploy_api',
+        idempotencyKey: 'copilot:execution-1:operation:deploy_as_api',
       })
     )
   })
@@ -170,7 +170,7 @@ describe('deployment handlers', () => {
       expect.any(Object),
       expect.objectContaining({ operation: expect.objectContaining({ id: 'workflows.deploy' }) }),
       expect.objectContaining({
-        idempotencyKey: 'copilot:execution-1:operation:deploy_api',
+        idempotencyKey: 'copilot:execution-1:operation:deploy_as_api',
       })
     )
   })
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
index 5fd15db45d..c8cc2fc7d1 100644
--- a/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/deploy.ts
@@ -4,6 +4,7 @@ import {
   messageForCopilotWorkflowError,
 } from '@/lib/copilot/application/execute-workflow-use-case'
 import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { resolveEnvReferenceSecretArg } from '@/lib/copilot/tools/server/env-reference'
 import { generateRequestId } from '@/lib/core/utils/request'
 import { getBaseUrl } from '@/lib/core/utils/urls'
 import {
@@ -211,7 +212,7 @@ export async function executeDeployApi(
       description: versionDescription,
       name: versionName,
       requestId: generateRequestId(),
-      idempotencyKey: getCopilotDeploymentIdempotencyKey(context, 'deploy_api'),
+      idempotencyKey: getCopilotDeploymentIdempotencyKey(context, 'deploy_as_api'),
     })
     if (!result.success) {
       return { success: false, error: result.error || 'Failed to deploy workflow' }
@@ -357,6 +358,19 @@ export async function executeDeployChat(
       }
     }
 
+    // "Use the password in {{CHAT_PW}}" arrives as the literal reference —
+    // resolve it, or the placeholder string becomes the chat's real password.
+    const resolvedPassword = await resolveEnvReferenceSecretArg({
+      userId: context.userId,
+      workspaceId: context.workspaceId,
+      value: params.password ?? undefined,
+      argName: 'password',
+      registry: context.resolvedSecretTraceRegistry,
+    })
+    if (resolvedPassword.error) {
+      return { success: false, error: resolvedPassword.error }
+    }
+
     const result = await executeCopilotWorkflowUseCase(context, deployWorkflowChat, {
       workflowId,
       assertedWorkspaceId: context.workspaceId,
@@ -371,13 +385,13 @@ export async function executeDeployChat(
         imageUrl: params.customizations?.imageUrl ?? params.customizations?.iconUrl,
       },
       authType: params.authType,
-      password: params.password,
+      password: resolvedPassword.value,
       allowedEmails: params.allowedEmails,
       outputConfigs: params.outputConfigs,
       includeThinking: params.includeThinking,
       includeToolCalls: params.includeToolCalls,
       requestId: generateRequestId(),
-      idempotencyKey: getCopilotDeploymentIdempotencyKey(context, 'deploy_chat'),
+      idempotencyKey: getCopilotDeploymentIdempotencyKey(context, 'deploy_as_chat'),
     })
 
     const baseUrl = getBaseUrl()
@@ -591,7 +605,7 @@ export async function executeRedeploy(
       description: versionDescription,
       name: versionName,
       requestId: generateRequestId(),
-      idempotencyKey: getCopilotDeploymentIdempotencyKey(context, 'deploy_api'),
+      idempotencyKey: getCopilotDeploymentIdempotencyKey(context, 'deploy_as_api'),
     })
     if (!result.success) {
       return { success: false, error: result.error || 'Failed to redeploy workflow' }
diff --git a/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts b/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
index 0ec758912f..f876876533 100644
--- a/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
+++ b/apps/sim/lib/copilot/tools/handlers/deployment/manage.ts
@@ -511,7 +511,8 @@ export async function executeUpdateDeploymentVersion(
     if (version === null) {
       return {
         success: false,
-        error: 'version must be a deployment version number (use get_deployment_log to find it)',
+        error:
+          'version must be a deployment version number (use list_deployment_versions to find it)',
       }
     }
 
diff --git a/apps/sim/lib/copilot/tools/handlers/function-execute.test.ts b/apps/sim/lib/copilot/tools/handlers/function-execute.test.ts
index 7501d3355b..78b4ce5311 100644
--- a/apps/sim/lib/copilot/tools/handlers/function-execute.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/function-execute.test.ts
@@ -297,7 +297,7 @@ describe('executeFunctionExecute trace-secret provenance', () => {
       names: ['TOKEN'],
     },
   ])(
-    'uses the shared $language compiler analysis before delegating source to function_execute',
+    'uses the shared $language compiler analysis before delegating source to run_function',
     async ({ language, code, names }) => {
       await executeFunctionExecute({ language, code }, context as never)
 
@@ -314,7 +314,7 @@ describe('executeFunctionExecute trace-secret provenance', () => {
     }
   )
 
-  it('routes run_code shell commands through the same function_execute boundary', async () => {
+  it('routes run_code shell commands through the same run_function boundary', async () => {
     const code = 'printf %s "{{CLI_TOKEN}}"'
     const abortController = new AbortController()
 
@@ -344,7 +344,7 @@ describe('executeFunctionExecute trace-secret provenance', () => {
     )
   })
 
-  it('uses the trusted Mothership profile for function_execute without accepting a param override', async () => {
+  it('uses the trusted Mothership profile for run_function without accepting a param override', async () => {
     await executeFunctionExecute(
       {
         code: 'return 1',
@@ -1218,7 +1218,7 @@ describe('executeFunctionExecute unmountable namespaces', () => {
   it('keeps the uploads/ guidance intact', async () => {
     const message = await mountError({ inputFiles: ['uploads/report.json'] })
 
-    expect(message).toContain('materialize_file')
+    expect(message).toContain('save_upload')
   })
 
   it('still reports a genuine files/ miss as not found', async () => {
diff --git a/apps/sim/lib/copilot/tools/handlers/function-execute.ts b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
index 6b6f24b043..9557a1c7e1 100644
--- a/apps/sim/lib/copilot/tools/handlers/function-execute.ts
+++ b/apps/sim/lib/copilot/tools/handlers/function-execute.ts
@@ -255,10 +255,10 @@ function unmountableNamespaceReason(filePath: string): string | null {
   const path = `${filePath.replace(/^\/+|\/+$/g, '')}/`
 
   if (path.startsWith('uploads/')) {
-    return 'uploads/ files are not mountable into the sandbox. Use materialize_file to save it to a files/... path first, then mount that canonical path.'
+    return 'uploads/ files are not mountable into the sandbox. Use save_upload to save it to a files/... path first, then mount that canonical path.'
   }
   if (path.startsWith('internal/tool-results/')) {
-    return 'tool-result artifacts are stored by the copilot backend, not in workspace storage, so read and grep reach them but the sandbox cannot. This path is correct — searching for a different one will not find anything. Either read or grep the artifact and inline the values you need in code, or re-run the tool that produced it with an output path under files/ (function_execute: outputs.files[].path, user_table: outputPath) and mount that files/... path.'
+    return 'tool-result artifacts are stored by the copilot backend, not in workspace storage, so read and grep reach them but the sandbox cannot. This path is correct — searching for a different one will not find anything. Either read or grep the artifact and inline the values you need in code, or re-run the tool that produced it with an output path under files/ (run_function: outputs.files[].path, user_table: outputPath) and mount that files/... path.'
   }
   if (path.startsWith('internal/')) {
     return 'internal/ paths are served by the copilot backend, not from workspace storage, so read and grep reach them but the sandbox cannot. This path is correct — read or grep it and inline the values you need in code instead of mounting it.'
@@ -418,7 +418,7 @@ export async function resolveInputFiles(
           `Input directory contains too many files (${descendants.length}). Maximum is ${MAX_MOUNTED_FILES}. Mount a smaller directory or individual files.`
         )
       }
-      logger.info('Mounting workspace directory for function_execute', {
+      logger.info('Mounting workspace directory for run_function', {
         vfsPath: dirPath,
         sandboxPath: mountRoot,
         fileCount: descendants.length,
@@ -637,6 +637,16 @@ export async function executeFunctionExecute(
     'internalSandboxProfile',
     PRIVATE_SECRET_PROVENANCE_FIELD,
   ])
+  // The copilot tool doc promises `timeout` in SECONDS ("Sim converts to
+  // milliseconds", default 10, cap 300); the underlying function tool takes
+  // MILLISECONDS. Nothing converted, so `timeout: 120` armed a 120ms abort.
+  // Values ≤ 600 are read as seconds; larger values are assumed to already be
+  // milliseconds (a model habit worth tolerating). Both clamp to the 300s cap.
+  if (typeof enrichedParams.timeout === 'number' && Number.isFinite(enrichedParams.timeout)) {
+    const raw = enrichedParams.timeout
+    const ms = raw <= 600 ? raw * 1000 : raw
+    enrichedParams.timeout = Math.min(Math.max(ms, 1000), 300_000)
+  }
   if (params.sandboxId !== undefined) {
     if (typeof params.sandboxId !== 'string' || !params.sandboxId.trim()) {
       throw new Error('sandboxId must be a non-empty Sim sandbox id')
@@ -752,6 +762,14 @@ export async function executeFunctionExecute(
     }
 
     try {
+      /**
+       * The copilot-facing tool is named `run_function`, but the app-tool
+       * registry id stays `function_execute` — the validator in tools/index.ts
+       * only admits `internalSandboxProfile` for that id, and every copilot
+       * call carries the internal `mothership` profile. Renaming this inner id
+       * without renaming the registry breaks every copilot sandbox call with
+       * "An internal sandbox profile may only be used with function_execute".
+       */
       const result = await executeAppTool('function_execute', enrichedParams, {
         resolvedSecretTraceRegistry: mountedRegistry,
         ...(context.abortSignal ? { signal: context.abortSignal } : {}),
diff --git a/apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.test.ts b/apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.test.ts
new file mode 100644
index 0000000000..46dc0b0dc0
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.test.ts
@@ -0,0 +1,105 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  performCreateCredential: vi.fn(),
+  getEffectiveDecryptedEnv: vi.fn(),
+}))
+
+vi.mock('@/lib/credentials/orchestration', () => ({
+  performCreateCredential: mocks.performCreateCredential,
+}))
+vi.mock('@/lib/environment/utils', () => ({
+  getEffectiveDecryptedEnv: mocks.getEffectiveDecryptedEnv,
+}))
+
+import { executeConnectSlackBot } from './connect-slack-bot'
+
+const context = { userId: 'user-1', workspaceId: 'ws-1' } as never
+
+const validParams = {
+  displayName: 'Elder Bot',
+  signingSecretEnvVar: 'SLACK_SIGNING_SECRET',
+  botTokenEnvVar: 'SLACK_BOT_TOKEN',
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  mocks.getEffectiveDecryptedEnv.mockResolvedValue({
+    SLACK_SIGNING_SECRET: 'shhh',
+    SLACK_BOT_TOKEN: 'xoxb-123',
+  })
+  mocks.performCreateCredential.mockResolvedValue({
+    success: true,
+    created: true,
+    credential: { id: 'cred-1', displayName: 'Elder Bot' },
+  })
+})
+
+describe('executeConnectSlackBot', () => {
+  it('resolves env vars server-side and mints the credential with the request URL', async () => {
+    const result = await executeConnectSlackBot(validParams, context)
+
+    expect(mocks.performCreateCredential).toHaveBeenCalledWith(
+      expect.objectContaining({
+        workspaceId: 'ws-1',
+        userId: 'user-1',
+        type: 'service_account',
+        providerId: 'slack-custom-bot',
+        displayName: 'Elder Bot',
+        signingSecret: 'shhh',
+        botToken: 'xoxb-123',
+      })
+    )
+    expect(result.success).toBe(true)
+    expect(result.output).toMatchObject({
+      credentialId: 'cred-1',
+      created: true,
+      requestUrl: expect.stringContaining('/api/webhooks/slack/custom/cred-1'),
+    })
+  })
+
+  it('names the missing env vars without leaking any values', async () => {
+    mocks.getEffectiveDecryptedEnv.mockResolvedValue({ SLACK_SIGNING_SECRET: 'shhh' })
+
+    const result = await executeConnectSlackBot(validParams, context)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('SLACK_BOT_TOKEN')
+    expect(result.error).not.toContain('shhh')
+    expect(mocks.performCreateCredential).not.toHaveBeenCalled()
+  })
+
+  it('requires displayName and both env var names', async () => {
+    const missingName = await executeConnectSlackBot(
+      { signingSecretEnvVar: 'A', botTokenEnvVar: 'B' },
+      context
+    )
+    expect(missingName.success).toBe(false)
+    expect(missingName.error).toContain('displayName')
+
+    const missingVars = await executeConnectSlackBot({ displayName: 'Bot' }, context)
+    expect(missingVars.success).toBe(false)
+    expect(missingVars.error).toContain('signingSecretEnvVar')
+  })
+
+  it('surfaces orchestration failures (e.g. auth.test rejection or name conflict)', async () => {
+    mocks.performCreateCredential.mockResolvedValue({
+      success: false,
+      error: 'Slack rejected the bot token',
+    })
+
+    const result = await executeConnectSlackBot(validParams, context)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Slack rejected the bot token')
+  })
+
+  it('requires workspace scope', async () => {
+    const result = await executeConnectSlackBot(validParams, { userId: 'user-1' } as never)
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Workspace')
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.ts b/apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.ts
new file mode 100644
index 0000000000..f02599e8d8
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/handlers/management/connect-slack-bot.ts
@@ -0,0 +1,91 @@
+import { toError } from '@sim/utils/errors'
+import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
+import { performCreateCredential } from '@/lib/credentials/orchestration'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+import { SLACK_CUSTOM_BOT_PROVIDER_ID } from '@/lib/oauth/types'
+import { buildSlackCustomBotRequestUrl } from '@/triggers/webhook-url'
+
+/**
+ * Mints a reusable Slack custom-bot credential from secrets ALREADY stored as
+ * environment variables (a v1 setup being migrated, or values saved via
+ * set_environment_variables after a browser-agent extraction). The agent
+ * passes env-var NAMES; the values are resolved here and validated by the
+ * credential orchestration (Slack auth.test), so no secret ever appears in
+ * tool args, checkpoints, or transcripts. When the USER holds the secrets,
+ * the service_account credential card is the right path instead.
+ */
+export function executeConnectSlackBot(
+  rawParams: Record<string, unknown>,
+  context: ExecutionContext
+): Promise<ToolCallResult> {
+  const params = rawParams as {
+    displayName?: string
+    description?: string
+    signingSecretEnvVar?: string
+    botTokenEnvVar?: string
+  }
+  return (async () => {
+    try {
+      if (!context?.userId) {
+        return { success: false, error: 'Authentication required' }
+      }
+      const workspaceId = context.workspaceId
+      if (!workspaceId) {
+        return { success: false, error: 'Workspace scope required' }
+      }
+      const { displayName, description, signingSecretEnvVar, botTokenEnvVar } = params
+      if (!displayName) {
+        return { success: false, error: 'displayName is required' }
+      }
+      if (!signingSecretEnvVar || !botTokenEnvVar) {
+        return {
+          success: false,
+          error:
+            'signingSecretEnvVar and botTokenEnvVar are required: the NAMES of the environment variables holding the Slack signing secret and bot token. Save the values with set_environment_variables first if needed.',
+        }
+      }
+
+      const env = await getEffectiveDecryptedEnv(context.userId, workspaceId)
+      const missing = [signingSecretEnvVar, botTokenEnvVar].filter((name) => !env[name])
+      if (missing.length > 0) {
+        return {
+          success: false,
+          error: `Environment variable(s) not found: ${missing.join(', ')}. Check environment/ in the VFS, or save the values with set_environment_variables first.`,
+        }
+      }
+
+      const result = await performCreateCredential({
+        workspaceId,
+        userId: context.userId,
+        type: 'service_account',
+        providerId: SLACK_CUSTOM_BOT_PROVIDER_ID,
+        displayName,
+        description,
+        signingSecret: env[signingSecretEnvVar],
+        botToken: env[botTokenEnvVar],
+      })
+      if (!result.success || !result.credential) {
+        return {
+          success: false,
+          error:
+            result.error ||
+            'Failed to connect the Slack custom bot. If a credential with this display name already exists, reuse it (environment/credentials.json) or pick a different name.',
+        }
+      }
+      return {
+        success: true,
+        output: {
+          credentialId: result.credential.id,
+          displayName: result.credential.displayName,
+          created: result.created !== false,
+          // The Slack app's Event Subscriptions Request URL — one per
+          // credential, shared by every trigger that selects it; live
+          // immediately, no deployment needed.
+          requestUrl: buildSlackCustomBotRequestUrl(result.credential.id),
+        },
+      }
+    } catch (error) {
+      return { success: false, error: toError(error).message }
+    }
+  })()
+}
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
index a0c5cbb908..adb9e45f3a 100644
--- a/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-custom-tool.ts
@@ -45,7 +45,7 @@ export async function executeManageCustomTool(
    * workspace — so a caller could name another workspace and have it
    * authorized against their own. `upsertCustomTools` does no authz of its own
    * (it only scopes queries by the id it is handed), so nothing downstream
-   * caught it. Matches manage_mcp_tool and manage_skill.
+   * caught it. Matches manage_mcp_connection and manage_skill.
    */
   const workspaceId = context.workspaceId
 
@@ -250,7 +250,7 @@ export async function executeManageCustomTool(
       error:
         classified && classified.code !== 'internal'
           ? classified.message
-          : 'Failed to manage custom tool',
+          : `The ${operation ?? 'custom tool'} operation failed inside Sim. The write may or may not have landed — run operation "list" to check current state before retrying.`,
     }
   }
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
index 5158176f27..066fb6b853 100644
--- a/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-mcp-tool.ts
@@ -184,12 +184,15 @@ export async function executeManageMcpTool(
       }
     }
 
-    return { success: false, error: `Unsupported operation for manage_mcp_tool: ${operation}` }
+    return {
+      success: false,
+      error: `Unsupported operation for manage_mcp_connection: ${operation}`,
+    }
   } catch (error) {
     logger.error(
       context.messageId
-        ? `manage_mcp_tool execution failed [messageId:${context.messageId}]`
-        : 'manage_mcp_tool execution failed',
+        ? `manage_mcp_connection execution failed [messageId:${context.messageId}]`
+        : 'manage_mcp_connection execution failed',
       {
         operation,
         workspaceId,
@@ -202,7 +205,7 @@ export async function executeManageMcpTool(
       error:
         classified && classified.code !== 'internal'
           ? classified.message
-          : 'Failed to manage MCP server',
+          : `The ${operation ?? 'MCP server'} operation failed inside Sim. The write may or may not have landed — run operation "list" to check current state before retrying.`,
     }
   }
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/management/manage-sandbox.ts b/apps/sim/lib/copilot/tools/handlers/management/manage-sandbox.ts
index 90f7517b80..47913ca610 100644
--- a/apps/sim/lib/copilot/tools/handlers/management/manage-sandbox.ts
+++ b/apps/sim/lib/copilot/tools/handlers/management/manage-sandbox.ts
@@ -102,7 +102,11 @@ export async function executeManageSandbox(
       workspaceId,
       SANDBOX_MUTATION_LIMIT
     )
-    if (limited) return { success: false, error: 'Rate limit exceeded' }
+    if (limited)
+      return {
+        success: false,
+        error: `Rate limit exceeded for sandbox ${operation} in this workspace — do not retry now; continue with other work or tell the user the limit was hit.`,
+      }
 
     if (operation === 'add') {
       const parsed = createSandboxBodySchema.safeParse({
diff --git a/apps/sim/lib/copilot/tools/handlers/materialize-file.test.ts b/apps/sim/lib/copilot/tools/handlers/materialize-file.test.ts
index 65af6a518c..45eb7b9fb9 100644
--- a/apps/sim/lib/copilot/tools/handlers/materialize-file.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/materialize-file.test.ts
@@ -223,19 +223,19 @@ describe('executeMaterializeFile - unsupported operation', () => {
     )
 
     expect(result.success).toBe(false)
-    expect(result.error).toContain('Unsupported materialize_file operation "table"')
+    expect(result.error).toContain('Unsupported save_upload operation "table"')
     expect(result.error).toContain('table subagent')
     expect(mockFindUpload).not.toHaveBeenCalled()
   })
 
-  it('rejects the knowledge_base operation and points to the knowledge subagent', async () => {
+  it('rejects the manage_knowledge_base operation and points to the knowledge subagent', async () => {
     const result = await executeMaterializeFile(
-      { fileNames: ['data.csv'], operation: 'knowledge_base' },
+      { fileNames: ['data.csv'], operation: 'manage_knowledge_base' },
       context
     )
 
     expect(result.success).toBe(false)
-    expect(result.error).toContain('Unsupported materialize_file operation "knowledge_base"')
+    expect(result.error).toContain('Unsupported save_upload operation "manage_knowledge_base"')
     expect(result.error).toContain('knowledge subagent')
     expect(mockFindUpload).not.toHaveBeenCalled()
   })
diff --git a/apps/sim/lib/copilot/tools/handlers/materialize-file.ts b/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
index d6b5e2dece..26f87478e5 100644
--- a/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
+++ b/apps/sim/lib/copilot/tools/handlers/materialize-file.ts
@@ -45,7 +45,7 @@ import { admitCreateWorkspaceFile } from '@/lib/workspace-files/application/crea
 import { readWorkspaceFileMetadata } from '@/lib/workspace-files/application/read-workspace-file-metadata'
 import { extractWorkflowMetadata } from '@/app/api/v1/admin/types'
 
-const logger = createLogger('MaterializeFile')
+const logger = createLogger('SaveUpload')
 const MAX_MATERIALIZE_NAME_RETRIES = 8
 const WORKSPACE_FILE_NAME_UNIQUE_INDEX = 'workspace_files_workspace_folder_name_active_unique'
 
@@ -102,7 +102,7 @@ async function executeSave(
   if (isArchiveFileName(displayName)) {
     return {
       success: false,
-      error: `"${fileName}" is a .zip archive — save it by extracting instead: materialize_file(fileNames: ["${fileName}"], operation: "extract") unpacks it into files/ where the contents stay readable. The raw .zip remains in uploads/ for this chat.`,
+      error: `"${fileName}" is a .zip archive — save it by extracting instead: save_upload(fileNames: ["${fileName}"], operation: "extract") unpacks it into files/ where the contents stay readable. The raw .zip remains in uploads/ for this chat.`,
     }
   }
 
@@ -256,7 +256,7 @@ async function executeImport(
   if (isArchiveFileName(row.displayName ?? row.originalName)) {
     return {
       success: false,
-      error: `"${fileName}" is a .zip archive, not a workflow JSON. Extract it first: materialize_file(fileNames: ["${fileName}"], operation: "extract").`,
+      error: `"${fileName}" is a .zip archive, not a workflow JSON. Extract it first: save_upload(fileNames: ["${fileName}"], operation: "extract").`,
     }
   }
 
@@ -553,11 +553,11 @@ export async function executeMaterializeFile(
   }
 
   if (!context.chatId) {
-    return { success: false, error: 'No chat context available for materialize_file' }
+    return { success: false, error: 'No chat context available for save_upload' }
   }
 
   if (!context.workspaceId) {
-    return { success: false, error: 'No workspace context available for materialize_file' }
+    return { success: false, error: 'No workspace context available for save_upload' }
   }
 
   const principal = resolveCopilotFilePrincipal(context)
@@ -569,7 +569,7 @@ export async function executeMaterializeFile(
   if (operation !== 'save' && operation !== 'import' && operation !== 'extract') {
     return {
       success: false,
-      error: `Unsupported materialize_file operation "${operation}". Use "save", "import", or "extract". For CSV/TSV/JSON → use the table subagent; for documents → use the knowledge subagent.`,
+      error: `Unsupported save_upload operation "${operation}". Use "save", "import", or "extract". For CSV/TSV/JSON → use the table subagent; for documents → use the knowledge subagent.`,
     }
   }
 
@@ -615,7 +615,7 @@ export async function executeMaterializeFile(
         failed.push({ fileName, error: result.error ?? 'Failed to materialize file' })
       }
     } catch (err) {
-      logger.error('materialize_file failed', {
+      logger.error('save_upload failed', {
         fileName,
         operation,
         chatId: context.chatId,
diff --git a/apps/sim/lib/copilot/tools/handlers/param-types.ts b/apps/sim/lib/copilot/tools/handlers/param-types.ts
index a7ece42315..afe24b1b1e 100644
--- a/apps/sim/lib/copilot/tools/handlers/param-types.ts
+++ b/apps/sim/lib/copilot/tools/handlers/param-types.ts
@@ -302,6 +302,8 @@ export interface OpenResourceItem {
   type?: OpenResourceType
   id?: string
   path?: string
+  /** Saved-view id or exact name to open a table pinned to (table type only). */
+  view?: string
 }
 
 export interface OpenResourceParams {
@@ -315,4 +317,5 @@ export interface ValidOpenResourceParams {
   type: OpenResourceType
   id?: string
   path?: string
+  view?: string
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/platform-actions.ts b/apps/sim/lib/copilot/tools/handlers/platform-actions.ts
deleted file mode 100644
index c3c3ac1438..0000000000
--- a/apps/sim/lib/copilot/tools/handlers/platform-actions.ts
+++ /dev/null
@@ -1,118 +0,0 @@
-/**
- * Static content for the get_platform_actions tool.
- * Contains the Sim platform quick reference and keyboard shortcuts.
- */
-export const PLATFORM_ACTIONS_CONTENT = `# Sim Platform Quick Reference & Keyboard Shortcuts
-
-## Keyboard Shortcuts
-**Mod** = Cmd (macOS) / Ctrl (Windows/Linux). Shortcuts work when canvas is focused.
-
-### Workflow Actions
-| Shortcut | Action |
-|----------|--------|
-| Mod+Enter | Run workflow (or cancel if running) |
-| Mod+Z | Undo |
-| Mod+Shift+Z | Redo |
-| Mod+C | Copy selected blocks |
-| Mod+X | Cut selected blocks |
-| Mod+V | Paste blocks |
-| Delete/Backspace | Delete selected blocks or edges |
-| Shift+L | Auto-layout canvas |
-| Mod+Shift+F | Fit to view |
-| Mod+Shift+Enter | Accept Copilot changes |
-
-### Panel Navigation
-| Shortcut | Action |
-|----------|--------|
-| Mod+F | Open workflow search and replace |
-| Mod+Alt+F | Focus Toolbar search |
-
-### Global Navigation
-| Shortcut | Action |
-|----------|--------|
-| Mod+K | Open search |
-| Mod+Shift+A | Add new agent workflow |
-| Mod+Shift+P | Create workflow |
-| Mod+B | Toggle sidebar |
-| Mod+L | Go to logs |
-
-### Utility
-| Shortcut | Action |
-|----------|--------|
-| Mod+D | Clear terminal console |
-
-### Mouse Controls
-| Action | Control |
-|--------|---------|
-| Pan/move canvas | Left-drag on empty space (hand mode, the default), middle-drag, scroll, or trackpad |
-| Select multiple blocks | Shift+drag to draw a selection box. In cursor mode, left-drag on empty space draws it instead |
-| Drag block | Left-drag on block header |
-| Add to selection | Mod+Click or Shift+Click on blocks |
-
-## Quick Reference — Workspaces
-| Action | How |
-|--------|-----|
-| Create workspace | Click workspace dropdown → New Workspace |
-| Switch workspaces | Click workspace dropdown → Select workspace |
-| Invite teammates | Sidebar → Invite |
-| Rename/Duplicate/Export/Delete workspace | Right-click workspace → action |
-
-## Quick Reference — Workflows
-| Action | How |
-|--------|-----|
-| Create workflow | Click + button in sidebar |
-| Reorder/move workflows | Drag workflow up/down or onto a folder |
-| Import workflow | Click import button in sidebar → Select file |
-| Multi-select workflows | Mod+Click or Shift+Click workflows in sidebar |
-| Open in new tab | Right-click workflow → Open in New Tab |
-| Rename/Duplicate/Export/Delete | Right-click workflow → action |
-
-## Quick Reference — Blocks
-| Action | How |
-|--------|-----|
-| Add a block | Drag from Toolbar panel, or right-click canvas → Add Block |
-| Multi-select blocks | Mod+Click or Shift+Click additional blocks, or Shift+drag a selection box |
-| Copy/Paste blocks | Mod+C / Mod+V |
-| Duplicate/Delete blocks | Right-click → action |
-| Rename a block | Click block name in header |
-| Enable/Disable block | Right-click → Enable/Disable |
-| Lock/Unlock block | Hover block → Click lock icon (Admin only) |
-| Toggle handle orientation | Right-click → Toggle Handles |
-| Open a block in the Editor panel | Right-click → Open Editor |
-| Move a block out of a loop/parallel | Right-click → Remove from Subflow |
-| Configure a block | Select block → use Editor panel on right |
-
-## Quick Reference — Connections
-| Action | How |
-|--------|-----|
-| Create connection | Drag from output handle to input handle |
-| Delete connection | Click edge to select → Delete key |
-| Use output in another block | Drag connection tag into input field |
-
-## Quick Reference — Running & Testing
-| Action | How |
-|--------|-----|
-| Run workflow | Click Run Workflow button or Mod+Enter |
-| Stop workflow | Click Stop button or Mod+Enter while running |
-| Test with chat | Use Chat panel on the right side |
-| Run from block | Hover block → Click play button, or right-click → Run from block |
-| Run until block | Right-click block → Run until block |
-| View execution logs | Open terminal panel at bottom, or Mod+L |
-| Filter/Search/Copy/Clear logs | Terminal panel controls |
-
-## Quick Reference — Deployment
-| Action | How |
-|--------|-----|
-| Deploy workflow | Click Deploy button in panel |
-| Update deployment | Click Update when changes are detected |
-| Revert deployment | Previous versions in Deploy tab → Promote to live |
-| Copy API endpoint | Deploy tab → API → Copy API cURL |
-
-## Quick Reference — Variables
-| Action | How |
-|--------|-----|
-| Add/Edit/Delete workflow variable | Panel → Variables → Add Variable |
-| Add environment variable | Settings → Environment Variables → Add |
-| Reference workflow variable | Use <variable.variableName> syntax |
-| Reference environment variable | Use {{ENV_VAR}} syntax |
-`
diff --git a/apps/sim/lib/copilot/tools/handlers/platform.ts b/apps/sim/lib/copilot/tools/handlers/platform.ts
deleted file mode 100644
index f5cc43f910..0000000000
--- a/apps/sim/lib/copilot/tools/handlers/platform.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
-import { PLATFORM_ACTIONS_CONTENT } from './platform-actions'
-
-export async function executeGetPlatformActions(
-  _rawParams: Record<string, unknown>,
-  _context: ExecutionContext
-): Promise<ToolCallResult> {
-  return { success: true, output: { content: PLATFORM_ACTIONS_CONTENT } }
-}
diff --git a/apps/sim/lib/copilot/tools/handlers/resources.test.ts b/apps/sim/lib/copilot/tools/handlers/resources.test.ts
index 4807406e83..64fa0d7610 100644
--- a/apps/sim/lib/copilot/tools/handlers/resources.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/resources.test.ts
@@ -39,6 +39,10 @@ vi.mock('@/lib/table/service', () => ({
   getTableById: vi.fn(),
 }))
 
+vi.mock('@/lib/table/views/service', () => ({
+  getTableView: vi.fn(),
+}))
+
 vi.mock('@/lib/knowledge/application/knowledge-bases', () => ({
   readKnowledgeBase: {
     operation: { id: 'knowledge.read' },
@@ -86,6 +90,8 @@ vi.mock('@/lib/logs/service', () => ({
   getLogById: vi.fn(),
 }))
 
+import { getTableById } from '@/lib/table/service'
+import { getTableView } from '@/lib/table/views/service'
 import { executeOpenResource } from './resources'
 
 describe('executeOpenResource', () => {
@@ -229,3 +235,52 @@ describe('executeOpenResource', () => {
     ).rejects.toThrow('knowledge database unavailable')
   })
 })
+
+describe('open_resource table views', () => {
+  const executionContext = { userId: 'user-1', workspaceId: 'ws-1' } as never
+
+  it('opens a table pinned to a saved view by id, stamping viewId and a pinned title', async () => {
+    vi.mocked(getTableById).mockResolvedValue({
+      id: 'tbl-1',
+      name: 'Leads',
+      workspaceId: 'ws-1',
+      schema: { columns: [{ id: 'col_a', name: 'status', type: 'string' }] },
+    } as never)
+    vi.mocked(getTableView).mockResolvedValue({
+      id: 'view-1',
+      name: 'Overdue',
+      isDefault: false,
+      config: {},
+    } as never)
+
+    const result = await executeOpenResource(
+      { resources: [{ type: 'table', id: 'tbl-1', view: 'view-1' }] },
+      executionContext
+    )
+
+    expect(result.success).toBe(true)
+    expect(result.resources?.[0]).toMatchObject({
+      type: 'table',
+      id: 'tbl-1',
+      title: 'Leads — Overdue',
+      viewId: 'view-1',
+    })
+  })
+
+  it('rejects an unknown view id and points at views.json', async () => {
+    vi.mocked(getTableById).mockResolvedValue({
+      id: 'tbl-1',
+      name: 'Leads',
+      workspaceId: 'ws-1',
+      schema: { columns: [] },
+    } as never)
+    vi.mocked(getTableView).mockResolvedValue(null as never)
+
+    const missing = await executeOpenResource(
+      { resources: [{ type: 'table', id: 'tbl-1', view: 'view-nope' }] },
+      executionContext
+    )
+    expect(missing.success).toBe(false)
+    expect((missing.output as { errors: string[] }).errors[0]).toContain('views.json')
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/handlers/resources.ts b/apps/sim/lib/copilot/tools/handlers/resources.ts
index 743c67b778..1dbfbeb00c 100644
--- a/apps/sim/lib/copilot/tools/handlers/resources.ts
+++ b/apps/sim/lib/copilot/tools/handlers/resources.ts
@@ -6,7 +6,9 @@ import { canonicalWorkspaceFilePath } from '@/lib/copilot/vfs/path-utils'
 import { asOrchestrationError } from '@/lib/core/orchestration/types'
 import { readKnowledgeBase } from '@/lib/knowledge/application/knowledge-bases'
 import { getLogById } from '@/lib/logs/service'
+import type { TableSchema } from '@/lib/table'
 import { getTableById } from '@/lib/table/service'
+import { getTableView } from '@/lib/table/views/service'
 import {
   findWorkspaceFileRecord,
   type WorkspaceFileRecord,
@@ -64,7 +66,9 @@ async function resolveResource(
     const wf = await getWorkflowById(item.id)
     if (!wf) return { error: `No workflow with id "${item.id}".` }
     if (context.workspaceId && wf.workspaceId !== context.workspaceId)
-      return { error: `Workflow not found in the current workspace.` }
+      return {
+        error: `Workflow "${item.id}" is not in the current workspace — run glob("workflows/*/meta.json") for workflows you can reference.`,
+      }
     resourceId = wf.id
     title = wf.name
   }
@@ -73,9 +77,26 @@ async function resolveResource(
     const tbl = await getTableById(item.id)
     if (!tbl) return { error: `No table with id "${item.id}".` }
     if (context.workspaceId && tbl.workspaceId !== context.workspaceId)
-      return { error: `Table not found in the current workspace.` }
+      return {
+        error: `Table "${item.id}" is not in the current workspace — run glob("tables/*") for tables you can reference.`,
+      }
     resourceId = tbl.id
     title = tbl.name
+    if (item.view) {
+      const view = await getTableView(
+        item.view.trim(),
+        tbl.id,
+        (tbl.schema as TableSchema).columns,
+        context.workspaceId ?? undefined
+      )
+      if (!view) {
+        return {
+          error: `No view with id "${item.view.trim()}" on table "${tbl.name}". View ids are listed in the table's views.json.`,
+        }
+      }
+      title = `${tbl.name} — ${view.name}`
+      return { type: resourceType, id: resourceId, title, viewId: view.id }
+    }
   }
   if (resourceType === 'knowledgebase') {
     if (!item.id) return { error: 'knowledgebase resources require `id`.' }
@@ -96,7 +117,9 @@ async function resolveResource(
         classified?.code === 'forbidden' ||
         classified?.code === 'unauthorized'
       ) {
-        return { error: 'Knowledge base not found in the current workspace.' }
+        return {
+          error: `Knowledge base "${item.id}" is not readable in the current workspace — it does not exist here or you lack access. Run glob("knowledgebases/*") for ids you can open.`,
+        }
       }
       throw error
     }
@@ -108,7 +131,9 @@ async function resolveResource(
     const logRecord = await getLogById(item.id)
     if (!logRecord) return { error: `No log with id "${item.id}".` }
     if (context.workspaceId && logRecord.workspaceId !== context.workspaceId)
-      return { error: `Log not found in the current workspace.` }
+      return {
+        error: `Log "${item.id}" is not in the current workspace — use query_logs to find valid execution ids.`,
+      }
     resourceId = logRecord.id
     const workflowName = logRecord.workflowName ?? 'Unknown Workflow'
     const timestamp = logRecord.startedAt.toLocaleString('en-US', {
@@ -174,5 +199,8 @@ function validateOpenResourceItem(
   if (!item.id && !(item.type === 'file' && item.path)) {
     return { success: false, error: `${item.type} resources require \`id\`` }
   }
-  return { success: true, params: { type: item.type, id: item.id, path: item.path } }
+  return {
+    success: true,
+    params: { type: item.type, id: item.id, path: item.path, view: item.view },
+  }
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/run-code.ts b/apps/sim/lib/copilot/tools/handlers/run-code.ts
index e27babc451..68345ea752 100644
--- a/apps/sim/lib/copilot/tools/handlers/run-code.ts
+++ b/apps/sim/lib/copilot/tools/handlers/run-code.ts
@@ -2,7 +2,7 @@ import type { ToolExecutionContext, ToolExecutionResult } from '@/lib/copilot/to
 import { executeFunctionExecute } from '@/lib/copilot/tools/handlers/function-execute'
 
 /**
- * Compute-only variant of function_execute for info-gathering agents: same
+ * Compute-only variant of run_function for info-gathering agents: same
  * sandbox and inputs, but it must never create or overwrite workspace
  * resources. The write vectors (outputs.files, outputTable) are rejected here
  * on top of the Go executor's fail-fast guard; run_code is also absent from
diff --git a/apps/sim/lib/copilot/tools/handlers/upload-file-reader.test.ts b/apps/sim/lib/copilot/tools/handlers/upload-file-reader.test.ts
index 3e511d1be0..633a4bacdd 100644
--- a/apps/sim/lib/copilot/tools/handlers/upload-file-reader.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/upload-file-reader.test.ts
@@ -184,7 +184,7 @@ describe('readChatUpload', () => {
 
     const result = await readChatUpload('bundle.zip', CHAT_ID)
 
-    expect(result?.content).toContain('materialize_file')
+    expect(result?.content).toContain('save_upload')
     expect(result?.content).toContain('extract')
     expect(mockReadFileRecord).not.toHaveBeenCalled()
   })
@@ -200,7 +200,7 @@ describe('readChatUpload', () => {
 
     const result = await readChatUpload('huge.zip', CHAT_ID)
 
-    expect(result?.content).toContain('materialize_file')
+    expect(result?.content).toContain('save_upload')
     expect(mockFetchBuffer).not.toHaveBeenCalled()
     expect(mockReadFileRecord).not.toHaveBeenCalled()
   })
@@ -243,7 +243,7 @@ describe('grepChatUpload', () => {
     const error = await grepChatUpload('bundle.zip', CHAT_ID, 'foo').catch((e) => e)
 
     expect(error).toBeInstanceOf(WorkspaceFileGrepError)
-    expect(error.message).toContain('materialize_file')
+    expect(error.message).toContain('save_upload')
     expect(error.message).toContain('extract')
     expect(mockReadFileRecord).not.toHaveBeenCalled()
   })
diff --git a/apps/sim/lib/copilot/tools/handlers/vfs-mutate.test.ts b/apps/sim/lib/copilot/tools/handlers/vfs-mutate.test.ts
index e19935bb9a..2d2d6880db 100644
--- a/apps/sim/lib/copilot/tools/handlers/vfs-mutate.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/vfs-mutate.test.ts
@@ -42,8 +42,14 @@ const mocks = vi.hoisted(() => ({
   deleteFileVfsItems: vi.fn(),
   renameTableVfs: vi.fn(),
   deleteTableVfs: vi.fn(),
+  transferTableVfs: vi.fn(),
+  createTableFolders: vi.fn(),
+  deleteTableFolders: vi.fn(),
   renameKnowledgeVfs: vi.fn(),
   deleteKnowledgeVfs: vi.fn(),
+  transferKnowledgeVfs: vi.fn(),
+  createKnowledgeFolders: vi.fn(),
+  deleteKnowledgeFolders: vi.fn(),
 }))
 
 vi.mock('@sim/db', () => ({ ...dbChainMock, ...schemaMock }))
@@ -163,6 +169,18 @@ vi.mock('@/lib/table/application/table-vfs', () => ({
     operation: tableOperations.deleteByVfsPath,
     execute: mocks.deleteTableVfs,
   },
+  transferTableVfsItems: {
+    operation: tableOperations.moveByVfsPath,
+    execute: mocks.transferTableVfs,
+  },
+  createTableVfsFolders: {
+    operation: tableOperations.createFolder,
+    execute: mocks.createTableFolders,
+  },
+  deleteTableVfsFolders: {
+    operation: tableOperations.deleteFolder,
+    execute: mocks.deleteTableFolders,
+  },
 }))
 
 vi.mock('@/lib/knowledge/application/knowledge-vfs', () => ({
@@ -174,6 +192,18 @@ vi.mock('@/lib/knowledge/application/knowledge-vfs', () => ({
     operation: knowledgeOperations.deleteByVfsPath,
     execute: mocks.deleteKnowledgeVfs,
   },
+  transferKnowledgeVfsItems: {
+    operation: knowledgeOperations.moveByVfsPath,
+    execute: mocks.transferKnowledgeVfs,
+  },
+  createKnowledgeVfsFolders: {
+    operation: knowledgeOperations.manageVfsFolders,
+    execute: mocks.createKnowledgeFolders,
+  },
+  deleteKnowledgeVfsFolders: {
+    operation: knowledgeOperations.manageVfsFolders,
+    execute: mocks.deleteKnowledgeFolders,
+  },
 }))
 
 vi.mock('@/lib/table/service', () => ({
@@ -291,13 +321,13 @@ describe('vfs mv/cp', () => {
       expect(result.error).toContain('across categories')
     })
 
-    it('rejects uploads with a materialize_file pointer', async () => {
+    it('rejects uploads with a save_upload pointer', async () => {
       const result = await executeVfsMv(
         { sources: ['uploads/data.csv'], destination: 'files/data.csv' },
         context
       )
       expect(result.success).toBe(false)
-      expect(result.error).toContain('materialize_file')
+      expect(result.error).toContain('save_upload')
     })
 
     it('rejects read-only categories', async () => {
@@ -776,15 +806,41 @@ describe('vfs mv/cp', () => {
       })
     })
 
-    it('rejects flat namespaces', async () => {
+    it('creates table folders through the table application operation', async () => {
+      mocks.createTableFolders.mockResolvedValue({
+        outcomes: [
+          { source: 'tables/CRM', kind: 'folder', resourceId: 'fld-1', targetSegments: ['CRM'] },
+        ],
+      })
+
       const result = await executeVfsMkdir({ paths: ['tables/CRM'] }, context)
-      expect(result.success).toBe(false)
+
+      expect(mocks.createTableFolders).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: {
+            workspaceId: 'ws-1',
+            paths: [{ source: 'tables/CRM', segments: ['CRM'] }],
+          },
+        })
+      )
+      expect(result.success).toBe(true)
       expect(result.output).toMatchObject({
-        results: [{ from: 'tables/CRM', error: expect.stringContaining('flat namespace') }],
+        results: [{ from: 'tables/CRM', to: 'tables/CRM', kind: 'table_folder', id: 'fld-1' }],
       })
       expect(mocks.ensureCopilotFileFolderPath).not.toHaveBeenCalled()
     })
 
+    it('rejects the reserved knowledgebases/connectors folder path', async () => {
+      const result = await executeVfsMkdir({ paths: ['knowledgebases/connectors/sub'] }, context)
+      expect(result.success).toBe(false)
+      expect(result.output).toMatchObject({
+        results: [
+          { from: 'knowledgebases/connectors/sub', error: expect.stringContaining('reserved') },
+        ],
+      })
+      expect(mocks.createKnowledgeFolders).not.toHaveBeenCalled()
+    })
+
     it('rejects creation inside a locked workflow folder', async () => {
       mocks.createWorkflowVfsFolders.mockResolvedValue({
         outcomes: [
@@ -804,30 +860,65 @@ describe('vfs mv/cp', () => {
     })
   })
 
-  describe('tables and knowledge bases (flat namespaces)', () => {
-    it('renames a table', async () => {
+  describe('tables and knowledge bases (foldered)', () => {
+    it('renames a table through the transfer application operation', async () => {
+      mocks.transferTableVfs.mockResolvedValue({
+        outcomes: [
+          {
+            source: 'tables/Leads',
+            kind: 'resource',
+            resourceId: 'tbl-1',
+            targetSegments: ['Customers'],
+          },
+        ],
+      })
+
       const result = await executeVfsMv(
         { sources: ['tables/Leads'], destination: 'tables/Customers' },
         context
       )
 
-      expect(mocks.renameTableVfs).toHaveBeenCalledWith(
+      expect(mocks.transferTableVfs).toHaveBeenCalledWith(
         expect.objectContaining({
-          input: { workspaceId: 'ws-1', sourceName: 'Leads', newName: 'Customers' },
+          input: {
+            workspaceId: 'ws-1',
+            sources: [{ source: 'tables/Leads', segments: ['Leads'] }],
+            destination: { segments: ['Customers'], trailingSlash: false },
+          },
         })
       )
       expect(result.success).toBe(true)
       expect(result.output).toMatchObject({ results: [{ to: 'tables/Customers', kind: 'table' }] })
     })
 
-    it('rejects nested table destinations as flat-namespace violations', async () => {
+    it('moves a table into a folder, folders auto-created server-side', async () => {
+      mocks.transferTableVfs.mockResolvedValue({
+        outcomes: [
+          {
+            source: 'tables/Leads',
+            kind: 'resource',
+            resourceId: 'tbl-1',
+            targetSegments: ['CRM', 'Leads'],
+          },
+        ],
+      })
+
       const result = await executeVfsMv(
-        { sources: ['tables/Leads'], destination: 'tables/CRM/Leads' },
+        { sources: ['tables/Leads'], destination: 'tables/CRM/' },
         context
       )
-      expect(result.success).toBe(false)
-      expect(result.error).toContain('flat namespace')
-      expect(mocks.renameTable).not.toHaveBeenCalled()
+
+      expect(mocks.transferTableVfs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: expect.objectContaining({
+            destination: { segments: ['CRM'], trailingSlash: true },
+          }),
+        })
+      )
+      expect(result.success).toBe(true)
+      expect(result.output).toMatchObject({
+        results: [{ to: 'tables/CRM/Leads', kind: 'table' }],
+      })
     })
 
     it('rejects copying tables', async () => {
@@ -840,12 +931,23 @@ describe('vfs mv/cp', () => {
     })
 
     it('renames a knowledge base through trusted application operations', async () => {
+      mocks.transferKnowledgeVfs.mockResolvedValue({
+        outcomes: [
+          {
+            source: 'knowledgebases/Docs',
+            kind: 'resource',
+            resourceId: 'kb-1',
+            targetSegments: ['Product Docs'],
+          },
+        ],
+      })
+
       const result = await executeVfsMv(
         { sources: ['knowledgebases/Docs'], destination: 'knowledgebases/Product Docs' },
         context
       )
 
-      expect(mocks.renameKnowledgeVfs).toHaveBeenCalledWith(
+      expect(mocks.transferKnowledgeVfs).toHaveBeenCalledWith(
         expect.objectContaining({
           principal: expect.objectContaining({
             kind: 'delegated',
@@ -855,8 +957,8 @@ describe('vfs mv/cp', () => {
           }),
           input: {
             workspaceId: 'ws-1',
-            sourceName: 'Docs',
-            newName: 'Product Docs',
+            sources: [{ source: 'knowledgebases/Docs', segments: ['Docs'] }],
+            destination: { segments: ['Product Docs'], trailingSlash: false },
           },
         })
       )
@@ -864,7 +966,7 @@ describe('vfs mv/cp', () => {
     })
 
     it('propagates knowledge application infrastructure failures', async () => {
-      mocks.renameKnowledgeVfs.mockRejectedValueOnce(new Error('knowledge database unavailable'))
+      mocks.transferKnowledgeVfs.mockRejectedValueOnce(new Error('knowledge database unavailable'))
 
       await expect(
         executeVfsMv(
@@ -875,7 +977,7 @@ describe('vfs mv/cp', () => {
     })
 
     it('preserves an actionable knowledge rename conflict', async () => {
-      mocks.renameKnowledgeVfs.mockRejectedValue(
+      mocks.transferKnowledgeVfs.mockRejectedValue(
         new OrchestrationError('conflict', 'A knowledge base named Product Docs already exists')
       )
 
@@ -912,11 +1014,71 @@ describe('vfs mv/cp', () => {
           input: {
             workspaceId: 'ws-1',
             sourceName: 'Docs',
+            sourceSegments: ['Docs'],
           },
         })
       )
     })
 
+    it('moves a whole table folder through the transfer operation', async () => {
+      mocks.transferTableVfs.mockResolvedValue({
+        outcomes: [
+          {
+            source: 'tables/CRM',
+            kind: 'folder',
+            resourceId: 'fld-1',
+            targetSegments: ['Archive', 'CRM'],
+          },
+        ],
+      })
+
+      const result = await executeVfsMv(
+        { sources: ['tables/CRM'], destination: 'tables/Archive/' },
+        context
+      )
+
+      expect(result.success).toBe(true)
+      expect(result.output).toMatchObject({
+        results: [{ to: 'tables/Archive/CRM', kind: 'table_folder' }],
+      })
+    })
+
+    it('rm retargets to the folder cascade when the path is a folder', async () => {
+      mocks.deleteTableVfs.mockRejectedValue(
+        new OrchestrationError('invalid', 'tables/CRM is a folder; this operation takes a table.')
+      )
+      mocks.deleteTableFolders.mockResolvedValue({
+        outcomes: [{ source: 'tables/CRM', kind: 'folder', resourceId: 'fld-1' }],
+      })
+
+      const result = await executeVfsRm({ paths: ['tables/CRM'] }, context)
+
+      expect(mocks.deleteTableFolders).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: { workspaceId: 'ws-1', paths: [{ source: 'tables/CRM', segments: ['CRM'] }] },
+        })
+      )
+      expect(result.success).toBe(true)
+      expect(result.output).toMatchObject({
+        results: [{ from: 'tables/CRM', kind: 'table_folder', id: 'fld-1' }],
+      })
+    })
+
+    it('deletes a nested knowledge base by its folder path', async () => {
+      const result = await executeVfsRm({ paths: ['knowledgebases/Legal/Contracts'] }, context)
+
+      expect(mocks.deleteKnowledgeVfs).toHaveBeenCalledWith(
+        expect.objectContaining({
+          input: {
+            workspaceId: 'ws-1',
+            sourceName: 'Contracts',
+            sourceSegments: ['Legal', 'Contracts'],
+          },
+        })
+      )
+      expect(result.success).toBe(true)
+    })
+
     it('preserves an actionable knowledge delete failure', async () => {
       mocks.deleteKnowledgeVfs.mockRejectedValue(
         new OrchestrationError('not_found', 'Knowledge base no longer exists')
diff --git a/apps/sim/lib/copilot/tools/handlers/vfs-mutate.ts b/apps/sim/lib/copilot/tools/handlers/vfs-mutate.ts
index 6516fe35f1..2be4f984ac 100644
--- a/apps/sim/lib/copilot/tools/handlers/vfs-mutate.ts
+++ b/apps/sim/lib/copilot/tools/handlers/vfs-mutate.ts
@@ -12,16 +12,23 @@ import {
 import { messageForCopilotTableError } from '@/lib/copilot/auth/table-delegation'
 import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { requireCopilotWorkspace } from '@/lib/copilot/tools/server/files/file-folder-application'
-import { normalizeVfsSegment } from '@/lib/copilot/vfs/normalize-segment'
 import { decodeVfsPathSegments, encodeVfsPathSegments } from '@/lib/copilot/vfs/path-utils'
 import { asOrchestrationError } from '@/lib/core/orchestration/types'
 import { PlatformEvents } from '@/lib/core/telemetry'
+import type { ResourceVfsOutcome } from '@/lib/folders/application/resource-vfs'
 import {
+  createKnowledgeVfsFolders,
   deleteKnowledgeBaseByVfsPath,
-  renameKnowledgeBaseByVfsPath,
+  deleteKnowledgeVfsFolders,
+  transferKnowledgeVfsItems,
 } from '@/lib/knowledge/application/knowledge-vfs'
 import { captureServerEvent } from '@/lib/posthog/server'
-import { deleteTableByVfsPath, renameTableByVfsPath } from '@/lib/table/application/table-vfs'
+import {
+  createTableVfsFolders,
+  deleteTableByVfsPath,
+  deleteTableVfsFolders,
+  transferTableVfsItems,
+} from '@/lib/table/application/table-vfs'
 import { VfsPathLimitError, validateVfsPathBatch } from '@/lib/vfs/limits'
 import {
   copyWorkflowVfsItems,
@@ -47,7 +54,7 @@ const MUTATE_CATEGORIES = new Set<string>(['files', 'workflows', 'tables', 'know
 
 const CATEGORY_REJECTIONS: Record<string, string> = {
   uploads:
-    'uploads/ files are chat-scoped and immutable. Use materialize_file to promote one into files/ first.',
+    'uploads/ files are chat-scoped and immutable. Use save_upload to promote one into files/ first.',
   'recently-deleted':
     'recently-deleted/ items cannot be moved or copied. Restore them with restore_resource first.',
 }
@@ -66,7 +73,15 @@ const RM_CATEGORY_REJECTIONS: Record<string, string> = {
 interface VfsMutateOutcome {
   from: string
   to?: string
-  kind: 'file' | 'file_folder' | 'workflow' | 'workflow_folder' | 'table' | 'knowledge_base'
+  kind:
+    | 'file'
+    | 'file_folder'
+    | 'workflow'
+    | 'workflow_folder'
+    | 'table'
+    | 'table_folder'
+    | 'knowledge_base'
+    | 'knowledge_base_folder'
   id?: string
   error?: string
 }
@@ -217,18 +232,76 @@ export async function executeVfsMkdir(
       }
     }
 
+    const folderedOutcomes = new Map<string, VfsMutateOutcome>()
+    for (const category of ['tables', 'knowledgebases'] as const) {
+      const categoryPaths = paths.filter((path) => topLevelSegment(path) === category)
+      if (categoryPaths.length === 0) continue
+      const folderKind = category === 'tables' ? 'table_folder' : 'knowledge_base_folder'
+      const reserved = categoryPaths.filter((path) =>
+        isReservedKnowledgePath(category, decodeVfsPathSegments(path).slice(1))
+      )
+      for (const path of reserved) {
+        folderedOutcomes.set(path, {
+          from: path,
+          kind: folderKind,
+          error: '"knowledgebases/connectors" is a reserved path.',
+        })
+      }
+      const eligible = categoryPaths.filter((path) => !folderedOutcomes.has(path))
+      if (eligible.length === 0) continue
+      const input = {
+        workspaceId,
+        paths: eligible.map((path) => ({
+          source: path,
+          segments: decodeVfsPathSegments(path).slice(1),
+        })),
+      }
+      try {
+        const result =
+          category === 'tables'
+            ? await executeCopilotTableUseCase(context, createTableVfsFolders, input, {})
+            : await executeCopilotKnowledgeUseCase(context, createKnowledgeVfsFolders, input)
+        for (const outcome of result.outcomes) {
+          folderedOutcomes.set(outcome.source, presentResourceVfsOutcome(category, outcome))
+        }
+      } catch (error) {
+        const message =
+          category === 'tables'
+            ? messageForExpectedTableVfsError(error)
+            : messageForKnowledgeVfsError(error, 'Write access required to create folders')
+        for (const path of eligible) {
+          folderedOutcomes.set(path, { from: path, kind: folderKind, error: message })
+        }
+      }
+    }
+
     const outcomes: VfsMutateOutcome[] = []
     for (const path of paths) {
       const top = topLevelSegment(path)
       const segments = decodeVfsPathSegments(path).slice(1)
-      const kind = top === 'workflows' ? 'workflow_folder' : 'file_folder'
+      const kind =
+        top === 'workflows'
+          ? 'workflow_folder'
+          : top === 'tables'
+            ? 'table_folder'
+            : top === 'knowledgebases'
+              ? 'knowledge_base_folder'
+              : 'file_folder'
 
+      if (top === 'tables' || top === 'knowledgebases') {
+        outcomes.push(
+          folderedOutcomes.get(path) ?? {
+            from: path,
+            kind,
+            error: `No result came back for "${path}" — the parent path may not exist or the name may collide. Run glob on the parent to confirm, and do not repeat the identical call.`,
+          }
+        )
+        continue
+      }
       if (top !== 'files' && top !== 'workflows') {
         const rejection =
-          top === 'tables' || top === 'knowledgebases'
-            ? `${top}/ is a flat namespace with no folders.`
-            : (CATEGORY_REJECTIONS[top] ??
-              `"${path}" is not a folder target. mkdir supports files/ and workflows/ paths.`)
+          CATEGORY_REJECTIONS[top] ??
+          `"${path}" is not a folder target. mkdir supports files/, workflows/, tables/, and knowledgebases/ paths.`
         outcomes.push({ from: path, kind, error: rejection })
         continue
       }
@@ -243,7 +316,7 @@ export async function executeVfsMkdir(
             fileOutcomes.get(path) ?? {
               from: path,
               kind: 'file_folder',
-              error: 'File folder creation failed',
+              error: `No result came back for "${path}" — the parent path may not exist or the name may collide. Run glob on the parent to confirm, and do not repeat the identical call.`,
             }
           )
         } else {
@@ -251,7 +324,7 @@ export async function executeVfsMkdir(
             workflowOutcomes.get(path) ?? {
               from: path,
               kind: 'workflow_folder',
-              error: 'Workflow folder creation failed',
+              error: `No result came back for "${path}" — the parent path may not exist or the name may collide. Run glob on the parent to confirm, and do not repeat the identical call.`,
             }
           )
         }
@@ -319,7 +392,14 @@ async function executeVfsMutate(
       case 'workflows':
         return await mutateWorkflows(verb, sources, destination, context, workspaceId)
       default:
-        return await renameFlatResource(verb, category, sources, destination, context, workspaceId)
+        return await transferFolderedResource(
+          verb,
+          category,
+          sources,
+          destination,
+          context,
+          workspaceId
+        )
     }
   } catch (error) {
     if (error instanceof KnowledgeVfsInfrastructureError) {
@@ -333,6 +413,28 @@ async function executeVfsMutate(
   }
 }
 
+function presentResourceVfsOutcome(
+  category: 'tables' | 'knowledgebases',
+  outcome: ResourceVfsOutcome
+): VfsMutateOutcome {
+  const resourceKind = category === 'tables' ? 'table' : 'knowledge_base'
+  const folderKind = category === 'tables' ? 'table_folder' : 'knowledge_base_folder'
+  return {
+    from: outcome.source,
+    ...(outcome.targetSegments
+      ? { to: `${category}/${encodeVfsPathSegments(outcome.targetSegments)}` }
+      : {}),
+    kind: outcome.kind === 'folder' ? folderKind : resourceKind,
+    id: outcome.resourceId,
+    error: outcome.error,
+  }
+}
+
+/** knowledgebases/connectors is a virtual tree, not a knowledge base or folder. */
+function isReservedKnowledgePath(category: string, segments: readonly string[]): boolean {
+  return category === 'knowledgebases' && segments[0]?.toLowerCase() === 'connectors'
+}
+
 async function mutateWorkspaceFiles(
   verb: MutateVerb,
   sources: string[],
@@ -419,7 +521,7 @@ async function mutateWorkflows(
   }
 }
 
-async function renameFlatResource(
+async function transferFolderedResource(
   verb: MutateVerb,
   category: 'tables' | 'knowledgebases',
   sources: string[],
@@ -428,77 +530,49 @@ async function renameFlatResource(
   workspaceId: string
 ): Promise<ToolCallResult> {
   const label = category === 'tables' ? 'Tables' : 'Knowledge bases'
-  const kind = category === 'tables' ? 'table' : 'knowledge_base'
-
   if (verb === 'cp') {
     return { success: false, error: `${label} cannot be copied — duplication is not supported.` }
   }
-  if (sources.length > 1) {
-    return { success: false, error: `${label} are renamed one at a time.` }
-  }
 
-  const sourceSegments = decodeVfsPathSegments(sources[0]).slice(1)
-  const destSegments = decodeVfsPathSegments(destination).slice(1)
-  if (sourceSegments.length !== 1 || destSegments.length !== 1 || hasTrailingSlash(destination)) {
-    return {
-      success: false,
-      error: `${label} have a flat namespace with no folders — mv only renames them, e.g. mv({sources: ["${category}/Old Name"], destination: "${category}/New Name"}).`,
+  const sourceRefs = sources.map((source) => ({
+    source,
+    segments: decodeVfsPathSegments(source).slice(1),
+  }))
+  const destinationSegments = decodeVfsPathSegments(destination).slice(1)
+  for (const ref of sourceRefs) {
+    if (isReservedKnowledgePath(category, ref.segments)) {
+      return { success: false, error: '"knowledgebases/connectors" is a reserved path.' }
     }
   }
-
-  const sourceName = sourceSegments[0]
-  const newName = destSegments[0]
-
-  if (category === 'tables') {
-    try {
-      const renamed = await executeCopilotTableUseCase(
-        context,
-        renameTableByVfsPath,
-        { workspaceId, sourceName, newName },
-        {}
-      )
-      return buildResult(verb, [
-        {
-          from: sources[0],
-          to: `tables/${normalizeVfsSegment(renamed.name)}`,
-          kind,
-          id: renamed.id,
-        },
-      ])
-    } catch (error) {
-      return { success: false, error: messageForExpectedTableVfsError(error) }
-    }
-  }
-
-  if (newName.toLowerCase() === 'connectors') {
+  if (isReservedKnowledgePath(category, destinationSegments)) {
     return { success: false, error: '"knowledgebases/connectors" is a reserved path.' }
   }
+
+  const input = {
+    workspaceId,
+    sources: sourceRefs,
+    destination: {
+      segments: destinationSegments,
+      trailingSlash: hasTrailingSlash(destination),
+    },
+  }
+  assertMutationNotAborted(context)
   try {
-    const renamed = await executeCopilotKnowledgeUseCase(context, renameKnowledgeBaseByVfsPath, {
-      workspaceId,
-      sourceName,
-      newName,
-    })
-    logger.info('Renamed knowledge base via mv', {
-      knowledgeBaseId: renamed.id,
-      workspaceId,
-    })
-    return buildResult(verb, [
-      {
-        from: sources[0],
-        to: `knowledgebases/${normalizeVfsSegment(renamed.name)}`,
-        kind,
-        id: renamed.id,
-      },
-    ])
+    const result =
+      category === 'tables'
+        ? await executeCopilotTableUseCase(context, transferTableVfsItems, input, {})
+        : await executeCopilotKnowledgeUseCase(context, transferKnowledgeVfsItems, input)
+    return buildResult(
+      verb,
+      result.outcomes.map((outcome) => presentResourceVfsOutcome(category, outcome))
+    )
   } catch (error) {
-    return {
-      success: false,
-      error: messageForKnowledgeVfsError(
-        error,
-        `Write access required to rename knowledge base "${sourceName}"`
-      ),
-    }
+    if (context.abortSignal?.aborted) throw error
+    const message =
+      category === 'tables'
+        ? messageForExpectedTableVfsError(error)
+        : messageForKnowledgeVfsError(error, `Write access required to move ${label.toLowerCase()}`)
+    return { success: false, error: message }
   }
 }
 
@@ -576,12 +650,16 @@ export async function executeVfsRm(
             workflowOutcomes.get(path) ?? {
               from: path,
               kind: 'workflow',
-              error: 'Workflow deletion failed',
+              error: `No result came back for deleting "${path}" — it may not exist or may already be deleted. Run glob("workflows/*") to confirm before retrying.`,
             }
           )
         } else if (classified.category === 'files') {
           outcomes.push(
-            fileOutcomes.get(path) ?? { from: path, kind: 'file', error: 'File deletion failed' }
+            fileOutcomes.get(path) ?? {
+              from: path,
+              kind: 'file',
+              error: `No result came back for deleting "${path}" — it may not exist or may already be deleted. Run glob("files/**") to confirm before retrying.`,
+            }
           )
         } else {
           outcomes.push(await removeOne(classified.category, path, context, workspaceId))
@@ -641,31 +719,25 @@ function removeOne(
   }
 }
 
-/** Resolves a flat tables/{name} or knowledgebases/{name} path to its single segment. */
-function flatResourceName(path: string): string | null {
-  const segments = decodeVfsPathSegments(path).slice(1)
-  if (segments.length !== 1) return null
-  return segments[0]
-}
-
 async function removeTablePath(
   path: string,
   context: ExecutionContext,
   workspaceId: string
 ): Promise<VfsMutateOutcome> {
-  const sourceName = flatResourceName(path)
-  if (!sourceName) {
+  const segments = decodeVfsPathSegments(path).slice(1)
+  if (segments.length === 0) {
     return {
       from: path,
       kind: 'table',
-      error: 'tables/ is a flat namespace — rm takes a single name, e.g. rm(["tables/Leads"]).',
+      error: 'rm takes a table or folder path, e.g. rm(["tables/Leads"]) or rm(["tables/CRM"]).',
     }
   }
+  const sourceName = segments[segments.length - 1]
   try {
     const deleted = await executeCopilotTableUseCase(
       context,
       deleteTableByVfsPath,
-      { workspaceId, sourceName },
+      { workspaceId, sourceName, sourceSegments: segments },
       {}
     )
     captureServerEvent(
@@ -677,7 +749,51 @@ async function removeTablePath(
     logger.info('Archived table via rm', { tableId: deleted.id, workspaceId })
     return { from: path, kind: 'table', id: deleted.id }
   } catch (error) {
-    return { from: path, kind: 'table', error: messageForExpectedTableVfsError(error) }
+    const message = messageForExpectedTableVfsError(error)
+    const folderOutcome = await removeResourceFolderFallback(
+      'tables',
+      path,
+      segments,
+      message,
+      context,
+      workspaceId
+    )
+    if (folderOutcome) return folderOutcome
+    return { from: path, kind: 'table', error: message }
+  }
+}
+
+/**
+ * rm resolution is resource-first (matching mv); when the resource resolver
+ * reports the path IS a folder, the delete retargets to the folder cascade.
+ */
+async function removeResourceFolderFallback(
+  category: 'tables' | 'knowledgebases',
+  path: string,
+  segments: string[],
+  resourceError: string,
+  context: ExecutionContext,
+  workspaceId: string
+): Promise<VfsMutateOutcome | null> {
+  if (!resourceError.includes('is a folder')) return null
+  const input = { workspaceId, paths: [{ source: path, segments }] }
+  try {
+    const result =
+      category === 'tables'
+        ? await executeCopilotTableUseCase(context, deleteTableVfsFolders, input, {})
+        : await executeCopilotKnowledgeUseCase(context, deleteKnowledgeVfsFolders, input)
+    const outcome = result.outcomes[0]
+    return outcome ? presentResourceVfsOutcome(category, outcome) : null
+  } catch (error) {
+    const message =
+      category === 'tables'
+        ? messageForExpectedTableVfsError(error)
+        : messageForKnowledgeVfsError(error, 'Write access required to delete folders')
+    return {
+      from: path,
+      kind: category === 'tables' ? 'table_folder' : 'knowledge_base_folder',
+      error: message,
+    }
   }
 }
 
@@ -686,16 +802,16 @@ async function removeKnowledgeBasePath(
   context: ExecutionContext,
   workspaceId: string
 ): Promise<VfsMutateOutcome> {
-  const sourceName = flatResourceName(path)
-  if (!sourceName) {
+  const segments = decodeVfsPathSegments(path).slice(1)
+  if (segments.length === 0) {
     return {
       from: path,
       kind: 'knowledge_base',
-      error:
-        'knowledgebases/ is a flat namespace — rm takes a single name, e.g. rm(["knowledgebases/support-docs"]).',
+      error: 'rm takes a knowledge base or folder path, e.g. rm(["knowledgebases/support-docs"]).',
     }
   }
-  if (sourceName.toLowerCase() === 'connectors') {
+  const sourceName = segments[segments.length - 1]
+  if (isReservedKnowledgePath('knowledgebases', segments)) {
     return {
       from: path,
       kind: 'knowledge_base',
@@ -706,6 +822,7 @@ async function removeKnowledgeBasePath(
     const deleted = await executeCopilotKnowledgeUseCase(context, deleteKnowledgeBaseByVfsPath, {
       workspaceId,
       sourceName,
+      sourceSegments: segments,
     })
     PlatformEvents.knowledgeBaseDeleted({ knowledgeBaseId: deleted.id })
     logger.info('Deleted knowledge base via rm', {
@@ -714,13 +831,19 @@ async function removeKnowledgeBasePath(
     })
     return { from: path, kind: 'knowledge_base', id: deleted.id }
   } catch (error) {
-    return {
-      from: path,
-      kind: 'knowledge_base',
-      error: messageForKnowledgeVfsError(
-        error,
-        `Write access required to delete knowledge base "${sourceName}"`
-      ),
-    }
+    const message = messageForKnowledgeVfsError(
+      error,
+      `Write access required to delete knowledge base "${sourceName}"`
+    )
+    const folderOutcome = await removeResourceFolderFallback(
+      'knowledgebases',
+      path,
+      segments,
+      message,
+      context,
+      workspaceId
+    )
+    if (folderOutcome) return folderOutcome
+    return { from: path, kind: 'knowledge_base', error: message }
   }
 }
diff --git a/apps/sim/lib/copilot/tools/handlers/vfs.test.ts b/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
index 5f89535f76..c1f2b378fc 100644
--- a/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/vfs.test.ts
@@ -2,7 +2,7 @@
  * @vitest-environment node
  */
 
-import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
 
 const { getOrMaterializeVFS } = vi.hoisted(() => ({
@@ -103,7 +103,7 @@ describe('vfs handlers oversize policy', () => {
     expect(result.error).toContain('context window')
   })
 
-  it('fails oversized read results from VFS with grep guidance', async () => {
+  it('fails oversized read results from VFS with paging guidance', async () => {
     const vfs = makeVfs()
     vfs.readFileContent.mockResolvedValue(null)
     vfs.read.mockReturnValue({ content: OVERSIZED_INLINE_CONTENT, totalLines: 1 })
@@ -112,11 +112,58 @@ describe('vfs handlers oversize policy', () => {
     const result = await executeVfsRead({ path: 'workflows/My Workflow/state.json' }, GREP_CTX)
 
     expect(result.success).toBe(false)
-    expect(result.error).toContain('Use grep')
-    expect(result.error).toContain('offset/limit')
+    expect(result.error).toContain('Page it')
+    expect(result.error).toContain('grep')
     expect(result.error).toContain('context window')
   })
 
+  it('pages an oversized workspace file when offset/limit are passed', async () => {
+    const vfs = makeVfs()
+    const lines = Array.from({ length: 5000 }, (_, i) => `line ${i} ${'y'.repeat(50)}`)
+    vfs.readFileContent.mockResolvedValue({
+      content: lines.join('\n'),
+      totalLines: lines.length,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const whole = await executeVfsRead({ path: 'files/big.log/content' }, GREP_CTX)
+    expect(whole.success).toBe(false)
+    expect(whole.error).toContain('Page it')
+
+    const paged = await executeVfsRead(
+      { path: 'files/big.log/content', offset: 10, limit: 5 },
+      GREP_CTX
+    )
+    expect(paged.success).toBe(true)
+    expect((paged.output as { content: string }).content).toBe(lines.slice(10, 15).join('\n'))
+  })
+
+  it('tells the model to reduce limit when the requested window is still oversized', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue({
+      content: Array.from({ length: 100 }, () => OVERSIZED_INLINE_CONTENT).join('\n'),
+      totalLines: 100,
+    })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead(
+      { path: 'files/big.log/content', offset: 0, limit: 50 },
+      GREP_CTX
+    )
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Reduce limit')
+  })
+
+  it('notes an empty file instead of returning bare empty content', async () => {
+    const vfs = makeVfs()
+    vfs.readFileContent.mockResolvedValue({ content: '', totalLines: 0 })
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsRead({ path: 'files/hi.txt/content' }, GREP_CTX)
+    expect(result.success).toBe(true)
+    expect((result.output as { note?: string }).note).toContain('empty')
+  })
+
   it('fails file-backed oversized read placeholders with original message', async () => {
     const vfs = makeVfs()
     vfs.readFileContent.mockResolvedValue(
@@ -723,6 +770,26 @@ describe('vfs uploads are opt-in (like recently-deleted/)', () => {
     expect((broad.output as { files: string[] }).files).not.toContain('uploads/My%20Report.json')
   })
 
+  it('explains an empty uploads glob instead of returning a bare []', async () => {
+    const vfs = makeVfs()
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+    listChatUploads.mockResolvedValue([])
+
+    const result = await executeVfsGlob({ pattern: 'uploads/*' }, GREP_CTX_CHAT)
+    expect(result.success).toBe(true)
+    expect((result.output as { files: string[]; note?: string }).files).toEqual([])
+    expect((result.output as { note?: string }).note).toContain('no uploads')
+  })
+
+  it('explains an empty user-local glob instead of returning a bare []', async () => {
+    const vfs = makeVfs()
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+
+    const result = await executeVfsGlob({ pattern: 'user-local/**' }, GREP_CTX_CHAT)
+    expect(result.success).toBe(true)
+    expect((result.output as { note?: string }).note).toContain('user-local')
+  })
+
   it('reads an upload directly, tolerating a spurious /content suffix', async () => {
     const vfs = makeVfs()
     getOrMaterializeVFS.mockResolvedValue(vfs)
@@ -746,3 +813,141 @@ describe('vfs uploads are opt-in (like recently-deleted/)', () => {
     expect(grepChatUpload).toHaveBeenCalledWith('report.json', 'chat-1', 'x', expect.any(Object))
   })
 })
+
+describe('vfs handlers docs corpus routing', () => {
+  const fetchMock = vi.fn()
+  const DOCS_PAGE = 'docs/workflows/blocks/agent.mdx'
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    fetchMock.mockReset()
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('globs the docs corpus without materializing the workspace VFS', async () => {
+    const result = await executeVfsGlob({ pattern: 'docs/**' }, GREP_CTX)
+
+    expect(result.success).toBe(true)
+    expect((result.output as { files: string[] }).files).toContain(DOCS_PAGE)
+    expect(getOrMaterializeVFS).not.toHaveBeenCalled()
+  })
+
+  it('reads a docs page via the live-site fetch, not the workspace VFS', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      text: async () => 'line one\nline two',
+    })
+
+    const result = await executeVfsRead({ path: DOCS_PAGE }, GREP_CTX)
+
+    expect(result.success).toBe(true)
+    expect(result.output).toEqual({ content: 'line one\nline two', totalLines: 2 })
+    expect(getOrMaterializeVFS).not.toHaveBeenCalled()
+  })
+
+  it('surfaces DocsCorpusError messages verbatim from read, without fetching', async () => {
+    const unknown = await executeVfsRead({ path: 'docs/not-a-real-page.mdx' }, GREP_CTX)
+    expect(unknown.success).toBe(false)
+    expect(unknown.error).toContain('Docs page not found')
+
+    const dir = await executeVfsRead({ path: 'docs/workflows/blocks' }, GREP_CTX)
+    expect(dir.success).toBe(false)
+    expect(dir.error).toContain('is a directory')
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+
+  it('greps one docs page and rejects directory scope without touching the workspace VFS', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      text: async () => 'alpha\ncron beta\ngamma',
+    })
+
+    const single = await executeVfsGrep({ pattern: 'cron', path: DOCS_PAGE }, GREP_CTX)
+    expect(single.success).toBe(true)
+
+    const directory = await executeVfsGrep(
+      { pattern: 'cron', path: 'docs/workflows', maxResults: 10_000 },
+      GREP_CTX
+    )
+    expect(directory.success).toBe(false)
+    expect(directory.error).toContain('grep must target one docs page')
+    expect(fetchMock).toHaveBeenCalledOnce()
+
+    const invalid = await executeVfsGrep({ pattern: 'cron', path: 'docs/not-a-page.mdx' }, GREP_CTX)
+    expect(invalid.success).toBe(false)
+    expect(invalid.error).toContain('not a docs page')
+    expect(getOrMaterializeVFS).not.toHaveBeenCalled()
+  })
+
+  it('truncates an oversized multi-line docs page to fit the inline cap', async () => {
+    const line = 'y'.repeat(200)
+    const totalLines = Math.ceil((TOOL_RESULT_MAX_INLINE_CHARS * 2) / (line.length + 1))
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      text: async () => Array.from({ length: totalLines }, () => line).join('\n'),
+    })
+
+    const result = await executeVfsRead({ path: DOCS_PAGE }, GREP_CTX)
+
+    expect(result.success).toBe(true)
+    const output = result.output as { content: string; totalLines: number }
+    expect(output.totalLines).toBe(totalLines)
+    expect(output.content).toContain('[Page truncated: returned lines 1-')
+    expect(output.content).toMatch(/offset: \d+ and limit: \d+/)
+    expect(output.content).toContain('reduce the limit if that window is still too large')
+    expect(JSON.stringify(output).length).toBeLessThanOrEqual(TOOL_RESULT_MAX_INLINE_CHARS)
+  })
+
+  it('fails a docs page whose single line cannot fit inline instead of returning it oversized', async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      text: async () => 'z'.repeat(TOOL_RESULT_MAX_INLINE_CHARS + 1000),
+    })
+
+    const result = await executeVfsRead({ path: DOCS_PAGE }, GREP_CTX)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Grep this page')
+  })
+
+  it('rejects an explicit window that still overflows instead of truncating it', async () => {
+    const line = 'y'.repeat(200)
+    const totalLines = Math.ceil((TOOL_RESULT_MAX_INLINE_CHARS * 2) / (line.length + 1))
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      text: async () => Array.from({ length: totalLines }, () => line).join('\n'),
+    })
+
+    const result = await executeVfsRead({ path: DOCS_PAGE, offset: 0, limit: totalLines }, GREP_CTX)
+
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('still too large over the requested window')
+  })
+
+  it('forwards caller cancellation to docs read and grep without fetching', async () => {
+    const controller = new AbortController()
+    controller.abort(new Error('user stopped docs tool'))
+    const context = { ...GREP_CTX, abortSignal: controller.signal }
+
+    const read = await executeVfsRead({ path: DOCS_PAGE }, context)
+    const grep = await executeVfsGrep({ pattern: 'agent', path: DOCS_PAGE }, context)
+
+    expect(read).toEqual({ success: false, error: 'user stopped docs tool' })
+    expect(grep).toEqual({ success: false, error: 'user stopped docs tool' })
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/handlers/vfs.ts b/apps/sim/lib/copilot/tools/handlers/vfs.ts
index dfa61ea388..894df5ea70 100644
--- a/apps/sim/lib/copilot/tools/handlers/vfs.ts
+++ b/apps/sim/lib/copilot/tools/handlers/vfs.ts
@@ -4,6 +4,14 @@ import { resolveCopilotKnowledgePrincipal } from '@/lib/copilot/application/exec
 import { resolveCopilotFilePrincipal } from '@/lib/copilot/auth/file-delegation'
 import { getBlockVisibilityForCopilot } from '@/lib/copilot/block-visibility'
 import { TOOL_RESULT_MAX_INLINE_CHARS } from '@/lib/copilot/constants'
+import {
+  couldMatchDocsScope,
+  DocsCorpusError,
+  globDocs,
+  grepDocs,
+  isDocsPath,
+  readDocsPage,
+} from '@/lib/copilot/docs/docs-corpus'
 import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
 import { getOrMaterializeVFS } from '@/lib/copilot/vfs'
 import type { GrepCountEntry, GrepMatch } from '@/lib/copilot/vfs/operations'
@@ -126,6 +134,42 @@ async function canReturnWorkspaceFileValue(
   return true
 }
 
+/**
+ * Trim an oversized docs page to a whole-line prefix that fits the
+ * inline budget, preserving the true `totalLines` so the model can page through
+ * the rest with offset/limit. Returns null when not even one line fits — a
+ * single line longer than the cap — so the caller can fail instead of returning
+ * an over-cap payload as success. The notice offers grep as an alternative to
+ * another read because either operation fetches the page once.
+ */
+function truncateDocsPageToInlineCap(page: { content: string; totalLines: number }): {
+  output: { content: string; totalLines: number }
+  returnedLines: number
+} | null {
+  const lines = page.content.split('\n')
+  const notice = (shown: number) =>
+    `\n\n[Page truncated: returned lines 1-${shown} of ${page.totalLines}. To continue, read this path with offset: ${shown} and limit: ${shown}; reduce the limit if that window is still too large. To jump straight to a section, grep this path INSTEAD of reading it — grep is the same single fetch and returns only matching lines with their numbers.]`
+
+  let kept = lines.length
+  while (kept > 0) {
+    const content = `${lines.slice(0, kept).join('\n')}${notice(kept)}`
+    if (
+      serializedResultSize({ content, totalLines: page.totalLines }) <= TOOL_RESULT_MAX_INLINE_CHARS
+    ) {
+      return { output: { content, totalLines: page.totalLines }, returnedLines: kept }
+    }
+    kept = Math.floor(kept / 2)
+  }
+  return null
+}
+
+/**
+ * Routes grep by content source. `docs/<page>` uses one network-backed docs
+ * page; `uploads/<file>` uses one chat-scoped upload; workspace file paths use
+ * one authorized file; all remaining paths use the materialized in-memory VFS.
+ * External and dynamic file contents are therefore opt-in and single-target,
+ * while an unscoped grep searches only static VFS resources and metadata.
+ */
 export async function executeVfsGrep(
   params: Record<string, unknown>,
   context: ExecutionContext
@@ -152,16 +196,11 @@ export async function executeVfsGrep(
       context: (params.context as number) ?? 0,
     }
 
-    // Routing mirrors read/glob:
-    //  - uploads/<file>  -> grep one chat upload's content (chat-scoped)
-    //  - files/<file>    -> grep one workspace file's content (one file only)
-    //  - everything else -> grep the in-memory VFS map (workflow JSON, metadata)
-    // Chat uploads are opt-in like recently-deleted/: they are never in the VFS
-    // map, so an unscoped grep can't touch them — only an explicit uploads/<file>
-    // path does, and only one upload at a time.
     let result: GrepMatch[] | string[] | GrepCountEntry[]
     let provenanceFile: WorkspaceFileSecretProvenanceIdentity | undefined
-    if (isChatUploadGrepPath(rawPath)) {
+    if (rawPath !== undefined && isDocsPath(rawPath)) {
+      result = await grepDocs(rawPath, pattern, grepOptions, context.abortSignal)
+    } else if (isChatUploadGrepPath(rawPath)) {
       if (!context.chatId) {
         return { success: false, error: 'No chat context available for uploads/' }
       }
@@ -223,8 +262,8 @@ export async function executeVfsGrep(
   } catch (err) {
     // Expected single-file scoping / no-text / too-large conditions: surface the
     // message verbatim instead of logging an internal failure.
-    if (err instanceof WorkspaceFileGrepError) {
-      logger.debug('vfs_grep workspace file rejected', {
+    if (err instanceof WorkspaceFileGrepError || err instanceof DocsCorpusError) {
+      logger.debug('vfs_grep single-file scope rejected', {
         pattern,
         path: rawPath,
         error: err.message,
@@ -255,6 +294,12 @@ export async function executeVfsGlob(
   }
 
   try {
+    if (couldMatchDocsScope(pattern)) {
+      const files = globDocs(pattern)
+      logger.debug('vfs_glob docs result', { pattern, fileCount: files.length })
+      return { success: true, output: { files } }
+    }
+
     const vfs = await getGatedVFS(context)
     let files = vfs.glob(pattern)
 
@@ -267,6 +312,25 @@ export async function executeVfsGlob(
     }
 
     logger.debug('vfs_glob result', { pattern, fileCount: files.length })
+    // A bare [] on a namespace that is legitimately absent reads as "my glob is
+    // wrong". Say why it's empty so the model doesn't retry pattern variants.
+    if (files.length === 0) {
+      if (pattern.startsWith('uploads')) {
+        return {
+          success: true,
+          output: { files, note: 'This chat has no uploads.' },
+        }
+      }
+      if (pattern.startsWith('user-local')) {
+        return {
+          success: true,
+          output: {
+            files,
+            note: 'No user-local folder is granted in this chat, so user-local/ is empty.',
+          },
+        }
+      }
+    }
     return { success: true, output: { files } }
   } catch (err) {
     logger.error('vfs_glob failed', {
@@ -323,6 +387,34 @@ export async function executeVfsRead(
       }
     }
 
+    if (isDocsPath(path)) {
+      const page = await readDocsPage(path, context.abortSignal)
+      const windowed = applyWindow(page)
+      if (serializedResultSize(windowed) > TOOL_RESULT_MAX_INLINE_CHARS) {
+        if (offset !== undefined || limit !== undefined) {
+          return {
+            success: false,
+            error: `${path} is still too large over the requested window. Narrow offset/limit, or grep this page for the section you need.`,
+          }
+        }
+        const truncated = truncateDocsPageToInlineCap(page)
+        if (!truncated) {
+          return {
+            success: false,
+            error: `${path} is too large to return inline even truncated. Grep this page for the section you need.`,
+          }
+        }
+        logger.debug('vfs_read truncated oversized docs page', {
+          path,
+          totalLines: page.totalLines,
+          returnedLines: truncated.returnedLines,
+        })
+        return { success: true, output: truncated.output }
+      }
+      logger.debug('vfs_read resolved docs page', { path, totalLines: page.totalLines })
+      return { success: true, output: windowed }
+    }
+
     // Handle chat-scoped uploads via the uploads/ virtual prefix.
     // Uploads are flat and have no metadata/content split like files/ — the upload
     // IS the first path segment after uploads/. Any trailing segment (e.g. a
@@ -336,28 +428,29 @@ export async function executeVfsRead(
       const uploadResult = uploadEnvelope?.value
       if (uploadResult) {
         const isAttachment = hasModelAttachment(uploadResult)
-        if (
-          !isAttachment &&
-          (isOversizedReadPlaceholder(uploadResult) ||
-            serializedResultSize(uploadResult) > TOOL_RESULT_MAX_INLINE_CHARS)
-        ) {
+        if (!isAttachment && isOversizedReadPlaceholder(uploadResult)) {
+          // The loader refused to materialize the bytes at all; a window can't help.
+          return { success: false, error: uploadResult.content }
+        }
+        // Window BEFORE the inline-size gate, so offset/limit genuinely page a
+        // large upload instead of the gate rejecting the whole file first.
+        const windowedUpload = applyWindow(uploadResult)
+        if (!isAttachment && serializedResultSize(windowedUpload) > TOOL_RESULT_MAX_INLINE_CHARS) {
           logger.warn('Upload read result too large', {
             path,
             hasAttachment: isAttachment,
             contentLength: uploadResult.content.length,
-            serializedSize: serializedResultSize(uploadResult),
+            serializedSize: serializedResultSize(windowedUpload),
+            windowed: offset !== undefined || limit !== undefined,
           })
           return {
             success: false,
-            error: isOversizedReadPlaceholder(uploadResult)
-              ? uploadResult.content
-              : // Same as the workspace-file branch below: this size gate runs on
-                // the whole upload before any window, so "retry with offset/limit"
-                // would loop. Point at grep scoped to this path instead.
-                `Read result too large to return inline. Grep this single upload instead of reading it — grep({pattern: "...", path: "${path}"}) — because offset/limit do NOT shrink an upload read: the size check runs on the whole file before the window is applied.`,
+            error:
+              offset !== undefined || limit !== undefined
+                ? `The requested window is still too large to return inline. Reduce limit (fewer lines per page) — e.g. read({path: "${path}", offset: ${offset ?? 0}, limit: 200}).`
+                : `Read result too large to return inline. Page it — read({path: "${path}", offset: 0, limit: 500}) — or locate the relevant section first with grep({pattern: "...", path: "${path}"}).`,
           }
         }
-        const windowedUpload = applyWindow(uploadResult)
         const provenanceView =
           offset === undefined && limit === undefined
             ? (uploadEnvelope?.view ?? 'derived')
@@ -406,25 +499,33 @@ export async function executeVfsRead(
     const fileContent = fileEnvelope?.value
     if (fileContent) {
       const isAttachment = hasModelAttachment(fileContent)
+      if (!isAttachment && isOversizedReadPlaceholder(fileContent)) {
+        // The loader refused to materialize the bytes at all; a window can't help.
+        return { success: false, error: fileContent.content }
+      }
+      // Window BEFORE the inline-size gate, so offset/limit genuinely page a
+      // large file instead of the gate rejecting the whole file first — the
+      // paging advice in the error below has to actually work.
+      const windowedFileContent = applyWindow(fileContent)
       if (
         !isAttachment &&
-        (isOversizedReadPlaceholder(fileContent) ||
-          serializedResultSize(fileContent) > TOOL_RESULT_MAX_INLINE_CHARS)
+        serializedResultSize(windowedFileContent) > TOOL_RESULT_MAX_INLINE_CHARS
       ) {
         logger.warn('File read result too large', {
           path,
           hasAttachment: isAttachment,
           contentLength: fileContent.content.length,
-          serializedSize: serializedResultSize(fileContent),
+          serializedSize: serializedResultSize(windowedFileContent),
+          windowed: offset !== undefined || limit !== undefined,
         })
         return {
           success: false,
-          error: isOversizedReadPlaceholder(fileContent)
-            ? fileContent.content
-            : 'Read result too large to return inline. Use grep with a more specific pattern or narrower path to locate the relevant section, then retry read with offset/limit. Avoid catch-all greps or full-file reads because they waste context window.',
+          error:
+            offset !== undefined || limit !== undefined
+              ? `The requested window is still too large to return inline. Reduce limit (fewer lines per page) — e.g. read({path: "${path}", offset: ${offset ?? 0}, limit: 200}).`
+              : `Read result too large to return inline. Page it — read({path: "${path}", offset: 0, limit: 500}) — or locate the relevant section first with grep({pattern: "...", path: "${path}"}), then read({path: "${path}", offset: <line>, limit: <lines>}). Avoid catch-all greps or full-file reads because they waste context window.`,
         }
       }
-      const windowedFileContent = applyWindow(fileContent)
       const provenanceView =
         offset === undefined && limit === undefined ? (fileEnvelope?.view ?? 'derived') : 'derived'
       if (
@@ -454,11 +555,30 @@ export async function executeVfsRead(
       })
       return {
         success: true,
-        output: windowedFileContent,
+        output:
+          fileContent.content === '' && !isAttachment
+            ? // An empty string with no explanation reads as a failed read.
+              { ...windowedFileContent, note: 'File is empty (0 bytes).' }
+            : windowedFileContent,
       }
     }
 
-    const result = await vfs.read(path, offset, limit)
+    let resolvedReadPath = path
+    let result = await vfs.read(path, offset, limit)
+    if (!result) {
+      // Same name, wrong encoding (spaces instead of %20) is the most common
+      // path mistake and carries zero ambiguity — resolve it instead of
+      // bouncing the model through a not-found round-trip.
+      const decodedEquivalent = vfs.resolveDecodedEquivalent(path)
+      if (decodedEquivalent) {
+        logger.info('vfs_read resolved decoded-equivalent path', {
+          requested: path,
+          resolved: decodedEquivalent,
+        })
+        resolvedReadPath = decodedEquivalent
+        result = await vfs.read(decodedEquivalent, offset, limit)
+      }
+    }
     if (!result) {
       const suggestions = vfs.suggestSimilar(path)
       logger.warn('vfs_read file not found', { path, suggestions })
@@ -476,7 +596,9 @@ export async function executeVfsRead(
       return {
         success: false,
         error:
-          'Read result too large to return inline. Use grep with a more specific pattern or narrower path to locate the relevant section, then retry read with offset/limit. Avoid catch-all greps or full-file reads because they waste context window.',
+          offset !== undefined || limit !== undefined
+            ? `The requested window is still too large to return inline. Reduce limit (fewer lines per page) — e.g. read({path: "${path}", offset: ${offset ?? 0}, limit: 200}).`
+            : 'Read result too large to return inline. Page it with read({path, offset, limit}), or use grep with a more specific pattern to locate the relevant section first. Avoid catch-all greps or full-file reads because they waste context window.',
       }
     }
     logger.debug('vfs_read result', { path, totalLines: result.totalLines, offset, limit })
@@ -485,6 +607,10 @@ export async function executeVfsRead(
       output: result,
     }
   } catch (err) {
+    if (err instanceof DocsCorpusError) {
+      logger.debug('vfs_read docs page rejected', { path, error: err.message })
+      return { success: false, error: err.message }
+    }
     logger.error('vfs_read failed', {
       path,
       error: toError(err).message,
diff --git a/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts b/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
index 0769954cad..ee40745010 100644
--- a/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/mutations.ts
@@ -102,6 +102,16 @@ function copilotRunLifecycle(context: ExecutionContext) {
     billingAttribution: context.billingAttribution,
     resolvedSecretTraceRegistry: context.resolvedSecretTraceRegistry,
     abortSignal: context.abortSignal,
+    // Present only when the request handler already claimed an execution id for
+    // this tool call because it is running the workflow server-side.
+    ...(context.boundWorkflowExecutionId && context.toolCallId
+      ? {
+          boundExecution: {
+            executionId: context.boundWorkflowExecutionId,
+            copilotToolCallId: context.toolCallId,
+          },
+        }
+      : {}),
   }
 }
 
diff --git a/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts b/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts
index f8f33c8289..54d47e30f2 100644
--- a/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/queries.test.ts
@@ -12,7 +12,7 @@ vi.mock('@/lib/copilot/application/execute-workflow-use-case', () => ({
     getErrorMessage(error, 'Workflow operation failed'),
 }))
 
-import { executeGetBlockOutputs } from './queries'
+import { executeGetBlockOutputs } from '@/lib/copilot/tools/handlers/workflow/queries'
 
 describe('executeGetBlockOutputs', () => {
   beforeEach(() => {
diff --git a/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts b/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
index 8861dbc98d..2129fc747b 100644
--- a/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
+++ b/apps/sim/lib/copilot/tools/handlers/workflow/queries.ts
@@ -1,5 +1,4 @@
 import { createLogger } from '@sim/logger'
-import { messageForCopilotApplicationError } from '@/lib/copilot/application/error'
 import { executeCopilotCustomToolUseCase } from '@/lib/copilot/application/execute-custom-tool-use-case'
 import { executeCopilotFileUseCase } from '@/lib/copilot/application/execute-file-use-case'
 import { executeCopilotMcpServerUseCase } from '@/lib/copilot/application/execute-mcp-server-use-case'
@@ -18,7 +17,6 @@ import {
 } from '@/lib/workflows/application/read-workflow-copilot-metadata'
 import { readWorkflowDefinition } from '@/lib/workflows/application/read-workflow-definition'
 import { listAllWorkspaceFiles } from '@/lib/workspace-files/application/list-workspace-files'
-import { listUserWorkspaces } from '@/lib/workspaces/utils'
 import type { Loop, Parallel } from '@/stores/workflows/workflow/types'
 import type {
   GetBlockOutputsParams,
@@ -30,22 +28,6 @@ import type {
 
 const logger = createLogger('WorkflowQueries')
 
-export async function executeListUserWorkspaces(
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  try {
-    const workspaces = await listUserWorkspaces(context.userId)
-
-    return { success: true, output: { workspaces } }
-  } catch (error) {
-    logger.error('Failed to list user workspaces for Copilot', { error })
-    return {
-      success: false,
-      error: messageForCopilotApplicationError(error, 'Failed to list workspaces'),
-    }
-  }
-}
-
 export async function executeGetWorkflowRunOptions(
   params: GetWorkflowRunOptionsParams,
   context: ExecutionContext
diff --git a/apps/sim/lib/copilot/tools/permissions.test.ts b/apps/sim/lib/copilot/tools/permissions.test.ts
index a15ee1f791..3edfc033df 100644
--- a/apps/sim/lib/copilot/tools/permissions.test.ts
+++ b/apps/sim/lib/copilot/tools/permissions.test.ts
@@ -34,8 +34,8 @@ describe('copilotWriteDeniedMessage', () => {
   })
 
   it('omits the operation label when there is no operation', () => {
-    expect(copilotWriteDeniedMessage('knowledge_base', undefined, 'read')).toBe(
-      "Permission denied: knowledge_base requires write access. You have 'read' permission."
+    expect(copilotWriteDeniedMessage('manage_knowledge_base', undefined, 'read')).toBe(
+      "Permission denied: manage_knowledge_base requires write access. You have 'read' permission."
     )
   })
 })
diff --git a/apps/sim/lib/copilot/tools/registry/server-tool-adapter.test.ts b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.test.ts
index 0f574e5611..f65a8b2ab7 100644
--- a/apps/sim/lib/copilot/tools/registry/server-tool-adapter.test.ts
+++ b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.test.ts
@@ -24,7 +24,7 @@ describe('server tool adapter authority boundary', () => {
   })
 
   it('overwrites model-supplied workspace scope and forwards trusted delegation context', async () => {
-    const handler = createServerToolHandler('workspace_file')
+    const handler = createServerToolHandler('prepare_file_edit')
 
     await handler(
       { workspaceId: 'attacker-workspace', operation: 'rename' },
@@ -39,7 +39,7 @@ describe('server tool adapter authority boundary', () => {
     )
 
     expect(mocks.routeExecution).toHaveBeenCalledWith(
-      'workspace_file',
+      'prepare_file_edit',
       expect.objectContaining({ workspaceId: 'workspace-1', operation: 'rename' }),
       expect.objectContaining({
         userId: 'user-1',
@@ -55,7 +55,7 @@ describe('server tool adapter authority boundary', () => {
     const storageError = new Error('update workspace_files set secret_column = value')
     mocks.routeExecution.mockRejectedValue(storageError)
 
-    const result = await createServerToolHandler('workspace_file')(
+    const result = await createServerToolHandler('prepare_file_edit')(
       {},
       {
         userId: 'user-1',
@@ -68,13 +68,13 @@ describe('server tool adapter authority boundary', () => {
 
     expect(result).toEqual({
       success: false,
-      error: `[workspace_file] ${TOOL_RESULT_UNAVAILABLE_ERROR}`,
+      error: `[prepare_file_edit] ${TOOL_RESULT_UNAVAILABLE_ERROR}`,
     })
     expect(result.error).not.toContain('workspace_files')
     expect(mocks.loggerError).toHaveBeenCalledWith(
       'Server tool execution failed',
       {
-        toolId: 'workspace_file',
+        toolId: 'prepare_file_edit',
         abortSignalAborted: false,
       },
       storageError
diff --git a/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
index b853e6ae49..a8cd970fba 100644
--- a/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
+++ b/apps/sim/lib/copilot/tools/registry/server-tool-adapter.ts
@@ -42,6 +42,8 @@ export function createServerToolHandler(toolId: string): ToolHandler {
       return { success: true, output: result }
     } catch (error) {
       const caughtError = toError(error)
+      // The generic projection below records the swallowed cause on the active
+      // span itself (messageForCopilotApplicationError) so Tempo carries it.
       logger.error(
         'Server tool execution failed',
         {
@@ -52,7 +54,8 @@ export function createServerToolHandler(toolId: string): ToolHandler {
       )
       const safeMessage = projectToolErrorMessageForCopilot(
         messageForCopilotApplicationError(error),
-        context.resolvedSecretTraceRegistry
+        context.resolvedSecretTraceRegistry,
+        toolId
       )
       return {
         success: false,
diff --git a/apps/sim/lib/copilot/tools/retired-tools.ts b/apps/sim/lib/copilot/tools/retired-tools.ts
new file mode 100644
index 0000000000..97790d4c43
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/retired-tools.ts
@@ -0,0 +1,19 @@
+/**
+ * Ids of tools that no longer exist in the catalog but still appear in
+ * persisted chat history.
+ *
+ * A retired tool stops being generated into `tool-catalog-v1`, so any render
+ * path that referenced its generated constant would fail to compile — and
+ * deleting those paths instead would silently downgrade every historical
+ * transcript that contains one. These literals keep replay intact without
+ * implying the tool is callable: nothing dispatches them, and no agent is
+ * offered them.
+ */
+
+/**
+ * Retired with the browser takeover flow. The browser panel is live and shared
+ * — the user can act in it whenever they want — so there was never anything to
+ * hand over, and the agent no longer has a concept of taking or returning
+ * control. Chats from before the removal still contain takeover cards.
+ */
+export const RETIRED_BROWSER_REQUEST_TAKEOVER_ID = 'browser_request_takeover'
diff --git a/apps/sim/lib/copilot/tools/server/base-tool.ts b/apps/sim/lib/copilot/tools/server/base-tool.ts
index 2af97ba749..b4081e340a 100644
--- a/apps/sim/lib/copilot/tools/server/base-tool.ts
+++ b/apps/sim/lib/copilot/tools/server/base-tool.ts
@@ -16,7 +16,7 @@ export interface ServerToolContext {
   messageId?: string
   /**
    * The invoking subagent's channel id (its outer tool_use id). Used to scope
-   * the workspace_file -> edit_content intent handoff to a single file subagent
+   * the prepare_file_edit -> apply_file_edit intent handoff to a single file subagent
    * so two file agents writing concurrently never consume each other's pending
    * intent. Undefined for main-agent tool calls (which never overlap).
    */
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-docs-dispatch.test.ts b/apps/sim/lib/copilot/tools/server/docs/search-docs-dispatch.test.ts
new file mode 100644
index 0000000000..3634648b5b
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/docs/search-docs-dispatch.test.ts
@@ -0,0 +1,39 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { TOOL_CATALOG } from '@/lib/copilot/generated/tool-catalog-v1'
+import { isKnownTool, isSimExecuted } from '@/lib/copilot/tool-executor/router'
+import { getHiddenToolNames } from '@/lib/copilot/tools/client/hidden-tools'
+import { getRegisteredServerToolNames } from '@/lib/copilot/tools/server/router'
+
+/**
+ * `executeTool` gates on `isKnownTool` (catalog membership) before it ever
+ * consults the handler registry, so a sim-routed tool needs every link of this
+ * chain or dispatch rejects it before the handler is reached. These assertions
+ * pin that chain for search_docs.
+ */
+describe('search_docs dispatch chain', () => {
+  it('is in the catalog, so dispatch does not reject it as unknown', () => {
+    expect(isKnownTool('search_docs')).toBe(true)
+  })
+
+  it('routes to sim, so dispatch reaches the server tool registry', () => {
+    expect(isSimExecuted('search_docs')).toBe(true)
+  })
+
+  it('has a registered server handler', () => {
+    expect(getRegisteredServerToolNames()).toContain('search_docs')
+  })
+})
+
+describe('removed docs-tool ids', () => {
+  for (const removed of ['search_documentation', 'get_platform_actions']) {
+    it(`${removed} is absent from the catalog, registries, and hidden-tool set`, () => {
+      expect(TOOL_CATALOG[removed]).toBeUndefined()
+      expect(isKnownTool(removed)).toBe(false)
+      expect(getRegisteredServerToolNames()).not.toContain(removed)
+      expect(getHiddenToolNames().has(removed)).toBe(false)
+    })
+  }
+})
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-docs.test.ts b/apps/sim/lib/copilot/tools/server/docs/search-docs.test.ts
new file mode 100644
index 0000000000..1b01c4c8dd
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/docs/search-docs.test.ts
@@ -0,0 +1,152 @@
+/**
+ * @vitest-environment node
+ */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { DocsSearchOutcome } from '@/lib/copilot/docs/docs-search'
+import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
+
+const { mockSearchDocs } = vi.hoisted(() => ({
+  mockSearchDocs: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/docs/docs-search', () => ({
+  searchDocs: mockSearchDocs,
+}))
+
+import { searchDocsServerTool } from '@/lib/copilot/tools/server/docs/search-docs'
+
+function outcome(overrides: Partial<DocsSearchOutcome>): DocsSearchOutcome {
+  return {
+    results: [],
+    candidatesConsidered: 0,
+    droppedBelowThreshold: 0,
+    droppedStale: 0,
+    ...overrides,
+  }
+}
+
+const RESULT = {
+  path: 'docs/agents.mdx',
+  url: 'https://docs.sim.ai/agents',
+  title: 'Agents',
+  content: 'body',
+  similarity: 0.9,
+}
+
+const CONTEXT = {
+  userId: 'user-1',
+  resolvedSecretTraceRegistry: new ResolvedSecretTraceRegistry(),
+}
+
+describe('searchDocsServerTool', () => {
+  beforeEach(() => {
+    mockSearchDocs.mockReset()
+  })
+
+  it('forwards query, path, and topK to the search layer', async () => {
+    mockSearchDocs.mockResolvedValue(outcome({ results: [RESULT], candidatesConsidered: 1 }))
+
+    const output = await searchDocsServerTool.execute(
+      {
+        query: 'how do agents work',
+        path: 'docs/agents.mdx',
+        topK: 7,
+      },
+      CONTEXT
+    )
+
+    expect(mockSearchDocs).toHaveBeenCalledWith('how do agents work', {
+      path: 'docs/agents.mdx',
+      topK: 7,
+    })
+    expect(output).toEqual({
+      results: [RESULT],
+      query: 'how do agents work',
+      totalResults: 1,
+    })
+  })
+
+  it('omits the note when nothing was dropped', async () => {
+    mockSearchDocs.mockResolvedValue(outcome({ results: [RESULT], candidatesConsidered: 1 }))
+
+    const output = await searchDocsServerTool.execute({ query: 'q' }, CONTEXT)
+
+    expect(output.note).toBeUndefined()
+  })
+
+  it('explains when the index returns no candidates', async () => {
+    mockSearchDocs.mockResolvedValue(outcome({}))
+
+    const output = await searchDocsServerTool.execute({ query: 'brand new feature' }, CONTEXT)
+
+    expect(output.note).toContain('search index may lag')
+    expect(output.note).toContain('read it directly')
+    expect(output.note).toContain('glob("docs/**")')
+  })
+
+  it('explains an empty result set caused by filtering, so it does not read as missing docs', async () => {
+    mockSearchDocs.mockResolvedValue(
+      outcome({ candidatesConsidered: 2, droppedBelowThreshold: 1, droppedStale: 1 })
+    )
+
+    const output = await searchDocsServerTool.execute({ query: 'q' }, CONTEXT)
+
+    expect(output.note).toContain('does NOT mean the docs lack this topic')
+    expect(output.note).toContain('1 scored too low')
+    expect(output.note).toContain('1 point at pages no longer in the docs')
+  })
+
+  it('notes threshold-only drops on a partial result set', async () => {
+    mockSearchDocs.mockResolvedValue(
+      outcome({ results: [RESULT], candidatesConsidered: 3, droppedBelowThreshold: 2 })
+    )
+
+    const output = await searchDocsServerTool.execute({ query: 'q' }, CONTEXT)
+
+    expect(output.note).toContain('Returned 1 of 3 candidate(s)')
+    expect(output.note).toContain('2 scored too low')
+    expect(output.note).not.toContain('no longer in the docs')
+  })
+
+  it('notes stale-only drops on a partial result set', async () => {
+    mockSearchDocs.mockResolvedValue(
+      outcome({ results: [RESULT], candidatesConsidered: 2, droppedStale: 1 })
+    )
+
+    const output = await searchDocsServerTool.execute({ query: 'q' }, CONTEXT)
+
+    expect(output.note).toContain('1 point at pages no longer in the docs')
+    expect(output.note).not.toContain('scored too low')
+  })
+
+  it('projects resolved secrets before embedding or returning the query', async () => {
+    const registry = new ResolvedSecretTraceRegistry([
+      {
+        name: 'DOCS_QUERY',
+        plaintext: 'private docs query',
+        encryptedValue: 'ciphertext',
+      },
+    ])
+    registry.recordResolved('DOCS_QUERY', 'private docs query')
+    mockSearchDocs.mockResolvedValue(outcome({ results: [RESULT], candidatesConsidered: 1 }))
+
+    const output = await searchDocsServerTool.execute(
+      { query: 'private docs query' },
+      { userId: 'user-1', resolvedSecretTraceRegistry: registry }
+    )
+
+    expect(mockSearchDocs).toHaveBeenCalledWith('{{DOCS_QUERY}}', {
+      path: undefined,
+      topK: undefined,
+    })
+    expect(output.query).toBe('{{DOCS_QUERY}}')
+    expect(JSON.stringify(output)).not.toContain('private docs query')
+  })
+
+  it('fails closed when secret provenance is unavailable', async () => {
+    await expect(searchDocsServerTool.execute({ query: 'query' })).rejects.toThrow(
+      'Docs search query could not be processed safely'
+    )
+    expect(mockSearchDocs).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-docs.ts b/apps/sim/lib/copilot/tools/server/docs/search-docs.ts
new file mode 100644
index 0000000000..7603bc9e6b
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/docs/search-docs.ts
@@ -0,0 +1,79 @@
+import type { DocsSearchResult } from '@/lib/copilot/docs/docs-search'
+import { searchDocs } from '@/lib/copilot/docs/docs-search'
+import { SearchDocs } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import { ServerToolModelInputError } from '@/lib/copilot/tools/server/model-input'
+import { projectResolvedSecretModelContent } from '@/executor/utils/resolved-secret-content-projection'
+
+interface SearchDocsParams {
+  query: string
+  topK?: number
+  path?: string
+}
+
+interface SearchDocsOutput {
+  results: DocsSearchResult[]
+  query: string
+  totalResults: number
+  /**
+   * Present only when the vector search matched chunks that were then filtered
+   * out. Without it an empty result set reads as "the docs do not cover this",
+   * which sends the caller off to guess instead of rephrasing or falling back
+   * to glob.
+   */
+  note?: string
+}
+
+/**
+ * Explain a short or empty result set in terms the caller can act on. Returns
+ * undefined when nothing was dropped — the common case needs no commentary.
+ */
+function shortfallNote(outcome: Awaited<ReturnType<typeof searchDocs>>): string | undefined {
+  const { results, candidatesConsidered, droppedBelowThreshold, droppedStale } = outcome
+  if (results.length === 0 && candidatesConsidered === 0) {
+    return 'No indexed candidates were returned. The search index may lag the live docs. If you know the page, read it directly; otherwise use glob("docs/**") to find the current path.'
+  }
+  if (droppedBelowThreshold === 0 && droppedStale === 0) return undefined
+
+  const reasons: string[] = []
+  if (droppedBelowThreshold > 0)
+    reasons.push(`${droppedBelowThreshold} scored too low to be relevant`)
+  if (droppedStale > 0) {
+    reasons.push(
+      `${droppedStale} point at pages no longer in the docs (the search index lags the site)`
+    )
+  }
+  const dropped = reasons.join(' and ')
+
+  return results.length === 0
+    ? `No relevant matches. The search index returned ${candidatesConsidered} candidate(s), but ${dropped} — this does NOT mean the docs lack this topic. Rephrase the query, widen it by dropping the path scope, or browse with glob("docs/**").`
+    : `Returned ${results.length} of ${candidatesConsidered} candidate(s); ${dropped}. Rephrase or widen the query if these look off-topic.`
+}
+
+/**
+ * Vector search over Sim's product documentation, scoped to the same pages the
+ * agent can `read` from the `docs/` VFS tree. Normal delegation exposes it to
+ * the platform agent; the `@Docs` compatibility path also invokes it directly.
+ * Corpus logic lives in `@/lib/copilot/docs/docs-search`.
+ */
+export const searchDocsServerTool: BaseServerTool<SearchDocsParams, SearchDocsOutput> = {
+  name: SearchDocs.id,
+  async execute(params: SearchDocsParams, context?: ServerToolContext): Promise<SearchDocsOutput> {
+    const queryProjection = projectResolvedSecretModelContent(
+      params.query,
+      context?.resolvedSecretTraceRegistry
+    )
+    if (!queryProjection.safe || typeof queryProjection.value !== 'string') {
+      throw new ServerToolModelInputError('Docs search query could not be processed safely')
+    }
+    const query = queryProjection.value
+    const outcome = await searchDocs(query, { path: params.path, topK: params.topK })
+    const note = shortfallNote(outcome)
+    return {
+      results: outcome.results,
+      query,
+      totalResults: outcome.results.length,
+      ...(note ? { note } : {}),
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-documentation.test.ts b/apps/sim/lib/copilot/tools/server/docs/search-documentation.test.ts
deleted file mode 100644
index 14693f7591..0000000000
--- a/apps/sim/lib/copilot/tools/server/docs/search-documentation.test.ts
+++ /dev/null
@@ -1,56 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { loggerMock } from '@sim/testing'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-const { mockGenerateSearchEmbedding } = vi.hoisted(() => ({
-  mockGenerateSearchEmbedding: vi.fn(),
-}))
-
-vi.mock('@/lib/copilot/generated/tool-catalog-v1', () => ({
-  SearchDocumentation: { id: 'search_documentation' },
-}))
-vi.mock('@/lib/knowledge/embeddings', () => ({
-  generateSearchEmbedding: mockGenerateSearchEmbedding,
-}))
-
-import { searchDocumentationServerTool } from '@/lib/copilot/tools/server/docs/search-documentation'
-import { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
-
-describe('documentation search model boundary', () => {
-  beforeEach(() => {
-    vi.clearAllMocks()
-    mockGenerateSearchEmbedding.mockResolvedValue({ embedding: [], isBYOK: false })
-  })
-
-  it('preserves a query that merely collides with ambient secret plaintext', async () => {
-    const registry = new ResolvedSecretTraceRegistry([
-      {
-        name: 'DOCS_QUERY',
-        plaintext: 'private documentation query',
-        encryptedValue: 'encrypted-query',
-      },
-    ])
-    registry.recordResolved('DOCS_QUERY', 'private documentation query')
-
-    const result = await searchDocumentationServerTool.execute(
-      { query: 'private documentation query' },
-      { userId: 'user-1', resolvedSecretTraceRegistry: registry }
-    )
-
-    expect(mockGenerateSearchEmbedding).toHaveBeenCalledWith('private documentation query')
-    expect(result).toEqual({
-      results: [],
-      query: 'private documentation query',
-      totalResults: 0,
-    })
-
-    const logger = loggerMock.createLogger.mock.results.at(-1)?.value
-    expect(logger?.info).toHaveBeenCalledWith('Executing docs search', {
-      queryLength: 'private documentation query'.length,
-      topK: 10,
-    })
-    expect(JSON.stringify(logger?.info.mock.calls)).not.toContain('private documentation query')
-  })
-})
diff --git a/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts b/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
deleted file mode 100644
index ad14c3937a..0000000000
--- a/apps/sim/lib/copilot/tools/server/docs/search-documentation.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { db } from '@sim/db'
-import { docsEmbeddings } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { sql } from 'drizzle-orm'
-import { SearchDocumentation } from '@/lib/copilot/generated/tool-catalog-v1'
-import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
-import { generateSearchEmbedding } from '@/lib/knowledge/embeddings'
-
-interface DocsSearchParams {
-  query: string
-  topK?: number
-  threshold?: number
-}
-
-const DEFAULT_DOCS_SIMILARITY_THRESHOLD = 0.3
-
-export const searchDocumentationServerTool: BaseServerTool<DocsSearchParams, any> = {
-  name: SearchDocumentation.id,
-  async execute(params: DocsSearchParams): Promise<any> {
-    const logger = createLogger('SearchDocumentationServerTool')
-    const { query, topK = 10, threshold } = params
-    if (!query || typeof query !== 'string') throw new Error('query is required')
-
-    logger.info('Executing docs search', { queryLength: query.length, topK })
-
-    const similarityThreshold = threshold ?? DEFAULT_DOCS_SIMILARITY_THRESHOLD
-
-    const modelQuery = query
-    const { embedding: queryEmbedding } = await generateSearchEmbedding(modelQuery)
-    if (!queryEmbedding || queryEmbedding.length === 0) {
-      return { results: [], query, totalResults: 0 }
-    }
-
-    const results = await db
-      .select({
-        chunkId: docsEmbeddings.chunkId,
-        chunkText: docsEmbeddings.chunkText,
-        sourceDocument: docsEmbeddings.sourceDocument,
-        sourceLink: docsEmbeddings.sourceLink,
-        headerText: docsEmbeddings.headerText,
-        headerLevel: docsEmbeddings.headerLevel,
-        similarity: sql<number>`1 - (${docsEmbeddings.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector)`,
-      })
-      .from(docsEmbeddings)
-      .orderBy(sql`${docsEmbeddings.embedding} <=> ${JSON.stringify(queryEmbedding)}::vector`)
-      .limit(topK)
-
-    const filteredResults = results.filter((r) => r.similarity >= similarityThreshold)
-    const documentationResults = filteredResults.map((r, idx) => ({
-      id: idx + 1,
-      title: String(r.headerText || 'Untitled Section'),
-      url: String(r.sourceLink || '#'),
-      content: String(r.chunkText || ''),
-      similarity: r.similarity,
-    }))
-
-    logger.info('Docs search complete', { count: documentationResults.length })
-    return { results: documentationResults, query, totalResults: documentationResults.length }
-  },
-}
diff --git a/apps/sim/lib/copilot/tools/server/enrichment/enrichment-run.ts b/apps/sim/lib/copilot/tools/server/enrichment/enrichment-run.ts
index bde0e4873b..8b7a2a3d7e 100644
--- a/apps/sim/lib/copilot/tools/server/enrichment/enrichment-run.ts
+++ b/apps/sim/lib/copilot/tools/server/enrichment/enrichment-run.ts
@@ -1,5 +1,5 @@
 import { createLogger } from '@sim/logger'
-import { EnrichmentRun } from '@/lib/copilot/generated/tool-catalog-v1'
+import { RunEnrichment } from '@/lib/copilot/generated/tool-catalog-v1'
 import type { BaseServerTool } from '@/lib/copilot/tools/server/base-tool'
 import { getEnrichment } from '@/enrichments/registry'
 import { runEnrichment } from '@/enrichments/run'
@@ -25,7 +25,7 @@ interface EnrichmentRunResult {
  * bill (see image/generate-image.ts).
  */
 export const enrichmentRunServerTool: BaseServerTool<EnrichmentRunParams, EnrichmentRunResult> = {
-  name: EnrichmentRun.id,
+  name: RunEnrichment.id,
   async execute(params: EnrichmentRunParams, context): Promise<EnrichmentRunResult> {
     const logger = createLogger('EnrichmentRunServerTool')
     const { enrichmentId, inputs } = params
diff --git a/apps/sim/lib/copilot/tools/server/env-reference.ts b/apps/sim/lib/copilot/tools/server/env-reference.ts
new file mode 100644
index 0000000000..e2339a22ab
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/env-reference.ts
@@ -0,0 +1,39 @@
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
+import type { ResolvedSecretTraceRegistry } from '@/executor/utils/resolved-secret-trace-registry'
+
+/**
+ * Resolves a whole-value `{{ENV_VAR}}` reference in a secret-bearing tool arg.
+ *
+ * Copilot agents never see secret values — the workspace exposes variable
+ * NAMES only — so when a user says "use the password in CHAT_PW" the model
+ * passes `{{CHAT_PW}}`. Without resolution the literal seven-character
+ * placeholder becomes the stored secret and nothing ever errors. Only the
+ * explicit braced form resolves here: unlike API keys, passwords are
+ * free-form strings, so `$NAME`/bare-name heuristics would corrupt real ones.
+ *
+ * Returns an error when the referenced variable is unset so the model learns
+ * the actual fix instead of silently storing the placeholder.
+ */
+export async function resolveEnvReferenceSecretArg(args: {
+  userId: string
+  workspaceId?: string
+  value: string | undefined
+  argName: string
+  registry?: ResolvedSecretTraceRegistry
+}): Promise<{ value?: string; error?: string }> {
+  const { value } = args
+  if (!value) return { value }
+  const braced = value.match(/^\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}$/)
+  if (!braced) return { value }
+  const name = braced[1]
+  const env = await getEffectiveDecryptedEnv(args.userId, args.workspaceId)
+  const resolved = env[name]
+  if (resolved === undefined || resolved === '') {
+    return {
+      error: `Environment variable "${name}" referenced by ${args.argName} is not set for this workspace or user. Set it first, or pass the raw value.`,
+    }
+  }
+  // Activate on the call's egress registry so an accidental echo is redacted.
+  args.registry?.recordResolved(name, resolved)
+  return { value: resolved }
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/create-file.ts b/apps/sim/lib/copilot/tools/server/files/create-file.ts
index 430545f8b0..a09bdccf57 100644
--- a/apps/sim/lib/copilot/tools/server/files/create-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/create-file.ts
@@ -7,13 +7,16 @@ import {
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
 import { inferContentType } from '@/lib/copilot/tools/server/files/workspace-file'
+import { asOrchestrationError } from '@/lib/core/orchestration/types'
+import { EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE } from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
 import {
   createWorkspaceFileByPath,
   updateWorkspaceFileContentByPath,
 } from '@/lib/workspace-files/application/write-workspace-file-by-path'
+import { SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
 
 const logger = createLogger('CreateFileServerTool')
-const CREATE_FILE_TOOL_ID = 'create_file'
+const CREATE_FILE_TOOL_ID = 'create_empty_file'
 
 interface CreateFileArgs {
   fileName: string
@@ -48,36 +51,64 @@ export const createFileServerTool: BaseServerTool<CreateFileArgs, CreateFileResu
     const explicitType = params.contentType || (nested?.contentType as string) || undefined
     const outputFile = params.outputs?.files?.[0]
     if (!outputFile?.path && !fileName) {
-      return { success: false, message: 'create_file requires outputs.files[0].path or fileName' }
+      return {
+        success: false,
+        message: 'create_empty_file requires outputs.files[0].path or fileName',
+      }
     }
     const outputPath =
       outputFile?.path ?? (fileName.startsWith('files/') ? fileName : `files/${fileName}`)
+    // .html defaults to plain text/html; a file is a Sim page only when the
+    // model DECLARES it (the skill passes contentType text/x-sim-page at
+    // creation) — or when the first apply_file_edit finds actual page
+    // source, which re-stamps the record from reality either way.
     const contentType = outputFile?.mimeType ?? inferContentType(outputPath, explicitType)
+    // A Sim page's stored name drops the .html the agent signals format with:
+    // the record type carries the format, every surface then shows the bare
+    // name with the plain file icon, and downloads re-append the extension.
+    const storedPath =
+      contentType === SIM_PAGE_CONTENT_TYPE ? outputPath.replace(/\.html?$/i, '') : outputPath
     assertServerToolNotAborted(context)
     const mode = outputFile?.mode ?? 'create'
+    // An empty shell provably contains no secrets; recording that keeps the
+    // file model-readable (an absent sidecar reads as "unknown" and gates
+    // every later content view of the file).
+    const emptyProvenance = EXACT_EMPTY_WORKSPACE_FILE_SECRET_PROVENANCE
+    const createShell = () =>
+      executeCopilotFileUseCase(context, createWorkspaceFileByPath, {
+        workspaceId,
+        path: storedPath,
+        mode: 'create',
+        content: '',
+        encoding: 'utf-8',
+        contentType,
+        exactName: true,
+        secretProvenance: emptyProvenance,
+      })
     try {
-      const result =
-        mode === 'overwrite'
-          ? await executeCopilotFileUseCase(context, updateWorkspaceFileContentByPath, {
-              workspaceId,
-              path: outputPath,
-              mode,
-              content: '',
-              encoding: 'utf-8',
-              contentType,
-              syncLiveDoc: false,
-            })
-          : await executeCopilotFileUseCase(context, createWorkspaceFileByPath, {
-              workspaceId,
-              path: outputPath,
-              mode,
-              content: '',
-              encoding: 'utf-8',
-              contentType,
-              exactName: true,
-            })
+      let result
+      if (mode === 'overwrite') {
+        try {
+          result = await executeCopilotFileUseCase(context, updateWorkspaceFileContentByPath, {
+            workspaceId,
+            path: storedPath,
+            mode,
+            content: '',
+            encoding: 'utf-8',
+            contentType,
+            syncLiveDoc: false,
+            secretProvenance: emptyProvenance,
+          })
+        } catch (overwriteError) {
+          // Upsert: overwrite of a missing path falls through to create.
+          if (asOrchestrationError(overwriteError)?.code !== 'not_found') throw overwriteError
+          result = await createShell()
+        }
+      } else {
+        result = await createShell()
+      }
 
-      logger.info('File created via create_file', {
+      logger.info('File created via create_empty_file', {
         fileId: result.id,
         name: result.vfsPath,
         contentType,
diff --git a/apps/sim/lib/copilot/tools/server/files/doc-asset-extract-pdf.ts b/apps/sim/lib/copilot/tools/server/files/doc-asset-extract-pdf.ts
new file mode 100644
index 0000000000..dc2000a2fd
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/doc-asset-extract-pdf.ts
@@ -0,0 +1,477 @@
+import { CodeLanguage } from '@/lib/execution/languages'
+import { executeInSandbox } from '@/lib/execution/remote-sandbox'
+
+const EXTRACT_TIMEOUT_MS = 180_000
+
+/**
+ * PDF asset extraction runs in the doc sandbox — the same vetted image that
+ * compiles and renders documents — because the PDF toolchain lives there:
+ * poppler's `pdfimages` dumps every embedded image in its native format,
+ * pdfplumber supplies each image's placement rects in page points plus the
+ * document's font families, and pdftoppm+Pillow sample a dominant-color
+ * palette from rendered pages.
+ *
+ * A transparent image in a PDF is stored as an opaque base image plus a
+ * separate alpha mask (`/SMask`), so the base alone carries a baked-in solid
+ * background. The script pairs each mask with its base via `pdfimages -list`
+ * row adjacency and recomposites them into an RGBA PNG; masks are never
+ * shipped as standalone assets.
+ *
+ * Assets are shipped at presentation resolution: print-dpi originals are
+ * downscaled to a 2560px long edge (alpha preserved) and exotic formats
+ * (TIFF/JP2) are normalized to PNG/JPEG, so the extracted set stays inside
+ * the doc-compile staging budget and re-stages fast on every slide edit.
+ * Images already within range keep their original bytes.
+ *
+ * Unlike OOXML there is no declared theme in a PDF, so the palette is
+ * explicitly labeled inferred; fonts are names only (embedded font files are
+ * subsetted and license-restricted).
+ */
+
+export interface PdfImagePlacement {
+  page: number
+  xPt: number
+  yPt: number
+  wPt: number
+  hPt: number
+}
+
+export interface ExtractedPdfTheme {
+  format: 'pdf'
+  /** Font family names used in the document (style suffixes split off). */
+  fonts: string[]
+  pageSize?: { widthPt: number; heightPt: number }
+  pageCount: number
+  /** Dominant colors sampled from rendered pages — inferred, not declared. */
+  inferredPalette: string[]
+  /** Per-asset intrinsic size and where each instance sits on its pages. */
+  images: Record<string, { widthPx: number; heightPx: number; placements: PdfImagePlacement[] }>
+}
+
+export interface ExtractedPdfMedia {
+  name: string
+  bytes: Buffer
+}
+
+export interface PdfTextBlock {
+  text: string
+  xPt: number
+  yPt: number
+  wPt: number
+  hPt: number
+  /** Font family name, with the PostScript style suffix split off. */
+  font: string
+  sizePt: number
+  colorHex: string | null
+  bold?: boolean
+  italic?: boolean
+}
+
+export interface PdfFilledRect {
+  xPt: number
+  yPt: number
+  wPt: number
+  hPt: number
+  colorHex: string | null
+}
+
+export interface PdfOverlay {
+  imageAt: { xPt: number; yPt: number }
+  colorHex: string | null
+  coverage: number
+}
+
+/** An extracted asset's placement on a page, by its written filename. */
+export interface PdfPlacedImage {
+  name: string
+  xPt: number
+  yPt: number
+  wPt: number
+  hPt: number
+}
+
+/** One page's rebuild recipe: what sits where, in which font and color. */
+export interface PdfPageLayout {
+  page: number
+  texts: PdfTextBlock[]
+  rects: PdfFilledRect[]
+  overlays: PdfOverlay[]
+  images: PdfPlacedImage[]
+}
+
+export interface ExtractedPdfAssets {
+  theme: ExtractedPdfTheme
+  media: ExtractedPdfMedia[]
+  layout: PdfPageLayout[]
+}
+
+const SCRIPT = `
+import subprocess, glob, json, base64, os, re
+import pdfplumber
+from PIL import Image
+
+inp = "/home/user/input.pdf"
+outdir = "/home/user/assets"
+os.makedirs(outdir, exist_ok=True)
+
+# Embedded images, native formats. No -p flag so filenames are asset-NNN.ext
+# with NNN matching the -list "num" column exactly.
+subprocess.run(["pdfimages", "-all", inp, outdir + "/asset"],
+               check=True, timeout=120, capture_output=True)
+listing = subprocess.run(["pdfimages", "-list", inp],
+                         check=True, timeout=60, capture_output=True, text=True).stdout
+rows = {}
+alpha_of = {}
+prev_image = None
+for line in listing.splitlines()[2:]:
+    parts = line.split()
+    if len(parts) < 5:
+        continue
+    try:
+        page, num, typ, w, h = int(parts[0]), int(parts[1]), parts[2], int(parts[3]), int(parts[4])
+    except ValueError:
+        continue
+    if typ == "image":
+        rows[num] = {"page": page, "width": w, "height": h}
+        prev_image = num
+    elif typ in ("smask", "mask") and prev_image is not None:
+        # poppler lists an image's alpha mask on the row directly after it.
+        # An smask's luminance IS the alpha; an explicit /Mask paints only
+        # where the sample is 0, hence the inversion downstream.
+        alpha_of[prev_image] = {"num": num, "invert": typ == "mask"}
+        prev_image = None
+    else:
+        prev_image = None
+
+paths = {}
+for path in sorted(glob.glob(outdir + "/asset-*")):
+    m = re.search(r"asset-(\\d+)\\.(\\w+)$", path)
+    if m:
+        paths[int(m.group(1))] = path
+files = {num: path for num, path in paths.items() if num in rows}
+
+# A transparent source image arrives as an opaque base plus a separate mask;
+# shipping the base alone would bake in a solid background. Recomposite the
+# pair into an RGBA PNG (the mask may be stored at a different resolution).
+for num, ref in alpha_of.items():
+    base_path, mask_path = files.get(num), paths.get(ref["num"])
+    if not base_path or not mask_path:
+        continue
+    try:
+        base = Image.open(base_path).convert("RGB")
+        mask = Image.open(mask_path).convert("L")
+        if ref["invert"]:
+            mask = Image.eval(mask, lambda v: 255 - v)
+        if mask.size != base.size:
+            mask = mask.resize(base.size, Image.BILINEAR)
+        base.putalpha(mask)
+        out = base_path.rsplit(".", 1)[0] + ".png"
+        base.save(out, "PNG")
+        if out != base_path:
+            os.remove(base_path)
+        files[num] = out
+    except Exception:
+        pass  # undecodable mask: the opaque base still beats losing the asset
+
+# Downscale print-resolution assets and normalize exotic formats. Embedded PDF
+# images are often 300-dpi originals several MB each, a slide never shows more
+# than ~2560px on the long edge, and every deck compile re-stages the whole
+# referenced set — so oversized extractions slow every edit and blow the byte
+# staging budget. Images already within range keep their original bytes.
+MAX_ASSET_EDGE = 2560
+shipped_dims = {}
+for num, path in list(files.items()):
+    try:
+        im = Image.open(path)
+        im.load()
+    except Exception:
+        continue  # undecodable (jbig2/ccitt params etc.): ship as-is
+    ext = path.rsplit(".", 1)[1].lower()
+    exotic = ext not in ("png", "jpg", "jpeg")
+    w, h = im.size
+    scale = MAX_ASSET_EDGE / float(max(w, h))
+    if scale >= 1 and not exotic:
+        continue
+    if scale < 1:
+        im = im.resize((max(1, int(w * scale)), max(1, int(h * scale))), Image.LANCZOS)
+    has_alpha = im.mode in ("RGBA", "LA", "PA") or (im.mode == "P" and "transparency" in im.info)
+    try:
+        if ext in ("jpg", "jpeg") or (exotic and not has_alpha):
+            out = path.rsplit(".", 1)[0] + ".jpg"
+            im.convert("RGB").save(out, "JPEG", quality=85, optimize=True)
+        else:
+            out = path.rsplit(".", 1)[0] + ".png"
+            im.convert("RGBA" if has_alpha else "RGB").save(out, "PNG", optimize=True)
+    except Exception:
+        continue  # unencodable: keep the original bytes
+    if out != path:
+        os.remove(path)
+    files[num] = out
+    shipped_dims[num] = im.size
+
+def to_hex(color):
+    if color is None:
+        return None
+    vals = list(color) if isinstance(color, (tuple, list)) else [color]
+    try:
+        if len(vals) == 1:
+            r = g = b = float(vals[0])
+        elif len(vals) == 3:
+            r, g, b = (float(v) for v in vals)
+        elif len(vals) == 4:
+            c, m, y, k = (float(v) for v in vals)
+            r, g, b = (1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k)
+        else:
+            return None
+    except (TypeError, ValueError):
+        return None
+    f = lambda v: max(0, min(255, int(round(v * 255))))
+    return "%02X%02X%02X" % (f(r), f(g), f(b))
+
+STYLE_TOKENS = {"bold", "black", "heavy", "light", "medium", "thin", "italic",
+                "oblique", "semibold", "demibold", "extrabold", "ultrabold",
+                "semi", "demi", "extra", "ultra", "condensed", "cond"}
+
+def parse_font_name(name):
+    # PostScript names pack family and style together ("Arial-BoldMT",
+    # "MyriadPro-Semibold"). Split them so the rebuild can set a real family
+    # plus bold/italic flags instead of asking PowerPoint for a face that
+    # does not exist (which silently falls back to a regular weight).
+    base = re.sub(r"^[A-Z]{6}\\+", "", name or "")
+    parts = re.split(r"[-,_]", base, maxsplit=1)
+    probe = parts[1] if len(parts) > 1 else base
+    bold = re.search(r"(?i)bold|black|heavy|demi", probe) is not None
+    italic = re.search(r"(?i)italic|oblique", probe) is not None
+    family = re.sub(r"(?:PS|MT|PSMT)$", "", parts[0])
+    family = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", " ", family)
+    words = family.split()
+    while len(words) > 1 and words[-1].lower() in STYLE_TOKENS:
+        words.pop()
+    return " ".join(words), bold, italic
+
+fonts = set()
+placements = []
+page_size = None
+layout = []
+with pdfplumber.open(inp) as pdf:
+    page_count = len(pdf.pages)
+    if pdf.pages:
+        p0 = pdf.pages[0]
+        page_size = {"widthPt": round(float(p0.width), 2), "heightPt": round(float(p0.height), 2)}
+    for pi, page in enumerate(pdf.pages[:100], start=1):
+        char_color = {}
+        for ch in page.chars[:8000]:
+            name = ch.get("fontname") or ""
+            if name:
+                family = parse_font_name(name)[0]
+                if family:
+                    fonts.add(family)
+            char_color[(round(ch["x0"], 1), round(ch["top"], 1))] = ch.get("non_stroking_color")
+        page_images = []
+        for im in page.images:
+            src = im.get("srcsize") or (0, 0)
+            entry = {
+                "page": pi,
+                "xPt": round(float(im["x0"]), 2),
+                "yPt": round(float(im["top"]), 2),
+                "wPt": round(float(im["x1"] - im["x0"]), 2),
+                "hPt": round(float(im["bottom"] - im["top"]), 2),
+                "srcW": int(src[0] or 0),
+                "srcH": int(src[1] or 0),
+            }
+            placements.append(entry)
+            page_images.append(entry)
+
+        # Text blocks: words grouped into lines, each line carrying its font,
+        # size, and fill color — the recipe for what text sits where.
+        words = page.extract_words(extra_attrs=["fontname", "size"])[:800]
+        lines = {}
+        for w in words:
+            lines.setdefault(round(w["top"] / 2), []).append(w)
+        texts = []
+        for key in sorted(lines):
+            ws = sorted(lines[key], key=lambda w: w["x0"])
+            # Side-by-side text boxes share a baseline; a gap much wider than
+            # a space means a new box, not a continuation of the same line.
+            runs = [[ws[0]]]
+            for w in ws[1:]:
+                prev = runs[-1][-1]
+                gap = float(w["x0"]) - float(prev["x1"])
+                if gap > max(2.5 * float(prev.get("size") or 10), 18):
+                    runs.append([w])
+                else:
+                    runs[-1].append(w)
+            for run in runs:
+                first = run[0]
+                color = to_hex(char_color.get((round(first["x0"], 1), round(first["top"], 1))))
+                family, bold, italic = parse_font_name(first.get("fontname") or "")
+                entry = {
+                    "text": " ".join(w["text"] for w in run)[:400],
+                    "xPt": round(float(first["x0"]), 2),
+                    "yPt": round(float(first["top"]), 2),
+                    "wPt": round(float(max(w["x1"] for w in run) - first["x0"]), 2),
+                    "hPt": round(float(max(w["bottom"] for w in run) - first["top"]), 2),
+                    "font": family,
+                    "sizePt": round(float(first.get("size") or 0), 1),
+                    "colorHex": color,
+                }
+                if bold:
+                    entry["bold"] = True
+                if italic:
+                    entry["italic"] = True
+                texts.append(entry)
+        texts = texts[:80]
+
+        # Filled rects: backgrounds and the scrims decks lay over photos.
+        rects = []
+        for r in page.rects[:80]:
+            if not r.get("fill"):
+                continue
+            rects.append({
+                "xPt": round(float(r["x0"]), 2),
+                "yPt": round(float(r["top"]), 2),
+                "wPt": round(float(r["x1"] - r["x0"]), 2),
+                "hPt": round(float(r["bottom"] - r["top"]), 2),
+                "colorHex": to_hex(r.get("non_stroking_color")),
+            })
+        rects = rects[:40]
+
+        # A rect covering most of an image is an overlay scrim — the "image
+        # opacity" effect. Alpha is not recoverable from the stream, so the
+        # renderer's page image is the reference for how strong it looks.
+        overlays = []
+        for r in rects:
+            for im in page_images:
+                ix0, iy0 = im["xPt"], im["yPt"]
+                ix1, iy1 = ix0 + im["wPt"], iy0 + im["hPt"]
+                rx0, ry0 = r["xPt"], r["yPt"]
+                rx1, ry1 = rx0 + r["wPt"], ry0 + r["hPt"]
+                inter = max(0, min(ix1, rx1) - max(ix0, rx0)) * max(0, min(iy1, ry1) - max(iy0, ry0))
+                area = im["wPt"] * im["hPt"]
+                if area > 0 and inter / area >= 0.5:
+                    overlays.append({
+                        "imageAt": {"xPt": ix0, "yPt": iy0},
+                        "colorHex": r["colorHex"],
+                        "coverage": round(inter / area, 2),
+                    })
+        layout.append({"page": pi, "texts": texts, "rects": rects, "overlays": overlays})
+
+# Inferred palette: quantized dominant colors over up to 3 rendered pages.
+palette = []
+try:
+    subprocess.run(["pdftoppm", "-jpeg", "-r", "50", "-f", "1", "-l", "3", inp, "/home/user/pal"],
+                   check=True, timeout=60, capture_output=True)
+    counts = {}
+    for p in glob.glob("/home/user/pal*.jpg"):
+        im = Image.open(p).convert("RGB").resize((120, 120))
+        for c, rgb in im.getcolors(120 * 120) or []:
+            q = tuple(v // 32 * 32 for v in rgb)
+            counts[q] = counts.get(q, 0) + c
+    top = sorted(counts.items(), key=lambda kv: -kv[1])[:10]
+    palette = ["%02X%02X%02X" % k for k, _ in top]
+except Exception:
+    palette = []
+
+MAX_FILE = 15 * 1024 * 1024
+MAX_TOTAL = 60 * 1024 * 1024
+total = 0
+images = []
+for num, path in sorted(files.items()):
+    size = os.path.getsize(path)
+    if size == 0 or size > MAX_FILE or total + size > MAX_TOTAL:
+        continue
+    total += size
+    row = rows[num]
+    ext = path.rsplit(".", 1)[1]
+    pls = [
+        {k: p[k] for k in ("page", "xPt", "yPt", "wPt", "hPt")}
+        for p in placements
+        if p["page"] == row["page"] and (
+            (p["srcW"] == row["width"] and p["srcH"] == row["height"]) or not p["srcW"]
+        )
+    ]
+    with open(path, "rb") as f:
+        data = base64.b64encode(f.read()).decode()
+    dims = shipped_dims.get(num)
+    images.append({
+        "name": "image%d.%s" % (num, ext),
+        "widthPx": dims[0] if dims else row["width"],
+        "heightPx": dims[1] if dims else row["height"],
+        "placements": pls,
+        "base64": data,
+    })
+
+print("__SIM_RESULT__=" + json.dumps({
+    "fonts": sorted(f for f in fonts if f),
+    "pageSize": page_size,
+    "pageCount": page_count,
+    "inferredPalette": palette,
+    "images": images,
+    "layout": layout,
+}))
+`.trim()
+
+interface SandboxPdfImage {
+  name: string
+  widthPx: number
+  heightPx: number
+  placements: PdfImagePlacement[]
+  base64: string
+}
+
+interface SandboxPdfResult {
+  fonts?: string[]
+  pageSize?: { widthPt: number; heightPt: number } | null
+  pageCount?: number
+  inferredPalette?: string[]
+  images?: SandboxPdfImage[]
+  layout?: Array<Omit<PdfPageLayout, 'images'>>
+}
+
+export async function extractPdfAssets(binary: Buffer): Promise<ExtractedPdfAssets> {
+  const result = await executeInSandbox({
+    code: SCRIPT,
+    language: CodeLanguage.Python,
+    timeoutMs: EXTRACT_TIMEOUT_MS,
+    sandboxKind: 'doc',
+    sandboxFiles: [
+      { path: '/home/user/input.pdf', content: binary.toString('base64'), encoding: 'base64' },
+    ],
+  })
+  if (result.error) {
+    throw new Error(`PDF asset extraction failed: ${result.error}`)
+  }
+  const payload = (result.result ?? {}) as SandboxPdfResult
+  const images = payload.images ?? []
+  const theme: ExtractedPdfTheme = {
+    format: 'pdf',
+    fonts: payload.fonts ?? [],
+    pageSize: payload.pageSize ?? undefined,
+    pageCount: payload.pageCount ?? 0,
+    inferredPalette: payload.inferredPalette ?? [],
+    images: Object.fromEntries(
+      images.map((image) => [
+        image.name,
+        { widthPx: image.widthPx, heightPx: image.heightPx, placements: image.placements },
+      ])
+    ),
+  }
+  // The sandbox reports placements per asset (asset → pages); the rebuild
+  // recipe reads per page, so join each asset's rects onto its page entries.
+  const layout = (payload.layout ?? []).map((page) => ({
+    ...page,
+    images: images.flatMap((image) =>
+      image.placements
+        .filter((placement) => placement.page === page.page)
+        .map(({ xPt, yPt, wPt, hPt }) => ({ name: image.name, xPt, yPt, wPt, hPt }))
+    ),
+  }))
+  return {
+    theme,
+    media: images.map((image) => ({
+      name: image.name,
+      bytes: Buffer.from(image.base64, 'base64'),
+    })),
+    layout,
+  }
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/doc-asset-extract.test.ts b/apps/sim/lib/copilot/tools/server/files/doc-asset-extract.test.ts
new file mode 100644
index 0000000000..bd841d5356
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/doc-asset-extract.test.ts
@@ -0,0 +1,156 @@
+/**
+ * @vitest-environment node
+ */
+import JSZip from 'jszip'
+import { describe, expect, it } from 'vitest'
+import { extractDocAssets } from '@/lib/copilot/tools/server/files/doc-asset-extract'
+
+const THEME_XML = `<?xml version="1.0"?>
+<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="Office">
+  <a:themeElements>
+    <a:clrScheme name="Office">
+      <a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1>
+      <a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1>
+      <a:dk2><a:srgbClr val="1F2937"/></a:dk2>
+      <a:lt2><a:srgbClr val="E7E6E6"/></a:lt2>
+      <a:accent1><a:srgbClr val="4F81BD"/></a:accent1>
+      <a:accent2><a:srgbClr val="C0504D"/></a:accent2>
+      <a:accent3><a:srgbClr val="9BBB59"/></a:accent3>
+      <a:accent4><a:srgbClr val="8064A2"/></a:accent4>
+      <a:accent5><a:srgbClr val="4BACC6"/></a:accent5>
+      <a:accent6><a:srgbClr val="F79646"/></a:accent6>
+      <a:hlink><a:srgbClr val="0000FF"/></a:hlink>
+      <a:folHlink><a:srgbClr val="800080"/></a:folHlink>
+    </a:clrScheme>
+    <a:fontScheme name="Office">
+      <a:majorFont><a:latin typeface="Calibri Light"/></a:majorFont>
+      <a:minorFont><a:latin typeface="Calibri"/></a:minorFont>
+    </a:fontScheme>
+  </a:themeElements>
+</a:theme>`
+
+const PNG_BYTES = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2, 3])
+const JPG_BYTES = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 9, 8, 7])
+
+async function buildPptx(): Promise<Buffer> {
+  const zip = new JSZip()
+  zip.file('ppt/theme/theme1.xml', THEME_XML)
+  zip.file(
+    'ppt/presentation.xml',
+    '<p:presentation xmlns:p="x"><p:sldSz cx="12192000" cy="6858000" type="screen16x9"/></p:presentation>'
+  )
+  zip.file('ppt/media/image1.png', PNG_BYTES)
+  zip.file('ppt/media/image2.jpeg', JPG_BYTES)
+  zip.file('ppt/slides/slide1.xml', '<p:sld/>')
+  return zip.generateAsync({ type: 'nodebuffer' })
+}
+
+describe('extractDocAssets', () => {
+  it('extracts theme colors, fonts, slide size, and media from a pptx', async () => {
+    const { theme, media } = await extractDocAssets(await buildPptx(), 'pptx')
+    expect(theme.format).toBe('pptx')
+    expect(theme.colors).toMatchObject({
+      dk1: '000000',
+      lt1: 'FFFFFF',
+      dk2: '1F2937',
+      accent1: '4F81BD',
+      accent6: 'F79646',
+      hlink: '0000FF',
+    })
+    expect(theme.fonts).toEqual({ major: 'Calibri Light', minor: 'Calibri' })
+    expect(theme.slideSize).toEqual({ widthIn: 13.33, heightIn: 7.5 })
+    expect(media.map((m) => m.name)).toEqual(['image1.png', 'image2.jpeg'])
+    expect(media[0]?.bytes.equals(PNG_BYTES)).toBe(true)
+    expect(media[1]?.bytes.equals(JPG_BYTES)).toBe(true)
+  })
+
+  it('extracts from a docx under the word/ prefix without a slide size', async () => {
+    const zip = new JSZip()
+    zip.file('word/theme/theme1.xml', THEME_XML)
+    zip.file('word/media/image1.png', PNG_BYTES)
+    zip.file('word/document.xml', '<w:document/>')
+    const { theme, media } = await extractDocAssets(
+      await zip.generateAsync({ type: 'nodebuffer' }),
+      'docx'
+    )
+    expect(theme.format).toBe('docx')
+    expect(theme.colors.accent1).toBe('4F81BD')
+    expect(theme.slideSize).toBeUndefined()
+    expect(media.map((m) => m.name)).toEqual(['image1.png'])
+  })
+
+  it('extracts slide text/image layout, inheriting placeholder frames from the slide layout', async () => {
+    const relNs = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships'
+    const zip = new JSZip()
+    zip.file('ppt/theme/theme1.xml', THEME_XML)
+    zip.file('ppt/media/image1.png', PNG_BYTES)
+    zip.file(
+      'ppt/slides/slide1.xml',
+      `<p:sld xmlns:p="p" xmlns:a="a" xmlns:r="r"><p:cSld><p:spTree>
+<p:sp><p:nvSpPr><p:cNvPr id="2" name="Title 1"/><p:nvPr><p:ph type="title"/></p:nvPr></p:nvSpPr><p:spPr/>
+<p:txBody><a:p><a:r><a:rPr lang="en-US" sz="3600" b="1"><a:solidFill><a:schemeClr val="accent1"/></a:solidFill><a:latin typeface="+mj-lt"/></a:rPr><a:t>Q3 &amp; Q4 Results</a:t></a:r></a:p></p:txBody></p:sp>
+<p:sp><p:spPr><a:xfrm><a:off x="914400" y="1828800"/><a:ext cx="4572000" cy="914400"/></a:xfrm></p:spPr>
+<p:txBody><a:p><a:r><a:rPr sz="1400"><a:solidFill><a:srgbClr val="112233"/></a:solidFill><a:latin typeface="Georgia"/></a:rPr><a:t>First line</a:t></a:r></a:p><a:p><a:r><a:t>Second line</a:t></a:r></a:p></p:txBody></p:sp>
+<p:grpSp><p:sp><p:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="914400" cy="914400"/></a:xfrm></p:spPr><p:txBody><a:p><a:r><a:t>grouped</a:t></a:r></a:p></p:txBody></p:sp></p:grpSp>
+<p:pic><p:blipFill><a:blip r:embed="rId2"/></p:blipFill><p:spPr><a:xfrm><a:off x="1828800" y="914400"/><a:ext cx="1828800" cy="1828800"/></a:xfrm></p:spPr></p:pic>
+</p:spTree></p:cSld></p:sld>`
+    )
+    zip.file(
+      'ppt/slides/_rels/slide1.xml.rels',
+      `<Relationships><Relationship Id="rId1" Type="${relNs}/slideLayout" Target="../slideLayouts/slideLayout1.xml"/><Relationship Id="rId2" Type="${relNs}/image" Target="../media/image1.png"/></Relationships>`
+    )
+    zip.file(
+      'ppt/slideLayouts/slideLayout1.xml',
+      `<p:sldLayout xmlns:p="p" xmlns:a="a"><p:cSld><p:spTree>
+<p:sp><p:nvSpPr><p:nvPr><p:ph type="ctrTitle"/></p:nvPr></p:nvSpPr><p:spPr><a:xfrm><a:off x="914400" y="457200"/><a:ext cx="10972800" cy="1143000"/></a:xfrm></p:spPr><p:txBody><a:p><a:r><a:t>Click to edit</a:t></a:r></a:p></p:txBody></p:sp>
+</p:spTree></p:cSld></p:sldLayout>`
+    )
+    const { theme, layout } = await extractDocAssets(
+      await zip.generateAsync({ type: 'nodebuffer' }),
+      'pptx'
+    )
+    expect(layout).toHaveLength(1)
+    const slide = layout[0]
+    expect(slide.slide).toBe(1)
+    expect(slide.images).toEqual([{ name: 'image1.png', xIn: 2, yIn: 1, wIn: 2, hIn: 2 }])
+    expect(theme.images?.['image1.png']?.placements).toEqual([
+      { slide: 1, xIn: 2, yIn: 1, wIn: 2, hIn: 2 },
+    ])
+    expect(slide.texts).toHaveLength(2)
+    expect(slide.texts[0]).toMatchObject({
+      text: 'Q3 & Q4 Results',
+      xIn: 1,
+      yIn: 0.5,
+      wIn: 12,
+      hIn: 1.25,
+      font: 'major',
+      sizePt: 36,
+      bold: true,
+      schemeColor: 'accent1',
+    })
+    expect(slide.texts[0].colorHex).toBeUndefined()
+    expect(slide.texts[1]).toMatchObject({
+      text: 'First line\nSecond line',
+      xIn: 1,
+      yIn: 2,
+      wIn: 5,
+      hIn: 1,
+      font: 'Georgia',
+      sizePt: 14,
+      colorHex: '112233',
+    })
+    expect(slide.texts[1].bold).toBeUndefined()
+    expect(slide.texts.some((t) => t.text.includes('grouped'))).toBe(false)
+  })
+
+  it('tolerates a package with no theme or media', async () => {
+    const zip = new JSZip()
+    zip.file('ppt/slides/slide1.xml', '<p:sld/>')
+    const { theme, media } = await extractDocAssets(
+      await zip.generateAsync({ type: 'nodebuffer' }),
+      'pptx'
+    )
+    expect(theme.colors).toEqual({})
+    expect(media).toEqual([])
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/files/doc-asset-extract.ts b/apps/sim/lib/copilot/tools/server/files/doc-asset-extract.ts
new file mode 100644
index 0000000000..fd2c1b6c40
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/doc-asset-extract.ts
@@ -0,0 +1,418 @@
+import JSZip from 'jszip'
+
+/**
+ * Pulls the reusable design material out of an OOXML document (.pptx/.docx):
+ * the theme (color scheme, font scheme, slide size), every embedded media
+ * file byte-identical, and — for pptx — a slide-by-slide layout of text
+ * blocks (content, frame, font, size, color) and placed images. OOXML
+ * packages are ZIP archives with fixed part names, so extraction is direct:
+ * `ppt|word/theme/theme1.xml` for the theme, `ppt|word/media/*` for assets,
+ * `ppt/presentation.xml` for slide size, and `ppt/slides/slideN.xml` (plus
+ * each slide's layout/master chain for inherited placeholder frames) for the
+ * layout. Read-only over the source bytes.
+ */
+
+/** OOXML theme color slots, in scheme order. */
+const THEME_COLOR_SLOTS = [
+  'dk1',
+  'lt1',
+  'dk2',
+  'lt2',
+  'accent1',
+  'accent2',
+  'accent3',
+  'accent4',
+  'accent5',
+  'accent6',
+  'hlink',
+  'folHlink',
+] as const
+
+const EMU_PER_INCH = 914400
+const MAX_TEXTS_PER_SLIDE = 80
+const MAX_TEXT_CHARS = 400
+
+export interface DocImagePlacement {
+  slide: number
+  xIn: number
+  yIn: number
+  wIn: number
+  hIn: number
+}
+
+/** An asset's placement on one slide, by its media basename. */
+export interface PptxPlacedImage {
+  name: string
+  xIn: number
+  yIn: number
+  wIn: number
+  hIn: number
+}
+
+export interface PptxTextBlock {
+  text: string
+  xIn: number
+  yIn: number
+  wIn: number
+  hIn: number
+  /** Typeface name, or "major"/"minor" when the run uses a theme font slot. */
+  font?: string
+  sizePt?: number
+  bold?: boolean
+  italic?: boolean
+  /** Literal run color. Absent when the run uses a theme slot instead. */
+  colorHex?: string
+  /** Theme color slot name (e.g. "accent1") — resolve via theme.json colors. */
+  schemeColor?: string
+}
+
+/** One slide's rebuild recipe: what sits where, in which font and color. */
+export interface PptxSlideLayout {
+  slide: number
+  texts: PptxTextBlock[]
+  images: PptxPlacedImage[]
+}
+
+export interface ExtractedDocTheme {
+  format: 'pptx' | 'docx'
+  /** Slot → 6-digit uppercase hex, no leading '#'. Only slots the theme defines. */
+  colors: Record<string, string>
+  fonts: { major?: string; minor?: string }
+  /** Slide dimensions in inches (pptx only). */
+  slideSize?: { widthIn: number; heightIn: number }
+  slideCount?: number
+  /** Per-asset slide-by-slide placements in inches (pptx only). */
+  images?: Record<string, { placements: DocImagePlacement[] }>
+}
+
+export interface ExtractedDocMedia {
+  /** Basename inside the package, e.g. "image1.png". */
+  name: string
+  bytes: Buffer
+}
+
+export interface ExtractedDocAssets {
+  theme: ExtractedDocTheme
+  media: ExtractedDocMedia[]
+  /** Slide-by-slide rebuild recipe (pptx only; empty for docx). */
+  layout: PptxSlideLayout[]
+}
+
+/**
+ * A slot's color is either a literal `<a:srgbClr val="RRGGBB"/>` or a system
+ * color carrying its resolved value in `lastClr`.
+ */
+function parseSlotColor(themeXml: string, slot: string): string | undefined {
+  const block = themeXml.match(new RegExp(`<a:${slot}>([\\s\\S]*?)</a:${slot}>`))?.[1]
+  if (!block) return undefined
+  const hex =
+    block.match(/<a:srgbClr val="([0-9A-Fa-f]{6})"/)?.[1] ??
+    block.match(/lastClr="([0-9A-Fa-f]{6})"/)?.[1]
+  return hex?.toUpperCase()
+}
+
+function parseFont(themeXml: string, scheme: 'majorFont' | 'minorFont'): string | undefined {
+  const block = themeXml.match(new RegExp(`<a:${scheme}>([\\s\\S]*?)</a:${scheme}>`))?.[1]
+  const typeface = block?.match(/<a:latin typeface="([^"]*)"/)?.[1]
+  return typeface || undefined
+}
+
+const emuToIn = (emu: string): number => Number((Number(emu) / EMU_PER_INCH).toFixed(2))
+
+interface ShapeFrame {
+  xIn: number
+  yIn: number
+  wIn: number
+  hIn: number
+}
+
+/**
+ * Placeholder frame lookup falls back across interchangeable ph types: a
+ * slide's "title" inherits from a layout's centered title and vice versa.
+ */
+const PH_TYPE_ALIASES: Record<string, readonly string[]> = {
+  title: ['title', 'ctrTitle'],
+  ctrTitle: ['ctrTitle', 'title'],
+  body: ['body', 'subTitle'],
+  subTitle: ['subTitle', 'body'],
+}
+
+const XML_ENTITIES: Record<string, string> = {
+  '&amp;': '&',
+  '&lt;': '<',
+  '&gt;': '>',
+  '&quot;': '"',
+  '&apos;': "'",
+}
+
+function decodeXml(value: string): string {
+  return value.replace(/&(?:amp|lt|gt|quot|apos|#x[0-9A-Fa-f]+|#\d+);/g, (entity) => {
+    const named = XML_ENTITIES[entity]
+    if (named) return named
+    const code = entity.startsWith('&#x')
+      ? Number.parseInt(entity.slice(3, -1), 16)
+      : Number.parseInt(entity.slice(2, -1), 10)
+    return code >= 0 && code <= 0x10ffff ? String.fromCodePoint(code) : entity
+  })
+}
+
+function parseFrame(block: string): ShapeFrame | null {
+  const off = block.match(/<a:off x="(-?\d+)" y="(-?\d+)"/)
+  const ext = block.match(/<a:ext cx="(\d+)" cy="(\d+)"/)
+  if (!off || !ext) return null
+  return { xIn: emuToIn(off[1]), yIn: emuToIn(off[2]), wIn: emuToIn(ext[1]), hIn: emuToIn(ext[2]) }
+}
+
+function parsePlaceholder(sp: string): { idx?: string; type?: string } | null {
+  const attrs = sp.match(/<p:ph\b([^>]*)>/)?.[1]
+  if (attrs === undefined) return null
+  return { idx: attrs.match(/ idx="(\d+)"/)?.[1], type: attrs.match(/ type="([^"]+)"/)?.[1] }
+}
+
+/**
+ * Drops grouped shapes from a slide/layout XML. Group members carry
+ * group-relative coordinates that need the full chOff/chExt transform to
+ * place absolutely; omitting them beats emitting frames at wrong positions.
+ * Balanced scan rather than a regex so nested groups drop cleanly.
+ */
+function stripGroups(xml: string): string {
+  let out = ''
+  let depth = 0
+  let last = 0
+  for (const tag of xml.matchAll(/<\/?p:grpSp>/g)) {
+    const at = tag.index ?? 0
+    if (depth === 0 && tag[0] === '<p:grpSp>') out += xml.slice(last, at)
+    depth = tag[0] === '<p:grpSp>' ? depth + 1 : Math.max(0, depth - 1)
+    if (depth === 0) last = at + tag[0].length
+  }
+  return depth === 0 ? out + xml.slice(last) : out
+}
+
+/** Frames of a layout/master's placeholder shapes, keyed by idx and type. */
+function collectPlaceholderFrames(xml: string): Map<string, ShapeFrame> {
+  const frames = new Map<string, ShapeFrame>()
+  for (const sp of stripGroups(xml).matchAll(/<p:sp>[\s\S]*?<\/p:sp>/g)) {
+    const ph = parsePlaceholder(sp[0])
+    if (!ph) continue
+    const frame = parseFrame(sp[0])
+    if (!frame) continue
+    if (ph.idx !== undefined && !frames.has(`idx:${ph.idx}`)) frames.set(`idx:${ph.idx}`, frame)
+    if (ph.type !== undefined && !frames.has(`type:${ph.type}`))
+      frames.set(`type:${ph.type}`, frame)
+  }
+  return frames
+}
+
+/** Resolves a rels Target like "../slideLayouts/slideLayout1.xml" to a zip path. */
+function resolveZipPath(baseDir: string, target: string): string {
+  const resolved: string[] = []
+  for (const part of `${baseDir}/${target}`.split('/')) {
+    if (part === '..') resolved.pop()
+    else if (part !== '.' && part !== '') resolved.push(part)
+  }
+  return resolved.join('/')
+}
+
+function matchRelTarget(relsXml: string, typeSuffix: string, baseDir: string): string | undefined {
+  for (const rel of relsXml.matchAll(/<Relationship [^>]*>/g)) {
+    const type = rel[0].match(/ Type="([^"]+)"/)?.[1]
+    const target = rel[0].match(/ Target="([^"]+)"/)?.[1]
+    if (target && type?.endsWith(`/${typeSuffix}`)) return resolveZipPath(baseDir, target)
+  }
+  return undefined
+}
+
+function relsPathFor(partPath: string): string {
+  const cut = partPath.lastIndexOf('/')
+  return `${partPath.slice(0, cut)}/_rels/${partPath.slice(cut + 1)}.rels`
+}
+
+/**
+ * A slide shape without its own xfrm inherits its frame from the matching
+ * placeholder in the slide's layout, then the layout's master. Parsed frames
+ * are cached per layout part since slides share layouts.
+ */
+async function inheritedFramesForSlide(
+  zip: JSZip,
+  slideRelsXml: string,
+  cache: Map<string, Map<string, ShapeFrame>>
+): Promise<Map<string, ShapeFrame>> {
+  const layoutPath = matchRelTarget(slideRelsXml, 'slideLayout', 'ppt/slides')
+  if (!layoutPath) return new Map()
+  const cached = cache.get(layoutPath)
+  if (cached) return cached
+  const layoutXml = (await zip.file(layoutPath)?.async('string')) ?? ''
+  const frames = collectPlaceholderFrames(layoutXml)
+  const layoutRelsXml = await zip.file(relsPathFor(layoutPath))?.async('string')
+  const layoutDir = layoutPath.slice(0, layoutPath.lastIndexOf('/'))
+  const masterPath = layoutRelsXml
+    ? matchRelTarget(layoutRelsXml, 'slideMaster', layoutDir)
+    : undefined
+  if (masterPath) {
+    const masterXml = (await zip.file(masterPath)?.async('string')) ?? ''
+    for (const [key, frame] of collectPlaceholderFrames(masterXml)) {
+      if (!frames.has(key)) frames.set(key, frame)
+    }
+  }
+  cache.set(layoutPath, frames)
+  return frames
+}
+
+function lookupPlaceholderFrame(
+  ph: { idx?: string; type?: string },
+  frames: Map<string, ShapeFrame>
+): ShapeFrame | null {
+  if (ph.idx !== undefined) {
+    const byIdx = frames.get(`idx:${ph.idx}`)
+    if (byIdx) return byIdx
+  }
+  for (const type of ph.type ? (PH_TYPE_ALIASES[ph.type] ?? [ph.type]) : []) {
+    const byType = frames.get(`type:${type}`)
+    if (byType) return byType
+  }
+  return null
+}
+
+function collectSlideTexts(
+  slideXml: string,
+  inheritedFrames: Map<string, ShapeFrame>
+): PptxTextBlock[] {
+  const texts: PptxTextBlock[] = []
+  for (const sp of stripGroups(slideXml).matchAll(/<p:sp>[\s\S]*?<\/p:sp>/g)) {
+    if (texts.length >= MAX_TEXTS_PER_SLIDE) break
+    const txBody = sp[0].match(/<p:txBody>([\s\S]*?)<\/p:txBody>/)?.[1]
+    if (!txBody) continue
+    const text = [...txBody.matchAll(/<a:p>([\s\S]*?)<\/a:p>/g)]
+      .map((para) =>
+        [...para[1].matchAll(/<a:t>([^<]*)<\/a:t>/g)].map((t) => decodeXml(t[1])).join('')
+      )
+      .filter((line) => line.trim().length > 0)
+      .join('\n')
+      .slice(0, MAX_TEXT_CHARS)
+    if (!text) continue
+    const ph = parsePlaceholder(sp[0])
+    const frame = parseFrame(sp[0]) ?? (ph ? lookupPlaceholderFrame(ph, inheritedFrames) : null)
+    if (!frame) continue
+    // Style is read from the shape's first styled run — the way decks are
+    // authored (one style per box) — without resolving list/master styles.
+    const rPrAttrs = txBody.match(/<a:rPr\b([^>]*)>/)?.[1] ?? ''
+    const sz = rPrAttrs.match(/ sz="(\d+)"/)?.[1]
+    const typeface = txBody.match(/<a:latin typeface="([^"]+)"/)?.[1]
+    const colorHex = txBody.match(/<a:solidFill><a:srgbClr val="([0-9A-Fa-f]{6})"/)?.[1]
+    texts.push({
+      text,
+      ...frame,
+      font: typeface === '+mj-lt' ? 'major' : typeface === '+mn-lt' ? 'minor' : typeface,
+      sizePt: sz ? Number(sz) / 100 : undefined,
+      bold: / b="1"/.test(rPrAttrs) ? true : undefined,
+      italic: / i="1"/.test(rPrAttrs) ? true : undefined,
+      colorHex: colorHex?.toUpperCase(),
+      schemeColor: colorHex
+        ? undefined
+        : txBody.match(/<a:solidFill><a:schemeClr val="([^"]+)"/)?.[1],
+    })
+  }
+  return texts
+}
+
+/**
+ * Walks every slide once, producing both indexes of the same facts: the
+ * per-asset placement lists for theme.json and the per-slide text/image
+ * layout. Slide rels resolve rIds to media basenames, and each <p:pic>/<p:sp>
+ * frame carries its offset/extent in EMU (or inherits it via placeholder).
+ */
+async function collectSlideLayouts(zip: JSZip): Promise<{
+  slideCount: number
+  images: Record<string, { placements: DocImagePlacement[] }>
+  slides: PptxSlideLayout[]
+}> {
+  const images: Record<string, { placements: DocImagePlacement[] }> = {}
+  const slides: PptxSlideLayout[] = []
+  const placeholderFrameCache = new Map<string, Map<string, ShapeFrame>>()
+  const slideNames = Object.keys(zip.files)
+    .map((name) => name.match(/^ppt\/slides\/slide(\d+)\.xml$/))
+    .filter((m): m is RegExpMatchArray => m !== null)
+    .sort((a, b) => Number(a[1]) - Number(b[1]))
+  for (const match of slideNames) {
+    const slide = Number(match[1])
+    const slideXml = (await zip.file(match[0])?.async('string')) ?? ''
+    const relsXml = await zip.file(`ppt/slides/_rels/slide${slide}.xml.rels`)?.async('string')
+    const relToMedia = new Map<string, string>()
+    if (relsXml) {
+      for (const rel of relsXml.matchAll(/<Relationship [^>]*>/g)) {
+        const id = rel[0].match(/ Id="([^"]+)"/)?.[1]
+        const target = rel[0].match(/ Target="([^"]+)"/)?.[1]
+        if (id && target?.includes('/media/')) {
+          relToMedia.set(id, target.slice(target.lastIndexOf('/') + 1))
+        }
+      }
+    }
+    const placed: PptxPlacedImage[] = []
+    for (const pic of slideXml.matchAll(/<p:pic>[\s\S]*?<\/p:pic>/g)) {
+      const embed = pic[0].match(/r:embed="([^"]+)"/)?.[1]
+      const name = embed ? relToMedia.get(embed) : undefined
+      if (!name) continue
+      const frame = parseFrame(pic[0])
+      if (!frame) continue
+      images[name] ??= { placements: [] }
+      images[name].placements.push({ slide, ...frame })
+      placed.push({ name, ...frame })
+    }
+    const inheritedFrames = relsXml
+      ? await inheritedFramesForSlide(zip, relsXml, placeholderFrameCache)
+      : new Map<string, ShapeFrame>()
+    slides.push({ slide, texts: collectSlideTexts(slideXml, inheritedFrames), images: placed })
+  }
+  return { slideCount: slideNames.length, images, slides }
+}
+
+export async function extractDocAssets(
+  binary: Buffer,
+  format: 'pptx' | 'docx'
+): Promise<ExtractedDocAssets> {
+  const zip = await JSZip.loadAsync(binary)
+  const prefix = format === 'pptx' ? 'ppt' : 'word'
+
+  const themeXml = await zip.file(`${prefix}/theme/theme1.xml`)?.async('string')
+  const colors: Record<string, string> = {}
+  for (const slot of THEME_COLOR_SLOTS) {
+    const hex = themeXml ? parseSlotColor(themeXml, slot) : undefined
+    if (hex) colors[slot] = hex
+  }
+  const theme: ExtractedDocTheme = {
+    format,
+    colors,
+    fonts: {
+      major: themeXml ? parseFont(themeXml, 'majorFont') : undefined,
+      minor: themeXml ? parseFont(themeXml, 'minorFont') : undefined,
+    },
+  }
+
+  let layout: PptxSlideLayout[] = []
+  if (format === 'pptx') {
+    const presentation = await zip.file('ppt/presentation.xml')?.async('string')
+    const size = presentation?.match(/<p:sldSz cx="(\d+)" cy="(\d+)"/)
+    if (size) {
+      theme.slideSize = {
+        widthIn: Number((Number(size[1]) / EMU_PER_INCH).toFixed(2)),
+        heightIn: Number((Number(size[2]) / EMU_PER_INCH).toFixed(2)),
+      }
+    }
+    const { slideCount, images, slides } = await collectSlideLayouts(zip)
+    theme.slideCount = slideCount
+    if (Object.keys(images).length > 0) theme.images = images
+    layout = slides
+  }
+
+  const mediaPrefix = `${prefix}/media/`
+  const media: ExtractedDocMedia[] = []
+  for (const [entryName, entry] of Object.entries(zip.files)) {
+    if (entry.dir || !entryName.startsWith(mediaPrefix)) continue
+    const name = entryName.slice(mediaPrefix.length)
+    if (!name || name.includes('/')) continue
+    media.push({ name, bytes: await entry.async('nodebuffer') })
+  }
+  media.sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }))
+
+  return { theme, media, layout }
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/doc-compile.test.ts b/apps/sim/lib/copilot/tools/server/files/doc-compile.test.ts
index 734761a5c0..0c2c5a0025 100644
--- a/apps/sim/lib/copilot/tools/server/files/doc-compile.test.ts
+++ b/apps/sim/lib/copilot/tools/server/files/doc-compile.test.ts
@@ -108,30 +108,29 @@ describe('collectReferencedFileIds', () => {
     expect(collectReferencedFileIds(`slide.addText('hello', { x: 1, y: 1 })`)).toEqual(new Set())
   })
 
-  it('retains all references at the remote staging limit', () => {
-    const ids = collectReferencedFileIds(referencedFileSource(20))
+  it('retains a full deck rebuild — every extracted image plus headroom fits the cap', () => {
+    const ids = collectReferencedFileIds(referencedFileSource(500))
 
-    expect(ids.size).toBe(20)
-    expect(ids.has('file-19')).toBe(true)
+    expect(ids.size).toBe(500)
+    expect(ids.has('file-0')).toBe(true)
+    expect(ids.has('file-499')).toBe(true)
   })
 
-  it('stops collecting at the one-over-limit sentinel', () => {
-    const ids = collectReferencedFileIds(referencedFileSource(100))
+  it('stops collecting at the one-over-cap sentinel', () => {
+    const ids = collectReferencedFileIds(referencedFileSource(2000))
 
-    expect(ids.size).toBe(21)
-    expect(ids.has('file-20')).toBe(true)
-    expect(ids.has('file-21')).toBe(false)
+    expect(ids.size).toBe(501)
   })
 
-  it('rejects remote compilation at 21 references before resolving file metadata', async () => {
+  it('rejects an over-cap reference set before resolving any file metadata', async () => {
     await expect(
       compileDoc({
-        source: referencedFileSource(21),
+        source: referencedFileSource(501),
         fileName: 'report.pdf',
         workspaceId: 'workspace-1',
         filePrincipal: FILE_PRINCIPAL,
       })
-    ).rejects.toThrow('More than 20 referenced input files; maximum is 20')
+    ).rejects.toThrow('More than 500 referenced input files; maximum is 500')
     expect(readWorkspaceFileMetadataMock).not.toHaveBeenCalled()
     expect(executeInSandboxMock).not.toHaveBeenCalled()
   })
diff --git a/apps/sim/lib/copilot/tools/server/files/doc-compile.ts b/apps/sim/lib/copilot/tools/server/files/doc-compile.ts
index b6dafb6826..88e6097b73 100644
--- a/apps/sim/lib/copilot/tools/server/files/doc-compile.ts
+++ b/apps/sim/lib/copilot/tools/server/files/doc-compile.ts
@@ -106,11 +106,14 @@ const FILE_HELPER_RE =
   /\b(?:getFileBase64|addImage|drawImage)\(\s*(?:[A-Za-z_$][\w$]*\s*,\s*)?['"]([A-Za-z0-9_-]+)['"]/g
 
 // The doc source is user/LLM-controlled, so bound how much it can pull into the
-// sandbox: each `/home/user/inputs/<id>` reference is only ~35 bytes, so the
-// source-size cap alone does not bound staging. These caps prevent an
-// authenticated member from forcing thousands of (or very large) workspace files
-// to be downloaded and base64-held in-process per compile request.
-const MAX_STAGED_INPUTS = 20
+// sandbox by BYTES (per file and total) — an authenticated member must not be
+// able to force very large workspace downloads to be base64-held in-process per
+// compile. The count cap is deliberately GENEROUS: a deck rebuild references
+// every extracted image across the whole source (asset extraction ships at most
+// 200 media files), so real documents sit far under it — it exists only so the
+// per-reference metadata lookups stay bounded against a source stuffed with
+// thousands of id-like strings, which the byte caps alone cannot bound.
+const MAX_REFERENCED_INPUTS = 500
 const MAX_STAGED_FILE_BYTES = 25 * 1024 * 1024
 const MAX_STAGED_TOTAL_BYTES = 50 * 1024 * 1024
 
@@ -147,8 +150,8 @@ function referencedImageIdentities(
  * image-helper call sites and the legacy `/home/user/inputs/<id>` path. Matching
  * is scoped to the helper calls (not bare id-like strings in slide text), and the
  * caller skips any id that does not resolve to a real file, so over-matching is
- * harmless. Retention stops at one over the remote staging limit: callers need
- * only distinguish no references, an admissible set, and an oversized set.
+ * harmless. Retention stops at one over the reference cap: callers need only
+ * distinguish no references, an admissible set, and an oversized set.
  */
 export function collectReferencedFileIds(source: string): Set<string> {
   const ids = new Set<string>()
@@ -156,7 +159,7 @@ export function collectReferencedFileIds(source: string): Set<string> {
     for (const match of source.matchAll(re)) {
       if (match[1]) {
         ids.add(match[1])
-        if (ids.size > MAX_STAGED_INPUTS) return ids
+        if (ids.size > MAX_REFERENCED_INPUTS) return ids
       }
     }
   }
@@ -169,9 +172,11 @@ async function resolveReferencedImages(
   principal: Principal,
   ids = collectReferencedFileIds(source)
 ): Promise<ReferencedImageResolution> {
-  if (ids.size > MAX_STAGED_INPUTS) {
-    throw new Error(
-      `More than ${MAX_STAGED_INPUTS} referenced input files; maximum is ${MAX_STAGED_INPUTS}. Reference fewer files.`
+  if (ids.size > MAX_REFERENCED_INPUTS) {
+    // User-fixable, not transient: each reference costs a metadata read, so an
+    // oversized set is refused before any resolution work starts.
+    throw new DocCompileUserError(
+      `More than ${MAX_REFERENCED_INPUTS} referenced input files; maximum is ${MAX_REFERENCED_INPUTS}. Reference fewer files.`
     )
   }
   if (ids.size === 0) {
@@ -207,12 +212,6 @@ async function stageReferencedImages(
   workspaceId: string,
   principal: Principal
 ): Promise<SandboxFile[]> {
-  if (resolution.referenceCount > MAX_STAGED_INPUTS) {
-    throw new Error(
-      `More than ${MAX_STAGED_INPUTS} referenced input files; maximum is ${MAX_STAGED_INPUTS}. Reference fewer files.`
-    )
-  }
-
   const files: SandboxFile[] = []
   let totalBytes = 0
   for (const { fileId, record } of resolution.images) {
@@ -225,8 +224,8 @@ async function stageReferencedImages(
       continue
     }
     if (totalBytes + (record.size ?? 0) > MAX_STAGED_TOTAL_BYTES) {
-      throw new Error(
-        `Referenced input files exceed the ${MAX_STAGED_TOTAL_BYTES} byte staging budget.`
+      throw new DocCompileUserError(
+        `Referenced input files exceed the ${Math.round(MAX_STAGED_TOTAL_BYTES / (1024 * 1024))} MB total staging budget (the whole document's references count). Use smaller/compressed copies of the largest images.`
       )
     }
     const content = await readWorkspaceFileContent.execute({
@@ -263,8 +262,10 @@ async function stageReferencedImages(
     // outside the catch above so it fails the compile rather than being skipped.
     totalBytes += buffer.length
     if (totalBytes > MAX_STAGED_TOTAL_BYTES) {
-      throw new Error(
-        `Referenced input files exceed the ${MAX_STAGED_TOTAL_BYTES} byte staging budget.`
+      // A user-fixable condition, not a transient failure: retrying with the
+      // same references can never succeed — the images must shrink.
+      throw new DocCompileUserError(
+        `Referenced input files exceed the ${Math.round(MAX_STAGED_TOTAL_BYTES / (1024 * 1024))} MB total staging budget (the whole document's references count). Use smaller/compressed copies of the largest images.`
       )
     }
     files.push({
@@ -358,7 +359,7 @@ async function compileDocViaE2BPython(
 // `pptx`/`docx` instances, geometry constants, and fileId-based image helpers
 // (reading staged /home/user/inputs/<id> files). pptx also gets `iconImage`
 // (react-icons → sharp → PNG), which only works here because the E2B sandbox is
-// a full Linux VM. The agent's edit_content source runs inside an async IIFE so
+// a full Linux VM. The agent's apply_file_edit source runs inside an async IIFE so
 // top-level await (addImage/iconImage) works; the finalizer writes the binary.
 const PPTX_NODE_PREAMBLE = `
 const PptxGenJS = require('pptxgenjs');
@@ -608,7 +609,7 @@ export async function loadCompiledDocByExt(
   const fmt = await getE2BDocFormat(`x.${ext}`)
   if (!fmt) return null
   const referencedFileIds = collectReferencedFileIds(source)
-  if (referencedFileIds.size > MAX_STAGED_INPUTS || !options.filePrincipal) {
+  if (!options.filePrincipal) {
     if (referencedFileIds.size === 0) {
       const buffer = await loadCompiledDoc(workspaceId, source, fmt.ext)
       return buffer ? { buffer, contentType: fmt.contentType } : null
diff --git a/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts b/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
index ff1f7b10f2..e87e861f9a 100644
--- a/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/download-to-workspace-file.ts
@@ -3,7 +3,7 @@ import { getErrorMessage } from '@sim/utils/errors'
 import { z } from 'zod'
 import { executeCopilotFileUseCase } from '@/lib/copilot/application/execute-file-use-case'
 import { messageForCopilotFileError } from '@/lib/copilot/auth/file-delegation'
-import { DownloadToWorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import { DownloadFile } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -137,7 +137,7 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
   DownloadToWorkspaceFileArgs,
   DownloadToWorkspaceFileResult
 > = {
-  name: DownloadToWorkspaceFile.id,
+  name: DownloadFile.id,
   inputSchema: DownloadToWorkspaceFileArgsSchema,
   outputSchema: DownloadToWorkspaceFileResultSchema,
 
@@ -166,9 +166,17 @@ export const downloadToWorkspaceFileServerTool: BaseServerTool<
       })
 
       if (!response.ok) {
+        const hint =
+          response.status === 401 || response.status === 403
+            ? ' — the URL requires authentication this tool cannot supply; ask for a public or pre-signed link instead'
+            : response.status === 404
+              ? ' — the URL does not exist; verify it before retrying'
+              : response.status === 429
+                ? ' — the host is rate-limiting; do not retry immediately'
+                : ' — the host rejected the request; retrying the same URL will fail again'
         return {
           success: false,
-          message: `Download failed with status ${response.status} ${response.statusText}`,
+          message: `Download failed with status ${response.status} ${response.statusText}${hint}`,
         }
       }
 
diff --git a/apps/sim/lib/copilot/tools/server/files/edit-content.test.ts b/apps/sim/lib/copilot/tools/server/files/edit-content.test.ts
index 432adbefa1..f278ab131d 100644
--- a/apps/sim/lib/copilot/tools/server/files/edit-content.test.ts
+++ b/apps/sim/lib/copilot/tools/server/files/edit-content.test.ts
@@ -6,7 +6,7 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 const {
   buildEmbeddedImageRefWarningMock,
   compileDocForWriteMock,
-  consumeLatestFileIntentMock,
+  waitForLatestFileIntentMock,
   executeCopilotFileUseCaseMock,
   getDocumentFormatInfoMock,
   inferContentTypeMock,
@@ -14,7 +14,7 @@ const {
 } = vi.hoisted(() => ({
   buildEmbeddedImageRefWarningMock: vi.fn(),
   compileDocForWriteMock: vi.fn(),
-  consumeLatestFileIntentMock: vi.fn(),
+  waitForLatestFileIntentMock: vi.fn(),
   executeCopilotFileUseCaseMock: vi.fn(),
   getDocumentFormatInfoMock: vi.fn(),
   inferContentTypeMock: vi.fn(),
@@ -41,7 +41,7 @@ vi.mock('@/lib/copilot/tools/server/files/embedded-image-refs', () => ({
   buildEmbeddedImageRefWarning: buildEmbeddedImageRefWarningMock,
 }))
 vi.mock('@/lib/copilot/tools/server/files/file-intent-store', () => ({
-  consumeLatestFileIntent: consumeLatestFileIntentMock,
+  waitForLatestFileIntent: waitForLatestFileIntentMock,
 }))
 vi.mock('@/lib/copilot/tools/server/files/workspace-file', () => ({
   compileDocForWrite: compileDocForWriteMock,
@@ -82,7 +82,7 @@ describe('edit_content', () => {
     compileDocForWriteMock.mockResolvedValue({ ok: true, sourceMime: 'text/x-python-pdf' })
     executeCopilotFileUseCaseMock.mockResolvedValue({})
     buildEmbeddedImageRefWarningMock.mockResolvedValue('')
-    consumeLatestFileIntentMock.mockResolvedValue({
+    waitForLatestFileIntentMock.mockResolvedValue({
       operation: 'update',
       fileId: 'pdf-1',
       workspaceId: 'workspace-1',
diff --git a/apps/sim/lib/copilot/tools/server/files/edit-content.ts b/apps/sim/lib/copilot/tools/server/files/edit-content.ts
index 1a0fe9ec51..62bb1ce7ff 100644
--- a/apps/sim/lib/copilot/tools/server/files/edit-content.ts
+++ b/apps/sim/lib/copilot/tools/server/files/edit-content.ts
@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
+import { truncate } from '@sim/utils/string'
 import { executeCopilotFileUseCase } from '@/lib/copilot/application/execute-file-use-case'
 import {
   messageForCopilotFileError,
@@ -12,9 +13,16 @@ import {
 } from '@/lib/copilot/tools/server/base-tool'
 import { isDocSandboxEnabled } from '@/lib/core/config/env-flags'
 import { updateWorkspaceFileContent } from '@/lib/workspace-files/application/update-workspace-file-content'
+import {
+  collectSimPageDiagnostics,
+  HAND_WRITTEN_PAGE_MESSAGE,
+  isHandWrittenCompiledPage,
+  isSimPageSource,
+  SIM_PAGE_CONTENT_TYPE,
+} from '@/lib/workspace-files/page-compile'
 import { getE2BDocFormat } from './doc-compile'
 import { buildEmbeddedImageRefWarning } from './embedded-image-refs'
-import { consumeLatestFileIntent } from './file-intent-store'
+import { waitForLatestFileIntent } from './file-intent-store'
 import { compileDocForWrite, getDocumentFormatInfo, inferContentType } from './workspace-file'
 
 const logger = createLogger('EditContentServerTool')
@@ -30,10 +38,10 @@ type EditContentResult = {
 }
 
 export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentResult> = {
-  name: 'edit_content',
+  name: 'apply_file_edit',
   async execute(params: EditContentArgs, context?: ServerToolContext): Promise<EditContentResult> {
     if (!context?.userId) {
-      logger.error('Unauthorized attempt to use edit_content')
+      logger.error('Unauthorized attempt to use apply_file_edit')
       throw new Error('Authentication required')
     }
 
@@ -52,15 +60,16 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
           : undefined
 
     if (content === undefined) {
-      return { success: false, message: 'content is required for edit_content' }
+      return { success: false, message: 'content is required for apply_file_edit' }
     }
 
     // Consume the intent from THIS file subagent's channel (its outer tool_use
     // id), not just the latest in the message — otherwise two file agents
-    // writing concurrently would each grab whichever workspace_file landed last
+    // writing concurrently would each grab whichever prepare_file_edit landed last
     // and write their content into the wrong file. Falls back to latest-in-
     // message when no channel id is present (main-agent / legacy calls).
-    const intent = await consumeLatestFileIntent(workspaceId, {
+    // Waits briefly: a prepare batched into the same round may still be running.
+    const intent = await waitForLatestFileIntent(workspaceId, {
       chatId: context.chatId,
       messageId: context.messageId,
       channelId: context.parentToolCallId,
@@ -69,7 +78,7 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
       return {
         success: false,
         message:
-          'No workspace_file context found. Call workspace_file first, wait for it to succeed, then call edit_content in the next step. Do not emit edit_content in parallel or in the same batch as workspace_file.',
+          'No prepare_file_edit context found. Call prepare_file_edit first, wait for it to succeed, then call apply_file_edit in the next step. Do not emit apply_file_edit in parallel or in the same batch as prepare_file_edit.',
       }
     }
 
@@ -77,11 +86,33 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
       const { operation, fileRecord } = intent
       const docInfo = getDocumentFormatInfo(fileRecord.name)
       const e2bFmt = isDocSandboxEnabled ? await getE2BDocFormat(fileRecord.name) : null
+      // Agent-authored pages are stored as SOURCE (frontmatter + markdown +
+      // sim: fences) and compiled to the docs-styled document at render time
+      // — the pdf model: the file holds the source, the preview/share/
+      // download surfaces serve the rendered version. Bespoke raw HTML
+      // passes through, but a hand-written copy of compiled output defeats
+      // the source format, so it is rejected with the steer back to source.
+      // Patches are exempt: small in-place fixes on a legacy stored-compiled
+      // page legitimately contain compiled fragments.
+      // Sim pages store an extensionless name; the record type marks them.
+      const isHtmlTarget =
+        fileRecord.name.toLowerCase().endsWith('.html') || fileRecord.type === SIM_PAGE_CONTENT_TYPE
+      if (
+        isHtmlTarget &&
+        (operation === 'append' || operation === 'update') &&
+        isHandWrittenCompiledPage(content)
+      ) {
+        return { success: false, message: HAND_WRITTEN_PAGE_MESSAGE }
+      }
 
       let finalContent: string
       switch (operation) {
         case 'append': {
           const existing = intent.existingContent ?? ''
+          if (isHtmlTarget) {
+            finalContent = existing ? `${existing}\n${content}` : content
+            break
+          }
           // The JS engines (isolated-vm and E2B-node pptx/docx) use the `{ ... }`
           // block-append convention — block statements scope cleanly inside the
           // compile wrapper. Python docs (pdf/xlsx) are a single cohesive script,
@@ -114,7 +145,19 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
             if (firstIdx === -1) {
               return {
                 success: false,
-                message: `Patch failed: search string not found in file "${fileRecord.name}"`,
+                message: `Patch failed: search string not found in file "${fileRecord.name}": ${JSON.stringify(truncate(search, 120))}`,
+              }
+            }
+            // The tool doc promises "must match exactly once unless
+            // replaceAll" — enforce it, or an ambiguous search silently
+            // rewrites the first occurrence with a success receipt.
+            if (!intent.edit.replaceAll) {
+              const occurrences = existing.split(search).length - 1
+              if (occurrences > 1) {
+                return {
+                  success: false,
+                  message: `Patch failed: search string matches ${occurrences} places in "${fileRecord.name}". Add surrounding context to make it unique, or pass replaceAll: true to change every occurrence.`,
+                }
               }
             }
             finalContent = intent.edit.replaceAll
@@ -238,6 +281,14 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
         return { success: false, message: compiled.message }
       }
 
+      // The internal page type: the record advertises what the .html holds so
+      // surfaces can force the rendered view before content loads. The file
+      // itself stays .html (serve/download emit text/html).
+      // create_empty_file stamps copilot .html as a page by default; the
+      // first real content confirms or corrects that from what was written.
+      const storedContentType =
+        isHtmlTarget && isSimPageSource(finalContent) ? SIM_PAGE_CONTENT_TYPE : compiled.sourceMime
+
       const fileBuffer = Buffer.from(finalContent, 'utf-8')
       assertServerToolNotAborted(context)
       // `updateWorkspaceFileContent` also streams this edit into any open collaborative editor as a live
@@ -251,7 +302,7 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
           assertedWorkspaceId: workspaceId,
           content: finalContent,
           encoding: 'utf-8',
-          contentType: compiled.sourceMime,
+          contentType: storedContentType,
           provenanceMode: operation === 'update' ? 'replace_empty' : 'preserve',
         },
         { fileId: intent.fileId }
@@ -259,7 +310,7 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
 
       const verb =
         operation === 'append' ? 'appended to' : operation === 'update' ? 'updated' : 'patched'
-      logger.info(`Workspace file ${verb} via copilot (edit_content)`, {
+      logger.info(`Workspace file ${verb} via copilot (apply_file_edit)`, {
         fileId: intent.fileId,
         name: fileRecord.name,
         operation,
@@ -271,20 +322,31 @@ export const editContentServerTool: BaseServerTool<EditContentArgs, EditContentR
       // (non-workspace or missing), so it can self-correct on the next step.
       const embedWarning = await buildEmbeddedImageRefWarning(content, workspaceId)
 
+      // Page-source lint: a malformed sim: block renders as NOTHING for the
+      // reader — the only place the failure surfaces is right here, so the
+      // agent can fix the fence instead of shipping a silent hole.
+      let pageLint = ''
+      if (storedContentType === SIM_PAGE_CONTENT_TYPE) {
+        const diagnostics = collectSimPageDiagnostics(finalContent)
+        if (diagnostics.length > 0) {
+          pageLint = ` WARNING — ${diagnostics.length} block(s) failed to compile and are OMITTED from the rendered page; fix them: ${diagnostics.join('; ')}`
+        }
+      }
+
       return {
         success: true,
-        message: `File "${fileRecord.name}" ${verb} successfully (${fileBuffer.length} bytes)${embedWarning}`,
+        message: `File "${fileRecord.name}" ${verb} successfully (${fileBuffer.length} bytes)${embedWarning}${pageLint}`,
         data: {
           id: intent.fileId,
           name: fileRecord.name,
           size: fileBuffer.length,
-          contentType: compiled.sourceMime,
+          contentType: storedContentType,
         },
       }
     } catch (error) {
       const safeMessage = messageForCopilotFileError(error, 'Failed to edit file content')
       const errorMessage = getErrorMessage(error, 'Unknown error occurred')
-      logger.error('Error in edit_content tool', {
+      logger.error('Error in apply_file_edit tool', {
         operation: intent.operation,
         fileId: intent.fileId,
         error: errorMessage,
diff --git a/apps/sim/lib/copilot/tools/server/files/extract-doc-assets.ts b/apps/sim/lib/copilot/tools/server/files/extract-doc-assets.ts
new file mode 100644
index 0000000000..5f8019b38c
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/files/extract-doc-assets.ts
@@ -0,0 +1,221 @@
+import { createLogger } from '@sim/logger'
+import { getErrorMessage } from '@sim/utils/errors'
+import { z } from 'zod'
+import {
+  executeCopilotFileUseCase,
+  resolveCopilotWorkspaceFileReference,
+} from '@/lib/copilot/application/execute-file-use-case'
+import { messageForCopilotFileError } from '@/lib/copilot/auth/file-delegation'
+import { ExtractDocAssets } from '@/lib/copilot/generated/tool-catalog-v1'
+import {
+  assertServerToolNotAborted,
+  type BaseServerTool,
+  type ServerToolContext,
+} from '@/lib/copilot/tools/server/base-tool'
+import { extractDocAssets } from '@/lib/copilot/tools/server/files/doc-asset-extract'
+import { extractPdfAssets } from '@/lib/copilot/tools/server/files/doc-asset-extract-pdf'
+import { getFileExtension, getMimeTypeFromExtension } from '@/lib/uploads/utils/file-utils'
+import { fileOperations } from '@/lib/workspace-files/application/operations'
+import { readWorkspaceFileContent } from '@/lib/workspace-files/application/read-workspace-file-content'
+import {
+  createWorkspaceFileByPath,
+  updateWorkspaceFileContentByPath,
+} from '@/lib/workspace-files/application/write-workspace-file-by-path'
+
+const logger = createLogger('ExtractDocAssetsTool')
+
+const MAX_SOURCE_BYTES = 100 * 1024 * 1024 // 100 MB
+const MAX_MEDIA_FILES = 200
+
+const ExtractDocAssetsArgsSchema = z.object({
+  path: z.string().min(1),
+  destination: z.string().min(1).optional(),
+})
+
+const ExtractDocAssetsResultSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  themePath: z.string().optional(),
+  theme: z.unknown().optional(),
+  files: z
+    .array(z.object({ fileId: z.string(), fileName: z.string(), vfsPath: z.string() }))
+    .optional(),
+})
+
+type ExtractDocAssetsArgs = z.infer<typeof ExtractDocAssetsArgsSchema>
+type ExtractDocAssetsResult = z.infer<typeof ExtractDocAssetsResultSchema>
+
+/**
+ * Materializes a reference document's design into workspace files with a
+ * fixed, predictable structure: `<destination>/theme.json` (color scheme,
+ * fonts, slide size), `<destination>/layout.json` (the slide/page-by-page
+ * text and asset layout, pptx and pdf), plus one file per embedded image —
+ * original bytes for OOXML media; for PDF, an image stored as base +
+ * separate alpha mask is recombined into a transparent PNG.
+ * Re-running against the same destination overwrites the previous set
+ * instead of duplicating it. The source document is never modified.
+ */
+export const extractDocAssetsServerTool: BaseServerTool<
+  ExtractDocAssetsArgs,
+  ExtractDocAssetsResult
+> = {
+  name: ExtractDocAssets.id,
+  inputSchema: ExtractDocAssetsArgsSchema,
+  outputSchema: ExtractDocAssetsResultSchema,
+
+  async execute(
+    params: ExtractDocAssetsArgs,
+    context?: ServerToolContext
+  ): Promise<ExtractDocAssetsResult> {
+    if (!context?.userId) {
+      throw new Error('Authentication required')
+    }
+    const workspaceId = context.workspaceId
+    if (!workspaceId) {
+      return { success: false, message: 'Workspace ID is required' }
+    }
+
+    try {
+      assertServerToolNotAborted(context)
+
+      const record = await resolveCopilotWorkspaceFileReference(
+        context,
+        fileOperations.readContent,
+        { workspaceId, reference: params.path }
+      )
+      const sourceName = record.name
+      const ext = getFileExtension(sourceName).toLowerCase()
+      if (ext !== 'pptx' && ext !== 'docx' && ext !== 'pdf') {
+        return {
+          success: false,
+          message: `"${sourceName}" is a .${ext || '?'} file — assets can only be extracted from .pptx, .docx, or .pdf documents`,
+        }
+      }
+
+      const { content } = await executeCopilotFileUseCase(
+        context,
+        readWorkspaceFileContent,
+        { fileId: record.id, assertedWorkspaceId: workspaceId, maxBytes: MAX_SOURCE_BYTES },
+        { fileId: record.id }
+      )
+
+      assertServerToolNotAborted(context)
+      // OOXML is a zip and extracts in-process; PDF needs the doc sandbox's
+      // poppler/pdfplumber toolchain (same environment that compiles docs).
+      const extracted =
+        ext === 'pdf' ? await extractPdfAssets(content) : await extractDocAssets(content, ext)
+      const totalMediaCount = extracted.media.length
+      if (totalMediaCount > MAX_MEDIA_FILES) {
+        extracted.media = extracted.media.slice(0, MAX_MEDIA_FILES)
+      }
+
+      const baseName = sourceName.replace(/\.[^.]+$/, '')
+      const destination = (params.destination ?? `files/${baseName} assets`).replace(/\/+$/, '')
+
+      // Overwrite-or-create per file: a re-run refreshes the set in place
+      // rather than erroring on the existing files or duplicating them.
+      const writeAsset = async (name: string, bytes: Buffer, contentType: string) => {
+        const writeInput = {
+          workspaceId,
+          path: `${destination}/${name}`,
+          content: bytes.toString('base64'),
+          encoding: 'base64' as const,
+          contentType,
+        }
+        try {
+          return await executeCopilotFileUseCase(context, createWorkspaceFileByPath, {
+            ...writeInput,
+            mode: 'create' as const,
+          })
+        } catch {
+          return await executeCopilotFileUseCase(context, updateWorkspaceFileContentByPath, {
+            ...writeInput,
+            mode: 'overwrite' as const,
+          })
+        }
+      }
+
+      const written: Array<{ fileId: string; fileName: string; vfsPath: string }> = []
+      const themeFile = await writeAsset(
+        'theme.json',
+        Buffer.from(JSON.stringify(extracted.theme, null, 2), 'utf8'),
+        'application/json'
+      )
+      written.push({ fileId: themeFile.id, fileName: themeFile.name, vfsPath: themeFile.vfsPath })
+
+      // The slide/page-by-page rebuild recipe — text blocks with their frame,
+      // font, size, and color, plus each slide's asset placements by extracted
+      // filename (pdf pages also carry filled rects and overlay scrims).
+      let wroteLayout = false
+      if (extracted.layout.length > 0) {
+        const layoutFile = await writeAsset(
+          'layout.json',
+          Buffer.from(JSON.stringify(extracted.layout, null, 2), 'utf8'),
+          'application/json'
+        )
+        written.push({
+          fileId: layoutFile.id,
+          fileName: layoutFile.name,
+          vfsPath: layoutFile.vfsPath,
+        })
+        wroteLayout = true
+      }
+
+      for (const media of extracted.media) {
+        assertServerToolNotAborted(context)
+        const mediaExt = getFileExtension(media.name)
+        const mime = mediaExt ? getMimeTypeFromExtension(mediaExt) : 'application/octet-stream'
+        const file = await writeAsset(media.name, media.bytes, mime)
+        written.push({ fileId: file.id, fileName: file.name, vfsPath: file.vfsPath })
+      }
+
+      logger.info('Extracted document assets to workspace', {
+        source: params.path,
+        destination,
+        mediaCount: extracted.media.length,
+        droppedMediaCount: totalMediaCount - extracted.media.length,
+        format: extracted.theme.format,
+      })
+
+      const themeSummary = (
+        extracted.theme.format === 'pdf'
+          ? [
+              extracted.theme.fonts.length > 0 ? 'font names' : null,
+              extracted.theme.inferredPalette.length > 0 ? 'inferred palette' : null,
+              'page size and image placements',
+            ]
+          : [
+              Object.keys(extracted.theme.colors).length > 0 ? 'theme colors' : null,
+              extracted.theme.fonts.major || extracted.theme.fonts.minor ? 'fonts' : null,
+              extracted.theme.slideSize ? 'slide size' : null,
+            ]
+      )
+        .filter(Boolean)
+        .join(', ')
+      const unit = extracted.theme.format === 'pdf' ? 'page' : 'slide'
+      const layoutNote = wroteLayout
+        ? `, plus layout.json (${unit}-by-${unit} text and asset layout)`
+        : ''
+      // Never report a truncated set as complete: theme/layout may reference
+      // media that was not written.
+      const truncationNote =
+        totalMediaCount > extracted.media.length
+          ? ` NOTE: the document holds ${totalMediaCount} media files; only the first ${extracted.media.length} were extracted — theme/layout references beyond that were not written.`
+          : ''
+      return {
+        success: true,
+        message: `Extracted ${extracted.media.length} asset file(s) and theme.json (${themeSummary || 'no theme data found'})${layoutNote} from "${sourceName}" into ${destination}/${truncationNote}`,
+        themePath: written[0]?.vfsPath,
+        theme: extracted.theme,
+        files: written,
+      }
+    } catch (error) {
+      const msg = getErrorMessage(error, 'Unknown error')
+      logger.error('Failed to extract document assets', { path: params.path, error: msg })
+      return {
+        success: false,
+        message: `Failed to extract assets: ${messageForCopilotFileError(error, 'Unable to extract document assets')}`,
+      }
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/files/file-intent-store.test.ts b/apps/sim/lib/copilot/tools/server/files/file-intent-store.test.ts
index af26937c4b..e9cc1dee13 100644
--- a/apps/sim/lib/copilot/tools/server/files/file-intent-store.test.ts
+++ b/apps/sim/lib/copilot/tools/server/files/file-intent-store.test.ts
@@ -1,9 +1,11 @@
+import { sleep } from '@sim/utils/helpers'
 import { generateShortId } from '@sim/utils/id'
 import { describe, expect, it } from 'vitest'
 import {
   consumeLatestFileIntent,
   type PendingFileIntent,
   storeFileIntent,
+  waitForLatestFileIntent,
 } from './file-intent-store'
 
 function makeIntent(overrides: Partial<PendingFileIntent>): PendingFileIntent {
@@ -47,11 +49,11 @@ describe('file-intent-store channel scoping', () => {
       })
     )
 
-    // edit_content from channel F1 must get fileA — NOT the latest (fileB).
+    // apply_file_edit from channel F1 must get fileA — NOT the latest (fileB).
     const a = await consumeLatestFileIntent(ws, { ...scope, channelId: 'F1' })
     expect(a?.fileId).toBe('fileA')
 
-    // edit_content from channel F2 gets fileB.
+    // apply_file_edit from channel F2 gets fileB.
     const b = await consumeLatestFileIntent(ws, { ...scope, channelId: 'F2' })
     expect(b?.fileId).toBe('fileB')
   })
@@ -118,3 +120,32 @@ describe('file-intent-store channel scoping', () => {
     expect(none).toBeUndefined()
   })
 })
+
+describe('waitForLatestFileIntent', () => {
+  // The model can batch prepare_file_edit + apply_file_edit into one round, and
+  // same-round tools execute concurrently — apply must tolerate its prepare
+  // landing a beat later instead of failing the pair.
+  it('picks up an intent staged after the wait began', async () => {
+    const ws = uniqueWorkspace()
+    const scope = { chatId: 'chat-1', messageId: 'msg-1', channelId: 'F1' }
+    const pending = waitForLatestFileIntent(ws, scope, { timeoutMs: 500, intervalMs: 10 })
+    await sleep(30)
+    await storeFileIntent(
+      ws,
+      'fileA',
+      makeIntent({ workspaceId: ws, fileId: 'fileA', channelId: 'F1', createdAt: Date.now() })
+    )
+    const intent = await pending
+    expect(intent?.fileId).toBe('fileA')
+  })
+
+  it('returns undefined once the deadline passes with no intent staged', async () => {
+    const ws = uniqueWorkspace()
+    const none = await waitForLatestFileIntent(
+      ws,
+      { chatId: 'chat-1', messageId: 'msg-1', channelId: 'F1' },
+      { timeoutMs: 40, intervalMs: 10 }
+    )
+    expect(none).toBeUndefined()
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts b/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts
index 726693b7b5..30fe0c8be5 100644
--- a/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts
+++ b/apps/sim/lib/copilot/tools/server/files/file-intent-store.ts
@@ -12,7 +12,7 @@ export type PendingFileIntent = {
   chatId?: string
   messageId?: string
   // The invoking file subagent's channel id (its outer tool_use id). Lets
-  // edit_content consume the intent for ITS OWN file subagent instead of the
+  // apply_file_edit consume the intent for ITS OWN file subagent instead of the
   // latest in the message, so two file agents writing concurrently never cross
   // their content into each other's file.
   channelId?: string
@@ -180,6 +180,36 @@ export async function peekFileIntent(
   return intent
 }
 
+const INTENT_WAIT_TIMEOUT_MS = 10_000
+const INTENT_WAIT_INTERVAL_MS = 300
+
+/**
+ * Bounded wait for the paired prepare_file_edit to stage its intent. The model
+ * may batch prepare_file_edit and apply_file_edit into one round, and the Go
+ * loop executes same-round tools concurrently — so apply_file_edit can reach
+ * this executor before its prepare has run. Failing instantly turns that
+ * ordinary race into a model-visible error, a wasted retry round, and a
+ * transient "Failed …" state on the chat's shared file row. Polling briefly
+ * lets the prepare land and the pair succeed first try; a truly missing
+ * prepare still returns undefined once the deadline passes.
+ */
+export async function waitForLatestFileIntent(
+  workspaceId: string,
+  scope?: FileIntentScope,
+  options?: { timeoutMs?: number; intervalMs?: number }
+): Promise<PendingFileIntent | undefined> {
+  const timeoutMs = options?.timeoutMs ?? INTENT_WAIT_TIMEOUT_MS
+  const intervalMs = options?.intervalMs ?? INTENT_WAIT_INTERVAL_MS
+  const deadline = Date.now() + timeoutMs
+  for (;;) {
+    const intent = await consumeLatestFileIntent(workspaceId, scope)
+    if (intent) return intent
+    const remainingMs = deadline - Date.now()
+    if (remainingMs <= 0) return undefined
+    await sleep(Math.min(intervalMs, remainingMs))
+  }
+}
+
 export async function consumeLatestFileIntent(
   workspaceId: string,
   scope?: FileIntentScope
diff --git a/apps/sim/lib/copilot/tools/server/files/file-preview.ts b/apps/sim/lib/copilot/tools/server/files/file-preview.ts
index d99f219021..f706231d5e 100644
--- a/apps/sim/lib/copilot/tools/server/files/file-preview.ts
+++ b/apps/sim/lib/copilot/tools/server/files/file-preview.ts
@@ -135,9 +135,9 @@ function buildAppendPreview(existingContent: string, incomingContent: string): s
 /**
  * Reads the current UTF-8 text of a workspace file for streaming previews.
  *
- * Preview runs in the SSE loop on `workspace_file` **call** events, which are
+ * Preview runs in the SSE loop on `prepare_file_edit` **call** events, which are
  * processed **before** the async tool executor persists {@link storeFileIntent}.
- * Loading the base here avoids a race where `edit_content` `args_delta` arrives
+ * Loading the base here avoids a race where `apply_file_edit` `args_delta` arrives
  * before Redis holds `existingContent`, which would make append previews look like
  * full-file replacement until the intent landed.
  */
@@ -193,7 +193,7 @@ export function buildFilePreviewText({
     // Fail closed (like `patch`/`update` below) when the base file content has not loaded yet: a base-less
     // `append` preview is just the streamed fragment, and a collaborative editor applying it as the full
     // body would reconcile the seeded doc down to that fragment (a wipe). Skipping the preview until the
-    // base is available costs only a brief render delay; the final durable `edit_content` write is
+    // base is available costs only a brief render delay; the final durable `apply_file_edit` write is
     // authoritative. An empty file has `existingContent === ''` (defined), so it is unaffected.
     if (existingContent === undefined) {
       return undefined
diff --git a/apps/sim/lib/copilot/tools/server/files/share-file.ts b/apps/sim/lib/copilot/tools/server/files/share-file.ts
index aafa2281f4..e59ae20c81 100644
--- a/apps/sim/lib/copilot/tools/server/files/share-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/share-file.ts
@@ -11,6 +11,7 @@ import {
   type BaseServerTool,
   type ServerToolContext,
 } from '@/lib/copilot/tools/server/base-tool'
+import { resolveEnvReferenceSecretArg } from '@/lib/copilot/tools/server/env-reference'
 import { asOrchestrationError } from '@/lib/core/orchestration/types'
 import { fileOperations } from '@/lib/workspace-files/application/operations'
 import { readWorkspaceFileMetadata } from '@/lib/workspace-files/application/read-workspace-file-metadata'
@@ -60,7 +61,20 @@ export const shareFileServerTool: BaseServerTool<ShareFileArgs, ShareFileResult>
     const authType = (params.authType || (nested?.authType as ShareAuthType | undefined)) as
       | ShareAuthType
       | undefined
-    const password = params.password || (nested?.password as string) || undefined
+    const rawPassword = params.password || (nested?.password as string) || undefined
+    // "Protect it with the password in {{SHARE_PW}}" arrives as the literal
+    // reference — resolve it, or the placeholder becomes the real password.
+    const resolvedPassword = await resolveEnvReferenceSecretArg({
+      userId: context.userId,
+      workspaceId: context.workspaceId,
+      value: rawPassword,
+      argName: 'password',
+      registry: context.resolvedSecretTraceRegistry,
+    })
+    if (resolvedPassword.error) {
+      return { success: false, message: resolvedPassword.error }
+    }
+    const password = resolvedPassword.value
     const allowedEmails =
       params.allowedEmails || (nested?.allowedEmails as string[] | undefined) || undefined
 
diff --git a/apps/sim/lib/copilot/tools/server/files/workspace-file.ts b/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
index f40fbe0065..443df45757 100644
--- a/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
+++ b/apps/sim/lib/copilot/tools/server/files/workspace-file.ts
@@ -10,7 +10,7 @@ import {
   messageForCopilotFileError,
   resolveCopilotFilePrincipal,
 } from '@/lib/copilot/auth/file-delegation'
-import { WorkspaceFile } from '@/lib/copilot/generated/tool-catalog-v1'
+import { PrepareFileEdit } from '@/lib/copilot/generated/tool-catalog-v1'
 import {
   assertServerToolNotAborted,
   type BaseServerTool,
@@ -111,6 +111,7 @@ const EXT_TO_MIME: Record<string, string> = {
   '.html': 'text/html',
   '.json': 'application/json',
   '.csv': 'text/csv',
+  '.chart': 'text/x-sim-chart',
   '.pptx': PPTX_MIME,
   '.docx': DOCX_MIME,
   '.pdf': PDF_MIME,
@@ -191,7 +192,7 @@ export type CompileForWriteResult =
   | { ok: false; message: string }
 
 /**
- * Shared write-time doc handling for create + edit_content: validates and builds
+ * Shared write-time doc handling for create + apply_file_edit: validates and builds
  * the document (E2B doc sandbox when enabled — Node pptx/docx, Python pdf/xlsx —
  * else isolated-vm JS) and returns the source MIME to store, or a user-facing
  * failure message. Non-doc files resolve to `fallbackMime`. The remote backend publishes a
@@ -260,7 +261,7 @@ export async function compileDocForWrite(args: {
 }
 
 export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, WorkspaceFileResult> = {
-  name: WorkspaceFile.id,
+  name: PrepareFileEdit.id,
   async execute(
     params: WorkspaceFileArgs,
     context?: ServerToolContext
@@ -381,7 +382,10 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
             if (classified?.code !== 'not_found') throw error
           }
           if (existingFile) {
-            return { success: false, message: `File "${target.fileName}" already exists` }
+            return {
+              success: false,
+              message: `File "${target.fileName}" already exists in this workspace (file names are workspace-scoped; folders do not namespace them). Use operation "update"/"append"/"patch" to change it, rename the existing file, or pick a different fileName.`,
+            }
           }
 
           const compiled = await compileDocForWrite({
@@ -478,7 +482,7 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           return {
             success: true,
             message: withMessageId(
-              `Intent set: append to "${existingFile.name}". Wait for this success result, then call edit_content in the next step with the content to write. Do not call edit_content in parallel.`
+              `Intent set: append to "${existingFile.name}". Wait for this success result, then call apply_file_edit in the next step with the content to write. Do not call apply_file_edit in parallel.`
             ),
             data: { id: existingFile.id, name: existingFile.name, vfsPath, operation: 'append' },
           }
@@ -506,7 +510,7 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           return {
             success: true,
             message: withMessageId(
-              `Intent set: update "${fileRecord.name}". Wait for this success result, then call edit_content in the next step with the replacement content. Do not call edit_content in parallel.`
+              `Intent set: update "${fileRecord.name}". Wait for this success result, then call apply_file_edit in the next step with the replacement content. Do not call apply_file_edit in parallel.`
             ),
             data: { id: fileRecord.id, name: fileRecord.name, vfsPath, operation: 'update' },
           }
@@ -710,7 +714,7 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
           return {
             success: true,
             message: withMessageId(
-              `Intent set: patch "${fileRecord.name}" (${normalized.edit.strategy}). Wait for this success result, then call edit_content in the next step with the replacement/insert content. Do not call edit_content in parallel.`
+              `Intent set: patch "${fileRecord.name}" (${normalized.edit.strategy}). Wait for this success result, then call apply_file_edit in the next step with the replacement/insert content. Do not call apply_file_edit in parallel.`
             ),
             data: { id: fileRecord.id, name: fileRecord.name, vfsPath, operation: 'patch' },
           }
@@ -724,7 +728,7 @@ export const workspaceFileServerTool: BaseServerTool<WorkspaceFileArgs, Workspac
       }
     } catch (error) {
       const errorMessage = getErrorMessage(error, 'Unknown error occurred')
-      logger.error('Error in workspace_file tool', {
+      logger.error('Error in prepare_file_edit tool', {
         operation,
         error: errorMessage,
         userId: context.userId,
diff --git a/apps/sim/lib/copilot/tools/server/image/generate-image.ts b/apps/sim/lib/copilot/tools/server/image/generate-image.ts
index 52cbc5c5db..f9f5be655e 100644
--- a/apps/sim/lib/copilot/tools/server/image/generate-image.ts
+++ b/apps/sim/lib/copilot/tools/server/image/generate-image.ts
@@ -18,6 +18,7 @@ import {
 import { writeCopilotWorkspaceFileByPath } from '@/lib/copilot/vfs/resource-writer'
 import { getRotatingApiKey } from '@/lib/core/config/api-keys'
 import { MAX_MEDIA_BYTES } from '@/lib/media/falai'
+import { createWorkspaceFileSecretProvenanceFromRegistry } from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
 import { fileOperations } from '@/lib/workspace-files/application/operations'
 import { readWorkspaceFileContent } from '@/lib/workspace-files/application/read-workspace-file-content'
 
@@ -188,6 +189,16 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
       const mode = outputFile?.mode ?? 'create'
 
       assertServerToolNotAborted(context)
+      // Reference images were asserted opaque-egress-safe above, so the prompt
+      // is the only secret-bearing input this file can inherit. Recording its
+      // provenance is what keeps the written file readable by the model later:
+      // a write without a sidecar stamps the file "unknown" and every
+      // content-view read of it is refused.
+      const promptProvenance = await createWorkspaceFileSecretProvenanceFromRegistry(
+        context.resolvedSecretTraceRegistry,
+        prompt,
+        { userId: context.userId, workspaceId }
+      )
       const written = await writeCopilotWorkspaceFileByPath(context, {
         workspaceId,
         target: {
@@ -197,6 +208,9 @@ export const generateImageServerTool: BaseServerTool<GenerateImageArgs, Generate
         },
         buffer: imageBuffer,
         inferredMimeType: mimeType,
+        secretProvenance: promptProvenance.safe
+          ? promptProvenance.provenance
+          : { status: 'unknown' },
       })
 
       logger.info('Generated image saved', {
diff --git a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.test.ts b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.test.ts
index f4eff85a65..95afa3a906 100644
--- a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.test.ts
+++ b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.test.ts
@@ -81,7 +81,13 @@ const {
 })
 
 vi.mock('@/lib/copilot/generated/tool-catalog-v1', () => ({
-  KnowledgeBase: { id: 'knowledge_base' },
+  ManageKnowledgeBase: { id: 'manage_knowledge_base' },
+}))
+const { mockGetEffectiveDecryptedEnv } = vi.hoisted(() => ({
+  mockGetEffectiveDecryptedEnv: vi.fn(),
+}))
+vi.mock('@/lib/environment/utils', () => ({
+  getEffectiveDecryptedEnv: mockGetEffectiveDecryptedEnv,
 }))
 vi.mock('@/lib/core/telemetry', () => ({
   PlatformEvents: {
@@ -224,7 +230,7 @@ function expectDelegatedPrincipal(call: unknown): void {
   })
 }
 
-describe('knowledge_base trusted application delegation', () => {
+describe('manage_knowledge_base trusted application delegation', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockReadKnowledgeBase.mockResolvedValue({ knowledgeBase: KNOWLEDGE_BASE, folderPath: '/' })
@@ -565,6 +571,48 @@ describe('knowledge_base trusted application delegation', () => {
     })
   })
 
+  it('delegates per-document typed tag values by tag definition ID', async () => {
+    mockUpdateKnowledgeDocument.mockResolvedValueOnce({
+      document: {},
+      updatedFields: ['tag1', 'number1'],
+    })
+
+    const result = await knowledgeBaseServerTool.execute(
+      {
+        operation: 'update_document',
+        args: {
+          knowledgeBaseId: KNOWLEDGE_BASE.id,
+          documentId: 'document-1',
+          tagValues: [
+            { tagDefinitionId: 'category-tag', value: 'support' },
+            { tagDefinitionId: 'priority-tag', value: 2 },
+          ],
+        },
+      },
+      CONTEXT
+    )
+
+    expect(result).toMatchObject({
+      success: true,
+      data: {
+        documentId: 'document-1',
+        tagDefinitionIds: ['category-tag', 'priority-tag'],
+      },
+    })
+    const call = mockUpdateKnowledgeDocument.mock.calls[0][0]
+    expectDelegatedPrincipal(call)
+    expect(call.input).toEqual({
+      knowledgeBaseId: KNOWLEDGE_BASE.id,
+      documentId: 'document-1',
+      assertedWorkspaceId: 'workspace-paid',
+      tagValues: [
+        { tagDefinitionId: 'category-tag', value: 'support' },
+        { tagDefinitionId: 'priority-tag', value: 2 },
+      ],
+      source: 'agent',
+    })
+  })
+
   it('does not expose connector infrastructure errors to the model', async () => {
     mockUpdateKnowledgeConnector.mockRejectedValueOnce(new Error('sql host=private-db'))
 
@@ -658,6 +706,70 @@ describe('knowledge_base trusted application delegation', () => {
     })
   })
 
+  it.each(['{{SIM_GITHUB_PAT}}', '$SIM_GITHUB_PAT', 'SIM_GITHUB_PAT'])(
+    'resolves the %s environment reference into the connector API key',
+    async (ref) => {
+      mockGetEffectiveDecryptedEnv.mockResolvedValue({ SIM_GITHUB_PAT: 'ghp_realtoken' })
+
+      const result = await knowledgeBaseServerTool.execute(
+        {
+          operation: 'add_connector',
+          args: { knowledgeBaseId: KNOWLEDGE_BASE.id, connectorType: 'github', apiKey: ref },
+        },
+        BILLED_CONTEXT
+      )
+
+      expect(result.success).toBe(true)
+      const call = mockCreateKnowledgeConnector.mock.calls.at(-1)?.[0] as {
+        input: { apiKey?: string }
+      }
+      expect(call.input.apiKey).toBe('ghp_realtoken')
+    }
+  )
+
+  it('names the missing variable instead of sending a placeholder upstream', async () => {
+    mockGetEffectiveDecryptedEnv.mockResolvedValue({})
+
+    const result = await knowledgeBaseServerTool.execute(
+      {
+        operation: 'add_connector',
+        args: {
+          knowledgeBaseId: KNOWLEDGE_BASE.id,
+          connectorType: 'github',
+          apiKey: '{{SIM_GITHUB_PAT}}',
+        },
+      },
+      BILLED_CONTEXT
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.message).toContain('SIM_GITHUB_PAT')
+    expect(result.message).toContain('not set')
+    expect(mockCreateKnowledgeConnector).not.toHaveBeenCalled()
+  })
+
+  it('passes a raw API key through untouched', async () => {
+    mockGetEffectiveDecryptedEnv.mockResolvedValue({ SIM_GITHUB_PAT: 'ghp_realtoken' })
+
+    const result = await knowledgeBaseServerTool.execute(
+      {
+        operation: 'add_connector',
+        args: {
+          knowledgeBaseId: KNOWLEDGE_BASE.id,
+          connectorType: 'github',
+          apiKey: 'ghp_literal_key',
+        },
+      },
+      BILLED_CONTEXT
+    )
+
+    expect(result.success).toBe(true)
+    const call = mockCreateKnowledgeConnector.mock.calls.at(-1)?.[0] as {
+      input: { apiKey?: string }
+    }
+    expect(call.input.apiKey).toBe('ghp_literal_key')
+  })
+
   it('preserves caller-actionable tag provenance conflicts', async () => {
     mockDeleteKnowledgeTag.mockRejectedValueOnce(
       new OrchestrationError(
@@ -712,7 +824,7 @@ describe('knowledge_base trusted application delegation', () => {
   )
 })
 
-describe('knowledge_base add_file delegation', () => {
+describe('manage_knowledge_base add_file delegation', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     mockAddWorkspaceFiles.mockResolvedValue({
diff --git a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
index 1695c5aa3e..20d88e2840 100644
--- a/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
+++ b/apps/sim/lib/copilot/tools/server/knowledge/knowledge-base.ts
@@ -10,7 +10,7 @@ import {
   messageForCopilotKnowledgeError,
   requireCopilotKnowledgeWorkspaceId,
 } from '@/lib/copilot/application/execute-knowledge-use-case'
-import { KnowledgeBase } from '@/lib/copilot/generated/tool-catalog-v1'
+import { ManageKnowledgeBase } from '@/lib/copilot/generated/tool-catalog-v1'
 import { projectToolErrorMessageForCopilot } from '@/lib/copilot/request/tools/resolved-secret-result'
 import {
   assertServerToolNotAborted,
@@ -19,6 +19,7 @@ import {
 } from '@/lib/copilot/tools/server/base-tool'
 import { asOrchestrationError } from '@/lib/core/orchestration/types'
 import { PlatformEvents } from '@/lib/core/telemetry'
+import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
 import { addWorkspaceFilesToKnowledgeBase } from '@/lib/knowledge/application/add-workspace-files'
 import { KnowledgeUsageLimitExceededError } from '@/lib/knowledge/application/billing'
 import {
@@ -29,6 +30,7 @@ import {
 } from '@/lib/knowledge/application/connectors'
 import {
   bulkDeleteKnowledgeDocuments,
+  type KnowledgeDocumentTagValueAssignment,
   updateKnowledgeDocument,
 } from '@/lib/knowledge/application/documents'
 import {
@@ -46,6 +48,7 @@ import {
   updateKnowledgeTag,
 } from '@/lib/knowledge/application/tags'
 import {
+  ALL_TAG_SLOTS,
   KNOWLEDGE_TAG_DISPLAY_NAME_MAX_LENGTH,
   MAX_KNOWLEDGE_BATCH_ITEMS,
 } from '@/lib/knowledge/constants'
@@ -54,6 +57,42 @@ import { projectResolvedSecretModelContent } from '@/executor/utils/resolved-sec
 
 const logger = createLogger('KnowledgeBaseServerTool')
 
+/**
+ * Resolves an environment-variable reference passed as a connector API key.
+ *
+ * Models reference workspace secrets the way workflows do — `{{SIM_GITHUB_PAT}}`
+ * (and, when improvising, `$SIM_GITHUB_PAT` or the bare name). Before this,
+ * the literal placeholder string was sent upstream as the bearer token and the
+ * provider answered 401 — an error that never named the real problem. A raw
+ * key that matches no reference form passes through untouched.
+ *
+ * Returns an error string when a reference names a variable that is not set,
+ * so the model learns the actual fix instead of retrying reference syntaxes.
+ */
+async function resolveConnectorApiKey(
+  context: ServerToolContext,
+  workspaceId: string,
+  apiKey: string | undefined
+): Promise<{ apiKey?: string; error?: string }> {
+  if (!apiKey) return { apiKey }
+  const braced = apiKey.match(/^\{\{\s*([A-Za-z_][A-Za-z0-9_]*)\s*\}\}$/)
+  const dollar = apiKey.match(/^\$([A-Za-z_][A-Za-z0-9_]*)$/)
+  const referencedName = braced?.[1] ?? dollar?.[1]
+  const env = await getEffectiveDecryptedEnv(context.userId, workspaceId)
+  const name = referencedName ?? (Object.hasOwn(env, apiKey) ? apiKey : undefined)
+  if (!name) return { apiKey }
+  const value = env[name]
+  if (value === undefined || value === '') {
+    return {
+      error: `Environment variable "${name}" is not set for this workspace or user, so it cannot be used as the connector API key. Set it first, pass a different {{ENV_VAR}} reference, or pass the raw key.`,
+    }
+  }
+  // Activate the resolved secret on the call's egress registry so any
+  // accidental echo of it (provider error bodies, logs) is redacted.
+  context.resolvedSecretTraceRegistry?.recordResolved(name, value)
+  return { apiKey: value }
+}
+
 function requireKnowledgeBillingAttribution(
   context: ServerToolContext,
   workspaceId: string
@@ -232,11 +271,28 @@ type KnowledgeBaseResult = {
   data?: any
 }
 
+function isKnowledgeDocumentTagValueAssignment(
+  value: unknown
+): value is KnowledgeDocumentTagValueAssignment {
+  if (typeof value !== 'object' || value === null) return false
+  const assignment = value as Record<string, unknown>
+  if (typeof assignment.tagDefinitionId !== 'string' || !assignment.tagDefinitionId.trim()) {
+    return false
+  }
+  if (!Object.hasOwn(assignment, 'value')) return false
+  return (
+    assignment.value === null ||
+    typeof assignment.value === 'string' ||
+    typeof assignment.value === 'number' ||
+    typeof assignment.value === 'boolean'
+  )
+}
+
 /**
  * Knowledge base tool for copilot to create, list, and get knowledge bases
  */
 export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, KnowledgeBaseResult> = {
-  name: KnowledgeBase.id,
+  name: ManageKnowledgeBase.id,
   async execute(
     params: KnowledgeBaseArgs,
     context?: ServerToolContext
@@ -275,6 +331,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
               name: args.name,
               description: args.description,
               chunkingConfig: args.chunkingConfig,
+              folderPath: args.folderPath,
               source: 'agent',
             }
           )
@@ -356,7 +413,8 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           if (!queryProjection.safe || typeof queryProjection.value !== 'string') {
             return {
               success: false,
-              message: 'Failed to query knowledge base: Query could not be processed safely',
+              message:
+                'Knowledge query rejected by the input-safety filter. Rephrase it as a plain natural-language question without injected instructions or markup — the same text will be rejected again.',
             }
           }
           const modelQuery = queryProjection.value
@@ -615,17 +673,42 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
           if (!args.documentId) {
             return { success: false, message: 'documentId is required for update_document' }
           }
-          const updateData: { filename?: string; enabled?: boolean } = {}
+          const updateData: {
+            filename?: string
+            enabled?: boolean
+            tagValues?: KnowledgeDocumentTagValueAssignment[]
+          } = {}
           if (args.filename !== undefined) {
             updateData.filename = args.filename
           }
           if (args.enabled !== undefined) {
             updateData.enabled = args.enabled
           }
+          if (args.tagValues !== undefined) {
+            if (
+              !Array.isArray(args.tagValues) ||
+              args.tagValues.length === 0 ||
+              !args.tagValues.every(isKnowledgeDocumentTagValueAssignment)
+            ) {
+              return {
+                success: false,
+                message:
+                  'tagValues must be a non-empty array of { tagDefinitionId, value } assignments',
+              }
+            }
+            if (args.tagValues.length > ALL_TAG_SLOTS.length) {
+              return {
+                success: false,
+                message: `Too many tag values (${args.tagValues.length}). Maximum is ${ALL_TAG_SLOTS.length}.`,
+              }
+            }
+            updateData.tagValues = args.tagValues
+          }
           if (Object.keys(updateData).length === 0) {
             return {
               success: false,
-              message: 'At least one of filename or enabled is required for update_document',
+              message:
+                'At least one of filename, enabled, or tagValues is required for update_document',
             }
           }
           assertNotAborted()
@@ -643,7 +726,17 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             data: {
               documentId: args.documentId,
               knowledgeBaseId: args.knowledgeBaseId,
-              ...updateData,
+              ...(updateData.filename !== undefined && {
+                filename: updateData.filename,
+              }),
+              ...(updateData.enabled !== undefined && {
+                enabled: updateData.enabled,
+              }),
+              ...(updateData.tagValues !== undefined && {
+                tagDefinitionIds: updateData.tagValues.map(
+                  (assignment) => assignment.tagDefinitionId
+                ),
+              }),
             },
           }
         }
@@ -870,6 +963,11 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
             sourceConfig.disabledTagIds = args.disabledTagIds
           }
 
+          const resolvedKey = await resolveConnectorApiKey(context, workspaceId, args.apiKey)
+          if (resolvedKey.error) {
+            return { success: false, message: resolvedKey.error }
+          }
+
           assertNotAborted()
           const { connector, workspaceId: canonicalWorkspaceId } =
             await executeCopilotKnowledgeUseCase(context, createKnowledgeConnector, {
@@ -877,7 +975,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
               assertedWorkspaceId: workspaceId,
               connectorType: args.connectorType,
               credentialId: args.credentialId,
-              apiKey: args.apiKey,
+              apiKey: resolvedKey.apiKey,
               sourceConfig,
               syncIntervalMinutes: args.syncIntervalMinutes ?? 1440,
               resolveBillingAttribution: async (billingWorkspaceId) =>
@@ -1011,7 +1109,7 @@ export const knowledgeBaseServerTool: BaseServerTool<KnowledgeBaseArgs, Knowledg
       }
     } catch (error) {
       const errorMessage = getErrorMessage(error, 'Unknown error occurred')
-      logger.error('Error in knowledge_base tool', {
+      logger.error('Error in manage_knowledge_base tool', {
         operation,
         error: projectToolErrorMessageForCopilot(errorMessage, context.resolvedSecretTraceRegistry),
         userId: context.userId,
diff --git a/apps/sim/lib/copilot/tools/server/knowledge/search-knowledge-base.ts b/apps/sim/lib/copilot/tools/server/knowledge/search-knowledge-base.ts
index 8b22ee7d7a..3f9ee829d5 100644
--- a/apps/sim/lib/copilot/tools/server/knowledge/search-knowledge-base.ts
+++ b/apps/sim/lib/copilot/tools/server/knowledge/search-knowledge-base.ts
@@ -16,7 +16,7 @@ type SearchKnowledgeBaseResult = {
 const READ_OPERATIONS = new Set(['get', 'query', 'list_tags'])
 
 /**
- * Read-only variant of knowledge_base for info-gathering agents. Copilot
+ * Read-only variant of manage_knowledge_base for info-gathering agents. Copilot
  * access control is a per-agent tool allowlist, so read-only access gets its
  * own tool name with its own operation contract — enforced here (where
  * execution happens) on top of the fail-fast guard in the Go executor.
@@ -31,7 +31,7 @@ export const searchKnowledgeBaseServerTool: BaseServerTool<
     if (!READ_OPERATIONS.has(operation)) {
       return {
         success: false,
-        message: `search_knowledge_base is read-only: operation '${operation}' is not available (allowed: get, list_tags, query); mutations go through the knowledge agent's knowledge_base tool`,
+        message: `search_knowledge_base is read-only: operation '${operation}' is not available (allowed: get, list_tags, query); mutations go through the knowledge agent's manage_knowledge_base tool`,
       }
     }
     return knowledgeBaseServerTool.execute(params, context)
diff --git a/apps/sim/lib/copilot/tools/server/media/ffmpeg.ts b/apps/sim/lib/copilot/tools/server/media/ffmpeg.ts
index a4673a1db5..3cc4f915f0 100644
--- a/apps/sim/lib/copilot/tools/server/media/ffmpeg.ts
+++ b/apps/sim/lib/copilot/tools/server/media/ffmpeg.ts
@@ -83,7 +83,10 @@ export const ffmpegServerTool: BaseServerTool<FfmpegArgs, FfmpegResult> = {
       return { success: false, message: 'Workspace ID is required' }
     }
     if (!VALID_OPERATIONS.includes(params.operation)) {
-      return { success: false, message: `Invalid operation "${params.operation}".` }
+      return {
+        success: false,
+        message: `Invalid operation "${params.operation}" (allowed: ${VALID_OPERATIONS.join(', ')}).`,
+      }
     }
 
     const inputPaths = params.inputs?.files?.map((f) => f.path) ?? []
diff --git a/apps/sim/lib/copilot/tools/server/media/generate-audio.ts b/apps/sim/lib/copilot/tools/server/media/generate-audio.ts
index fd8572eb2a..a391ec11f0 100644
--- a/apps/sim/lib/copilot/tools/server/media/generate-audio.ts
+++ b/apps/sim/lib/copilot/tools/server/media/generate-audio.ts
@@ -14,6 +14,7 @@ import { assertOpaqueWorkspaceFileModelSafe } from '@/lib/copilot/tools/server/m
 import { writeCopilotWorkspaceFileByPath } from '@/lib/copilot/vfs/resource-writer'
 import { MAX_MEDIA_BYTES } from '@/lib/media/falai'
 import { type AudioType, generateFalAudio } from '@/lib/media/falai-audio'
+import { createWorkspaceFileSecretProvenanceFromRegistry } from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
 import { fileOperations } from '@/lib/workspace-files/application/operations'
 import { readWorkspaceFileContent } from '@/lib/workspace-files/application/read-workspace-file-content'
 
@@ -132,11 +133,21 @@ export const generateAudioServerTool: BaseServerTool<GenerateAudioArgs, Generate
       const mode = outputFile?.mode ?? 'create'
 
       assertServerToolNotAborted(context)
+      // The prompt is the only secret-bearing input; recording its provenance
+      // keeps the written file model-readable (see generate-image).
+      const promptProvenance = await createWorkspaceFileSecretProvenanceFromRegistry(
+        context.resolvedSecretTraceRegistry,
+        params.prompt,
+        { userId: context.userId, workspaceId }
+      )
       const written = await writeCopilotWorkspaceFileByPath(context, {
         workspaceId,
         target: { path: outputPath, mode, mimeType: outputFile?.mimeType },
         buffer: result.buffer,
         inferredMimeType: result.contentType,
+        secretProvenance: promptProvenance.safe
+          ? promptProvenance.provenance
+          : { status: 'unknown' },
       })
 
       logger.info('Generated audio saved', {
diff --git a/apps/sim/lib/copilot/tools/server/media/generate-video.ts b/apps/sim/lib/copilot/tools/server/media/generate-video.ts
index 3b50f807eb..6ec49e564b 100644
--- a/apps/sim/lib/copilot/tools/server/media/generate-video.ts
+++ b/apps/sim/lib/copilot/tools/server/media/generate-video.ts
@@ -14,6 +14,7 @@ import { assertOpaqueWorkspaceFileModelSafe } from '@/lib/copilot/tools/server/m
 import { writeCopilotWorkspaceFileByPath } from '@/lib/copilot/vfs/resource-writer'
 import { MAX_MEDIA_BYTES } from '@/lib/media/falai'
 import { generateFalVideo } from '@/lib/media/falai-video'
+import { createWorkspaceFileSecretProvenanceFromRegistry } from '@/lib/uploads/contexts/workspace/workspace-file-secret-provenance'
 import { fileOperations } from '@/lib/workspace-files/application/operations'
 import { readWorkspaceFileContent } from '@/lib/workspace-files/application/read-workspace-file-content'
 
@@ -112,11 +113,21 @@ export const generateVideoServerTool: BaseServerTool<GenerateVideoArgs, Generate
       const mode = outputFile?.mode ?? 'create'
 
       assertServerToolNotAborted(context)
+      // The prompt is the only secret-bearing input; recording its provenance
+      // keeps the written file model-readable (see generate-image).
+      const promptProvenance = await createWorkspaceFileSecretProvenanceFromRegistry(
+        context.resolvedSecretTraceRegistry,
+        params.prompt,
+        { userId: context.userId, workspaceId }
+      )
       const written = await writeCopilotWorkspaceFileByPath(context, {
         workspaceId,
         target: { path: outputPath, mode, mimeType: outputFile?.mimeType },
         buffer: result.buffer,
         inferredMimeType: result.contentType,
+        secretProvenance: promptProvenance.safe
+          ? promptProvenance.provenance
+          : { status: 'unknown' },
       })
 
       logger.info('Generated video saved', {
diff --git a/apps/sim/lib/copilot/tools/server/other/search-online.test.ts b/apps/sim/lib/copilot/tools/server/other/search-online.test.ts
index cfd3ebaa67..569791042b 100644
--- a/apps/sim/lib/copilot/tools/server/other/search-online.test.ts
+++ b/apps/sim/lib/copilot/tools/server/other/search-online.test.ts
@@ -9,7 +9,7 @@ const { mockExecuteTool } = vi.hoisted(() => ({
 }))
 
 vi.mock('@/lib/copilot/generated/tool-catalog-v1', () => ({
-  SearchOnline: { id: 'search_online' },
+  WebSearch: { id: 'web_search' },
 }))
 vi.mock('@/tools', () => ({ executeTool: mockExecuteTool }))
 
diff --git a/apps/sim/lib/copilot/tools/server/other/search-online.ts b/apps/sim/lib/copilot/tools/server/other/search-online.ts
index 330d930c64..6a517accfb 100644
--- a/apps/sim/lib/copilot/tools/server/other/search-online.ts
+++ b/apps/sim/lib/copilot/tools/server/other/search-online.ts
@@ -1,6 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
-import { SearchOnline } from '@/lib/copilot/generated/tool-catalog-v1'
+import { WebSearch } from '@/lib/copilot/generated/tool-catalog-v1'
 import { projectToolErrorMessageForCopilot } from '@/lib/copilot/request/tools/resolved-secret-result'
 import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
 import { env } from '@/lib/core/config/env'
@@ -31,7 +31,7 @@ interface SearchResponse {
 }
 
 export const searchOnlineServerTool: BaseServerTool<OnlineSearchParams, SearchResponse> = {
-  name: SearchOnline.id,
+  name: WebSearch.id,
   async execute(params: OnlineSearchParams, context?: ServerToolContext): Promise<SearchResponse> {
     const logger = createLogger('SearchOnlineServerTool')
     const { query, num = 10, type = 'search', gl, hl } = params
@@ -104,7 +104,9 @@ export const searchOnlineServerTool: BaseServerTool<OnlineSearchParams, SearchRe
     }
 
     if (!hasSerperApiKey) {
-      throw new Error('No search API keys available (EXA_API_KEY or SERPER_API_KEY required)')
+      throw new Error(
+        'Web search is not configured on this Sim deployment and cannot be enabled from a tool. Answer from the workspace instead (grep/glob/read, search_sim_docs) or tell the user web search is unavailable.'
+      )
     }
 
     const toolParams = {
diff --git a/apps/sim/lib/copilot/tools/server/router.ts b/apps/sim/lib/copilot/tools/server/router.ts
index d53a43748a..dbdb851691 100644
--- a/apps/sim/lib/copilot/tools/server/router.ts
+++ b/apps/sim/lib/copilot/tools/server/router.ts
@@ -3,19 +3,19 @@ import { isRecordLike } from '@sim/utils/object'
 import { z } from 'zod'
 import { getBlockVisibilityForCopilot } from '@/lib/copilot/block-visibility'
 import {
-  CreateFile,
-  DownloadToWorkspaceFile,
+  CreateEmptyFile,
+  DownloadFile,
   Ffmpeg,
   GenerateAudio,
   GenerateImage,
   GenerateVideo,
-  KnowledgeBase,
   ManageCredential,
   ManageCustomTool,
-  ManageMcpTool,
+  ManageKnowledgeBase,
+  ManageMcpConnection,
   ManageSkill,
+  PrepareFileEdit,
   UserTable,
-  WorkspaceFile,
 } from '@/lib/copilot/generated/tool-catalog-v1'
 import { copilotToolCanWrite } from '@/lib/copilot/tools/permissions'
 import {
@@ -25,11 +25,12 @@ import {
 } from '@/lib/copilot/tools/server/base-tool'
 import { getBlocksMetadataServerTool } from '@/lib/copilot/tools/server/blocks/get-blocks-metadata-tool'
 import { getTriggerBlocksServerTool } from '@/lib/copilot/tools/server/blocks/get-trigger-blocks'
-import { searchDocumentationServerTool } from '@/lib/copilot/tools/server/docs/search-documentation'
+import { searchDocsServerTool } from '@/lib/copilot/tools/server/docs/search-docs'
 import { enrichmentRunServerTool } from '@/lib/copilot/tools/server/enrichment/enrichment-run'
 import { createFileServerTool } from '@/lib/copilot/tools/server/files/create-file'
 import { downloadToWorkspaceFileServerTool } from '@/lib/copilot/tools/server/files/download-to-workspace-file'
 import { editContentServerTool } from '@/lib/copilot/tools/server/files/edit-content'
+import { extractDocAssetsServerTool } from '@/lib/copilot/tools/server/files/extract-doc-assets'
 import {
   createFileFolderServerTool,
   listFileFoldersServerTool,
@@ -49,6 +50,12 @@ import { generateAudioServerTool } from '@/lib/copilot/tools/server/media/genera
 import { generateVideoServerTool } from '@/lib/copilot/tools/server/media/generate-video'
 import { searchOnlineServerTool } from '@/lib/copilot/tools/server/other/search-online'
 import { queryUserTableServerTool } from '@/lib/copilot/tools/server/table/query-user-table'
+import { tableAutomationsServerTool } from '@/lib/copilot/tools/server/table/table-automations'
+import { tableColumnsServerTool } from '@/lib/copilot/tools/server/table/table-columns'
+import { tableEnrichmentsServerTool } from '@/lib/copilot/tools/server/table/table-enrichments'
+import { tableManageServerTool } from '@/lib/copilot/tools/server/table/table-manage'
+import { tableRowsServerTool } from '@/lib/copilot/tools/server/table/table-rows'
+import { tableViewsServerTool } from '@/lib/copilot/tools/server/table/table-views'
 import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
 import { getCredentialsServerTool } from '@/lib/copilot/tools/server/user/get-credentials'
 import { setEnvironmentVariablesServerTool } from '@/lib/copilot/tools/server/user/set-environment-variables'
@@ -86,7 +93,7 @@ const VISIBILITY_GATED_TOOLS = new Set([
 ])
 
 const WRITE_ACTIONS: Record<string, string[]> = {
-  [KnowledgeBase.id]: [
+  [ManageKnowledgeBase.id]: [
     'create',
     'add_file',
     'update',
@@ -129,19 +136,19 @@ const WRITE_ACTIONS: Record<string, string[]> = {
     'add_enrichment',
   ],
   [ManageCustomTool.id]: ['add', 'edit', 'delete'],
-  [ManageMcpTool.id]: ['add', 'edit', 'delete'],
+  [ManageMcpConnection.id]: ['add', 'edit', 'delete'],
   [ManageSkill.id]: ['add', 'edit', 'delete'],
   [ManageCredential.id]: ['rename', 'delete'],
-  [WorkspaceFile.id]: ['create', 'append', 'update', 'delete', 'rename', 'patch'],
+  [PrepareFileEdit.id]: ['create', 'append', 'update', 'delete', 'rename', 'patch'],
   [editContentServerTool.name]: ['*'],
-  [CreateFile.id]: ['*'],
+  [CreateEmptyFile.id]: ['*'],
   rename_file: ['*'],
   [shareFileServerTool.name]: ['*'],
   move_file: ['*'],
   create_file_folder: ['*'],
   rename_file_folder: ['*'],
   move_file_folder: ['*'],
-  [DownloadToWorkspaceFile.id]: ['*'],
+  [DownloadFile.id]: ['*'],
   [GenerateImage.id]: ['generate'],
   [GenerateVideo.id]: ['generate'],
   [GenerateAudio.id]: ['generate'],
@@ -164,7 +171,7 @@ const baseServerToolRegistry: Record<string, BaseServerTool> = {
   [getTriggerBlocksServerTool.name]: getTriggerBlocksServerTool,
   [editWorkflowServerTool.name]: editWorkflowServerTool,
   [queryLogsServerTool.name]: queryLogsServerTool,
-  [searchDocumentationServerTool.name]: searchDocumentationServerTool,
+  [searchDocsServerTool.name]: searchDocsServerTool,
   [searchOnlineServerTool.name]: searchOnlineServerTool,
   [setEnvironmentVariablesServerTool.name]: setEnvironmentVariablesServerTool,
   [getCredentialsServerTool.name]: getCredentialsServerTool,
@@ -173,6 +180,12 @@ const baseServerToolRegistry: Record<string, BaseServerTool> = {
   [enrichmentRunServerTool.name]: enrichmentRunServerTool,
   [userTableServerTool.name]: userTableServerTool,
   [queryUserTableServerTool.name]: queryUserTableServerTool,
+  [tableManageServerTool.name]: tableManageServerTool,
+  [tableRowsServerTool.name]: tableRowsServerTool,
+  [tableColumnsServerTool.name]: tableColumnsServerTool,
+  [tableAutomationsServerTool.name]: tableAutomationsServerTool,
+  [tableEnrichmentsServerTool.name]: tableEnrichmentsServerTool,
+  [tableViewsServerTool.name]: tableViewsServerTool,
   [workspaceFileServerTool.name]: workspaceFileServerTool,
   [editContentServerTool.name]: editContentServerTool,
   [createFileServerTool.name]: createFileServerTool,
@@ -184,6 +197,7 @@ const baseServerToolRegistry: Record<string, BaseServerTool> = {
   [renameFileFolderServerTool.name]: renameFileFolderServerTool,
   [moveFileFolderServerTool.name]: moveFileFolderServerTool,
   [downloadToWorkspaceFileServerTool.name]: downloadToWorkspaceFileServerTool,
+  [extractDocAssetsServerTool.name]: extractDocAssetsServerTool,
   [generateImageServerTool.name]: generateImageServerTool,
   [generateVideoServerTool.name]: generateVideoServerTool,
   [generateAudioServerTool.name]: generateAudioServerTool,
diff --git a/apps/sim/lib/copilot/tools/server/table/table-automations.ts b/apps/sim/lib/copilot/tools/server/table/table-automations.ts
new file mode 100644
index 0000000000..e2b9492940
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-automations.ts
@@ -0,0 +1,49 @@
+import { TableAutomations } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
+
+type TableAutomationsArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type TableAutomationsResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
+const ALLOWED_OPERATIONS = new Set([
+  'list_workflow_outputs',
+  'add_workflow_group',
+  'update_workflow_group',
+  'delete_workflow_group',
+  'add_workflow_group_output',
+  'delete_workflow_group_output',
+  'run_column',
+  'cancel_table_runs',
+])
+
+/**
+ * per-row workflow automations slice of the split user_table surface. Copilot access control is a
+ * per-agent tool allowlist, so each slice gets its own tool name with its own
+ * operation contract — enforced here (where execution happens) on top of the
+ * schema enum in the Go catalog. Delegates to the shared user_table executor,
+ * so argument semantics stay identical by construction.
+ */
+export const tableAutomationsServerTool: BaseServerTool<
+  TableAutomationsArgs,
+  TableAutomationsResult
+> = {
+  name: TableAutomations.id,
+  async execute(params: TableAutomationsArgs, context?: ServerToolContext) {
+    const operation = params?.operation
+    if (!ALLOWED_OPERATIONS.has(operation)) {
+      return {
+        success: false,
+        message: `table_automations does not support operation '${operation}' (allowed: list_workflow_outputs, add_workflow_group, update_workflow_group, delete_workflow_group, add_workflow_group_output, delete_workflow_group_output, run_column, cancel_table_runs); other table operations live on their own table_* tools`,
+      }
+    }
+    return userTableServerTool.execute(params, context)
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/table/table-columns.ts b/apps/sim/lib/copilot/tools/server/table/table-columns.ts
new file mode 100644
index 0000000000..9e4ebc2f49
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-columns.ts
@@ -0,0 +1,42 @@
+import { TableColumns } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
+
+type TableColumnsArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type TableColumnsResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
+const ALLOWED_OPERATIONS = new Set([
+  'add_column',
+  'rename_column',
+  'delete_column',
+  'update_column',
+])
+
+/**
+ * column DDL (add/rename/retype/delete) slice of the split user_table surface. Copilot access control is a
+ * per-agent tool allowlist, so each slice gets its own tool name with its own
+ * operation contract — enforced here (where execution happens) on top of the
+ * schema enum in the Go catalog. Delegates to the shared user_table executor,
+ * so argument semantics stay identical by construction.
+ */
+export const tableColumnsServerTool: BaseServerTool<TableColumnsArgs, TableColumnsResult> = {
+  name: TableColumns.id,
+  async execute(params: TableColumnsArgs, context?: ServerToolContext) {
+    const operation = params?.operation
+    if (!ALLOWED_OPERATIONS.has(operation)) {
+      return {
+        success: false,
+        message: `table_columns does not support operation '${operation}' (allowed: add_column, rename_column, delete_column, update_column); other table operations live on their own table_* tools`,
+      }
+    }
+    return userTableServerTool.execute(params, context)
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/table/table-enrichments.ts b/apps/sim/lib/copilot/tools/server/table/table-enrichments.ts
new file mode 100644
index 0000000000..caa317ebdf
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-enrichments.ts
@@ -0,0 +1,40 @@
+import { TableEnrichments } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
+
+type TableEnrichmentsArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type TableEnrichmentsResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
+const ALLOWED_OPERATIONS = new Set(['list_enrichments', 'add_enrichment'])
+
+/**
+ * prebuilt per-row enrichments slice of the split user_table surface. Copilot access control is a
+ * per-agent tool allowlist, so each slice gets its own tool name with its own
+ * operation contract — enforced here (where execution happens) on top of the
+ * schema enum in the Go catalog. Delegates to the shared user_table executor,
+ * so argument semantics stay identical by construction.
+ */
+export const tableEnrichmentsServerTool: BaseServerTool<
+  TableEnrichmentsArgs,
+  TableEnrichmentsResult
+> = {
+  name: TableEnrichments.id,
+  async execute(params: TableEnrichmentsArgs, context?: ServerToolContext) {
+    const operation = params?.operation
+    if (!ALLOWED_OPERATIONS.has(operation)) {
+      return {
+        success: false,
+        message: `table_enrichments does not support operation '${operation}' (allowed: list_enrichments, add_enrichment); other table operations live on their own table_* tools`,
+      }
+    }
+    return userTableServerTool.execute(params, context)
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/table/table-manage.ts b/apps/sim/lib/copilot/tools/server/table/table-manage.ts
new file mode 100644
index 0000000000..b8030fc5f4
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-manage.ts
@@ -0,0 +1,37 @@
+import { TableManage } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
+
+type TableManageArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type TableManageResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
+const ALLOWED_OPERATIONS = new Set(['create', 'create_from_file', 'import_file', 'rename'])
+
+/**
+ * table lifecycle (create, create_from_file, import_file, rename) slice of the split user_table surface. Copilot access control is a
+ * per-agent tool allowlist, so each slice gets its own tool name with its own
+ * operation contract — enforced here (where execution happens) on top of the
+ * schema enum in the Go catalog. Delegates to the shared user_table executor,
+ * so argument semantics stay identical by construction.
+ */
+export const tableManageServerTool: BaseServerTool<TableManageArgs, TableManageResult> = {
+  name: TableManage.id,
+  async execute(params: TableManageArgs, context?: ServerToolContext) {
+    const operation = params?.operation
+    if (!ALLOWED_OPERATIONS.has(operation)) {
+      return {
+        success: false,
+        message: `table_manage does not support operation '${operation}' (allowed: create, create_from_file, import_file, rename); other table operations live on their own table_* tools`,
+      }
+    }
+    return userTableServerTool.execute(params, context)
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/table/table-rows.ts b/apps/sim/lib/copilot/tools/server/table/table-rows.ts
new file mode 100644
index 0000000000..aec5ee0821
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-rows.ts
@@ -0,0 +1,46 @@
+import { TableRows } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import { userTableServerTool } from '@/lib/copilot/tools/server/table/user-table'
+
+type TableRowsArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type TableRowsResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
+const ALLOWED_OPERATIONS = new Set([
+  'insert_row',
+  'batch_insert_rows',
+  'update_row',
+  'batch_update_rows',
+  'delete_row',
+  'batch_delete_rows',
+  'update_rows_by_filter',
+  'delete_rows_by_filter',
+])
+
+/**
+ * row data (insert/update/delete, batch and by-filter) slice of the split user_table surface. Copilot access control is a
+ * per-agent tool allowlist, so each slice gets its own tool name with its own
+ * operation contract — enforced here (where execution happens) on top of the
+ * schema enum in the Go catalog. Delegates to the shared user_table executor,
+ * so argument semantics stay identical by construction.
+ */
+export const tableRowsServerTool: BaseServerTool<TableRowsArgs, TableRowsResult> = {
+  name: TableRows.id,
+  async execute(params: TableRowsArgs, context?: ServerToolContext) {
+    const operation = params?.operation
+    if (!ALLOWED_OPERATIONS.has(operation)) {
+      return {
+        success: false,
+        message: `table_rows does not support operation '${operation}' (allowed: insert_row, batch_insert_rows, update_row, batch_update_rows, delete_row, batch_delete_rows, update_rows_by_filter, delete_rows_by_filter); other table operations live on their own table_* tools`,
+      }
+    }
+    return userTableServerTool.execute(params, context)
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/table/table-split.test.ts b/apps/sim/lib/copilot/tools/server/table/table-split.test.ts
new file mode 100644
index 0000000000..00233836d3
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-split.test.ts
@@ -0,0 +1,60 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const executeUserTable = vi.hoisted(() => vi.fn())
+
+vi.mock('@/lib/copilot/tools/server/table/user-table', () => ({
+  userTableServerTool: { execute: executeUserTable },
+}))
+
+import { tableAutomationsServerTool } from '@/lib/copilot/tools/server/table/table-automations'
+import { tableColumnsServerTool } from '@/lib/copilot/tools/server/table/table-columns'
+import { tableEnrichmentsServerTool } from '@/lib/copilot/tools/server/table/table-enrichments'
+import { tableManageServerTool } from '@/lib/copilot/tools/server/table/table-manage'
+import { tableRowsServerTool } from '@/lib/copilot/tools/server/table/table-rows'
+
+/**
+ * Every split tool delegates its own operations to the shared user_table
+ * executor untouched, and rejects operations that belong to a sibling slice
+ * without ever invoking it — the per-slice allowlist is the access contract.
+ */
+describe('split table tools', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    executeUserTable.mockResolvedValue({ success: true, message: 'ok' })
+  })
+
+  const cases = [
+    { tool: tableManageServerTool, own: 'create', foreign: 'insert_row' },
+    { tool: tableRowsServerTool, own: 'batch_update_rows', foreign: 'add_column' },
+    { tool: tableColumnsServerTool, own: 'update_column', foreign: 'create' },
+    { tool: tableAutomationsServerTool, own: 'run_column', foreign: 'add_enrichment' },
+    { tool: tableEnrichmentsServerTool, own: 'add_enrichment', foreign: 'run_column' },
+  ] as const
+
+  it.each(cases)(
+    '$tool.name delegates $own and rejects $foreign',
+    async ({ tool, own, foreign }) => {
+      const context = { userId: 'user-1', workspaceId: 'workspace-1', copilotToolExecution: true }
+      const params = { operation: own, args: { tableId: 'table-1' } }
+
+      await expect(tool.execute(params as never, context as never)).resolves.toEqual({
+        success: true,
+        message: 'ok',
+      })
+      expect(executeUserTable).toHaveBeenCalledWith(params, context)
+
+      executeUserTable.mockClear()
+      await expect(
+        tool.execute({ operation: foreign, args: { tableId: 'table-1' } } as never)
+      ).resolves.toMatchObject({
+        success: false,
+        message: expect.stringContaining(foreign),
+      })
+      expect(executeUserTable).not.toHaveBeenCalled()
+    }
+  )
+})
diff --git a/apps/sim/lib/copilot/tools/server/table/table-views.test.ts b/apps/sim/lib/copilot/tools/server/table/table-views.test.ts
new file mode 100644
index 0000000000..56d4df7e79
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-views.test.ts
@@ -0,0 +1,123 @@
+/**
+ * @vitest-environment node
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const useCases = vi.hoisted(() => ({
+  list: vi.fn(),
+  read: vi.fn(),
+  create: vi.fn(),
+  update: vi.fn(),
+  del: vi.fn(),
+}))
+
+vi.mock('@/lib/table/application/views', () => ({
+  listTableViewsUseCase: { operation: { id: 'tables.views.list' }, execute: useCases.list },
+  readTableViewUseCase: { operation: { id: 'tables.views.read' }, execute: useCases.read },
+  createTableViewUseCase: { operation: { id: 'tables.views.create' }, execute: useCases.create },
+  updateTableViewUseCase: { operation: { id: 'tables.views.update' }, execute: useCases.update },
+  deleteTableViewUseCase: { operation: { id: 'tables.views.delete' }, execute: useCases.del },
+}))
+
+const executeUseCase = vi.hoisted(() => vi.fn())
+vi.mock('@/lib/copilot/application/execute-table-use-case', () => ({
+  executeCopilotTableUseCase: executeUseCase,
+}))
+
+import { tableViewsServerTool } from '@/lib/copilot/tools/server/table/table-views'
+
+const context = { userId: 'user-1', workspaceId: 'ws-1', copilotToolExecution: true } as never
+
+const columns = [
+  { id: 'col_a', name: 'status', type: 'string' },
+  { id: 'col_b', name: 'due', type: 'date' },
+]
+const table = { id: 'tbl-1', schema: { columns } }
+
+describe('table_views adapter', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('translates stored id-domain configs to column names on list', async () => {
+    executeUseCase.mockResolvedValueOnce({
+      table,
+      views: [
+        {
+          id: 'view-1',
+          name: 'Overdue',
+          isDefault: true,
+          config: {
+            filter: { all: [{ field: 'col_a', op: 'ne', value: 'Done' }] },
+            sort: [{ field: 'col_b', direction: 'asc' }],
+          },
+        },
+      ],
+    })
+
+    const result = await tableViewsServerTool.execute(
+      { operation: 'list_views', args: { tableId: 'tbl-1' } },
+      context
+    )
+
+    expect(result.success).toBe(true)
+    expect(result.data.views[0].filter).toEqual({
+      all: [{ field: 'status', op: 'ne', value: 'Done' }],
+    })
+    expect(result.data.views[0].sort).toEqual([{ field: 'due', direction: 'asc' }])
+  })
+
+  it('translates agent column names to stable ids on create', async () => {
+    executeUseCase.mockResolvedValueOnce({ table, views: [] }).mockResolvedValueOnce({
+      view: { id: 'view-2', name: 'Mine', isDefault: false, config: {} },
+      table,
+    })
+
+    const result = await tableViewsServerTool.execute(
+      {
+        operation: 'create_view',
+        args: {
+          tableId: 'tbl-1',
+          name: 'Mine',
+          filter: { all: [{ field: 'status', op: 'eq', value: 'Open' }] },
+        },
+      },
+      context
+    )
+
+    expect(result.success).toBe(true)
+    const createInput = executeUseCase.mock.calls[1][2]
+    expect(createInput.config.filter).toEqual({
+      all: [{ field: 'col_a', op: 'eq', value: 'Open' }],
+    })
+  })
+
+  it('rejects unknown column names with the columns spelled out', async () => {
+    executeUseCase.mockResolvedValueOnce({ table, views: [] })
+
+    await expect(
+      tableViewsServerTool.execute(
+        {
+          operation: 'create_view',
+          args: {
+            tableId: 'tbl-1',
+            name: 'Broken',
+            filter: { all: [{ field: 'nope', op: 'eq', value: 1 }] },
+          },
+        },
+        context
+      )
+    ).rejects.toThrow(/Unknown column/)
+  })
+
+  it('rejects unsupported operations without invoking anything', async () => {
+    const result = await tableViewsServerTool.execute(
+      { operation: 'insert_row', args: { tableId: 'tbl-1' } },
+      context
+    )
+    expect(result.success).toBe(false)
+    expect(result.message).toContain('insert_row')
+    expect(executeUseCase).not.toHaveBeenCalled()
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/table/table-views.ts b/apps/sim/lib/copilot/tools/server/table/table-views.ts
new file mode 100644
index 0000000000..7b004bb1b9
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/server/table/table-views.ts
@@ -0,0 +1,199 @@
+import { executeCopilotTableUseCase } from '@/lib/copilot/application/execute-table-use-case'
+import { TableViews } from '@/lib/copilot/generated/tool-catalog-v1'
+import type { BaseServerTool, ServerToolContext } from '@/lib/copilot/tools/server/base-tool'
+import type { SortSpec, TablePredicateInput, TableSchema, TableViewConfig } from '@/lib/table'
+import {
+  createTableViewUseCase,
+  deleteTableViewUseCase,
+  listTableViewsUseCase,
+  readTableViewUseCase,
+  updateTableViewUseCase,
+} from '@/lib/table/application/views'
+import { viewConfigIdsToNames, viewConfigNamesToIds } from '@/lib/table/views/service'
+
+type TableViewsArgs = {
+  operation: string
+  args?: Record<string, any>
+}
+
+type TableViewsResult = {
+  success: boolean
+  message: string
+  data?: any
+}
+
+/**
+ * Saved-view slice of the split table surface. Unlike the other slices this is
+ * NOT a user_table passthrough — it adapts the dedicated view use cases.
+ * Agents speak column NAMES; stored configs are keyed by stable column id, so
+ * inputs translate names→ids on the way in and every returned view translates
+ * ids→names on the way out.
+ */
+export const tableViewsServerTool: BaseServerTool<TableViewsArgs, TableViewsResult> = {
+  name: TableViews.id,
+  async execute(params: TableViewsArgs, context?: ServerToolContext) {
+    const operation = params?.operation
+    const args = params?.args ?? {}
+    const tableId = args.tableId as string | undefined
+    const workspaceId = context?.workspaceId
+    if (!tableId) return { success: false, message: 'Table ID is required' }
+    if (!workspaceId) return { success: false, message: 'Workspace ID is required' }
+
+    const presentView = (
+      view: { id: string; name: string; isDefault: boolean; config: TableViewConfig },
+      columns: TableSchema['columns']
+    ) => {
+      const named = viewConfigIdsToNames(view.config, columns)
+      return {
+        id: view.id,
+        name: view.name,
+        isDefault: view.isDefault,
+        filter: named.filter ?? null,
+        sort: named.sort ?? null,
+        hiddenColumns: named.hiddenColumns?.length ? named.hiddenColumns : undefined,
+      }
+    }
+
+    // Build the patch from only the keys the caller actually sent: the update
+    // path shallow-merges this into the stored config, so including an absent
+    // part as `null` silently wiped a view's saved sort when only the filter
+    // changed (and vice versa) — the doc promises "omit to keep".
+    const namedConfigFromArgs = (columns: TableSchema['columns']): TableViewConfig => {
+      const patch: Record<string, unknown> = {}
+      if (args.filter !== undefined) patch.filter = args.filter as TablePredicateInput | null
+      if (args.sort !== undefined) patch.sort = args.sort as SortSpec | null
+      if (args.hiddenColumns !== undefined) patch.hiddenColumns = args.hiddenColumns as string[]
+      return viewConfigNamesToIds(patch as TableViewConfig, columns)
+    }
+
+    switch (operation) {
+      case 'list_views': {
+        const result = await executeCopilotTableUseCase(
+          context,
+          listTableViewsUseCase,
+          { tableId, workspaceId },
+          { tableId }
+        )
+        const columns = (result.table.schema as TableSchema).columns
+        const views = result.views.map((view) => presentView(view, columns))
+        return {
+          success: true,
+          message: `Table has ${views.length} view(s)`,
+          data: { views },
+        }
+      }
+      case 'get_view': {
+        if (!args.viewId) return { success: false, message: 'viewId is required' }
+        const result = await executeCopilotTableUseCase(
+          context,
+          readTableViewUseCase,
+          { tableId, workspaceId, viewId: args.viewId },
+          { tableId }
+        )
+        const columns = (result.table.schema as TableSchema).columns
+        return {
+          success: true,
+          message: 'View loaded',
+          data: { view: presentView(result.view, columns) },
+        }
+      }
+      case 'create_view': {
+        if (!args.name) return { success: false, message: 'name is required' }
+        const listed = await executeCopilotTableUseCase(
+          context,
+          listTableViewsUseCase,
+          { tableId, workspaceId },
+          { tableId }
+        )
+        const columns = (listed.table.schema as TableSchema).columns
+        const created = await executeCopilotTableUseCase(
+          context,
+          createTableViewUseCase,
+          { tableId, workspaceId, name: args.name, config: namedConfigFromArgs(columns) },
+          { tableId }
+        )
+        if (args.isDefault === true) {
+          await executeCopilotTableUseCase(
+            context,
+            updateTableViewUseCase,
+            { tableId, workspaceId, viewId: created.view.id, isDefault: true },
+            { tableId }
+          )
+        }
+        return {
+          success: true,
+          message: `Created view "${created.view.name}" (${created.view.id})${args.isDefault === true ? ' as default' : ''}`,
+          data: {
+            view: presentView({ ...created.view, isDefault: args.isDefault === true }, columns),
+          },
+        }
+      }
+      case 'update_view': {
+        if (!args.viewId) return { success: false, message: 'viewId is required' }
+        const listed = await executeCopilotTableUseCase(
+          context,
+          listTableViewsUseCase,
+          { tableId, workspaceId },
+          { tableId }
+        )
+        const columns = (listed.table.schema as TableSchema).columns
+        const hasConfigChange =
+          args.filter !== undefined || args.sort !== undefined || args.hiddenColumns !== undefined
+        const updated = await executeCopilotTableUseCase(
+          context,
+          updateTableViewUseCase,
+          {
+            tableId,
+            workspaceId,
+            viewId: args.viewId,
+            name: args.name as string | undefined,
+            ...(hasConfigChange ? { configPatch: namedConfigFromArgs(columns) } : {}),
+            isDefault: args.isDefault as boolean | undefined,
+          },
+          { tableId }
+        )
+        return {
+          success: true,
+          message: `Updated view "${updated.view.name}"`,
+          data: { view: presentView(updated.view, columns) },
+        }
+      }
+      case 'delete_view': {
+        if (!args.viewId) return { success: false, message: 'viewId is required' }
+        const result = await executeCopilotTableUseCase(
+          context,
+          deleteTableViewUseCase,
+          { tableId, workspaceId, viewId: args.viewId },
+          { tableId }
+        )
+        return { success: true, message: `Deleted view "${result.viewName}"` }
+      }
+      case 'set_default_view': {
+        if (!args.viewId) return { success: false, message: 'viewId is required' }
+        const listed = await executeCopilotTableUseCase(
+          context,
+          listTableViewsUseCase,
+          { tableId, workspaceId },
+          { tableId }
+        )
+        const columns = (listed.table.schema as TableSchema).columns
+        const updated = await executeCopilotTableUseCase(
+          context,
+          updateTableViewUseCase,
+          { tableId, workspaceId, viewId: args.viewId, isDefault: true },
+          { tableId }
+        )
+        return {
+          success: true,
+          message: `"${updated.view.name}" is now the default view`,
+          data: { view: presentView(updated.view, columns) },
+        }
+      }
+      default:
+        return {
+          success: false,
+          message: `table_views does not support operation '${operation}' (allowed: list_views, get_view, create_view, update_view, delete_view, set_default_view)`,
+        }
+    }
+  },
+}
diff --git a/apps/sim/lib/copilot/tools/server/table/user-table.test.ts b/apps/sim/lib/copilot/tools/server/table/user-table.test.ts
index c762ce5a4b..6c24b403c4 100644
--- a/apps/sim/lib/copilot/tools/server/table/user-table.test.ts
+++ b/apps/sim/lib/copilot/tools/server/table/user-table.test.ts
@@ -608,7 +608,7 @@ describe('userTableServerTool.import_file', () => {
     expect(mockBatchInsertRows).not.toHaveBeenCalled()
   })
 
-  it('points a chat-upload path at materialize_file instead of globbing files/', async () => {
+  it('points a chat-upload path at save_upload instead of globbing files/', async () => {
     mockResolveWorkspaceFileReference.mockResolvedValueOnce(null)
 
     const result = await userTableServerTool.execute(
@@ -620,7 +620,7 @@ describe('userTableServerTool.import_file', () => {
     )
 
     expect(result.success).toBe(false)
-    expect(result.message).toMatch(/materialize_file/)
+    expect(result.message).toMatch(/save_upload/)
     expect(result.message).not.toMatch(/glob\("files/)
   })
 
diff --git a/apps/sim/lib/copilot/tools/server/table/user-table.ts b/apps/sim/lib/copilot/tools/server/table/user-table.ts
index c43fca7faf..f6ce6df1cb 100644
--- a/apps/sim/lib/copilot/tools/server/table/user-table.ts
+++ b/apps/sim/lib/copilot/tools/server/table/user-table.ts
@@ -48,6 +48,7 @@ import {
   readTableUseCase,
   updateTableUseCase,
 } from '@/lib/table/application/tables'
+import { readTableViewUseCase } from '@/lib/table/application/views'
 import { namedRowMapper } from '@/lib/table/cell-format'
 import { isSupportedCurrencyCode } from '@/lib/table/currency'
 import { normalizeTablePredicate } from '@/lib/table/query-builder/predicate'
@@ -56,11 +57,13 @@ import { normalizeSelectOptionsInput } from '@/lib/table/select-options'
 import type {
   RowData,
   SortSpec,
+  TablePredicate,
   TablePredicateInput,
   TableSchema,
   WorkflowGroupDependencies,
   WorkflowGroupDeploymentMode,
 } from '@/lib/table/types'
+import { viewConfigIdsToNames } from '@/lib/table/views/service'
 import type { ResolvedSecretTraceProvenanceV1 } from '@/executor/utils/resolved-secret-trace-registry'
 
 const logger = createLogger('UserTableServerTool')
@@ -145,6 +148,19 @@ async function importRowsProvenanceForModel(
   await registry.importCrossingProvenance(provenance, values, { trusted: true })
 }
 
+/** AND-combines a saved view's predicate with an explicit one; either may be absent. */
+function mergeViewPredicate(
+  viewFilter: TablePredicateInput | undefined,
+  explicit: TablePredicateInput | undefined
+): TablePredicate | undefined {
+  const parts: TablePredicate[] = []
+  if (viewFilter) parts.push(normalizeTablePredicate(viewFilter))
+  if (explicit) parts.push(normalizeTablePredicate(explicit))
+  if (parts.length === 0) return undefined
+  if (parts.length === 1) return parts[0]
+  return { all: parts }
+}
+
 export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult> = {
   name: UserTable.id,
   async execute(params: UserTableArgs, context?: ServerToolContext): Promise<UserTableResult> {
@@ -178,6 +194,7 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             name: args.name,
             description: args.description,
             schema: normalizeSchemaSelectColumns(args.schema as TableSchema),
+            folderPath: args.folderPath,
             workspaceId,
           })
 
@@ -402,6 +419,31 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             return { success: false, message: 'Workspace ID is required' }
           }
 
+          // Saved-view scope: the view's stored filter ANDs with any explicit
+          // filter (query-within-the-view), its sort applies only when no
+          // explicit order is given, and layout fields (hidden columns, order,
+          // widths) are ignored — agents always see full rows. Views are
+          // referenced by id only (from views.json or table_views list_views).
+          let viewFilter: TablePredicateInput | undefined
+          let viewSort: SortSpec | undefined
+          let appliedViewName: string | undefined
+          if (typeof args.view === 'string' && args.view.trim() !== '') {
+            const viewId = (args.view as string).trim()
+            const resolved = await executeCopilotTableUseCase(
+              context,
+              readTableViewUseCase,
+              { tableId: args.tableId, workspaceId, viewId },
+              { tableId: args.tableId }
+            )
+            const named = viewConfigIdsToNames(
+              resolved.view.config,
+              (resolved.table.schema as TableSchema).columns
+            )
+            viewFilter = (named.filter as TablePredicateInput | null) ?? undefined
+            viewSort = (named.sort as SortSpec | null) ?? undefined
+            appliedViewName = resolved.view.name
+          }
+
           const queryLimitError = limitError(args.limit, TABLE_LIMITS.MAX_QUERY_LIMIT)
           if (queryLimitError) {
             return { success: false, message: queryLimitError }
@@ -413,10 +455,11 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
             {
               tableId: args.tableId,
               assertedWorkspaceId: workspaceId,
-              predicate: args.filter
-                ? normalizeTablePredicate(args.filter as TablePredicateInput)
-                : undefined,
-              sort: args.order as SortSpec | undefined,
+              predicate: mergeViewPredicate(
+                viewFilter,
+                args.filter as TablePredicateInput | undefined
+              ),
+              sort: (args.order as SortSpec | undefined) ?? viewSort,
               limit: args.limit ?? TABLE_LIMITS.MAX_QUERY_LIMIT,
               cursor: args.cursor,
               includeTotal: !args.cursor,
@@ -435,7 +478,9 @@ export const userTableServerTool: BaseServerTool<UserTableArgs, UserTableResult>
           // nextCursor covers both cut kinds (explicit limit or the 5MB byte
           // budget) — either way the truthful signal is "more rows exist". The
           // token is opaque; the agent echoes it back as `cursor` to continue.
-          const countSuffix = result.totalCount != null ? ` of ${result.totalCount}` : ''
+          const viewSuffix = appliedViewName ? ` (view: ${appliedViewName})` : ''
+          const countSuffix =
+            (result.totalCount != null ? ` of ${result.totalCount}` : '') + viewSuffix
           const message = result.nextCursor
             ? `Returned ${result.rows.length}${countSuffix} rows (more available — pass cursor=${result.nextCursor} to continue)`
             : `Returned ${result.rows.length}${countSuffix} rows`
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.test.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.test.ts
index baf77b90ea..c73c80ada2 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.test.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.test.ts
@@ -3,11 +3,14 @@
  */
 import { describe, expect, it, vi } from 'vitest'
 import {
+  applyBlockRetry,
   applyTriggerConfigToBlockSubblocks,
   createBlockFromParams,
   filterDisallowedTools,
   normalizeSubblockValue,
+  resolveBlockRetryUpdate,
 } from '@/lib/copilot/tools/server/workflow/edit-workflow/builders'
+import type { SkippedItem } from '@/lib/copilot/tools/server/workflow/edit-workflow/types'
 
 const { mockIsIntegrationDeploymentAvailable } = vi.hoisted(() => ({
   mockIsIntegrationDeploymentAvailable: vi.fn(() => true),
@@ -245,3 +248,79 @@ describe('applyTriggerConfigToBlockSubblocks', () => {
     })
   })
 })
+
+describe('block retry policy', () => {
+  it('defaults the numbers when only enabling', () => {
+    expect(resolveBlockRetryUpdate({ enabled: true }, undefined)).toEqual({
+      enabled: true,
+      maxTries: 3,
+      waitBetweenTriesMs: 1000,
+    })
+  })
+
+  it('treats numbers alone as an intent to retry', () => {
+    expect(resolveBlockRetryUpdate({ maxTries: 4 }, undefined)).toMatchObject({
+      enabled: true,
+      maxTries: 4,
+    })
+  })
+
+  it('keeps configured numbers when retry is switched off', () => {
+    const existing = { enabled: true, maxTries: 5, waitBetweenTriesMs: 250 }
+    expect(resolveBlockRetryUpdate({ enabled: false }, existing)).toEqual({
+      enabled: false,
+      maxTries: 5,
+      waitBetweenTriesMs: 250,
+    })
+  })
+
+  it('clamps out-of-range values instead of rejecting them', () => {
+    expect(resolveBlockRetryUpdate({ enabled: true, maxTries: 99 }, undefined).maxTries).toBe(5)
+    expect(resolveBlockRetryUpdate({ enabled: true, maxTries: 1 }, undefined).maxTries).toBe(2)
+    expect(
+      resolveBlockRetryUpdate({ enabled: true, waitBetweenTriesMs: 999999 }, undefined)
+        .waitBetweenTriesMs
+    ).toBe(5000)
+  })
+
+  it('applies a policy to an eligible block', () => {
+    const block: Record<string, unknown> = { type: 'agent' }
+    applyBlockRetry(
+      block,
+      { enabled: true, maxTries: 4 },
+      {
+        operationType: 'edit',
+        blockId: 'b1',
+      }
+    )
+    expect(block.retry).toMatchObject({ enabled: true, maxTries: 4 })
+  })
+
+  it('reports why an ineligible block cannot retry instead of storing dead config', () => {
+    const skippedItems: SkippedItem[] = []
+    const block: Record<string, unknown> = { type: 'agent', triggerMode: true }
+
+    applyBlockRetry(
+      block,
+      { enabled: true },
+      {
+        operationType: 'edit',
+        blockId: 'b1',
+        skippedItems,
+      }
+    )
+
+    expect(block.retry).toBeUndefined()
+    expect(skippedItems).toHaveLength(1)
+    expect(skippedItems[0]).toMatchObject({ type: 'retry_not_supported', blockId: 'b1' })
+  })
+
+  it('clears the policy when null is sent', () => {
+    const block: Record<string, unknown> = {
+      type: 'agent',
+      retry: { enabled: true, maxTries: 3, waitBetweenTriesMs: 1000 },
+    }
+    applyBlockRetry(block, null, { operationType: 'edit', blockId: 'b1' })
+    expect(block.retry).toBeUndefined()
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.ts
index 524567f7f9..ed09443441 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/builders.ts
@@ -1,9 +1,15 @@
 import { createLogger } from '@sim/logger'
 import { generateId, isValidUuid } from '@sim/utils/id'
 import { sortObjectKeysDeep } from '@sim/utils/object'
+import {
+  type BlockRetryConfig,
+  normalizeBlockRetryTries,
+  normalizeBlockRetryWaitMs,
+} from '@sim/workflow-types/workflow'
 import { isIntegrationDeploymentAvailableForVisibility } from '@/lib/integrations/availability.server'
 import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
 import { getEffectiveBlockOutputs } from '@/lib/workflows/blocks/block-outputs'
+import { isRetryEligibleBlock } from '@/lib/workflows/blocks/retry-eligibility'
 import {
   buildCanonicalIndex,
   buildDefaultCanonicalModes,
@@ -22,6 +28,73 @@ import {
   validateTargetHandle,
 } from './validation'
 
+/**
+ * Merges a requested retry policy onto whatever the block already had, clamped
+ * to the executor's bounds.
+ *
+ * `enabled` is optional and falls back to the block's current state (or `true`
+ * for a block with no policy yet), so `{maxTries: 4}` reads as "retry four
+ * times" rather than silently storing a disabled policy. Numbers are kept when
+ * only `enabled` changes, matching the editor: toggling retry off and back on
+ * restores what was configured instead of resetting to the defaults.
+ *
+ * Clamped through the shared normalizers rather than rejected, so a value that
+ * drifts outside the bounds still yields a runnable policy — same contract the
+ * editor and executor already follow.
+ */
+export function resolveBlockRetryUpdate(
+  requested: Partial<BlockRetryConfig>,
+  existing: BlockRetryConfig | undefined
+): BlockRetryConfig {
+  return {
+    enabled:
+      typeof requested.enabled === 'boolean' ? requested.enabled : (existing?.enabled ?? true),
+    maxTries: normalizeBlockRetryTries(requested.maxTries ?? existing?.maxTries),
+    waitBetweenTriesMs: normalizeBlockRetryWaitMs(
+      requested.waitBetweenTriesMs ?? existing?.waitBetweenTriesMs
+    ),
+  }
+}
+
+/**
+ * Applies a requested retry policy to a block, or records why it could not be.
+ *
+ * Eligibility is checked with the same predicate the executor uses, so a policy
+ * the runtime would ignore (triggers, human-in-the-loop, sentinels) is reported
+ * back instead of being written as dead configuration.
+ */
+export function applyBlockRetry(
+  block: any,
+  requested: unknown,
+  context: { operationType: string; blockId: string; skippedItems?: SkippedItem[] }
+): void {
+  if (requested === null) {
+    block.retry = undefined
+    return
+  }
+  if (typeof requested !== 'object' || Array.isArray(requested)) return
+
+  if (
+    !isRetryEligibleBlock({
+      blockType: block.type,
+      category: getBlock(block.type)?.category,
+      triggerMode: block.triggerMode,
+    })
+  ) {
+    if (context.skippedItems) {
+      logSkippedItem(context.skippedItems, {
+        type: 'retry_not_supported',
+        operationType: context.operationType,
+        blockId: context.blockId,
+        reason: `Block "${context.blockId}" (${block.type}) cannot retry - triggers, human-in-the-loop, and container blocks always run once`,
+      })
+    }
+    return
+  }
+
+  block.retry = resolveBlockRetryUpdate(requested as Partial<BlockRetryConfig>, block.retry)
+}
+
 /**
  * Helper to create a block state from operation params
  */
@@ -88,6 +161,16 @@ export function createBlockFromParams(
     locked: false,
   }
 
+  // Block-level setting like `enabled`, not a subBlock input — the executor
+  // reads it from block state when wrapping the run, never from the tool params.
+  if (params.retry !== undefined) {
+    applyBlockRetry(blockState, params.retry, {
+      operationType: 'add',
+      blockId,
+      skippedItems,
+    })
+  }
+
   // Add validated inputs as subBlocks
   if (validatedInputs) {
     Object.entries(validatedInputs).forEach(([key, value]) => {
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.ts
index e2e8bb65f9..b5e5fe20ec 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/operations.ts
@@ -9,6 +9,7 @@ import { getBlock } from '@/blocks/registry'
 import { normalizeName, RESERVED_BLOCK_NAMES } from '@/executor/constants'
 import { TRIGGER_RUNTIME_SUBBLOCK_IDS } from '@/triggers/constants'
 import {
+  applyBlockRetry,
   applyTriggerConfigToBlockSubblocks,
   createBlockFromParams,
   filterDisallowedTools,
@@ -657,6 +658,17 @@ export function handleEditOperation(op: EditWorkflowOperation, ctx: OperationCon
     block.advancedMode = params.advancedMode
   }
 
+  // Handle retry policy. Runs after the trigger-mode branch above so eligibility
+  // sees the block's post-update mode: turning a block into a trigger in the
+  // same operation makes it ineligible, exactly as the editor treats it.
+  if (params?.retry !== undefined) {
+    applyBlockRetry(block, params.retry, {
+      operationType: 'edit',
+      blockId: block_id,
+      skippedItems,
+    })
+  }
+
   // Handle nested nodes update (for loops/parallels) using merge strategy.
   // Existing children that match an incoming node by name are updated in place
   // (preserving their block ID). New children are created. Children not present
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/types.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/types.ts
index c12e16c4ad..305e175c16 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/types.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/types.ts
@@ -48,6 +48,7 @@ export type SkippedItemType =
   | 'nested_subflow_not_allowed'
   | 'duplicate_block_name'
   | 'reserved_block_name'
+  | 'retry_not_supported'
   | 'duplicate_trigger'
   | 'duplicate_single_instance_block'
 
diff --git a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
index 2780a90249..7d87fbdba6 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/edit-workflow/validation.ts
@@ -22,7 +22,11 @@ import { BlockType, EDGE, normalizeName } from '@/executor/constants'
 import { isAutoModel, isKnownModelId, suggestModelIdsForUnknownModel } from '@/providers/models'
 import { isPiByokOnlyMode } from '@/providers/pi-providers'
 import { getTool } from '@/tools/utils'
-import { TRIGGER_RUNTIME_SUBBLOCK_IDS, TRIGGER_WEBHOOK_URL_FIELD } from '@/triggers/constants'
+import {
+  TRIGGER_ROUTING_FIELD,
+  TRIGGER_RUNTIME_SUBBLOCK_IDS,
+  TRIGGER_WEBHOOK_URL_FIELD,
+} from '@/triggers/constants'
 import type {
   EdgeHandleValidationResult,
   EditWorkflowOperation,
@@ -75,6 +79,17 @@ export function validateInputsForBlock(
     inputs = omit(inputs, [TRIGGER_WEBHOOK_URL_FIELD])
   }
 
+  if (TRIGGER_ROUTING_FIELD in inputs) {
+    errors.push({
+      blockId,
+      blockType,
+      field: TRIGGER_ROUTING_FIELD,
+      value: inputs[TRIGGER_ROUTING_FIELD],
+      error: `"${TRIGGER_ROUTING_FIELD}" is read-only. Event routing is derived from the selected credential and cannot be edited on the block.`,
+    })
+    inputs = omit(inputs, [TRIGGER_ROUTING_FIELD])
+  }
+
   const blockConfig = getBlock(blockType)
 
   if (!blockConfig) {
@@ -1109,7 +1124,7 @@ export async function validateWorkflowSelectorIds(
         blockType: selector.blockType,
         field: selector.fieldName,
         value: selector.value,
-        error: `Invalid ${selector.selectorType} ID(s): ${result.invalid.join(', ')} - ID(s) do not exist or user doesn't have access${warningInfo}`,
+        error: `Invalid ${selector.selectorType} ID(s): ${result.invalid.join(', ')} — they do not exist in this workspace or you lack access. Discover valid ids first (glob/read the matching workspace resource, e.g. environment/credentials.json, knowledgebases/*/meta.json, tables/*/meta.json) instead of guessing${warningInfo}`,
       })
     } else if (result.warning) {
       // Log warnings that don't have errors (shouldn't happen for credentials but may for other selectors)
@@ -1718,7 +1733,7 @@ export async function preValidateCredentialInputs(
           blockType: credInput.blockType,
           field: credInput.fieldName,
           value: credInput.value,
-          error: `Invalid credential ID "${credInput.value}" - credential does not exist or user doesn't have access${warningInfo}`,
+          error: `Invalid credential ID "${credInput.value}" for ${credInput.blockType}.${credInput.fieldName} — the field was removed from the block. Read environment/credentials.json for connected credential ids, or use oauth_get_auth_link (via the auth agent) to connect the provider first; never invent credential ids${warningInfo}`,
         })
       }
 
diff --git a/apps/sim/lib/copilot/tools/server/workflow/query-logs.test.ts b/apps/sim/lib/copilot/tools/server/workflow/query-logs.test.ts
index 6f195ac4a3..d4c5541ab2 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/query-logs.test.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/query-logs.test.ts
@@ -4,21 +4,31 @@
 
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { listLogsMock, fetchLogDetailMock, toOverviewMock, toFullMock, grepSpansMock } = vi.hoisted(
-  () => ({
-    listLogsMock: vi.fn(),
-    fetchLogDetailMock: vi.fn(),
-    toOverviewMock: vi.fn(),
-    toFullMock: vi.fn(),
-    grepSpansMock: vi.fn(),
-  })
-)
+const {
+  listLogsMock,
+  statsLogsMock,
+  fetchLogDetailMock,
+  toOverviewMock,
+  toFullMock,
+  toTraceMock,
+  grepSpansMock,
+} = vi.hoisted(() => ({
+  listLogsMock: vi.fn(),
+  statsLogsMock: vi.fn(),
+  fetchLogDetailMock: vi.fn(),
+  toOverviewMock: vi.fn(),
+  toFullMock: vi.fn(),
+  toTraceMock: vi.fn(),
+  grepSpansMock: vi.fn(),
+}))
 
 vi.mock('@/lib/logs/list-logs', () => ({ listLogs: listLogsMock }))
+vi.mock('@/lib/logs/stats-logs', () => ({ statsLogs: statsLogsMock }))
 vi.mock('@/lib/logs/fetch-log-detail', () => ({ fetchLogDetail: fetchLogDetailMock }))
 vi.mock('@/lib/logs/log-views', () => ({
   toOverview: toOverviewMock,
   toFull: toFullMock,
+  toTrace: toTraceMock,
   grepSpans: grepSpansMock,
 }))
 vi.mock('@/lib/execution/payloads/large-execution-value', () => ({
@@ -47,8 +57,8 @@ beforeEach(() => {
 })
 
 describe('queryLogsServerTool', () => {
-  it('list view delegates to listLogs with workspaceId and no view field', async () => {
-    listLogsMock.mockResolvedValue({ data: [{ id: 'log-1' }], nextCursor: null })
+  it('list view delegates to listLogs and leads with total and cursor', async () => {
+    listLogsMock.mockResolvedValue({ data: [{ id: 'log-1' }], nextCursor: null, total: 42 })
 
     const result = await queryLogsServerTool.execute(
       { view: 'list', sortBy: 'date', sortOrder: 'desc', limit: 100 } as any,
@@ -59,8 +69,68 @@ describe('queryLogsServerTool', () => {
     const [params, userId] = listLogsMock.mock.calls[0]
     expect(userId).toBe('user-1')
     expect(params.workspaceId).toBe('ws-1')
+    expect(params.includeTotal).toBe(true)
     expect(params).not.toHaveProperty('view')
-    expect(result).toEqual({ data: [{ id: 'log-1' }], nextCursor: null })
+    expect(params).not.toHaveProperty('title')
+    expect(result).toEqual({ total: 42, nextCursor: null, data: [{ id: 'log-1' }] })
+    expect(Object.keys(result as object)).toEqual(['total', 'nextCursor', 'data'])
+  })
+
+  it('stats view delegates to statsLogs with the workspace scoped in', async () => {
+    statsLogsMock.mockResolvedValue({ totals: { executions: 7 } })
+
+    const result = await queryLogsServerTool.execute(
+      { view: 'stats', bucket: 'day', timezone: 'UTC', workflowIds: 'wf-1' } as any,
+      ctx
+    )
+
+    expect(statsLogsMock).toHaveBeenCalledTimes(1)
+    const [params, userId] = statsLogsMock.mock.calls[0]
+    expect(userId).toBe('user-1')
+    expect(params).toMatchObject({ workspaceId: 'ws-1', bucket: 'day', workflowIds: 'wf-1' })
+    expect(result).toEqual({ totals: { executions: 7 } })
+  })
+
+  it('defaults to the condensed trace digest when only an executionId is given', async () => {
+    fetchLogDetailMock.mockResolvedValue(detail())
+    toTraceMock.mockReturnValue([{ blockId: 'blk-1', name: 'Agent', executions: 3 }])
+
+    const result: any = await queryLogsServerTool.execute({ executionId: 'exec-1' } as any, ctx)
+
+    expect(toTraceMock).toHaveBeenCalledTimes(1)
+    expect(result.blocks).toEqual([{ blockId: 'blk-1', name: 'Agent', executions: 3 }])
+    expect(toOverviewMock).not.toHaveBeenCalled()
+    expect(toFullMock).not.toHaveBeenCalled()
+  })
+
+  it('defaults to list when no executionId is given', async () => {
+    listLogsMock.mockResolvedValue({ data: [], nextCursor: null, total: 0 })
+
+    await queryLogsServerTool.execute({} as any, ctx)
+
+    expect(listLogsMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('passes blockIds and fields through to toFull', async () => {
+    fetchLogDetailMock.mockResolvedValue(detail())
+    toFullMock.mockResolvedValue([{ id: 's1' }])
+
+    await queryLogsServerTool.execute(
+      {
+        view: 'full',
+        executionId: 'exec-1',
+        blockIds: ['blk-1', 'blk-2'],
+        fields: ['output.rows'],
+      } as any,
+      ctx
+    )
+
+    expect(toFullMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      { blockId: undefined, blockIds: ['blk-1', 'blk-2'], blockName: undefined },
+      ['output.rows']
+    )
   })
 
   it('overview view returns the projected span tree', async () => {
@@ -87,10 +157,16 @@ describe('queryLogsServerTool', () => {
       ctx
     )
 
-    expect(toFullMock).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
-      blockId: 'blk-1',
-      blockName: undefined,
-    })
+    expect(toFullMock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      {
+        blockId: 'blk-1',
+        blockIds: undefined,
+        blockName: undefined,
+      },
+      undefined
+    )
     expect(result.spans).toEqual([{ id: 's1', input: { a: 1 } }])
     expect(result.truncated).toBe(false)
   })
diff --git a/apps/sim/lib/copilot/tools/server/workflow/query-logs.ts b/apps/sim/lib/copilot/tools/server/workflow/query-logs.ts
index 9ab073f7dd..a60e271140 100644
--- a/apps/sim/lib/copilot/tools/server/workflow/query-logs.ts
+++ b/apps/sim/lib/copilot/tools/server/workflow/query-logs.ts
@@ -8,7 +8,8 @@ import {
 } from '@/lib/execution/payloads/large-execution-value'
 import { fetchLogDetail } from '@/lib/logs/fetch-log-detail'
 import { type ListLogsParams, listLogs } from '@/lib/logs/list-logs'
-import { grepSpans, type LogViewContext, toFull, toOverview } from '@/lib/logs/log-views'
+import { grepSpans, type LogViewContext, toFull, toOverview, toTrace } from '@/lib/logs/log-views'
+import { statsLogs } from '@/lib/logs/stats-logs'
 import type { TraceSpan } from '@/lib/logs/types'
 
 const logger = createLogger('QueryLogsServerTool')
@@ -21,8 +22,12 @@ const MAX_FULL_RESULT_BYTES = 512 * 1024
 
 const comparisonOperator = z.enum(['=', '>', '<', '>=', '<=', '!='])
 
+/** Display-only label rendered in the UI tool row; never used server-side. */
+const displayTitle = z.string().optional()
+
 const listArgsSchema = z.object({
   view: z.literal('list'),
+  title: displayTitle,
   workspaceId: z.string().optional(),
   level: z.string().optional(),
   workflowIds: z.string().optional(),
@@ -44,8 +49,33 @@ const listArgsSchema = z.object({
   sortOrder: z.enum(['asc', 'desc']).optional().default('desc'),
 })
 
+const statsArgsSchema = z.object({
+  view: z.literal('stats'),
+  title: displayTitle,
+  workspaceId: z.string().optional(),
+  level: z.string().optional(),
+  workflowIds: z.string().optional(),
+  folderIds: z.string().optional(),
+  triggers: z.string().optional(),
+  startDate: z.string().optional(),
+  endDate: z.string().optional(),
+  search: z.string().optional(),
+  workflowName: z.string().optional(),
+  folderName: z.string().optional(),
+  bucket: z.enum(['day', 'hour']).optional(),
+  timezone: z.string().optional(),
+})
+
+const traceArgsSchema = z.object({
+  view: z.literal('trace'),
+  title: displayTitle,
+  workspaceId: z.string().optional(),
+  executionId: z.string(),
+})
+
 const overviewArgsSchema = z.object({
   view: z.literal('overview'),
+  title: displayTitle,
   workspaceId: z.string().optional(),
   executionId: z.string(),
   pattern: z.string().optional(),
@@ -53,19 +83,38 @@ const overviewArgsSchema = z.object({
 
 const fullArgsSchema = z.object({
   view: z.literal('full'),
+  title: displayTitle,
   workspaceId: z.string().optional(),
   executionId: z.string(),
   blockId: z.string().optional(),
+  blockIds: z.array(z.string()).optional(),
   blockName: z.string().optional(),
+  fields: z.array(z.string()).optional(),
   pattern: z.string().optional(),
 })
 
-const queryLogsArgsSchema = z.discriminatedUnion('view', [
+const queryLogsViewsSchema = z.discriminatedUnion('view', [
   listArgsSchema,
+  statsArgsSchema,
+  traceArgsSchema,
   overviewArgsSchema,
   fullArgsSchema,
 ])
 
+/**
+ * `view` defaults to the compact disclosure level: `trace` when an
+ * `executionId` is supplied, `list` otherwise.
+ */
+const queryLogsArgsSchema = z.preprocess((value) => {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    const record = value as Record<string, unknown>
+    if (record.view === undefined) {
+      return { ...record, view: record.executionId ? 'trace' : 'list' }
+    }
+  }
+  return value
+}, queryLogsViewsSchema)
+
 type QueryLogsArgs = z.infer<typeof queryLogsArgsSchema>
 
 function resolveWorkspaceId(args: QueryLogsArgs, context?: ServerToolContext): string {
@@ -100,11 +149,17 @@ function buildLogViewContext(
  * Consolidated execution/log read tool.
  *
  * - `view: "list"` — paginated execution summaries with the full Logs-UI filter
- *   set (reuses `listLogs`).
+ *   set (reuses `listLogs`); always carries `total` for the filtered set.
+ * - `view: "stats"` — server-side aggregation (counts by status, per workflow,
+ *   optionally calendar-bucketed) under the same filters; answers quantitative
+ *   questions in one call instead of a paginate-and-count walk.
+ * - `view: "trace"` — one execution's condensed per-block digest: names,
+ *   statuses, execution counts (loop iterations collapse), block ids to drill
+ *   into.
  * - `view: "overview"` — a single execution's trace-span tree (timing + cost,
  *   no input/output).
  * - `view: "full"` — a single execution's trace spans with materialized
- *   input/output, optionally scoped to one block via `blockId`/`blockName`.
+ *   input/output, scoped via `blockIds` (from the trace digest) / `blockName`.
  * - `pattern` (with `overview`/`full`) — grep that execution's trace spans,
  *   streaming large values chunk-by-chunk.
  */
@@ -112,7 +167,10 @@ export const queryLogsServerTool: BaseServerTool<QueryLogsArgs, unknown> = {
   name: QueryLogs.id,
   inputSchema: queryLogsArgsSchema,
   outputSchema: z.unknown(),
-  async execute(args: QueryLogsArgs, context?: ServerToolContext): Promise<unknown> {
+  async execute(rawArgs: QueryLogsArgs, context?: ServerToolContext): Promise<unknown> {
+    // Re-parse so the compact-view default applies even when a caller bypasses
+    // the router's schema validation; idempotent on already-parsed args.
+    const args = queryLogsArgsSchema.parse(rawArgs) as QueryLogsArgs
     if (!context?.userId) {
       throw new Error('Unauthorized access')
     }
@@ -120,10 +178,18 @@ export const queryLogsServerTool: BaseServerTool<QueryLogsArgs, unknown> = {
     const workspaceId = resolveWorkspaceId(args, context)
 
     if (args.view === 'list') {
-      const { view: _view, ...rest } = args
-      const params = { ...rest, workspaceId } as ListLogsParams
+      const { view: _view, title: _title, ...rest } = args
+      const params = { ...rest, workspaceId, includeTotal: true } as ListLogsParams
       logger.info('query_logs list', { workspaceId, sortBy: params.sortBy })
-      return listLogs(params, userId)
+      const { data, nextCursor, total } = await listLogs(params, userId)
+      // Cursor and total lead the payload so a truncated render still shows them.
+      return { total, nextCursor, data }
+    }
+
+    if (args.view === 'stats') {
+      const { view: _view, title: _title, ...rest } = args
+      logger.info('query_logs stats', { workspaceId, bucket: rest.bucket })
+      return statsLogs({ ...rest, workspaceId }, userId)
     }
 
     // overview / full / grep — single execution by id
@@ -141,6 +207,18 @@ export const queryLogsServerTool: BaseServerTool<QueryLogsArgs, unknown> = {
       | { traceSpans?: TraceSpan[]; totalDuration?: number | null }
       | undefined
     const traceSpans = (execData?.traceSpans ?? []) as TraceSpan[]
+
+    if (args.view === 'trace') {
+      return {
+        executionId: detail.executionId,
+        workflowId: detail.workflowId,
+        status: detail.status,
+        trigger: detail.trigger,
+        durationMs: execData?.totalDuration ?? null,
+        blocks: toTrace(traceSpans),
+      }
+    }
+
     const viewCtx = buildLogViewContext(detail, workspaceId, userId)
 
     if (args.pattern) {
@@ -174,10 +252,16 @@ export const queryLogsServerTool: BaseServerTool<QueryLogsArgs, unknown> = {
     }
 
     // full
-    const spans = await toFull(traceSpans, viewCtx, {
-      blockId: args.blockId,
-      blockName: args.blockName,
-    })
+    const spans = await toFull(
+      traceSpans,
+      viewCtx,
+      {
+        blockId: args.blockId,
+        blockIds: args.blockIds,
+        blockName: args.blockName,
+      },
+      args.fields
+    )
     const result = {
       executionId: detail.executionId,
       workflowId: detail.workflowId,
@@ -194,7 +278,7 @@ export const queryLogsServerTool: BaseServerTool<QueryLogsArgs, unknown> = {
         workflowId: detail.workflowId,
         status: detail.status,
         truncated: true,
-        note: 'Full result too large; returning the compact overview. Scope with blockId/blockName, or use pattern to grep.',
+        note: 'Full result too large; returning the compact overview. Scope with blockIds/blockName (ids from view "trace"), or use pattern to grep.',
         spans: toOverview(traceSpans),
       }
     }
diff --git a/apps/sim/lib/copilot/tools/tool-display.test.ts b/apps/sim/lib/copilot/tools/tool-display.test.ts
index 027ce68d91..253dd9d94d 100644
--- a/apps/sim/lib/copilot/tools/tool-display.test.ts
+++ b/apps/sim/lib/copilot/tools/tool-display.test.ts
@@ -4,9 +4,9 @@
 import { describe, expect, it } from 'vitest'
 import {
   FfmpegOperationValues,
-  KnowledgeBaseOperationValues,
-  MaterializeFileOperationValues,
+  ManageKnowledgeBaseOperationValues,
   QueryUserTableOperationValues,
+  SaveUploadOperationValues,
   SearchKnowledgeBaseOperationValues,
   TOOL_CATALOG,
   type ToolCatalogEntry,
@@ -65,22 +65,41 @@ describe('humanizeToolName', () => {
 
   it('keeps canonical acronym casing', () => {
     expect(humanizeToolName('create_workspace_mcp_server')).toBe('Create Workspace MCP Server')
-    expect(humanizeToolName('deploy_api')).toBe('Deploy API')
+    expect(humanizeToolName('deploy_as_api')).toBe('Deploy As API')
     expect(humanizeToolName('oauth_request_access')).toBe('OAuth Request Access')
   })
 })
 
 describe('getToolDisplayTitle natural-language coverage', () => {
   it('gives gerund titles to tools that previously fell through to humanize', () => {
-    expect(getToolDisplayTitle('deploy_api')).toBe('Deploying API')
+    expect(getToolDisplayTitle('deploy_as_api')).toBe('Deploying as API')
     expect(getToolDisplayTitle('list_workspace_mcp_servers')).toBe('Listing MCP servers')
-    expect(getToolDisplayTitle('oauth_get_auth_link')).toBe('Getting authorization link')
+    expect(getToolDisplayTitle('oauth_get_auth_link')).toBe('Creating sign-in link')
     expect(getToolDisplayTitle('diff_workflows')).toBe('Comparing workflows')
+    expect(getToolDisplayTitle('get_enterprise_context')).toBe('Checking enterprise access')
   })
 
-  it('falls back to running code for function_execute without a title', () => {
-    expect(getToolDisplayTitle('function_execute')).toBe('Running code')
-    expect(getToolDisplayTitle('function_execute', { title: 'Crunching numbers' })).toBe(
+  it('includes the query in search_docs titles', () => {
+    expect(getToolDisplayTitle('search_docs')).toBe('Searching Sim docs')
+    expect(getToolDisplayTitle('search_docs', { query: 'loop blocks iteration' })).toBe(
+      'Searching Sim docs for "loop blocks iteration"'
+    )
+    expect(
+      getToolCompletedTitle(
+        getToolDisplayTitle('search_docs', { query: 'how to read workflow logs' })
+      )
+    ).toBe('Searched Sim docs for "how to read workflow logs"')
+    expect(
+      getToolDisplayTitle('search_docs', {
+        query:
+          'reference block outputs connection tags blockname.field pass data between blocks in a workflow',
+      })?.length
+    ).toBeLessThanOrEqual('Searching Sim docs for ""'.length + 32 + '...'.length)
+  })
+
+  it('falls back to running code for run_function without a title', () => {
+    expect(getToolDisplayTitle('run_function')).toBe('Running code')
+    expect(getToolDisplayTitle('run_function', { title: 'Crunching numbers' })).toBe(
       'Crunching numbers'
     )
   })
@@ -107,16 +126,16 @@ describe('getToolDisplayTitle natural-language coverage', () => {
 
   it('resolves every catalog action and operation enum without a generic placeholder', () => {
     const genericPlaceholders = new Set([
-      'Credential action',
-      'Custom tool action',
+      'Managing credential',
+      'Managing custom tool',
       'Editing file',
       'Folder action',
-      'MCP server action',
+      'Managing MCP server',
       'Managing knowledge base',
       'Managing table',
       'Preparing file',
       'Processing media',
-      'Skill action',
+      'Managing skill',
     ])
     const unresolvedVariants: string[] = []
 
@@ -141,14 +160,14 @@ describe('getToolDisplayTitle natural-language coverage', () => {
 
 describe('getToolDisplayTitle for deployments', () => {
   it.each([
-    ['deploy_api', undefined, 'Deploying API'],
-    ['deploy_api', { action: 'deploy' }, 'Deploying API'],
-    ['deploy_api', { action: 'undeploy' }, 'Undeploying API'],
-    ['deploy_chat', { action: 'deploy' }, 'Deploying chat'],
-    ['deploy_chat', { action: 'undeploy' }, 'Undeploying chat'],
-    ['deploy_custom_block', { action: 'deploy' }, 'Deploying custom block'],
-    ['deploy_custom_block', { action: 'undeploy' }, 'Undeploying custom block'],
-    ['deploy_mcp', undefined, 'Deploying MCP tool'],
+    ['deploy_as_api', undefined, 'Deploying as API'],
+    ['deploy_as_api', { action: 'deploy' }, 'Deploying as API'],
+    ['deploy_as_api', { action: 'undeploy' }, 'Undeploying as API'],
+    ['deploy_as_chat', { action: 'deploy' }, 'Deploying as chat'],
+    ['deploy_as_chat', { action: 'undeploy' }, 'Undeploying as chat'],
+    ['publish_custom_block', { action: 'deploy' }, 'Publishing custom block'],
+    ['publish_custom_block', { action: 'undeploy' }, 'Unpublishing custom block'],
+    ['deploy_as_mcp', undefined, 'Deploying as MCP tool'],
     ['redeploy', undefined, 'Redeploying API'],
   ])('uses the action and deployment type for %s', (toolName, args, expected) => {
     expect(getToolDisplayTitle(toolName, args)).toBe(expected)
@@ -167,7 +186,7 @@ describe('getToolCompletedTitle', () => {
     expect(getToolCompletedTitle('Creating workflow')).toBe('Created workflow')
     expect(getToolCompletedTitle('Running workflow')).toBe('Ran workflow')
     expect(getToolCompletedTitle('Reading file')).toBe('Read file')
-    expect(getToolCompletedTitle('Undeploying API')).toBe('Undeployed API')
+    expect(getToolCompletedTitle('Undeploying as API')).toBe('Undeployed as API')
     expect(getToolCompletedTitle('Duplicating workflow')).toBe('Duplicated workflow')
     expect(getToolCompletedTitle('Viewing custom tools')).toBe('Viewed custom tools')
     expect(getToolCompletedTitle('Saving report.pdf')).toBe('Saved report.pdf')
@@ -179,12 +198,26 @@ describe('getToolCompletedTitle', () => {
     expect(getToolCompletedTitle('Custom title from the model')).toBeUndefined()
   })
 
-  it('projects completed titles only for successful rows', () => {
+  it('projects a terminal tense for every settled row, present tense only while running', () => {
     expect(getToolStatusDisplayTitle('Comparing workflows', 'success')).toBe('Compared workflows')
     expect(getToolStatusDisplayTitle('Comparing workflows', 'executing')).toBe(
       'Comparing workflows'
     )
-    expect(getToolStatusDisplayTitle('Comparing workflows', 'error')).toBe('Comparing workflows')
+    // An errored row must not read as still running — the frozen present-tense
+    // title ("Searching for X" forever) was reported as a stuck tool call.
+    expect(getToolStatusDisplayTitle('Comparing workflows', 'error')).toBe(
+      'Failed comparing workflows'
+    )
+    expect(getToolStatusDisplayTitle('Searching for admin mentions', 'error')).toBe(
+      'Failed searching for admin mentions'
+    )
+    expect(getToolStatusDisplayTitle('Comparing workflows', 'cancelled')).toBe(
+      'Stopped comparing workflows'
+    )
+    // Non-gerund titles get a prefix rather than a bad rewrite.
+    expect(getToolStatusDisplayTitle('Read recent emails', 'error')).toBe(
+      'Failed: Read recent emails'
+    )
   })
 })
 
@@ -216,19 +249,21 @@ describe('mvDisplayVerb', () => {
 describe('getToolDisplayTitle for the vfs verbs', () => {
   it('shows the created file name', () => {
     expect(
-      getToolDisplayTitle('create_file', {
+      getToolDisplayTitle('create_empty_file', {
         outputs: {
           files: [{ path: 'files/Reports/Quarterly%20Report.pdf', mode: 'create' }],
         },
       })
     ).toBe('Creating Quarterly Report.pdf')
-    expect(getToolDisplayTitle('create_file', { fileName: 'notes.md' })).toBe('Creating notes.md')
+    expect(getToolDisplayTitle('create_empty_file', { fileName: 'notes.md' })).toBe(
+      'Creating notes.md'
+    )
     expect(
-      getToolDisplayTitle('create_file', {
+      getToolDisplayTitle('create_empty_file', {
         outputs: { files: [{ path: 'files/notes.md', mode: 'overwrite' }] },
       })
     ).toBe('Overwriting notes.md')
-    expect(getToolDisplayTitle('create_file')).toBe('Creating file')
+    expect(getToolDisplayTitle('create_empty_file')).toBe('Creating file')
   })
 
   it('titles rm from toolTitle, falling back to the paths', () => {
@@ -305,7 +340,7 @@ describe('getToolDisplayTitle for managed resources', () => {
       },
       'Creating lookupWeather',
     ],
-    ['manage_mcp_tool', { operation: 'edit', config: { name: 'Linear' } }, 'Updating Linear'],
+    ['manage_mcp_connection', { operation: 'edit', config: { name: 'Linear' } }, 'Updating Linear'],
     ['manage_skill', { operation: 'delete', name: 'sales-research' }, 'Deleting sales-research'],
     [
       'manage_credential',
@@ -318,7 +353,7 @@ describe('getToolDisplayTitle for managed resources', () => {
     ],
     ['rm', { paths: ['workflows/Marketing/Q3%20Campaigns'] }, 'Deleting Q3 Campaigns'],
     ['manage_custom_tool', { operation: 'list' }, 'Viewing custom tools'],
-    ['manage_mcp_tool', { operation: 'list' }, 'Viewing MCP servers'],
+    ['manage_mcp_connection', { operation: 'list' }, 'Viewing MCP servers'],
     ['manage_skill', { operation: 'list' }, 'Viewing skills'],
   ])('uses verb + resource name for %s', (toolName, args, expected) => {
     expect(getToolDisplayTitle(toolName, args)).toBe(expected)
@@ -335,15 +370,15 @@ describe('getToolDisplayTitle for operation-driven tools', () => {
   })
 
   it('covers every knowledge-base operation with its actual verb and resource', () => {
-    for (const operation of KnowledgeBaseOperationValues) {
-      expect(getToolDisplayTitle('knowledge_base', { operation })).not.toBe(
+    for (const operation of ManageKnowledgeBaseOperationValues) {
+      expect(getToolDisplayTitle('manage_knowledge_base', { operation })).not.toBe(
         'Managing knowledge base'
       )
     }
-    expect(getToolDisplayTitle('knowledge_base', { operation: 'query' })).toBe(
+    expect(getToolDisplayTitle('manage_knowledge_base', { operation: 'query' })).toBe(
       'Searching knowledge base'
     )
-    expect(getToolDisplayTitle('knowledge_base', { operation: 'sync_connector' })).toBe(
+    expect(getToolDisplayTitle('manage_knowledge_base', { operation: 'sync_connector' })).toBe(
       'Syncing knowledge base connector'
     )
   })
@@ -381,19 +416,19 @@ describe('getToolDisplayTitle for operation-driven tools', () => {
   })
 
   it('distinguishes saving uploads from importing workflows', () => {
-    for (const operation of MaterializeFileOperationValues) {
+    for (const operation of SaveUploadOperationValues) {
       expect(
-        getToolDisplayTitle('materialize_file', { operation, fileNames: ['Lead Router.json'] })
+        getToolDisplayTitle('save_upload', { operation, fileNames: ['Lead Router.json'] })
       ).not.toBe('Preparing file')
     }
     expect(
-      getToolDisplayTitle('materialize_file', {
+      getToolDisplayTitle('save_upload', {
         operation: 'save',
         fileNames: ['Quarterly Report.pdf'],
       })
     ).toBe('Saving Quarterly Report.pdf')
     expect(
-      getToolDisplayTitle('materialize_file', {
+      getToolDisplayTitle('save_upload', {
         operation: 'import',
         fileNames: ['Lead Router.json'],
       })
@@ -604,3 +639,114 @@ describe('wait countdown', () => {
     expect(getWaitCountdownTitle(args, 0)).toBe(getToolDisplayTitle('wait', args))
   })
 })
+
+describe('opaque id suppression', () => {
+  const uuid = '5bae7849-ffa5-4f57-984f-feab73e513df'
+
+  it('falls back to the generic label instead of printing a workflow id', () => {
+    expect(getToolDisplayTitle('run_workflow', { workflowName: uuid })).toBe('Running workflow')
+    expect(getToolDisplayTitle('run_workflow', { name: uuid })).toBe('Running workflow')
+  })
+
+  it('suppresses a bare-hex id too', () => {
+    expect(getToolDisplayTitle('run_workflow', { name: 'a'.repeat(32) })).toBe('Running workflow')
+  })
+
+  it('still shows real names, including id-adjacent ones', () => {
+    expect(getToolDisplayTitle('run_workflow', { workflowName: 'Elder v1' })).toBe(
+      'Running Elder v1'
+    )
+    expect(getToolDisplayTitle('run_workflow', { workflowName: 'GoogleSheets_v2Block' })).toBe(
+      'Running GoogleSheets_v2Block'
+    )
+  })
+
+  it('degrades a block-id fallback rather than leaking it', () => {
+    expect(getToolDisplayTitle('run_block', { blockId: uuid })).toBe('Running block')
+  })
+})
+
+describe('terminal-title projection is idempotent', () => {
+  // The client tool store phrases its own error/skip labels, so the render
+  // boundary must not project a second time onto them.
+  const storeErrorLabel = 'Attempted to read metadata for thread_tracking'
+  const storeSkipLabel = 'Skipped reading metadata for thread_tracking'
+
+  it('leaves a store-phrased error label alone instead of prefixing it', () => {
+    expect(getToolStatusDisplayTitle(storeErrorLabel, 'error')).toBe(storeErrorLabel)
+    expect(getToolStatusDisplayTitle(storeErrorLabel, 'rejected')).toBe(storeErrorLabel)
+  })
+
+  it('never stacks a second Failed prefix', () => {
+    const once = getToolStatusDisplayTitle('Reading table', 'error')
+    expect(once).toBe('Failed reading table')
+    expect(getToolStatusDisplayTitle(once, 'error')).toBe(once)
+    expect(getToolStatusDisplayTitle('Failed: Something', 'error')).toBe('Failed: Something')
+  })
+
+  it('leaves a store-phrased skip label alone when cancelled', () => {
+    expect(getToolStatusDisplayTitle(storeSkipLabel, 'aborted')).toBe(storeSkipLabel)
+    const stopped = getToolStatusDisplayTitle('Reading table', 'cancelled')
+    expect(stopped).toBe('Stopped reading table')
+    expect(getToolStatusDisplayTitle(stopped, 'cancelled')).toBe(stopped)
+  })
+
+  it('still projects an ordinary present-tense title', () => {
+    expect(getToolStatusDisplayTitle('Searching Sim docs', 'error')).toBe(
+      'Failed searching Sim docs'
+    )
+    expect(getToolStatusDisplayTitle('Running workflow', 'cancelled')).toBe(
+      'Stopped running workflow'
+    )
+  })
+})
+
+describe('resource-naming titles', () => {
+  it('names the table a row/column operation targets', () => {
+    expect(getToolDisplayTitle('table_rows', { operation: 'insert', tableName: 'Runtimes' })).toBe(
+      'Adding rows to Runtimes'
+    )
+    expect(
+      getToolDisplayTitle('table_columns', {
+        operation: 'add',
+        columnName: 'status',
+        tableName: 'Runtimes',
+      })
+    ).toBe('Adding column status in Runtimes')
+    expect(getToolDisplayTitle('table_views', { operation: 'list', tableName: 'Runtimes' })).toBe(
+      'Reading views of Runtimes'
+    )
+  })
+
+  it('falls back cleanly when the table is unnamed', () => {
+    expect(getToolDisplayTitle('table_rows', { operation: 'update' })).toBe('Updating rows')
+  })
+
+  it('names the block behind a block-schema read', () => {
+    expect(getToolDisplayTitle('read', { path: 'components/blocks/slack_v2.json' })).toBe(
+      'Loading Slack'
+    )
+    expect(
+      getToolDisplayTitle('read', { path: 'components/blocks/google_sheets_v2/README.md' })
+    ).toBe('Loading Google Sheets tips')
+  })
+
+  it('shows the text a browser type/insert call sends', () => {
+    expect(getToolDisplayTitle('browser_type', { text: 'hello there' })).toBe(
+      'Typing "hello there"'
+    )
+    expect(getToolDisplayTitle('browser_insert_text', {})).toBe('Inserting text')
+  })
+
+  it('names downloads, docs searches, and generated files', () => {
+    expect(getToolDisplayTitle('download_file', { fileName: 'report.csv' })).toBe(
+      'Downloading report.csv'
+    )
+    expect(
+      getToolDisplayTitle('search_library_docs', { library_name: 'React', query: 'useEffect' })
+    ).toBe('Searching React docs for useEffect')
+    expect(getToolDisplayTitle('generate_image', { path: 'files/hero.png' })).toBe(
+      'Generating hero.png'
+    )
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/tool-display.ts b/apps/sim/lib/copilot/tools/tool-display.ts
index c62db5ce32..947f084585 100644
--- a/apps/sim/lib/copilot/tools/tool-display.ts
+++ b/apps/sim/lib/copilot/tools/tool-display.ts
@@ -1,5 +1,5 @@
 import { isRecordLike } from '@sim/utils/object'
-import { stripVersionSuffix } from '@sim/utils/string'
+import { stripVersionSuffix, truncate } from '@sim/utils/string'
 
 /**
  * Single source of truth for copilot tool-call display titles.
@@ -19,9 +19,31 @@ type ToolArgs = Record<string, unknown> | undefined
 
 export const CONTEXT_COMPACTION_DISPLAY_TITLE = 'Summarizing context'
 
+/**
+ * A machine id never belongs in a human title ("Running
+ * 5bae7849-ffa5-4f57-984f-feab73e513df"). Matches the UUIDs `generateId()`
+ * mints, in dashed and bare-hex form — what leaks when a model passes a
+ * workflow or block id where a name was expected, whether through an explicit
+ * `*Id` fallback key or by putting the id in a `name` field.
+ *
+ * Deliberately narrow. A looser "looks random" rule would swallow legitimate
+ * names like `GoogleSheets_v2Block`, and a wrong suppression is invisible while
+ * a leaked id is merely ugly.
+ */
+const OPAQUE_ID_PATTERN =
+  /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{32})$/i
+
+/**
+ * Reads a display-safe string argument. Every title in this module goes through
+ * here, so suppressing opaque ids once covers each call site — including ones
+ * whose fallback list ends in `blockId`, which then degrades to the generic
+ * label instead of printing a UUID.
+ */
 function stringArg(args: ToolArgs, key: string): string {
   const value = args?.[key]
-  return typeof value === 'string' ? value.trim() : ''
+  if (typeof value !== 'string') return ''
+  const trimmed = value.trim()
+  return OPAQUE_ID_PATTERN.test(trimmed) ? '' : trimmed
 }
 
 function firstStringArg(args: ToolArgs, ...keys: string[]): string {
@@ -54,8 +76,62 @@ function stringOrNumberArg(args: ToolArgs, key: string): string {
   return typeof value === 'string' || typeof value === 'number' ? String(value).trim() : ''
 }
 
+/**
+ * Titles for the split table tools: each names its own action, refined by the
+ * operation and the named target when the args carry one — a card full of
+ * table work should read as adds, updates, and wiring, never a wall of
+ * identical "Queried table" rows.
+ */
+function splitTableTitle(name: string, args: ToolArgs): string {
+  const op = stringArg(args, 'operation')
+  const target = firstStringArg(args, 'columnName', 'viewName', 'name', 'title')
+  const suffix = target ? ` ${target}` : ''
+  // "in Runtimes" / "of Runtimes" — enrichment resolves the nested tableId.
+  const table = stringArg(args, 'tableName')
+  const inTable = table ? ` in ${table}` : ''
+  const ofTable = table ? ` of ${table}` : ''
+  switch (name) {
+    case 'table_manage':
+      if (op === 'create') return `Creating table${suffix || (table ? ` ${table}` : '')}`
+      if (op === 'delete') return `Deleting table${table ? ` ${table}` : suffix}`
+      if (op === 'read' || op === 'get' || op === 'list')
+        return `Reading${table ? ` ${table}` : ' table'}`
+      return `Updating${table ? ` ${table}` : ' table'}`
+    case 'table_rows':
+      if (op === 'insert' || op === 'add' || op === 'create')
+        return `Adding rows${inTable ? ` to ${table}` : ''}`
+      if (op === 'update') return `Updating rows${inTable}`
+      if (op === 'delete') return `Deleting rows${inTable}`
+      if (op === 'read' || op === 'list' || op === 'query') return `Reading rows${ofTable}`
+      return `Editing rows${ofTable}`
+    case 'table_columns':
+      if (op === 'add' || op === 'create') return `Adding column${suffix}${inTable}`
+      if (op === 'update') return `Updating column${suffix}${inTable}`
+      if (op === 'delete') return `Deleting column${suffix}${inTable}`
+      if (op === 'read' || op === 'list') return `Reading columns${ofTable}`
+      return `Editing columns${ofTable}`
+    case 'table_automations':
+      if (op === 'read' || op === 'list') return `Reading automations${ofTable}`
+      if (op === 'delete') return `Removing automation${inTable}`
+      return `Wiring automation${inTable}`
+    case 'table_enrichments':
+      if (op === 'read' || op === 'list') return `Reading enrichments${ofTable}`
+      if (op === 'delete') return `Removing enrichment${inTable}`
+      return `Configuring enrichment${suffix}${inTable}`
+    case 'table_views':
+      if (op === 'create') return `Creating view${suffix}${inTable}`
+      if (op === 'delete') return `Deleting view${suffix}${inTable}`
+      if (op === 'read' || op === 'list') return `Reading views${ofTable}`
+      return `Editing views${ofTable}`
+    default:
+      return `Updating${table ? ` ${table}` : ' table'}`
+  }
+}
+
 function deploymentTitle(args: ToolArgs, deploymentType: string): string {
-  return `${stringArg(args, 'action') === 'undeploy' ? 'Undeploying' : 'Deploying'} ${deploymentType}`
+  const verb = stringArg(args, 'action') === 'undeploy' ? 'Undeploying' : 'Deploying'
+  const workflow = firstStringArg(args, 'workflowName', 'name', 'title')
+  return workflow ? `${verb} ${workflow} as ${deploymentType}` : `${verb} as ${deploymentType}`
 }
 
 function resourceTypeLabel(type: string): string {
@@ -95,6 +171,29 @@ function displayUrl(raw: string): string {
   }
 }
 
+/**
+ * Human name for a block type id: strip the version suffix and title-case the
+ * snake_case stem (`slack_v2` -> `Slack`, `google_sheets_v2` -> `Google Sheets`).
+ */
+export function blockDisplayName(blockType: string): string {
+  const stem = stripVersionSuffix(blockType.trim())
+  if (!stem) return blockType
+  return stem
+    .split('_')
+    .filter(Boolean)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ')
+}
+
+/** Ellipsizes the middle so both ends of a value stay recognizable. */
+function truncateMiddle(value: string, maxChars: number): string {
+  const text = value.replace(/\s+/g, ' ').trim()
+  if (text.length <= maxChars) return text
+  const head = Math.ceil((maxChars - 1) / 2)
+  const tail = Math.floor((maxChars - 1) / 2)
+  return `${text.slice(0, head)}…${text.slice(text.length - tail)}`
+}
+
 function isWorkflowArtifactPath(path: string, filename: string): boolean {
   const trimmed = path.trim()
   return trimmed.startsWith('workflows/') && trimmed.endsWith(`/${filename}`)
@@ -235,12 +334,12 @@ function queryUserTableTitle(args: ToolArgs): string {
 }
 
 function searchKnowledgeBaseTitle(args: ToolArgs): string {
-  const titles: Record<string, string> = {
-    get: 'Reading knowledge base',
-    query: 'Searching knowledge base',
-    list_tags: 'Listing knowledge base tags',
-  }
-  return titles[stringArg(args, 'operation')] ?? 'Searching knowledge base'
+  const query = stringArg(args, 'query')
+  const operation = stringArg(args, 'operation')
+  if (operation === 'get') return 'Reading knowledge base'
+  if (operation === 'list_tags') return 'Listing knowledge base tags'
+  // A search row is far more useful with the question it asked.
+  return query ? `Searching knowledge base for ${query}` : 'Searching knowledge base'
 }
 
 function manageSandboxTitle(args: ToolArgs): string {
@@ -253,19 +352,6 @@ function manageSandboxTitle(args: ToolArgs): string {
   return titles[stringArg(args, 'operation')] ?? 'Managing sandbox'
 }
 
-function manageScheduledTaskTitle(args: ToolArgs): string {
-  const operationArgs = recordArg(args, 'args')
-  const title = stringArg(operationArgs, 'title')
-  const titles: Record<string, string> = {
-    create: `Creating ${title || 'scheduled task'}`,
-    list: 'Listing scheduled tasks',
-    get: 'Reading scheduled task',
-    update: `Updating ${title || 'scheduled task'}`,
-    delete: 'Deleting scheduled task',
-  }
-  return titles[stringArg(args, 'operation')] ?? 'Managing scheduled task'
-}
-
 function userTableTitle(args: ToolArgs): string {
   const operation = stringArg(args, 'operation')
   const operationArgs = recordArg(args, 'args')
@@ -351,6 +437,9 @@ function materializeFileTitle(args: ToolArgs): string {
   if (operation === 'import') {
     return `Importing ${summarizeTargets(targets, 'workflow')}`
   }
+  if (operation === 'extract') {
+    return `Extracting ${summarizeTargets(targets, 'archive')}`
+  }
   return `Saving ${summarizeTargets(targets, 'file')}`
 }
 
@@ -365,8 +454,14 @@ function openResourceTitle(args: ToolArgs): string {
 }
 
 function setGlobalWorkflowVariablesTitle(args: ToolArgs): string {
+  // Enrichment resolves the workflow id to a name; "in {workflow}" is dropped
+  // when the call targets the workflow already in view and none resolves.
+  const workflow = firstStringArg(args, 'workflowName', 'name')
+  const scope = workflow ? ` in ${workflow}` : ''
   const operations = args?.operations
-  if (!Array.isArray(operations) || operations.length === 0) return 'Setting workflow variables'
+  if (!Array.isArray(operations) || operations.length === 0) {
+    return `Setting workflow variables${scope}`
+  }
 
   const parsed = operations.filter((operation): operation is Record<string, unknown> =>
     isRecordLike(operation)
@@ -384,9 +479,9 @@ function setGlobalWorkflowVariablesTitle(args: ToolArgs): string {
 
   if (parsed.length === 1) {
     const variableName = stringArg(parsed[0], 'name')
-    return `${verb} workflow variable${variableName ? ` ${variableName}` : ''}`
+    return `${verb} workflow variable${variableName ? ` ${variableName}` : ''}${scope}`
   }
-  return `${verb} ${parsed.length} workflow variables`
+  return `${verb} ${parsed.length} workflow variables${scope}`
 }
 
 /**
@@ -437,56 +532,64 @@ const TOOL_TITLES: Record<string, string> = {
   // covers only the instant before the integration is known. The raw
   // humanized name ("Call Integration Tool") must never render.
   call_integration_tool: 'Calling integration',
+  search_integration_tools: 'Finding the right integration',
+  load_integration_tool: 'Loading integration tools',
+  load_skill: 'Loading skill',
   read: 'Reading file',
   search_library_docs: 'Searching library docs',
   user_table: 'Managing table',
   run_code: 'Running code',
   query_user_table: 'Querying table',
-  workspace_file: 'Editing file',
-  edit_content: 'Applying file content',
+  table_manage: 'Updating table',
+  table_rows: 'Editing rows',
+  table_columns: 'Editing columns',
+  table_automations: 'Wiring automation',
+  table_enrichments: 'Configuring enrichment',
+  table_views: 'Editing views',
+  prepare_file_edit: 'Editing file',
+  apply_file_edit: 'Writing changes',
   create_workflow: 'Creating workflow',
   edit_workflow: 'Editing workflow',
-  knowledge_base: 'Managing knowledge base',
+  manage_knowledge_base: 'Managing knowledge base',
   search_knowledge_base: 'Searching knowledge base',
   open_resource: 'Opening resource',
-  generate_image: 'Generating image',
-  generate_video: 'Generating video',
-  generate_audio: 'Generating audio',
+
   ffmpeg: 'Processing media',
-  check_deployment_status: 'Checking deployment status',
-  create_file: 'Creating file',
+  get_deployment_status: 'Checking deployment status',
+  create_empty_file: 'Creating file',
   create_file_folder: 'Creating folder',
   create_workspace_mcp_server: 'Creating MCP server',
   delete_workspace_mcp_server: 'Deleting MCP server',
-  deploy_api: 'Deploying API',
-  deploy_chat: 'Deploying chat',
-  deploy_custom_block: 'Deploying custom block',
-  deploy_mcp: 'Deploying MCP tool',
+  deploy_as_api: 'Deploying as API',
+  deploy_as_chat: 'Deploying as chat',
+  publish_custom_block: 'Publishing custom block',
+  deploy_as_mcp: 'Deploying as MCP tool',
   diff_workflows: 'Comparing workflows',
-  download_to_workspace_file: 'Downloading file',
-  function_execute: 'Running code',
-  complete_scheduled_task: 'Completing scheduled task',
+
+  run_function: 'Running code',
   generate_api_key: 'Generating API key',
-  get_block_outputs: 'Getting block outputs',
-  get_block_upstream_references: 'Getting block references',
-  get_deployed_workflow_state: 'Getting deployed workflow',
-  get_deployment_log: 'Getting deployment logs',
-  get_platform_actions: 'Getting platform actions',
-  get_scheduled_task_logs: 'Reading scheduled task logs',
-  get_workflow_data: 'Getting workflow data',
-  get_workflow_run_options: 'Getting run options',
+  // Retired in favor of the account/ and organization/ VFS namespaces. Kept so
+  // a replayed transcript from before the switch still renders its rows.
+  get_account_billing: 'Checking plan and usage',
+  get_block_outputs: 'Reading block outputs',
+  get_block_upstream_references: 'Tracing block inputs',
+  get_deployed_workflow_state: 'Reading the deployed version',
+  get_enterprise_context: 'Checking enterprise access',
+  list_deployment_versions: 'Listing deployment versions',
+  get_workflow_data: 'Reading workflow',
+  get_workflow_run_options: 'Checking run settings',
   list_file_folders: 'Listing folders',
   list_integration_tools: 'Listing integration tools',
   list_user_workspaces: 'Listing workspaces',
   list_workspace_mcp_servers: 'Listing MCP servers',
   load_deployment: 'Loading deployment',
-  materialize_file: 'Preparing file',
+  save_upload: 'Saving upload',
+  connect_slack_bot: 'Connecting Slack bot',
   manage_sandbox: 'Managing sandbox',
-  manage_scheduled_task: 'Managing scheduled task',
   move_file: 'Moving file',
   move_file_folder: 'Moving folder',
   move_workflow: 'Moving workflow',
-  oauth_get_auth_link: 'Getting authorization link',
+  oauth_get_auth_link: 'Creating sign-in link',
   oauth_request_access: 'Requesting access',
   promote_to_live: 'Promoting to live',
   redeploy: 'Redeploying API',
@@ -495,14 +598,11 @@ const TOOL_TITLES: Record<string, string> = {
   rename_workflow: 'Renaming workflow',
   restore_resource: 'Restoring resource',
   run_block: 'Running block',
-  scheduled_task: 'Managing scheduled task',
-  search_documentation: 'Searching documentation',
-  search_patterns: 'Searching patterns',
+  search_docs: 'Searching Sim docs',
   set_block_enabled: 'Toggling block',
   set_environment_variables: 'Setting environment variables',
   set_global_workflow_variables: 'Setting workflow variables',
   update_deployment_version: 'Updating deployment',
-  update_scheduled_task_history: 'Updating scheduled task history',
   update_workspace_mcp_server: 'Updating MCP server',
   // Browser agent tools without an argument-aware title.
   browser_go_back: 'Going back',
@@ -515,7 +615,9 @@ const TOOL_TITLES: Record<string, string> = {
   browser_read_text: 'Reading page',
   browser_screenshot: 'Taking screenshot',
   browser_click: 'Clicking element',
-  browser_type: 'Typing text',
+  browser_click_at: 'Clicking point',
+
+  browser_drag: 'Dragging element',
   browser_select_option: 'Selecting option',
   browser_hover: 'Hovering element',
   // Subagent trigger tools, when surfaced as a tool call.
@@ -525,10 +627,11 @@ const TOOL_TITLES: Record<string, string> = {
   auth: 'Auth Agent',
   knowledge: 'Knowledge Agent',
   table: 'Table Agent',
-  agent: 'Tools Agent',
+  extensions: 'Extensions Agent',
   research: 'Research Agent',
   scout: 'Scout Agent',
   search: 'Search Agent',
+  platform: 'Platform Agent',
   file: 'File Agent',
   media: 'Media Agent',
   browser: 'Browser Agent',
@@ -596,6 +699,30 @@ function waitTitle(args: ToolArgs): string {
   return formatWaitTitle(requestedWaitSeconds(args), stringArg(args, 'reason'))
 }
 
+/**
+ * An async agent id is its slugified display name plus a sequence suffix
+ * ("digest-workflow-build-4"); recover the human name for titles.
+ */
+function humanizeAgentId(id: string): string {
+  const words = id.replace(/-\d+$/, '').split('-').filter(Boolean)
+  if (words.length === 0) return id
+  return words.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')
+}
+
+/** Title for a wait_agents sleep, naming the agents and honoring mode "any". */
+function waitAgentsTitle(args: ToolArgs): string {
+  const raw = args?.agent_ids
+  const ids = Array.isArray(raw) ? raw.filter((id): id is string => typeof id === 'string') : []
+  const names = ids.map(humanizeAgentId)
+  const anyMode = stringArg(args, 'mode') === 'any'
+  if (names.length === 1) return `Waiting for ${names[0]}`
+  if (names.length > 1) {
+    const listed = `${names[0]} + ${names.length - 1}`
+    return anyMode ? `Waiting for the first of ${listed}` : `Waiting for ${listed}`
+  }
+  return 'Waiting for agents'
+}
+
 /**
  * The title of a pause that is still running, counting down what is left.
  *
@@ -613,6 +740,19 @@ export function getWaitCountdownTitle(args: ToolArgs, elapsedMs: number): string
 /** Past this a command wraps the row; the terminal panel still shows it in full. */
 const MAX_COMMAND_TITLE_LENGTH = 48
 
+/**
+ * Budget for a quoted value embedded in a title.
+ *
+ * Much shorter than {@link MAX_COMMAND_TITLE_LENGTH}: these rows carry a
+ * subagent prefix ("Workflow Agent — ") plus a verb phrase ("Searched Sim docs
+ * for ") ahead of the value, and quotes and an ellipsis cost five more columns —
+ * roughly 44 characters of fixed overhead before the value starts. The chat pane
+ * also narrows whenever a resource panel is open, so the budget is set to keep
+ * the row on one line there rather than at full width. A model-written search
+ * query runs well past any of this if left alone.
+ */
+const MAX_QUOTED_TITLE_VALUE_LENGTH = 32
+
 function runningCommandTitle(rawCommand: string): string {
   const command = rawCommand.replace(/\s+/g, ' ')
   if (!command) return 'Running command'
@@ -666,32 +806,45 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
   }
 
   switch (name) {
-    case 'deploy_api':
+    case 'deploy_as_api':
       return deploymentTitle(args, 'API')
-    case 'deploy_chat':
+    case 'deploy_as_chat':
       return deploymentTitle(args, 'chat')
-    case 'deploy_custom_block':
-      return deploymentTitle(args, 'custom block')
+    case 'publish_custom_block':
+      return `${stringArg(args, 'action') === 'undeploy' ? 'Unpublishing' : 'Publishing'} custom block`
     case 'ffmpeg':
       return ffmpegTitle(args)
-    case 'knowledge_base':
+    case 'manage_knowledge_base':
       return knowledgeBaseTitle(args)
     case 'query_user_table':
       return queryUserTableTitle(args)
+    case 'table_manage':
+    case 'table_rows':
+    case 'table_columns':
+    case 'table_automations':
+    case 'table_enrichments':
+    case 'table_views':
+      return splitTableTitle(name, args)
     case 'search_knowledge_base':
       return searchKnowledgeBaseTitle(args)
     case 'manage_sandbox':
       return manageSandboxTitle(args)
-    case 'manage_scheduled_task':
-      return manageScheduledTaskTitle(args)
     case 'user_table':
       return userTableTitle(args)
-    case 'materialize_file':
+    case 'save_upload':
       return materializeFileTitle(args)
     case 'open_resource':
       return openResourceTitle(args)
     case 'wait':
       return waitTitle(args)
+    case 'wait_agents':
+      return waitAgentsTitle(args)
+    case 'tail_agent':
+      return `Checking on ${humanizeAgentId(stringArg(args, 'agent_id')) || 'agent'}`
+    case 'steer_agent':
+      return `Steering ${humanizeAgentId(stringArg(args, 'agent_id')) || 'agent'}`
+    case 'interrupt_agent':
+      return `Stopping ${humanizeAgentId(stringArg(args, 'agent_id')) || 'agent'}`
     case 'terminal':
       return terminalTitle(args)
     // The surface used to be one tool per operation. Conversations recorded
@@ -719,12 +872,6 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
       const type = stringArg(args, 'type')
       return `Restoring ${type ? resourceTypeLabel(type) : 'resource'}`
     }
-    case 'set_block_enabled': {
-      const enabled = args?.enabled
-      return typeof enabled === 'boolean'
-        ? `${enabled ? 'Enabling' : 'Disabling'} block`
-        : 'Toggling block'
-    }
     case 'load_deployment': {
       const version = stringOrNumberArg(args, 'version')
       if (!version) return 'Loading deployment'
@@ -732,10 +879,6 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
         ? 'Loading live deployment'
         : `Loading deployment version ${version}`
     }
-    case 'promote_to_live': {
-      const version = stringOrNumberArg(args, 'version')
-      return version ? `Promoting version ${version} to live` : 'Promoting to live'
-    }
     case 'update_deployment_version': {
       const version = stringOrNumberArg(args, 'version')
       return version ? `Updating deployment version ${version}` : 'Updating deployment'
@@ -756,7 +899,7 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
     }
     case 'set_global_workflow_variables':
       return setGlobalWorkflowVariablesTitle(args)
-    case 'create_file':
+    case 'create_empty_file':
       return createFileTitle(args)
     case 'share_file': {
       const action = stringArg(args, 'action') || 'share'
@@ -784,10 +927,16 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
       const target = firstStringArg(args, 'serverName', 'name', 'title')
       return `Deleting ${target || 'MCP server'}`
     }
-    case 'search_online': {
+    case 'web_search': {
       const target = firstStringArg(args, 'toolTitle', 'title')
       return target ? `Searching online for ${target}` : 'Searching online'
     }
+    case 'search_docs': {
+      const target = firstStringArg(args, 'toolTitle', 'title', 'query')
+      return target
+        ? `Searching Sim docs for "${truncate(target, MAX_QUOTED_TITLE_VALUE_LENGTH)}"`
+        : 'Searching Sim docs'
+    }
     case 'grep': {
       const target = firstStringArg(args, 'toolTitle', 'title')
       return target ? `Searching for ${target}` : 'Searching'
@@ -804,14 +953,24 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
         const destination = stringArg(args, 'destination')
         if (destination) return `Renaming ${pathLeaf(sources[0])} to ${pathLeaf(destination)}`
       }
+      // The model's own phrasing wins; otherwise name both ends of the
+      // move: "Moving apple.md to fruits".
       const target = firstStringArg(args, 'toolTitle', 'title')
-      return target ? `${verb} ${target}` : verb
+      if (target) return `${verb} ${target}`
+      const destination = stringArg(args, 'destination')
+      if (sources.length > 0 && destination) {
+        const what = summarizeTargets(sources.map(pathLeaf), 'files')
+        return `${verb} ${what} to ${pathLeaf(destination)}`
+      }
+      return verb
     }
     case 'cp': {
       const target = firstStringArg(args, 'toolTitle', 'title')
       return target ? `Duplicating ${target}` : 'Duplicating workflow'
     }
     case 'mkdir': {
+      const path = stringArg(args, 'path')
+      if (path) return `Creating folder ${pathLeaf(path)}`
       const target = firstStringArg(args, 'toolTitle', 'title')
       return target ? `Creating ${target}` : 'Creating folder'
     }
@@ -823,7 +982,15 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
         summarizeTargets(stringArrayArg(args, 'paths').map(pathLeaf), 'resource')
       return target ? `Deleting ${target}` : 'Deleting'
     }
-    case 'enrichment_run': {
+    case 'load_integration_tool': {
+      const integration = firstStringArg(args, 'integration', 'service', 'toolId')
+      return integration ? `Loading ${integration} tools` : 'Loading integration tools'
+    }
+    case 'load_skill': {
+      const skill = firstStringArg(args, 'name', 'skillId', 'skill')
+      return skill ? `Loading skill ${skill}` : 'Loading skill'
+    }
+    case 'run_enrichment': {
       const subject = nestedStringArg(
         args,
         'inputs',
@@ -833,9 +1000,9 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
         'email',
         'companyDomain'
       )
-      return subject ? `Searching for ${subject}` : 'Searching'
+      return subject ? `Looking up ${subject}` : 'Looking up data'
     }
-    case 'scrape_page': {
+    case 'web_scrape': {
       const url = stringArg(args, 'url')
       return url ? `Scraping ${url}` : 'Scraping page'
     }
@@ -855,6 +1022,44 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
       const text = stringArg(args, 'text')
       return text ? `Waiting for "${text}"` : 'Waiting for page'
     }
+    case 'generate_image':
+    case 'generate_video':
+    case 'generate_audio': {
+      const kind =
+        name === 'generate_image' ? 'image' : name === 'generate_video' ? 'video' : 'audio'
+      const target =
+        firstStringArg(args, 'toolTitle', 'title') ||
+        (stringArg(args, 'path') ? pathLeaf(stringArg(args, 'path')) : '')
+      return target ? `Generating ${target}` : `Generating ${kind}`
+    }
+    case 'download_file': {
+      const target =
+        firstStringArg(args, 'fileName', 'toolTitle', 'title') ||
+        (stringArg(args, 'path') ? pathLeaf(stringArg(args, 'path')) : '') ||
+        (stringArg(args, 'url') ? displayUrl(stringArg(args, 'url')) : '')
+      return target ? `Downloading ${target}` : 'Downloading file'
+    }
+    case 'extract_doc_assets': {
+      const target = stringArg(args, 'path') ? pathLeaf(stringArg(args, 'path')) : ''
+      return target ? `Extracting assets from ${target}` : 'Extracting document assets'
+    }
+    case 'search_library_docs': {
+      const library = firstStringArg(args, 'library_name', 'libraryName', 'library')
+      const query = stringArg(args, 'query')
+      if (library && query) return `Searching ${library} docs for ${query}`
+      if (library) return `Searching ${library} docs`
+      return query ? `Searching library docs for ${query}` : 'Searching library docs'
+    }
+    case 'run_code': {
+      const title = stringArg(args, 'title')
+      return title || 'Running code'
+    }
+    case 'browser_type':
+    case 'browser_insert_text': {
+      const verb = name === 'browser_type' ? 'Typing' : 'Inserting'
+      const text = stringArg(args, 'text')
+      return text ? `${verb} "${truncateMiddle(text, 32)}"` : `${verb} text`
+    }
     case 'browser_press_key': {
       const key = stringArg(args, 'key')
       return key ? `Pressing ${key}` : 'Pressing key'
@@ -871,15 +1076,15 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
       const reason = stringArg(args, 'reason')
       return reason ? `Waiting for you: ${reason}` : 'Waiting for you in the browser'
     }
-    case 'crawl_website': {
+    case 'web_crawl': {
       const url = stringArg(args, 'url')
       return url ? `Crawling ${url}` : 'Crawling website'
     }
-    case 'get_page_contents': {
+    case 'web_fetch': {
       const urls = stringArrayArg(args, 'urls')
-      if (urls.length === 1) return `Getting ${urls[0]}`
-      if (urls.length > 1) return `Getting ${urls.length} pages`
-      return 'Getting page contents'
+      if (urls.length === 1) return `Fetching ${urls[0]}`
+      if (urls.length > 1) return `Fetching ${urls.length} pages`
+      return 'Fetching page'
     }
     case 'manage_custom_tool': {
       const schema = args?.schema
@@ -888,18 +1093,18 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
         (schema && typeof schema === 'object'
           ? nestedStringArg(schema as Record<string, unknown>, 'function', 'name')
           : '')
-      return namedOperationTitle(args, target, 'Custom tool action', {
+      return namedOperationTitle(args, target, 'Managing custom tool', {
         add: { verb: 'Creating', resource: 'custom tool' },
         edit: { verb: 'Updating', resource: 'custom tool' },
         delete: { verb: 'Deleting', resource: 'custom tool' },
         list: { verb: 'Viewing', resource: 'custom tools' },
       })
     }
-    case 'manage_mcp_tool': {
+    case 'manage_mcp_connection': {
       const target =
         firstStringArg(args, 'serverName', 'name', 'title') ||
         nestedStringArg(args, 'config', 'name')
-      return namedOperationTitle(args, target, 'MCP server action', {
+      return namedOperationTitle(args, target, 'Managing MCP server', {
         add: { verb: 'Creating', resource: 'MCP server' },
         edit: { verb: 'Updating', resource: 'MCP server' },
         delete: { verb: 'Deleting', resource: 'MCP server' },
@@ -908,7 +1113,7 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
     }
     case 'manage_skill': {
       const target = firstStringArg(args, 'name', 'skillName', 'title')
-      return namedOperationTitle(args, target, 'Skill action', {
+      return namedOperationTitle(args, target, 'Managing skill', {
         add: { verb: 'Creating', resource: 'skill' },
         edit: { verb: 'Updating', resource: 'skill' },
         delete: { verb: 'Deleting', resource: 'skill' },
@@ -924,27 +1129,128 @@ export function getToolDisplayTitle(name: string, args?: Record<string, unknown>
         return to ? `Renaming credential to ${to}` : 'Renaming credential'
       }
       const target = firstStringArg(args, 'credentialName', 'displayName', 'name', 'title')
-      return namedOperationTitle(args, target, 'Credential action', {
+      return namedOperationTitle(args, target, 'Managing credential', {
         delete: { verb: 'Deleting', resource: 'credential' },
       })
     }
-    case 'run_workflow':
-    case 'run_from_block':
-    case 'run_workflow_until_block':
-      return 'Running workflow'
+    case 'get_deployment_status': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Checking ${workflow} deployment status` : 'Checking deployment status'
+    }
+    case 'get_deployed_workflow_state': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Reading deployed ${workflow}` : 'Reading the deployed version'
+    }
+    case 'get_workflow_run_options': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Checking ${workflow} run settings` : 'Checking run settings'
+    }
+    case 'get_block_outputs': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Reading ${workflow} block outputs` : 'Reading block outputs'
+    }
+    case 'get_block_upstream_references': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Tracing ${workflow} block inputs` : 'Tracing block inputs'
+    }
+    case 'redeploy': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Redeploying ${workflow}` : 'Redeploying API'
+    }
+    case 'promote_to_live': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      const version = stringOrNumberArg(args, 'version')
+      if (workflow && version) return `Promoting ${workflow} version ${version} to live`
+      if (workflow) return `Promoting ${workflow} to live`
+      return version ? `Promoting version ${version} to live` : 'Promoting to live'
+    }
+    case 'run_workflow': {
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      return workflow ? `Running ${workflow}` : 'Running workflow'
+    }
+    case 'run_from_block': {
+      const block = firstStringArg(args, 'blockName', 'block_name', 'startBlockName')
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      if (!block) return 'Running workflow'
+      return workflow ? `Running from ${block} in ${workflow}` : `Running from ${block}`
+    }
+    case 'run_workflow_until_block': {
+      const block = firstStringArg(args, 'blockName', 'block_name', 'untilBlockName')
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      if (!block) return workflow ? `Running ${workflow}` : 'Running workflow'
+      return `Running ${workflow || 'workflow'} until ${block}`
+    }
+    case 'run_block': {
+      const block = firstStringArg(args, 'blockName', 'block_name')
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      if (!block) return 'Running block'
+      return workflow ? `Running ${block} in ${workflow}` : `Running ${block}`
+    }
+    case 'set_block_enabled': {
+      const block = firstStringArg(args, 'blockName', 'block_name')
+      const workflow = firstStringArg(args, 'workflowName', 'name')
+      const verb =
+        args?.enabled === false ? 'Disabling' : args?.enabled === true ? 'Enabling' : 'Toggling'
+      if (!block) return `${verb} block`
+      return workflow ? `${verb} ${block} in ${workflow}` : `${verb} ${block}`
+    }
     case 'query_logs': {
+      // The model narrates its own query; the per-view titles are fallbacks.
+      const title = stringArg(args, 'title')
+      if (title) return title
       const workflowName = stringArg(args, 'workflowName')
-      return workflowName ? `Querying logs for ${workflowName}` : 'Querying logs'
+      const scope = workflowName ? ` for ${workflowName}` : ''
+      switch (stringArg(args, 'view')) {
+        case 'stats':
+          return `Analyzing run stats${scope}`
+        case 'trace':
+          return 'Reading execution trace'
+        case 'overview':
+          return 'Reading execution overview'
+        case 'full':
+          return 'Reading execution details'
+        case 'list':
+          return `Querying logs${scope}`
+        default:
+          // view is optional: executionId implies the trace digest default.
+          return stringArg(args, 'executionId')
+            ? 'Reading execution trace'
+            : `Querying logs${scope}`
+      }
     }
     case 'read': {
-      if (isWorkflowArtifactPath(stringArg(args, 'path'), 'lint.json')) {
+      const path = stringArg(args, 'path')
+      if (isWorkflowArtifactPath(path, 'lint.json')) {
         return 'Validating workflow state'
       }
+      // Workflow artifacts name BOTH the workflow and which part, so five
+      // reads in a row differentiate instead of all saying the same thing.
+      // A block schema read is the model looking up how a block works; name
+      // the block, not the file. The row's icon is chosen from the same id.
+      const blockSchema = path.match(/^components\/blocks\/([^/]+)\.json$/)
+      if (blockSchema) return `Loading ${blockDisplayName(decodePathSegment(blockSchema[1]))}`
+      const blockTips = path.match(/^components\/blocks\/([^/]+)\/README\.md$/)
+      if (blockTips) return `Loading ${blockDisplayName(decodePathSegment(blockTips[1]))} tips`
+      const workflowArtifact = path.match(/^workflows\/([^/]+)\/([^/]+)$/)
+      if (workflowArtifact) {
+        const part =
+          (
+            {
+              'meta.json': 'meta',
+              'state.json': 'state',
+              'deployment.json': 'deployment',
+              'README.md': 'notes',
+            } as Record<string, string>
+          )[workflowArtifact[2]] ?? decodePathSegment(workflowArtifact[2])
+        return `Reading ${decodePathSegment(workflowArtifact[1])} ${part}`
+      }
+      if (path) return `Reading ${pathLeaf(path)}`
       break
     }
-    case 'workspace_file':
-    case 'function_execute': {
-      const title = name === 'workspace_file' ? workspaceFileTitle(args) : stringArg(args, 'title')
+    case 'prepare_file_edit':
+    case 'run_function': {
+      const title =
+        name === 'prepare_file_edit' ? workspaceFileTitle(args) : stringArg(args, 'title')
       if (title) return title
       break
     }
@@ -974,7 +1280,13 @@ const COMPLETED_VERB_REWRITES: Record<string, string> = {
   Crawling: 'Crawled',
   Creating: 'Created',
   Deleting: 'Deleted',
+  Connecting: 'Connected',
   Deploying: 'Deployed',
+  Dragging: 'Dragged',
+  Inserting: 'Inserted',
+  Publishing: 'Published',
+  Unpublishing: 'Unpublished',
+  Analyzing: 'Analyzed',
   Disabling: 'Disabled',
   Downloading: 'Downloaded',
   Duplicating: 'Duplicated',
@@ -986,8 +1298,13 @@ const COMPLETED_VERB_REWRITES: Record<string, string> = {
   Finding: 'Found',
   Gathering: 'Gathered',
   Generating: 'Generated',
-  Getting: 'Got',
   Going: 'Went',
+  Fetching: 'Fetched',
+  Tracing: 'Traced',
+  Wiring: 'Wired',
+  Configuring: 'Configured',
+  Looking: 'Looked',
+  Rotating: 'Rotated',
   Hovering: 'Hovered',
   Importing: 'Imported',
   Inspecting: 'Inspected',
@@ -1005,6 +1322,7 @@ const COMPLETED_VERB_REWRITES: Record<string, string> = {
   Querying: 'Queried',
   Reading: 'Read',
   Redeploying: 'Redeployed',
+  Removing: 'Removed',
   Renaming: 'Renamed',
   Requesting: 'Requested',
   Resizing: 'Resized',
@@ -1018,6 +1336,7 @@ const COMPLETED_VERB_REWRITES: Record<string, string> = {
   Selecting: 'Selected',
   Setting: 'Set',
   Sharing: 'Shared',
+  Steering: 'Steered',
   Stopping: 'Stopped',
   Summarizing: 'Summarized',
   Switching: 'Switched',
@@ -1053,11 +1372,58 @@ export function getToolCompletedTitle(title: string): string | undefined {
   return past + title.slice(firstWord.length)
 }
 
+/**
+ * Titles that already say the work is over.
+ *
+ * Two layers project a terminal tense: the client tool store phrases its own
+ * error and skip labels ("Attempted to read X", "Skipped reading X"), and this
+ * module projects again at the render boundary. Re-projecting an
+ * already-projected title stacked prefixes — "Failed: Failed: Attempted to read
+ * metadata for thread_tracking" — and even a single pass over a store label
+ * reads as doubly hedged. Whichever layer spoke first wins.
+ */
+const TERMINAL_TITLE_PREFIXES = new Set(['Failed', 'Attempted', 'Skipped', 'Stopped'])
+
+function firstWordOf(title: string): string {
+  const spaceIndex = title.indexOf(' ')
+  return spaceIndex === -1 ? title : title.slice(0, spaceIndex)
+}
+
+/** Whether a title already states a terminal outcome and must pass through. */
+function statesTerminalOutcome(title: string): boolean {
+  return TERMINAL_TITLE_PREFIXES.has(firstWordOf(title).replace(/:$/, ''))
+}
+
+/**
+ * Rewrite a resolved display title for a FAILED tool call. A gerund title
+ * becomes "Failed <gerund>…" ("Searching for X" → "Failed searching for X");
+ * anything else gets a "Failed: " prefix. Without this, an errored row kept
+ * its present-tense activity title verbatim and read as still running.
+ */
+export function getToolFailedTitle(title: string): string {
+  if (statesTerminalOutcome(title)) return title
+  const firstWord = firstWordOf(title)
+  if (COMPLETED_VERB_REWRITES[firstWord]) {
+    return `Failed ${firstWord.charAt(0).toLowerCase()}${firstWord.slice(1)}${title.slice(firstWord.length)}`
+  }
+  return `Failed: ${title}`
+}
+
+/** Rewrite a resolved display title for a CANCELLED tool call ("Stopped <gerund>…"). */
+export function getToolStoppedTitle(title: string): string {
+  if (statesTerminalOutcome(title)) return title
+  const firstWord = firstWordOf(title)
+  if (COMPLETED_VERB_REWRITES[firstWord]) {
+    return `Stopped ${firstWord.charAt(0).toLowerCase()}${firstWord.slice(1)}${title.slice(firstWord.length)}`
+  }
+  return `Stopped: ${title}`
+}
+
 /**
  * Resolve the final title for a tool status at a rendering boundary. Persisted
  * and live snapshots intentionally keep the present-tense activity title so a
- * running/error row remains truthful; every successful renderer calls this to
- * project the corresponding completed title from the canonical verb map.
+ * RUNNING row remains truthful; terminal states project a tense that says the
+ * work is over — completed (past tense), failed, or stopped.
  */
 export function getToolStatusDisplayTitle(
   title: string,
@@ -1067,5 +1433,8 @@ export function getToolStatusDisplayTitle(
   if (status === 'success' && toolName === 'browser_request_takeover') {
     return 'Resumed browser control'
   }
-  return status === 'success' ? (getToolCompletedTitle(title) ?? title) : title
+  if (status === 'success') return getToolCompletedTitle(title) ?? title
+  if (status === 'error' || status === 'rejected') return getToolFailedTitle(title)
+  if (status === 'cancelled' || status === 'aborted') return getToolStoppedTitle(title)
+  return title
 }
diff --git a/apps/sim/lib/copilot/tools/workflow-tools.test.ts b/apps/sim/lib/copilot/tools/workflow-tools.test.ts
new file mode 100644
index 0000000000..b461634bad
--- /dev/null
+++ b/apps/sim/lib/copilot/tools/workflow-tools.test.ts
@@ -0,0 +1,86 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import {
+  COPILOT_WORKFLOW_TOOL_BINDING_ERRORS,
+  classifyWorkflowToolBinding,
+  resolveWorkflowToolTargetId,
+} from './workflow-tools'
+
+const runningToolCall = {
+  toolName: 'run_workflow',
+  status: 'running' as const,
+  permissionDecision: null,
+  args: { workflowId: 'workflow-1' },
+}
+
+const run = { userId: 'user-1', workflowId: 'workflow-1' }
+
+function classify(overrides: Partial<Parameters<typeof classifyWorkflowToolBinding>[0]> = {}) {
+  return classifyWorkflowToolBinding({
+    toolCall: runningToolCall,
+    run,
+    userId: 'user-1',
+    workflowId: 'workflow-1',
+    ...overrides,
+  })
+}
+
+describe('classifyWorkflowToolBinding', () => {
+  it('accepts a live call bound to the requested workflow', () => {
+    expect(classify()).toEqual({ ok: true })
+  })
+
+  it.each([
+    ['missing row', { toolCall: null }, COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.unknown],
+    [
+      'non-workflow tool',
+      { toolCall: { ...runningToolCall, toolName: 'read' } },
+      COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.notWorkflowTool,
+    ],
+    [
+      'finished call',
+      { toolCall: { ...runningToolCall, status: 'completed' as const } },
+      COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.alreadySettled,
+    ],
+    [
+      'unapproved call',
+      { toolCall: { ...runningToolCall, status: 'pending' as const } },
+      COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.awaitingPermission,
+    ],
+    [
+      'another user',
+      { run: { ...run, userId: 'someone-else' } },
+      COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.foreignOwner,
+    ],
+    [
+      'another workflow',
+      { workflowId: 'workflow-2' },
+      COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.workflowMismatch,
+    ],
+  ])('rejects %s with its own reason', (_name, overrides, expected) => {
+    expect(classify(overrides)).toEqual({ ok: false, rejection: expected })
+  })
+
+  it('reports a finished call as the same conflict the execution claim uses', () => {
+    // The client already treats this status/code pair as benign on both the sync
+    // and async paths, so a duplicate stops rendering as a workflow failure.
+    expect(COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.alreadySettled).toMatchObject({
+      statusCode: 409,
+      code: 'COPILOT_WORKFLOW_EXECUTION_CONFLICT',
+    })
+  })
+
+  it('falls back to the run workflow only for rows persisted without a stamped target', () => {
+    // Kept for the deploy window: in-flight tool calls created before the target
+    // was stamped into args still resolve through the run.
+    expect(resolveWorkflowToolTargetId({}, 'workflow-1')).toBe('workflow-1')
+    expect(classify({ toolCall: { ...runningToolCall, args: {} } })).toEqual({ ok: true })
+    // A workspace chat has no run workflow, so nothing can rescue it.
+    expect(
+      classify({ toolCall: { ...runningToolCall, args: {} }, run: { ...run, workflowId: null } })
+    ).toEqual({ ok: false, rejection: COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.workflowMismatch })
+  })
+})
diff --git a/apps/sim/lib/copilot/tools/workflow-tools.ts b/apps/sim/lib/copilot/tools/workflow-tools.ts
index b493f55c19..a922924b7e 100644
--- a/apps/sim/lib/copilot/tools/workflow-tools.ts
+++ b/apps/sim/lib/copilot/tools/workflow-tools.ts
@@ -1,8 +1,12 @@
+import type { CopilotAsyncToolStatus, CopilotToolPermissionDecision } from '@sim/db/schema'
 import { isPlainRecord } from '@sim/utils/object'
 import {
   ASYNC_TOOL_CONFIRMATION_STATUS,
   type AsyncConfirmationStatus,
+  isTerminalAsyncStatus,
+  isWorkflowToolExecutionClaimable,
 } from '@/lib/copilot/async-runs/lifecycle'
+import { COPILOT_WORKFLOW_EXECUTION_CONFLICT_CODE } from '@/lib/copilot/constants'
 
 const WORKFLOW_TOOL_NAMES = [
   'run_workflow',
@@ -31,6 +35,103 @@ const ASYNC_WORKFLOW_DEPLOYMENT_ERROR_BY_CODE = new Map<string, AsyncWorkflowDep
   Object.values(ASYNC_WORKFLOW_DEPLOYMENT_ERRORS).map((error) => [error.code, error])
 )
 
+/**
+ * Why a workflow-tool execution request is not bound to the tool call it claims.
+ *
+ * These used to collapse into one opaque 403, which cost the caller any chance of
+ * telling "someone already ran this" (benign) from "this can never run" (a real
+ * defect), and told the model nothing it could act on.
+ *
+ * `alreadySettled` deliberately reuses `COPILOT_WORKFLOW_EXECUTION_CONFLICT_CODE`:
+ * it IS the same conflict as losing the execution claim, and both client paths
+ * already treat that status/code pair as benign and silent.
+ */
+export const COPILOT_WORKFLOW_TOOL_BINDING_ERRORS = {
+  unknown: {
+    code: 'COPILOT_WORKFLOW_TOOL_BINDING_UNKNOWN',
+    message: 'No Copilot workflow tool call matches this execution request',
+    statusCode: 404,
+  },
+  notWorkflowTool: {
+    code: 'COPILOT_WORKFLOW_TOOL_BINDING_NOT_WORKFLOW_TOOL',
+    message: 'This Copilot tool call does not run a workflow',
+    statusCode: 403,
+  },
+  alreadySettled: {
+    code: COPILOT_WORKFLOW_EXECUTION_CONFLICT_CODE,
+    message: 'This Copilot workflow tool call has already completed',
+    statusCode: 409,
+  },
+  awaitingPermission: {
+    code: 'COPILOT_WORKFLOW_TOOL_BINDING_AWAITING_APPROVAL',
+    message: 'This Copilot workflow tool call has not been approved yet',
+    statusCode: 403,
+  },
+  foreignOwner: {
+    code: 'COPILOT_WORKFLOW_TOOL_BINDING_FOREIGN_OWNER',
+    message: 'This Copilot workflow tool call belongs to a different user',
+    statusCode: 403,
+  },
+  workflowMismatch: {
+    code: 'COPILOT_WORKFLOW_TOOL_BINDING_WORKFLOW_MISMATCH',
+    message: 'This Copilot workflow tool call is bound to a different workflow',
+    statusCode: 403,
+  },
+} as const
+
+export type CopilotWorkflowToolBindingError =
+  (typeof COPILOT_WORKFLOW_TOOL_BINDING_ERRORS)[keyof typeof COPILOT_WORKFLOW_TOOL_BINDING_ERRORS]
+
+export type CopilotWorkflowToolBindingResult =
+  | { ok: true }
+  | { ok: false; rejection: CopilotWorkflowToolBindingError }
+
+interface WorkflowToolBindingCandidate {
+  toolName: string
+  status: CopilotAsyncToolStatus
+  permissionDecision: CopilotToolPermissionDecision | null
+  args: unknown
+}
+
+/**
+ * Decides whether an execution request may run under a Copilot workflow tool call.
+ *
+ * Non-authoritative on its own — the single-winner claim in
+ * `claimWorkflowToolExecution` is what actually prevents a double run. This exists
+ * so the request fails fast, and with a distinguishable reason, before spending
+ * admission and billing work on something that cannot legally run.
+ */
+export function classifyWorkflowToolBinding(params: {
+  toolCall: WorkflowToolBindingCandidate | null | undefined
+  run: { userId: string; workflowId: string | null } | null | undefined
+  userId: string
+  workflowId: string
+}): CopilotWorkflowToolBindingResult {
+  const { toolCall, run, userId, workflowId } = params
+  const reject = (rejection: CopilotWorkflowToolBindingError) => ({ ok: false as const, rejection })
+
+  if (!toolCall) return reject(COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.unknown)
+  if (!isWorkflowToolName(toolCall.toolName)) {
+    return reject(COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.notWorkflowTool)
+  }
+  if (!isWorkflowToolExecutionClaimable(toolCall.status, toolCall.permissionDecision)) {
+    // Split the one unclaimable bucket: a finished call is a benign duplicate,
+    // an unapproved one is a real refusal.
+    return reject(
+      isTerminalAsyncStatus(toolCall.status)
+        ? COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.alreadySettled
+        : COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.awaitingPermission
+    )
+  }
+  if (!run || run.userId !== userId) {
+    return reject(COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.foreignOwner)
+  }
+  if (resolveWorkflowToolTargetId(toolCall.args, run.workflowId) !== workflowId) {
+    return reject(COPILOT_WORKFLOW_TOOL_BINDING_ERRORS.workflowMismatch)
+  }
+  return { ok: true }
+}
+
 export function isWorkflowToolName(name: string): boolean {
   return WORKFLOW_TOOL_NAME_SET.has(name)
 }
diff --git a/apps/sim/lib/copilot/vfs/file-reader.ts b/apps/sim/lib/copilot/vfs/file-reader.ts
index 3940152b02..75bb5c5bdf 100644
--- a/apps/sim/lib/copilot/vfs/file-reader.ts
+++ b/apps/sim/lib/copilot/vfs/file-reader.ts
@@ -40,8 +40,14 @@ function recordSpanError(span: Span, err: unknown) {
 
 const logger = createLogger('FileReader')
 
-/** Inline text-read cap — exported so callers can align their own byte-sniff budgets with what read() can actually display. */
-export const MAX_TEXT_READ_BYTES = 5 * 1024 * 1024 // 5 MB
+/**
+ * Text-read materialization cap — exported so callers can align their own byte-sniff budgets
+ * with what read() can actually load. This bounds what the server LOADS, not what the model
+ * receives inline: the read handler windows (offset/limit) and inline-size-gates the result,
+ * so a large file is paged rather than sent whole. 20MB keeps multi-MB logs/exports greppable
+ * and pageable while still refusing genuinely unbounded blobs.
+ */
+export const MAX_TEXT_READ_BYTES = 20 * 1024 * 1024 // 20 MB
 /** Vision-attachment cap: what the prepared image must fit into after resizing. */
 export const MAX_IMAGE_READ_BYTES = 5 * 1024 * 1024 // 5 MB
 // Parseable-document byte cap. Large office/PDF files can still
diff --git a/apps/sim/lib/copilot/vfs/operations.test.ts b/apps/sim/lib/copilot/vfs/operations.test.ts
index 26c5b89b84..1f238d010e 100644
--- a/apps/sim/lib/copilot/vfs/operations.test.ts
+++ b/apps/sim/lib/copilot/vfs/operations.test.ts
@@ -2,7 +2,13 @@
  * @vitest-environment node
  */
 import { describe, expect, it } from 'vitest'
-import { glob, grep, grepReadResult, WorkspaceFileGrepError } from '@/lib/copilot/vfs/operations'
+import {
+  glob,
+  grep,
+  grepReadResult,
+  pathWithinGrepScope,
+  WorkspaceFileGrepError,
+} from '@/lib/copilot/vfs/operations'
 import { readPlaceholder } from '@/lib/copilot/vfs/read-placeholders'
 
 function vfsFromEntries(entries: [string, string][]): Map<string, string> {
@@ -48,14 +54,36 @@ describe('glob', () => {
     expect(hits).toContain('files/a/meta.json')
   })
 
-  it('treats braces literally when nobrace is set (matches old builder)', () => {
+  it('expands brace alternatives across path segments', () => {
     const files = vfsFromEntries([
-      ['weird{brace}/x', ''],
-      ['weirdA/x', ''],
+      ['workflows/Elder/state.json', '{}'],
+      ['workflows/Utils/state.json', '{}'],
+      ['workflows/Other/state.json', '{}'],
+    ])
+    const hits = glob(files, 'workflows/{Elder,Utils}/state.json')
+    expect(hits.sort()).toEqual(['workflows/Elder/state.json', 'workflows/Utils/state.json'])
+  })
+
+  it('expands extension braces', () => {
+    const files = vfsFromEntries([
+      ['files/a.png', ''],
+      ['files/b.md', ''],
+      ['files/c.txt', ''],
+    ])
+    const hits = glob(files, 'files/*.{png,md}')
+    expect(hits.sort()).toEqual(['files/a.png', 'files/b.md'])
+  })
+
+  it('expands braces in decoded-form patterns against encoded keys', () => {
+    const files = vfsFromEntries([
+      ['workflows/Elder%20v1/state.json', '{}'],
+      ['workflows/Elder%20v2/state.json', '{}'],
+    ])
+    const hits = glob(files, 'workflows/{Elder v1,Elder v2}/state.json')
+    expect(hits.sort()).toEqual([
+      'workflows/Elder%20v1/state.json',
+      'workflows/Elder%20v2/state.json',
     ])
-    const hits = glob(files, 'weird{brace}/*')
-    expect(hits).toContain('weird{brace}/x')
-    expect(hits).not.toContain('weirdA/x')
   })
 })
 
@@ -235,3 +263,18 @@ describe('grepReadResult placeholders', () => {
     expect(grepResult({ content, totalLines: 1 })).toHaveLength(1)
   })
 })
+
+describe('decode-normalized matching', () => {
+  it('glob matches a decoded display pattern against encoded keys, returning canonical paths', () => {
+    const files = new Map([['workflows/Elder%20v2/The%20Elder/state.json', '{}']])
+    const matches = glob(files, 'workflows/Elder v2/**')
+    expect(matches).toContain('workflows/Elder%20v2/The%20Elder/state.json')
+  })
+
+  it('grep scope written in decoded form filters in encoded keys', () => {
+    expect(
+      pathWithinGrepScope('workflows/Elder%20v2/The%20Elder/state.json', 'workflows/Elder v2')
+    ).toBe(true)
+    expect(pathWithinGrepScope('workflows/Other/state.json', 'workflows/Elder v2')).toBe(false)
+  })
+})
diff --git a/apps/sim/lib/copilot/vfs/operations.ts b/apps/sim/lib/copilot/vfs/operations.ts
index ac6d87c78a..b22d28d649 100644
--- a/apps/sim/lib/copilot/vfs/operations.ts
+++ b/apps/sim/lib/copilot/vfs/operations.ts
@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { truncate } from '@sim/utils/string'
 import micromatch from 'micromatch'
+import { decodeVfsSegmentSafe } from '@/lib/copilot/vfs/path-utils'
 import {
   isNonGreppablePlaceholder,
   type PlaceholderKind,
@@ -107,15 +108,30 @@ export interface ReadResult {
 
 /**
  * Micromatch options tuned to match the prior in-house glob: `bash: false` so a single `*`
- * never crosses path slashes (required for `files` + star + `meta.json` style paths). `nobrace`
- * and `noext` disable brace and extglob expansion like the old builder. Uses `micromatch` for
+ * never crosses path slashes (required for `files` + star + `meta.json` style paths). Brace
+ * expansion is ON — `workflows/{A,B}/**` and `*.{png,md}` are the natural way to batch a
+ * glob, and with `nobrace` they silently matched nothing, which reads as "no such files".
+ * `noext` still disables extglob expansion like the old builder. Uses `micromatch` for
  * well-tested `**` and edge cases instead of a custom `RegExp`.
  */
+/**
+ * Matching is decode-normalized: canonical keys are percent-encoded, but the
+ * model routinely writes the decoded display form ("Elder v2"). Comparing both
+ * sides decoded makes scope/glob matching tolerant of the encoding difference
+ * while canonical (encoded) inputs behave exactly as before. Returned paths
+ * are always the canonical encoded keys.
+ */
+function decodePathForMatch(path: string): string {
+  return path
+    .split('/')
+    .map((segment) => decodeVfsSegmentSafe(segment))
+    .join('/')
+}
+
 const VFS_GLOB_OPTIONS: micromatch.Options = {
   bash: false,
   dot: false,
   windows: false,
-  nobrace: true,
   noext: true,
 }
 
@@ -139,14 +155,19 @@ function splitLinesForGrep(content: string): string[] {
  */
 export function pathWithinGrepScope(filePath: string, scope: string): boolean {
   const scopeUsesStarOrQuestionGlob = /[*?]/.test(scope)
+  const decodedPath = decodePathForMatch(filePath)
+  const decodedScope = decodePathForMatch(scope)
   if (scopeUsesStarOrQuestionGlob) {
-    return micromatch.isMatch(filePath, scope, VFS_GLOB_OPTIONS)
+    return (
+      micromatch.isMatch(filePath, scope, VFS_GLOB_OPTIONS) ||
+      micromatch.isMatch(decodedPath, decodedScope, VFS_GLOB_OPTIONS)
+    )
   }
-  const base = scope.replace(/\/+$/, '')
+  const base = decodedScope.replace(/\/+$/, '')
   if (base === '') {
     return true
   }
-  return filePath === base || filePath.startsWith(`${base}/`)
+  return decodedPath === base || decodedPath.startsWith(`${base}/`)
 }
 
 /**
@@ -275,15 +296,22 @@ export function glob(files: Map<string, string>, pattern: string): string[] {
     }
   }
 
+  const decodedPattern = decodePathForMatch(pattern)
   for (const filePath of files.keys()) {
     if (filePath.endsWith('/.folder')) continue
-    if (micromatch.isMatch(filePath, pattern, VFS_GLOB_OPTIONS)) {
+    if (
+      micromatch.isMatch(filePath, pattern, VFS_GLOB_OPTIONS) ||
+      micromatch.isMatch(decodePathForMatch(filePath), decodedPattern, VFS_GLOB_OPTIONS)
+    ) {
       result.add(filePath)
     }
   }
 
   for (const dir of directories) {
-    if (micromatch.isMatch(dir, pattern, VFS_GLOB_OPTIONS)) {
+    if (
+      micromatch.isMatch(dir, pattern, VFS_GLOB_OPTIONS) ||
+      micromatch.isMatch(decodePathForMatch(dir), decodedPattern, VFS_GLOB_OPTIONS)
+    ) {
       result.add(dir)
     }
   }
diff --git a/apps/sim/lib/copilot/vfs/resource-writer.test.ts b/apps/sim/lib/copilot/vfs/resource-writer.test.ts
index d133cf95cd..47cbbabb95 100644
--- a/apps/sim/lib/copilot/vfs/resource-writer.test.ts
+++ b/apps/sim/lib/copilot/vfs/resource-writer.test.ts
@@ -223,4 +223,58 @@ describe('resource writer', () => {
       vfsPath: 'files/Reports/2026/summary.csv',
     })
   })
+
+  it('upserts: an overwrite of a missing target falls through to create', async () => {
+    const { OrchestrationError } = await import('@/lib/core/orchestration/types')
+    mocks.resolveWorkspaceFileReference.mockRejectedValue(
+      new OrchestrationError('not_found', 'File not found')
+    )
+    mocks.createWorkspaceFileBufferByPath.execute.mockResolvedValue({
+      id: 'file-new',
+      name: 'chart.png',
+      size: 3,
+      contentType: 'image/png',
+      downloadUrl: 'url',
+      vfsPath: 'files/chart.png',
+    })
+
+    const written = await writeWorkspaceFileByPath({
+      workspaceId: 'workspace-1',
+      principal: { kind: 'session' as const, userId: 'user-1', sessionId: 'session-1' },
+      target: { path: 'files/chart.png', mode: 'overwrite' },
+      buffer: Buffer.from('png'),
+      inferredMimeType: 'image/png',
+    })
+
+    expect(mocks.updateWorkspaceFileContentBufferByPath.execute).not.toHaveBeenCalled()
+    expect(mocks.createWorkspaceFileBufferByPath.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        input: expect.objectContaining({ path: 'files/chart.png', mode: 'create' }),
+      })
+    )
+    expect(written).toMatchObject({ id: 'file-new', mode: 'create' })
+  })
+
+  it('keeps a genuine overwrite on the update path', async () => {
+    mocks.resolveWorkspaceFileReference.mockResolvedValue({ id: 'file-1', name: 'chart.png' })
+    mocks.updateWorkspaceFileContentBufferByPath.execute.mockResolvedValue({
+      id: 'file-1',
+      name: 'chart.png',
+      size: 3,
+      contentType: 'image/png',
+      downloadUrl: 'url',
+      vfsPath: 'files/chart.png',
+    })
+
+    const written = await writeWorkspaceFileByPath({
+      workspaceId: 'workspace-1',
+      principal: { kind: 'session' as const, userId: 'user-1', sessionId: 'session-1' },
+      target: { path: 'files/chart.png', mode: 'overwrite' },
+      buffer: Buffer.from('png'),
+      inferredMimeType: 'image/png',
+    })
+
+    expect(mocks.createWorkspaceFileBufferByPath.execute).not.toHaveBeenCalled()
+    expect(written).toMatchObject({ id: 'file-1', mode: 'overwrite' })
+  })
 })
diff --git a/apps/sim/lib/copilot/vfs/resource-writer.ts b/apps/sim/lib/copilot/vfs/resource-writer.ts
index 0c3dd20a16..58d8c527aa 100644
--- a/apps/sim/lib/copilot/vfs/resource-writer.ts
+++ b/apps/sim/lib/copilot/vfs/resource-writer.ts
@@ -4,6 +4,7 @@ import {
   resolveCopilotFilePrincipal,
 } from '@/lib/copilot/auth/file-delegation'
 import { canonicalWorkspaceFilePath } from '@/lib/copilot/vfs/path-utils'
+import { asOrchestrationError } from '@/lib/core/orchestration/types'
 import { findWorkspaceFileFolderIdByPath } from '@/lib/uploads/contexts/workspace/workspace-file-folder-manager'
 import {
   getWorkspaceFileByName,
@@ -146,40 +147,54 @@ export async function writeWorkspaceFileByPath(args: {
   /**
    * Forwarded to {@link updateWorkspaceFileContent} on an overwrite. Defaults to `true` (stream a
    * markdown overwrite into any open collaborative editor). Pass `false` for a write whose content is
-   * only a placeholder — e.g. `create_file`'s empty shell, whose real content lands via a later write.
+   * only a placeholder — e.g. `create_empty_file`'s empty shell, whose real content lands via a later write.
    */
   syncLiveDoc?: boolean
   /** Private provenance for the exact bytes being written. */
   secretProvenance?: WorkspaceFileSecretProvenance
 }): Promise<WorkspaceFileWriteResult> {
-  await assertWorkspaceFileWriteAccess(args)
-
   const contentType = args.target.mimeType || args.inferredMimeType
   if (args.target.mode === 'overwrite') {
-    const updated = await updateWorkspaceFileContentBufferByPath.execute({
-      principal: args.principal,
-      input: {
-        workspaceId: args.workspaceId,
-        path: args.target.path,
-        mode: 'overwrite',
-        content: args.buffer,
-        contentType,
-        syncLiveDoc: args.syncLiveDoc,
-        secretProvenance: args.secretProvenance,
-      },
-    })
-
-    return {
-      id: updated.id,
-      name: updated.name,
-      size: updated.size,
-      contentType: updated.contentType,
-      downloadUrl: updated.downloadUrl,
-      vfsPath: updated.vfsPath,
-      mode: 'overwrite',
+    // Overwrite is an upsert: "put these bytes at this path". A missing target
+    // falls through to create instead of failing — otherwise every generator
+    // (generate_image, ffmpeg, downloads) forces the model through a
+    // create-vs-overwrite guessing dance racing its own earlier writes.
+    let missingTarget = false
+    try {
+      await assertWorkspaceFileWriteAccess(args)
+    } catch (accessError) {
+      if (asOrchestrationError(accessError)?.code !== 'not_found') throw accessError
+      missingTarget = true
     }
+    if (!missingTarget) {
+      const updated = await updateWorkspaceFileContentBufferByPath.execute({
+        principal: args.principal,
+        input: {
+          workspaceId: args.workspaceId,
+          path: args.target.path,
+          mode: 'overwrite',
+          content: args.buffer,
+          contentType,
+          syncLiveDoc: args.syncLiveDoc,
+          secretProvenance: args.secretProvenance,
+        },
+      })
+
+      return {
+        id: updated.id,
+        name: updated.name,
+        size: updated.size,
+        contentType: updated.contentType,
+        downloadUrl: updated.downloadUrl,
+        vfsPath: updated.vfsPath,
+        mode: 'overwrite',
+      }
+    }
+    args = { ...args, target: { ...args.target, mode: 'create' } }
   }
 
+  await assertWorkspaceFileWriteAccess(args)
+
   const created = await createWorkspaceFileBufferByPath.execute({
     principal: args.principal,
     input: {
diff --git a/apps/sim/lib/copilot/vfs/serializers.test.ts b/apps/sim/lib/copilot/vfs/serializers.test.ts
index 9853a305cd..236c3524ed 100644
--- a/apps/sim/lib/copilot/vfs/serializers.test.ts
+++ b/apps/sim/lib/copilot/vfs/serializers.test.ts
@@ -11,17 +11,31 @@ import type { BlockConfig } from '@/blocks/types'
 import { hostedKeyEnabledWhen } from '@/tools/hosting'
 import type { ToolConfig } from '@/tools/types'
 import {
+  buildOrganizationReadme,
+  serializeAccessControl,
+  serializeAccountBilling,
+  serializeAccountMembers,
+  serializeAccountWorkspace,
+  serializeAccountWorkspaces,
   serializeApiKeyIntegrations,
   serializeBlockSchema,
+  serializeConnectors,
+  serializeCredentialGroups,
   serializeCredentials,
   serializeDeployments,
   serializeFileMeta,
   serializeIntegrationSchema,
   serializeKBMeta,
+  serializeOrganization,
+  serializeOrganizationCustomBlocks,
+  serializeOrganizationWorkspaces,
+  serializeOrgCustomBlockDetail,
+  serializePermissionGroupRoster,
   serializeSandbox,
   serializeSandboxCatalog,
   serializeTableMeta,
   serializeWorkflowMeta,
+  serializeWorkspaceForks,
 } from './serializers'
 
 function hostedTool(id: string, conditional = false): ToolConfig {
@@ -544,3 +558,360 @@ describe('serializeCredentials — type distinguishes reconnect flow', () => {
     expect(json[1]).not.toHaveProperty('description')
   })
 })
+
+describe('serializeConnectors — cloneable references, never key material', () => {
+  const now = new Date('2026-08-14T00:00:00.000Z')
+
+  it('exposes credentialId and sourceConfig so a connector can be recreated', () => {
+    const json = JSON.parse(
+      serializeConnectors([
+        {
+          id: 'conn-1',
+          connectorType: 'slack',
+          status: 'active',
+          syncMode: 'incremental',
+          syncIntervalMinutes: 1440,
+          credentialId: 'cred-42',
+          sourceConfig: { channel: 'eng-help', maxMessages: '500' },
+          lastSyncAt: now,
+          lastSyncError: null,
+          lastSyncDocCount: 12,
+          nextSyncAt: null,
+          consecutiveFailures: 0,
+          createdAt: now,
+        },
+      ])
+    )
+    expect(json[0]).toMatchObject({
+      id: 'conn-1',
+      credentialId: 'cred-42',
+      sourceConfig: { channel: 'eng-help', maxMessages: '500' },
+    })
+    expect(JSON.stringify(json)).not.toContain('encryptedApiKey')
+  })
+
+  it('omits the credential reference when a connector has none (API-key connectors)', () => {
+    const json = JSON.parse(
+      serializeConnectors([
+        {
+          id: 'conn-2',
+          connectorType: 'github',
+          status: 'active',
+          syncMode: 'incremental',
+          syncIntervalMinutes: 1440,
+          credentialId: null,
+          sourceConfig: { repository: 'simstudioai/sim', branch: 'staging' },
+          lastSyncAt: null,
+          lastSyncError: null,
+          lastSyncDocCount: null,
+          nextSyncAt: null,
+          consecutiveFailures: 0,
+          createdAt: now,
+        },
+      ])
+    )
+    expect(json[0].credentialId).toBeUndefined()
+    expect(json[0].sourceConfig).toMatchObject({ repository: 'simstudioai/sim' })
+  })
+})
+
+describe('account and organization namespace serializers', () => {
+  it('references the files that own org and fork detail instead of restating them', () => {
+    const workspace = JSON.parse(
+      serializeAccountWorkspace({
+        workspace: { id: 'ws-1', name: 'Elder', workspaceMode: 'standard' },
+        viewer: { permission: 'admin', organizationRole: 'owner' },
+        organization: { id: 'org-1', name: 'Acme' },
+        forkedFrom: { id: 'ws-0', name: 'Elder (parent)' },
+        entitlements: ['custom-blocks'],
+      })
+    )
+
+    expect(workspace.yourPermission).toBe('admin')
+    expect(workspace.organization).toEqual({
+      id: 'org-1',
+      name: 'Acme',
+      yourRole: 'owner',
+      detail: 'organization/organization.json',
+    })
+    expect(workspace.forkedFrom.detail).toBe('organization/forks.json')
+    // The org record itself (plan, restrictions, members) must not be inlined —
+    // one relation per file is what keeps the two from disagreeing.
+    expect(workspace.organization.plan).toBeUndefined()
+  })
+
+  it('omits organization and fork stubs for a personal, unforked workspace', () => {
+    const workspace = JSON.parse(
+      serializeAccountWorkspace({
+        workspace: { id: 'ws-1', name: 'Personal' },
+        viewer: { permission: 'admin' },
+        organization: null,
+        forkedFrom: null,
+        entitlements: [],
+      })
+    )
+
+    expect(workspace.organization).toBeNull()
+    expect(workspace.forkedFrom).toBeNull()
+  })
+
+  it('withholds member emails from a non-admin viewer and says so', () => {
+    const members = [
+      { userId: 'u-1', name: 'Ada', email: 'ada@example.com', permissionType: 'admin' },
+      {
+        userId: 'u-2',
+        name: 'Grace',
+        email: 'grace@example.com',
+        permissionType: 'read',
+        isExternal: true,
+      },
+    ]
+
+    const asAdmin = JSON.parse(serializeAccountMembers(members, { includeContactDetails: true }))
+    expect(asAdmin.members[0].email).toBe('ada@example.com')
+    expect(asAdmin.note).toBeUndefined()
+
+    const asMember = JSON.parse(serializeAccountMembers(members, { includeContactDetails: false }))
+    expect(asMember.members.map((m: { email?: string }) => m.email)).toEqual([undefined, undefined])
+    expect(asMember.members[0].name).toBe('Ada')
+    expect(asMember.members[1].isExternal).toBe(true)
+    expect(asMember.note).toContain('admins only')
+  })
+
+  it('keeps money and usage numbers in billing.json alone', () => {
+    const billing = JSON.parse(
+      serializeAccountBilling({
+        plan: 'team',
+        billingScope: 'organization',
+        organizationId: 'org-1',
+        usage: {
+          currentPeriodCost: 12.5,
+          limit: 100,
+          remaining: 87.5,
+          percentUsed: 12.5,
+          isExceeded: false,
+          billingPeriodEnd: new Date('2026-09-01T00:00:00.000Z'),
+        },
+        credits: { balance: 40, scope: 'organization' },
+      })
+    )
+
+    expect(billing.plan).toBe('team')
+    expect(billing.billedTo).toBe('organization')
+    expect(billing.usage.billingPeriodEnd).toBe('2026-09-01T00:00:00.000Z')
+    expect(billing.credits.balance).toBe(40)
+
+    const organization = JSON.parse(
+      serializeOrganization({
+        organization: { id: 'org-1', relationship: 'internal', role: 'admin' },
+        capabilities: { canManageOrganization: true, canManageBilling: true },
+        plan: 'team',
+        isEnterprise: false,
+      })
+    )
+    expect(organization.usage).toBeUndefined()
+    expect(organization.credits).toBeUndefined()
+    expect(organization.note).toContain('account/billing.json')
+  })
+
+  it('describes access control as this viewer’s own binding restrictions', () => {
+    const accessControl = JSON.parse(
+      serializeAccessControl({
+        entitled: true,
+        permissionGroup: { id: 'pg-1', name: 'Contractors', resolution: 'explicit-member' },
+        restrictions: [{ key: 'hideDeployApi', description: 'Cannot deploy workflows as APIs' }],
+      })
+    )
+
+    expect(accessControl.governingPermissionGroup.appliedBecause).toBe('explicit-member')
+    expect(accessControl.activeRestrictions).toEqual([
+      { key: 'hideDeployApi', description: 'Cannot deploy workflows as APIs' },
+    ])
+    expect(accessControl.note).toContain('THIS user')
+  })
+
+  it('keeps the index to names and defers depth to per-block detail files', () => {
+    const blocks = JSON.parse(
+      serializeOrganizationCustomBlocks([
+        {
+          type: 'acme_scorer',
+          name: 'Acme Scorer',
+          description: 'Scores a lead',
+          enabled: true,
+          workflowId: 'wf-1',
+          workflowName: 'Scorer',
+          workspaceId: 'ws-9',
+          workspaceName: 'Platform',
+        },
+      ])
+    )
+
+    expect(blocks.customBlocks[0]).toEqual({
+      type: 'acme_scorer',
+      name: 'Acme Scorer',
+      enabled: true,
+      detail: 'organization/custom-blocks/acme_scorer.json',
+    })
+    // Depth belongs to the detail file — an index row carrying provenance
+    // would drift from it.
+    expect(blocks.customBlocks[0].publishedFrom).toBeUndefined()
+  })
+
+  it('gives the detail file provenance, the schema pointer, and the read-only deployed graph', () => {
+    const detail = JSON.parse(
+      serializeOrgCustomBlockDetail(
+        {
+          type: 'acme_scorer',
+          name: 'Acme Scorer',
+          enabled: true,
+          workflowId: 'wf-1',
+          workflowName: 'Scorer',
+          workspaceId: 'ws-9',
+          workspaceName: 'Platform',
+        },
+        { blocks: { b1: { type: 'agent' } }, edges: [{ source: 'b1', target: 'b2' }] }
+      )
+    )
+
+    expect(detail.publishedFrom.workflowId).toBe('wf-1')
+    expect(detail.schema).toBe('components/blocks/acme_scorer.json')
+    expect(detail.deployedWorkflowState.edges).toHaveLength(1)
+    // The graph is the deployed one and is not editable from here; the note
+    // is what tells the model both facts.
+    expect(detail.note).toContain('DEPLOYED')
+    expect(detail.note).toContain('publishing workspace')
+  })
+
+  it('writes the namespace guide with the inventory the index defers', () => {
+    const readme = buildOrganizationReadme({
+      organizationId: 'org-1',
+      isEnterprise: true,
+      customBlocks: [
+        {
+          type: 'acme_scorer',
+          name: 'Acme Scorer',
+          enabled: true,
+          workflowName: 'Scorer',
+          workspaceName: 'Platform',
+        },
+        { type: 'acme_retired', name: 'Retired', enabled: false },
+      ],
+      forksMounted: false,
+      permissionGroupsMounted: false,
+      credentialGroupsMounted: true,
+    })
+
+    expect(readme).toContain('# Organization')
+    expect(readme).toContain('custom-blocks/{type}.json')
+    expect(readme).toContain('**Acme Scorer** (`acme_scorer`) — published from Scorer in Platform')
+    expect(readme).toContain('**Retired** (`acme_retired`) — disabled')
+    // Gated files must not be advertised when unmounted for this viewer.
+    expect(readme).not.toContain('forks.json')
+    expect(readme).not.toContain('permission-groups.json')
+    expect(readme).toContain('credential-groups.json')
+  })
+
+  it('scopes credential-group people to admins and flags truncated counts', () => {
+    const base = {
+      id: 'cg-1',
+      name: 'Clients',
+      description: null,
+      status: 'active' as const,
+      options: [
+        { provider: 'gmail', label: 'Work email', required: true, configurationStatus: 'ready' },
+        { provider: 'slack', configurationStatus: 'not_configured' },
+      ],
+      enrollmentCounts: { completed: 2, invited: 1 },
+      enrollmentsTruncated: true,
+      people: [{ email: 'a@x.com', status: 'completed' }],
+    }
+
+    const admin = JSON.parse(serializeCredentialGroups([base], { includeEmails: true }))
+    expect(admin.credentialGroups[0].people).toHaveLength(1)
+    expect(admin.credentialGroups[0].enrollments.countsFromFirstPageOnly).toBe(true)
+    expect(admin.credentialGroups[0].options[1].configurationStatus).toBe('not_configured')
+
+    const member = JSON.parse(serializeCredentialGroups([base], { includeEmails: false }))
+    expect(member.credentialGroups[0].people).toBeUndefined()
+    // The runtime contract the model most needs: empty loop, not an error.
+    expect(member.note).toContain('empty loop, not an error')
+  })
+
+  it('maps the org workspace directory with access flags and fork parentage', () => {
+    const dir = JSON.parse(
+      serializeOrganizationWorkspaces([
+        { id: 'ws-1', name: 'Platform', hasAccess: true, forkedFromWorkspaceId: null },
+        { id: 'ws-2', name: 'Client Fork', hasAccess: false, forkedFromWorkspaceId: 'ws-1' },
+      ])
+    )
+    expect(dir.workspaces[1]).toEqual({
+      id: 'ws-2',
+      name: 'Client Fork',
+      hasAccess: false,
+      forkedFromWorkspaceId: 'ws-1',
+    })
+    expect(dir.note).toContain('nameable, not readable')
+  })
+
+  it('gives the admin roster restrictions per group, not per viewer', () => {
+    const roster = JSON.parse(
+      serializePermissionGroupRoster([
+        {
+          id: 'pg-1',
+          name: 'Contractors',
+          description: null,
+          isDefault: false,
+          memberCount: 4,
+          workspaces: [{ id: 'ws-1', name: 'Platform' }],
+          activeRestrictions: [{ key: 'hideDeployApi', description: 'Cannot deploy as API' }],
+        },
+      ])
+    )
+    expect(roster.permissionGroups[0].memberCount).toBe(4)
+    expect(roster.permissionGroups[0].activeRestrictions[0].key).toBe('hideDeployApi')
+    expect(roster.note).toContain('access-control.json')
+  })
+
+  it('summarizes fork mappings by resource type and omits them at the root', () => {
+    const forked = JSON.parse(
+      serializeWorkspaceForks({
+        parent: { id: 'ws-0', name: 'Template' },
+        children: [{ id: 'ws-2', name: 'Child', createdAt: new Date('2026-08-01T00:00:00.000Z') }],
+        resourceMappingCounts: { workflow: 3, table: 1 },
+        blockMappingCount: 12,
+      })
+    )
+    expect(forked.mappedFromParent).toEqual({ resources: { workflow: 3, table: 1 }, blocks: 12 })
+    expect(forked.children[0].createdAt).toBe('2026-08-01T00:00:00.000Z')
+
+    const root = JSON.parse(
+      serializeWorkspaceForks({
+        parent: null,
+        children: [],
+        resourceMappingCounts: {},
+        blockMappingCount: 0,
+      })
+    )
+    expect(root.mappedFromParent).toBeUndefined()
+  })
+
+  it('marks the current workspace and never implies the others are readable', () => {
+    const roster = JSON.parse(
+      serializeAccountWorkspaces([
+        { id: 'ws-1', name: 'Elder', role: 'admin', isCurrent: true, organizationId: 'org-1' },
+        {
+          id: 'ws-2',
+          name: 'Other',
+          role: 'read',
+          isCurrent: false,
+          forkedFromWorkspaceId: 'ws-1',
+        },
+      ])
+    )
+
+    expect(roster.workspaces[0].isCurrent).toBe(true)
+    expect(roster.workspaces[1].isCurrent).toBeUndefined()
+    expect(roster.workspaces[1].forkedFromWorkspaceId).toBe('ws-1')
+    expect(roster.note).toContain('isCurrent')
+  })
+})
diff --git a/apps/sim/lib/copilot/vfs/serializers.ts b/apps/sim/lib/copilot/vfs/serializers.ts
index 46220afdb9..02a33625af 100644
--- a/apps/sim/lib/copilot/vfs/serializers.ts
+++ b/apps/sim/lib/copilot/vfs/serializers.ts
@@ -12,7 +12,9 @@ import {
   SANDBOX_SELECTABLE_CLI_TOOL_IDS,
 } from '@/lib/execution/remote-sandbox/cli-tools'
 import { type FilterFieldType, getOperatorsForFieldType } from '@/lib/knowledge/filters/types'
+import { SLACK_CUSTOM_BOT_PROVIDER_ID } from '@/lib/oauth/types'
 import { getServiceAccountProviderForProviderId } from '@/lib/oauth/utils'
+import { isRetryEligibleBlock } from '@/lib/workflows/blocks/retry-eligibility'
 import { isSubBlockHidden } from '@/lib/workflows/subblocks/visibility'
 import { getBlock } from '@/blocks'
 import { isCustomBlockType } from '@/blocks/custom/build-config'
@@ -24,6 +26,8 @@ import {
   SIM_AUTO_MODEL_ID,
 } from '@/providers/models'
 import type { ToolConfig, ToolHostingCondition } from '@/tools/types'
+import { buildSlackManifest, SLACK_CAPABILITIES } from '@/triggers/slack/capabilities'
+import { buildSlackCustomBotRequestUrl } from '@/triggers/webhook-url'
 
 /** The service-account alternative to OAuth for a service, when it offers one. */
 export interface VfsServiceAccountAuth {
@@ -221,6 +225,8 @@ export function serializeRecentExecutions(
  * but never filters anything.
  */
 export interface KbTagDefinitionSummary {
+  /** The tagDefinitionId that update_tag / delete_tag / update_document.tagValues require. */
+  id: string
   tagName: string
   tagSlot: string
   fieldType: string
@@ -310,7 +316,11 @@ export function serializeDocuments(
 
 /**
  * Serialize KB connectors for VFS knowledgebases/{name}/connectors.json.
- * Shows connector type, sync status, and schedule — NOT credentials or source config.
+ * Shows connector type, sync status, schedule, the credential REFERENCE
+ * (an opaque id — never key material; API keys stay encrypted and are never
+ * serialized), and the source config (repo/branch/channels). The last two are
+ * what make a connector cloneable: without them, recreating a working
+ * connector on a new KB meant guessing both the credential and the channels.
  */
 export function serializeConnectors(
   connectors: Array<{
@@ -319,6 +329,8 @@ export function serializeConnectors(
     status: string
     syncMode: string
     syncIntervalMinutes: number
+    credentialId?: string | null
+    sourceConfig?: unknown
     lastSyncAt: Date | null
     lastSyncError: string | null
     lastSyncDocCount: number | null
@@ -334,6 +346,8 @@ export function serializeConnectors(
       status: c.status,
       syncMode: c.syncMode,
       syncIntervalMinutes: c.syncIntervalMinutes,
+      credentialId: c.credentialId ?? undefined,
+      sourceConfig: c.sourceConfig ?? undefined,
       lastSyncAt: c.lastSyncAt?.toISOString(),
       lastSyncError: c.lastSyncError || undefined,
       lastSyncDocCount: c.lastSyncDocCount ?? undefined,
@@ -679,6 +693,15 @@ export function serializeBlockSchema(
       longDescription: block.longDescription || undefined,
       bestPractices: block.bestPractices || undefined,
       triggerAllowed: block.triggerAllowed || undefined,
+      // Retry is block STATE (like `enabled`), not a subBlock input — set it via
+      // edit_workflow's `retry` param, never through `inputs`. Emitted only when
+      // eligible so the agent never proposes a policy the executor would ignore.
+      retryAllowed:
+        isRetryEligibleBlock({
+          blockType: block.type,
+          category: block.category,
+          triggerMode: undefined,
+        }) || undefined,
       singleInstance: block.singleInstance || undefined,
       authMode: block.authMode || undefined,
       // Custom (deploy-as-block) blocks execute via a baked `workflow_executor`
@@ -736,6 +759,15 @@ export function serializeCredentials(
       // credential) — they reconnect differently, so the agent must branch on
       // this. Env-var credentials carry no type.
       type: a.credentialType,
+      // Derived, not stored: the public Request URL a Slack custom-bot app
+      // posts events to. One per credential; every workflow trigger that
+      // selects this credential shares it. This is what the setup wizard shows
+      // in Slack's Event Subscriptions step.
+      ...(a.credentialType === 'service_account' &&
+      a.providerId === SLACK_CUSTOM_BOT_PROVIDER_ID &&
+      a.id
+        ? { requestUrl: buildSlackCustomBotRequestUrl(a.id) }
+        : {}),
       connectedAt: a.createdAt.toISOString(),
     })),
     null,
@@ -855,12 +887,17 @@ export interface DeploymentData {
     authType: string
     customizations: unknown
     isActive: boolean
+    allowedEmails?: unknown
+    outputConfigs?: unknown
+    includeThinking?: boolean | null
+    includeToolCalls?: boolean | null
   } | null
   mcp: Array<{
     serverId: string
     serverName: string
     toolId: string
     toolName: string
+    parameterDescriptionOverrides?: unknown
     toolDescription?: string | null
   }>
   versions?: Array<{
@@ -894,6 +931,9 @@ export function serializeDeployments(data: DeploymentData): string {
     : { isDeployed: false }
 
   if (data.chat) {
+    // allowedEmails/outputConfigs/includeThinking/includeToolCalls are the
+    // fields deploy_as_chat accepts on redeploy; exposing the current values is
+    // what lets a caller change one setting without blanking the others.
     result.chat = {
       id: data.chat.id,
       identifier: data.chat.identifier,
@@ -903,6 +943,10 @@ export function serializeDeployments(data: DeploymentData): string {
       authType: data.chat.authType,
       customizations: data.chat.customizations,
       isActive: data.chat.isActive,
+      allowedEmails: data.chat.allowedEmails ?? undefined,
+      outputConfigs: data.chat.outputConfigs ?? undefined,
+      includeThinking: data.chat.includeThinking ?? undefined,
+      includeToolCalls: data.chat.includeToolCalls ?? undefined,
     }
   }
 
@@ -913,6 +957,9 @@ export function serializeDeployments(data: DeploymentData): string {
       toolId: m.toolId,
       toolName: m.toolName,
       toolDescription: m.toolDescription || undefined,
+      // What deploy_as_mcp accepts as `parameters` on redeploy; omitting it
+      // there resets the overrides, so expose the current value.
+      parameterDescriptionOverrides: m.parameterDescriptionOverrides ?? undefined,
     }))
   }
 
@@ -1140,6 +1187,38 @@ export function serializeIntegrationSchema(
   )
 }
 
+/**
+ * Derived setup reference for `slack_oauth` — the same material the custom-bot
+ * setup wizard shows, surfaced so the copilot can walk a user (or the browser
+ * agent) through Slack app creation without guessing. None of this is a block
+ * field: the manifest is a template for api.slack.com, and the Request URL is a
+ * per-credential property (`requestUrl` in environment/credentials.json).
+ */
+function slackOAuthSetupReference(): Record<string, unknown> {
+  const defaults = SLACK_CAPABILITIES.filter((c) => c.defaultChecked).map((c) => c.id)
+  return {
+    note:
+      'Setup reference (derived; NOT block fields). A custom bot is a reusable workspace credential: ' +
+      'one Slack app, one Request URL, shared by every trigger that selects it. To create or rotate one, ' +
+      'emit a service_account credential card for provider "slack" — the wizard collects the signing secret ' +
+      'and bot token without them entering the chat. Existing custom bots appear as service_account ' +
+      'credentials in environment/credentials.json, each with its requestUrl.',
+    requestUrlPattern: '{baseUrl}/api/webhooks/slack/custom/{credentialId}',
+    capabilities: SLACK_CAPABILITIES.map((c) => ({
+      id: c.id,
+      label: c.label,
+      group: c.group,
+      defaultChecked: c.defaultChecked,
+      scopes: c.scopes,
+      events: c.events,
+    })),
+    defaultManifest: buildSlackManifest(new Set(defaults), {
+      appName: 'Sim Bot',
+      webhookUrl: '<the credential requestUrl>',
+    }),
+  }
+}
+
 /**
  * Serialize a trigger schema for VFS components/triggers/{provider}/{id}.json
  */
@@ -1163,6 +1242,7 @@ export function serializeTriggerSchema(trigger: {
       webhook: trigger.webhook || undefined,
       subBlocks: trigger.subBlocks.map(serializeSubBlock),
       outputs: trigger.outputs,
+      ...(trigger.id === 'slack_oauth' ? { setup: slackOAuthSetupReference() } : {}),
     },
     null,
     2
@@ -1224,3 +1304,554 @@ export function serializeTriggerOverview(
   lines.push('')
   return lines.join('\n')
 }
+
+/**
+ * tables/{name}/views.json — the table's saved views in the column-NAME
+ * domain agents speak (stored configs are id-keyed; the caller translates).
+ * Layout-only fields (order, widths, pinned) are omitted: they are UI
+ * concerns and never change which rows a view selects.
+ */
+export function serializeTableViews(
+  views: Array<{
+    id: string
+    name: string
+    isDefault: boolean
+    filter?: unknown
+    sort?: unknown
+    hiddenColumns?: string[]
+    updatedAt: Date | string
+  }>
+): string {
+  return JSON.stringify(
+    {
+      views: views.map((view) => ({
+        id: view.id,
+        name: view.name,
+        isDefault: view.isDefault,
+        filter: view.filter ?? null,
+        sort: view.sort ?? null,
+        hiddenColumns: view.hiddenColumns?.length ? view.hiddenColumns : undefined,
+        updatedAt: view.updatedAt instanceof Date ? view.updatedAt.toISOString() : view.updatedAt,
+      })),
+      note: 'Query a view via query_user_table {operation: "query_rows", args: {tableId, view: "<view id>"}} — the saved filter ANDs with any extra filter you pass. Manage views via the table agent (table_views).',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `account/workspace.json` — the current workspace as this viewer sees it:
+ * identity, the viewer's effective permission, org linkage, and fork parentage.
+ *
+ * Owns the current-workspace record. Org detail lives in
+ * `organization/organization.json` and fork topology in
+ * `organization/forks.json`; both are referenced here by id-and-name stub only,
+ * so a fact can never disagree with the file that owns it.
+ */
+export function serializeAccountWorkspace(input: {
+  workspace: { id: string; name: string; workspaceMode?: string | null }
+  viewer: { permission: string | null; organizationRole?: string | null }
+  organization: { id: string; name?: string | null } | null
+  forkedFrom: { id: string; name: string } | null
+  entitlements: string[]
+}): string {
+  return JSON.stringify(
+    {
+      id: input.workspace.id,
+      name: input.workspace.name,
+      ...(input.workspace.workspaceMode ? { mode: input.workspace.workspaceMode } : {}),
+      yourPermission: input.viewer.permission,
+      organization: input.organization
+        ? {
+            id: input.organization.id,
+            ...(input.organization.name ? { name: input.organization.name } : {}),
+            ...(input.viewer.organizationRole ? { yourRole: input.viewer.organizationRole } : {}),
+            detail: 'organization/organization.json',
+          }
+        : null,
+      forkedFrom: input.forkedFrom
+        ? {
+            id: input.forkedFrom.id,
+            name: input.forkedFrom.name,
+            detail: 'organization/forks.json',
+          }
+        : null,
+      entitlements: input.entitlements,
+      note: 'Read-only. Your accessible workspaces are in account/workspaces.json; members in account/members.json; plan and usage in account/billing.json.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `account/workspaces.json` — every workspace the viewer can reach, as stubs.
+ *
+ * Deliberately a roster, not a set of records: id, name, the viewer's role, and
+ * org/fork parentage by id. Anything richer about the *current* workspace is in
+ * `account/workspace.json`; other workspaces are not readable from here at all.
+ */
+export function serializeAccountWorkspaces(
+  workspaces: Array<{
+    id: string
+    name: string
+    role: string
+    organizationId?: string | null
+    forkedFromWorkspaceId?: string | null
+    isCurrent: boolean
+  }>
+): string {
+  return JSON.stringify(
+    {
+      workspaces: workspaces.map((workspace) => ({
+        id: workspace.id,
+        name: workspace.name,
+        yourRole: workspace.role,
+        ...(workspace.organizationId ? { organizationId: workspace.organizationId } : {}),
+        ...(workspace.forkedFromWorkspaceId
+          ? { forkedFromWorkspaceId: workspace.forkedFromWorkspaceId }
+          : {}),
+        ...(workspace.isCurrent ? { isCurrent: true } : {}),
+      })),
+      note: 'Only the current workspace (isCurrent) is mounted in this VFS — the others are listed so you can name them, not read them. Switching workspaces is the user’s action, not yours.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `account/members.json` — who is in the current workspace, with roles.
+ *
+ * `includeContactDetails` is the viewer's own admin bit: emails and pending
+ * invitations are the same privilege as the members settings page, so a
+ * non-admin viewer gets names and roles without contact details.
+ */
+export function serializeAccountMembers(
+  members: Array<{
+    userId: string
+    name: string | null
+    email: string | null
+    permissionType: string
+    isExternal?: boolean
+    roleSource?: string
+  }>,
+  options: { includeContactDetails: boolean }
+): string {
+  return JSON.stringify(
+    {
+      members: members.map((member) => ({
+        userId: member.userId,
+        name: member.name ?? null,
+        ...(options.includeContactDetails && member.email ? { email: member.email } : {}),
+        role: member.permissionType,
+        ...(member.isExternal ? { isExternal: true } : {}),
+        ...(member.roleSource && member.roleSource !== 'explicit'
+          ? { roleSource: member.roleSource }
+          : {}),
+      })),
+      total: members.length,
+      ...(options.includeContactDetails
+        ? {}
+        : { note: 'Email addresses are shown to workspace admins only.' }),
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `account/billing.json` — the acting user's live plan, usage, and credits.
+ *
+ * The only file that carries money and usage numbers; `organization.json` links
+ * here rather than repeating them. Read at request time, so the numbers are
+ * current rather than as-of-materialization.
+ */
+export function serializeAccountBilling(snapshot: {
+  plan: string
+  billingScope: 'user' | 'organization'
+  organizationId: string | null
+  usage: {
+    currentPeriodCost: number
+    limit: number
+    remaining: number
+    percentUsed: number
+    isExceeded: boolean
+    billingPeriodEnd: Date | string | null
+  }
+  credits: { balance: number; scope: 'user' | 'organization' }
+}): string {
+  const periodEnd = snapshot.usage.billingPeriodEnd
+  return JSON.stringify(
+    {
+      plan: snapshot.plan,
+      billedTo: snapshot.billingScope,
+      ...(snapshot.organizationId ? { organizationId: snapshot.organizationId } : {}),
+      usage: {
+        currentPeriodCost: snapshot.usage.currentPeriodCost,
+        limit: snapshot.usage.limit,
+        remaining: snapshot.usage.remaining,
+        percentUsed: snapshot.usage.percentUsed,
+        isExceeded: snapshot.usage.isExceeded,
+        billingPeriodEnd: periodEnd instanceof Date ? periodEnd.toISOString() : periodEnd,
+      },
+      credits: { balance: snapshot.credits.balance, scope: snapshot.credits.scope },
+      note: 'Live values for the acting user, read at access time. What the plan tiers and credits mean is a documentation question, not a value in this file.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/organization.json` — the org that hosts this workspace and the
+ * viewer's standing in it. Owns the organization record; plan economics stay in
+ * `account/billing.json`.
+ */
+export function serializeOrganization(input: {
+  organization: { id: string; relationship: string; role: string | null }
+  capabilities: { canManageOrganization: boolean; canManageBilling: boolean }
+  plan: string | null
+  isEnterprise: boolean
+}): string {
+  return JSON.stringify(
+    {
+      id: input.organization.id,
+      yourRelationship: input.organization.relationship,
+      yourRole: input.organization.role,
+      canManageOrganization: input.capabilities.canManageOrganization,
+      canManageBilling: input.capabilities.canManageBilling,
+      ...(input.plan ? { plan: input.plan } : {}),
+      isEnterprise: input.isEnterprise,
+      note: 'Plan usage and credits are in account/billing.json. Your effective restrictions are in organization/access-control.json.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/access-control.json` — who can see and do what, from the
+ * viewer's vantage: the permission group governing them and the restrictions it
+ * actually imposes.
+ *
+ * Scoped to the viewer on purpose. The full group roster is an org-admin
+ * settings surface, not workspace context.
+ */
+export function serializeAccessControl(input: {
+  entitled: boolean
+  permissionGroup: { id: string; name: string; resolution: string } | null
+  restrictions: Array<{ key: string; description: string }>
+}): string {
+  return JSON.stringify(
+    {
+      entitled: input.entitled,
+      governingPermissionGroup: input.permissionGroup
+        ? {
+            id: input.permissionGroup.id,
+            name: input.permissionGroup.name,
+            appliedBecause: input.permissionGroup.resolution,
+          }
+        : null,
+      activeRestrictions: input.restrictions.map((restriction) => ({
+        key: restriction.key,
+        description: restriction.description,
+      })),
+      note: 'These restrictions are enforced server-side on every action, so a blocked request fails no matter how it is phrased. They describe THIS user; other members may be governed by different groups.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/custom-blocks.json` — names-only index of org-published
+ * blocks, mirroring the root pattern: the index lists, the per-item file
+ * carries depth. Everything beyond name/enabled lives in
+ * `organization/custom-blocks/{type}.json`.
+ */
+export function serializeOrganizationCustomBlocks(
+  blocks: Array<{
+    type: string
+    name: string
+    description?: string | null
+    enabled: boolean
+    workflowId: string
+    workflowName?: string | null
+    workspaceId: string | null
+    workspaceName?: string | null
+  }>
+): string {
+  return JSON.stringify(
+    {
+      customBlocks: blocks.map((block) => ({
+        type: block.type,
+        name: block.name,
+        enabled: block.enabled,
+        detail: `organization/custom-blocks/${block.type}.json`,
+      })),
+      note: 'Names only — provenance and the deployed workflow graph are in each detail file. Start at organization/README.md.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/custom-blocks/{type}.json` — one published block in depth:
+ * provenance, the callable-schema pointer, and a READ-ONLY view of the
+ * deployed workflow graph backing it (blocks/edges as deployed, not the
+ * publishing workspace's live editor state). Publishing a block org-wide is
+ * the act of sharing it, which is what justifies this cross-workspace read.
+ */
+export function serializeOrgCustomBlockDetail(
+  block: {
+    type: string
+    name: string
+    description?: string | null
+    enabled: boolean
+    workflowId: string
+    workflowName?: string | null
+    workspaceId: string | null
+    workspaceName?: string | null
+  },
+  deployedState: unknown
+): string {
+  return JSON.stringify(
+    {
+      type: block.type,
+      name: block.name,
+      ...(block.description ? { description: block.description } : {}),
+      enabled: block.enabled,
+      publishedFrom: {
+        workflowId: block.workflowId,
+        ...(block.workflowName ? { workflowName: block.workflowName } : {}),
+        ...(block.workspaceId ? { workspaceId: block.workspaceId } : {}),
+        ...(block.workspaceName ? { workspaceName: block.workspaceName } : {}),
+      },
+      ...(block.enabled ? { schema: `components/blocks/${block.type}.json` } : {}),
+      deployedWorkflowState: deployedState,
+      note: 'Read-only: this is the DEPLOYED graph the block executes, not live editor state, and it cannot be edited from here. Credential ids and {{ENV_VAR}} references inside it belong to the publishing workspace and resolve only there. To wire the block into a workflow, use its schema under components/blocks/.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/README.md` — the namespace guide, playing the role
+ * WORKSPACE.md plays at the root: what each file is for and how to use it,
+ * plus the in-depth custom-block inventory the names-only index defers.
+ */
+export function buildOrganizationReadme(input: {
+  organizationId: string
+  isEnterprise: boolean
+  customBlocks: Array<{
+    type: string
+    name: string
+    enabled: boolean
+    workflowName?: string | null
+    workspaceName?: string | null
+  }>
+  forksMounted: boolean
+  permissionGroupsMounted: boolean
+  credentialGroupsMounted: boolean
+}): string {
+  const lines: string[] = [
+    '# Organization',
+    '',
+    `Read-only truth about organization \`${input.organizationId}\` as the acting user sees it. Nothing here is writable — org membership, permission groups, block publishing, and forking are all managed in the Sim UI.`,
+    '',
+    '## Files',
+    '',
+    '- `organization.json` — org identity, your relationship (internal/external) and role, who can manage it. Plan usage and credits live in `account/billing.json`, not here.',
+    '- `access-control.json` — the permission group governing YOU and the restrictions it enforces. Restrictions are enforced server-side on every action, so consult this before promising an action is possible. It describes this user only.',
+    '- `custom-blocks.json` — names-only index of org-published blocks.',
+    '- `custom-blocks/{type}.json` — one block in depth: provenance and a read-only view of the DEPLOYED workflow graph backing it (org members only). To add the block to a workflow, use its callable schema at `components/blocks/{type}.json`; the deployed graph is for understanding what the block does, not for editing.',
+    '- `workspaces.json` — every workspace in the organization with your access flag and fork parentage (org members only).',
+  ]
+  if (input.permissionGroupsMounted) {
+    lines.push(
+      '- `permission-groups.json` — the admin roster: every group with member count, targeted workspaces, and active restrictions.'
+    )
+  }
+  if (input.credentialGroupsMounted) {
+    lines.push(
+      '- `credential-groups.json` — managed credential groups: per-provider configuration readiness and enrollment progress. Consumed in workflows via the credential_group block.'
+    )
+  }
+  if (input.forksMounted) {
+    lines.push(
+      "- `forks.json` — this workspace's place in the fork tree and what was mapped from the parent. Forking, promoting, and rolling back are admin actions in the UI."
+    )
+  }
+  lines.push('', '## Published custom blocks', '')
+  if (input.customBlocks.length === 0) {
+    lines.push('None published yet.')
+  } else {
+    for (const block of input.customBlocks) {
+      const from = [block.workflowName, block.workspaceName].filter(Boolean).join(' in ')
+      lines.push(
+        `- **${block.name}** (\`${block.type}\`)${block.enabled ? '' : ' — disabled'}${from ? ` — published from ${from}` : ''}`
+      )
+    }
+  }
+  lines.push('')
+  return lines.join('\n')
+}
+
+/**
+ * `organization/workspaces.json` — the org's workspace map: every workspace in
+ * the organization, with whether the viewer can open it and its fork
+ * parentage. Broader than `account/workspaces.json`, which lists only what the
+ * viewer can reach.
+ */
+export function serializeOrganizationWorkspaces(
+  workspaces: Array<{
+    id: string
+    name: string
+    hasAccess: boolean
+    forkedFromWorkspaceId?: string | null
+  }>
+): string {
+  return JSON.stringify(
+    {
+      workspaces: workspaces.map((entry) => ({
+        id: entry.id,
+        name: entry.name,
+        hasAccess: entry.hasAccess,
+        ...(entry.forkedFromWorkspaceId
+          ? { forkedFromWorkspaceId: entry.forkedFromWorkspaceId }
+          : {}),
+      })),
+      note: 'Every workspace in the organization. hasAccess is YOUR access; workspaces without it are nameable, not readable, and only the current workspace is mounted in this VFS.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/permission-groups.json` — the org-admin roster: every group
+ * with member count, targeted workspaces, and the restrictions its config
+ * activates. `access-control.json` stays the per-viewer view; this is the
+ * management matrix.
+ */
+export function serializePermissionGroupRoster(
+  groups: Array<{
+    id: string
+    name: string
+    description: string | null
+    isDefault: boolean
+    memberCount: number
+    workspaces: Array<{ id: string; name: string }>
+    activeRestrictions: Array<{ key: string; description: string }>
+  }>
+): string {
+  return JSON.stringify(
+    {
+      permissionGroups: groups.map((group) => ({
+        id: group.id,
+        name: group.name,
+        ...(group.description ? { description: group.description } : {}),
+        isDefault: group.isDefault,
+        memberCount: group.memberCount,
+        workspaces: group.workspaces,
+        activeRestrictions: group.activeRestrictions,
+      })),
+      note: 'Management view (org admins). The group governing THIS user, with resolution reason, is in access-control.json. Group membership and scopes are edited in the Sim UI.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/credential-groups.json` — managed credential groups with the
+ * two facts that decide whether a workflow using them will actually run:
+ * per-option configuration readiness and enrollment progress. Enrollee emails
+ * are the same privilege as the settings page, so they appear for workspace
+ * admins only.
+ */
+export function serializeCredentialGroups(
+  groups: Array<{
+    id: string
+    name: string
+    description: string | null
+    status: 'active' | 'disabled'
+    options: Array<{
+      provider: string
+      label?: string | null
+      required?: boolean
+      configurationStatus: string
+    }>
+    enrollmentCounts: Record<string, number>
+    enrollmentsTruncated: boolean
+    people?: Array<{ email: string; status: string }>
+  }>,
+  options: { includeEmails: boolean }
+): string {
+  return JSON.stringify(
+    {
+      credentialGroups: groups.map((group) => ({
+        id: group.id,
+        name: group.name,
+        ...(group.description ? { description: group.description } : {}),
+        status: group.status,
+        options: group.options.map((option) => ({
+          provider: option.provider,
+          ...(option.label ? { label: option.label } : {}),
+          ...(option.required !== undefined ? { required: option.required } : {}),
+          configurationStatus: option.configurationStatus,
+        })),
+        enrollments: {
+          ...group.enrollmentCounts,
+          ...(group.enrollmentsTruncated ? { countsFromFirstPageOnly: true } : {}),
+        },
+        ...(options.includeEmails && group.people ? { people: group.people } : {}),
+      })),
+      note: 'A workflow consumes a group through a credential_group block (operation list_credentials -> ForEach over the returned credentialId page). list_credentials returns only ACTIVE credentials of in_progress/completed people — an active group with zero completed enrollments yields an empty loop, not an error. An option at not_configured makes the whole group unusable. Enrollment is admin-driven from the settings UI; invite links cannot be created or read from here.',
+    },
+    null,
+    2
+  )
+}
+
+/**
+ * `organization/forks.json` — this workspace's place in the fork tree plus the
+ * parent/child resource and block mappings.
+ *
+ * Owns fork topology; rosters elsewhere carry only `forkedFromWorkspaceId`.
+ * Mapping counts are summarized per resource type — the raw id pairs are an
+ * implementation detail of promote/rollback, not workspace context.
+ */
+export function serializeWorkspaceForks(input: {
+  parent: { id: string; name: string } | null
+  children: Array<{ id: string; name: string; createdAt: Date | string }>
+  resourceMappingCounts: Record<string, number>
+  blockMappingCount: number
+}): string {
+  return JSON.stringify(
+    {
+      parent: input.parent,
+      children: input.children.map((child) => ({
+        id: child.id,
+        name: child.name,
+        createdAt:
+          child.createdAt instanceof Date ? child.createdAt.toISOString() : child.createdAt,
+      })),
+      ...(input.parent
+        ? {
+            mappedFromParent: {
+              resources: input.resourceMappingCounts,
+              blocks: input.blockMappingCount,
+            },
+          }
+        : {}),
+      note: 'A forked workspace keeps a mapping back to the resources it was copied from, which is what promote and rollback follow. Forking, promoting, and rolling back are workspace-admin actions in the UI — you cannot perform them.',
+    },
+    null,
+    2
+  )
+}
diff --git a/apps/sim/lib/copilot/vfs/workspace-vfs.test.ts b/apps/sim/lib/copilot/vfs/workspace-vfs.test.ts
index 9ea57ae935..7e0a108007 100644
--- a/apps/sim/lib/copilot/vfs/workspace-vfs.test.ts
+++ b/apps/sim/lib/copilot/vfs/workspace-vfs.test.ts
@@ -34,6 +34,7 @@ vi.mock('@/lib/workspace-files/application/read-workspace-file-content', () => (
 }))
 
 import { WorkspaceVFS } from '@/lib/copilot/vfs/workspace-vfs'
+import { PayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
 
 const MAX_DOC_READ_INPUT_BYTES = 50 * 1024 * 1024
 const MAX_DOCUMENT_PREVIEW_CODE_BYTES = 1024 * 1024
@@ -130,3 +131,104 @@ describe('WorkspaceVFS dynamic render reads', () => {
     })
   })
 })
+
+describe('WorkspaceVFS lazy grep resilience', () => {
+  it('skips an unmaterializable lazy artifact instead of failing the whole sweep', async () => {
+    const vfs = new WorkspaceVFS({ kind: 'session', userId: 'user-1', sessionId: 'session-1' })
+    const internals = vfs as unknown as {
+      files: Map<string, string>
+      registerLazy: (path: string, loader: () => Promise<string | null>) => void
+      resolveLazyPath: (path: string) => Promise<string | null>
+    }
+    internals.files.set('workflows/A/state.json', '{"needle": true}')
+    internals.registerLazy.call(vfs, 'knowledgebases/huge/documents.json', async () => {
+      throw new Error(
+        'Knowledge base kb-1 has more than 10000 documents; documents.json cannot be materialized'
+      )
+    })
+    internals.registerLazy.call(
+      vfs,
+      'knowledgebases/small/documents.json',
+      async () => '{"needle": "lazy"}'
+    )
+
+    const matches = (await vfs.grep('needle')) as Array<{ path: string }>
+    const paths = matches.map((m) => m.path)
+    expect(paths).toContain('workflows/A/state.json')
+    expect(paths).toContain('knowledgebases/small/documents.json')
+
+    // Reading the failing artifact directly still surfaces its own error, and
+    // the loader stays re-armed for that read.
+    await expect(
+      internals.resolveLazyPath.call(vfs, 'knowledgebases/huge/documents.json')
+    ).rejects.toThrow('cannot be materialized')
+  })
+})
+
+describe('WorkspaceVFS oversized content reads', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  function arrangeOversizedContentRead() {
+    const record = {
+      id: 'file-big',
+      workspaceId: 'ws-1',
+      name: 'big.tsv',
+      key: 'big.tsv',
+      path: '/api/files/serve/big.tsv',
+      size: 7_500_000,
+      type: 'text/tab-separated-values',
+      uploadedBy: 'user-1',
+      deletedAt: null,
+      uploadedAt: new Date('2026-01-01T00:00:00.000Z'),
+      updatedAt: new Date('2026-01-01T00:00:00.000Z'),
+      storageContext: 'workspace' as const,
+    }
+    listAllWorkspaceFilesExecute.mockResolvedValue({ files: [record] })
+    findWorkspaceFileRecord.mockReturnValue(record)
+    readWorkspaceFileContentExecute.mockRejectedValue(
+      new PayloadSizeLimitError({ label: 'Workspace file', maxBytes: 20_971_520 })
+    )
+
+    const vfs = new WorkspaceVFS({ kind: 'session', userId: 'user-1', sessionId: 'session-1' })
+    Object.assign(vfs, { _workspaceId: 'ws-1' })
+    const internals = vfs as unknown as { files: Map<string, string> }
+    internals.files.set('files/big.tsv', '')
+    return vfs
+  }
+
+  it('answers a cap breach with an oversized placeholder, not "not found"', async () => {
+    const vfs = arrangeOversizedContentRead()
+
+    const result = await vfs.readFileContent('files/big.tsv/content')
+
+    expect(result).not.toBeNull()
+    expect(result).toMatchObject({ placeholder: 'oversized' })
+    expect(result?.content).toContain('File too large')
+    expect(result?.content).toContain('big.tsv')
+  })
+
+  it('reports a cap breach honestly for grep instead of "content not found"', async () => {
+    const vfs = arrangeOversizedContentRead()
+
+    await expect(vfs.grepFile('files/big.tsv', 'needle')).rejects.toThrow(/too large to search/)
+  })
+})
+
+describe('WorkspaceVFS decoded-equivalent resolution', () => {
+  it('resolves a decoded path to its single encoded twin and rejects ambiguity', () => {
+    const vfs = new WorkspaceVFS({ kind: 'session', userId: 'user-1', sessionId: 'session-1' })
+    const internals = vfs as unknown as { files: Map<string, string> }
+    internals.files.set('workflows/Elder%20v2/The%20Elder/state.json', '{}')
+
+    expect(vfs.resolveDecodedEquivalent('workflows/Elder v2/The Elder/state.json')).toBe(
+      'workflows/Elder%20v2/The%20Elder/state.json'
+    )
+    expect(vfs.resolveDecodedEquivalent('workflows/Elder v2/The Elder/meta.json')).toBeNull()
+
+    // Two keys decoding identically (pathological) must refuse to guess.
+    internals.files.set('workflows/Elder v2/The Elder/state.json', '{}')
+    expect(vfs.resolveDecodedEquivalent('workflows/Elder v2/The Elder/state.json')).toBeNull()
+  })
+})
diff --git a/apps/sim/lib/copilot/vfs/workspace-vfs.ts b/apps/sim/lib/copilot/vfs/workspace-vfs.ts
index b5e7d943f6..924c685507 100644
--- a/apps/sim/lib/copilot/vfs/workspace-vfs.ts
+++ b/apps/sim/lib/copilot/vfs/workspace-vfs.ts
@@ -16,12 +16,14 @@ import { createLogger } from '@sim/logger'
 import { toError } from '@sim/utils/errors'
 import { and, desc, eq, inArray, isNotNull, isNull, or } from 'drizzle-orm'
 import { listApiKeys } from '@/lib/api-key/service'
+import { getAccountBillingSnapshot } from '@/lib/billing/core/account-billing-snapshot'
 import { hasWorkspaceSandboxAccess } from '@/lib/billing/core/subscription'
 import {
   buildWorkspaceContextMd,
   buildWorkspaceMd,
   type WorkspaceMdData,
 } from '@/lib/copilot/chat/workspace-context'
+import { computeWorkspaceEntitlements } from '@/lib/copilot/entitlements'
 import { TraceAttr } from '@/lib/copilot/generated/trace-attributes-v1'
 import { TraceSpan } from '@/lib/copilot/generated/trace-spans-v1'
 import {
@@ -60,12 +62,19 @@ import {
   buildVfsFolderPathMap,
   canonicalWorkflowVfsDir,
   canonicalWorkspaceFilePath,
+  decodeVfsSegmentSafe,
   encodeVfsPathSegments,
 } from '@/lib/copilot/vfs/path-utils'
 import { readPlaceholder } from '@/lib/copilot/vfs/read-placeholders'
 import type { DeploymentData, VfsServiceAccountAuth } from '@/lib/copilot/vfs/serializers'
 import {
+  buildOrganizationReadme,
   describeServiceAccountForOAuthProvider,
+  serializeAccessControl,
+  serializeAccountBilling,
+  serializeAccountMembers,
+  serializeAccountWorkspace,
+  serializeAccountWorkspaces,
   serializeApiKeyIntegrations,
   serializeApiKeys,
   serializeBlockSchema,
@@ -73,6 +82,7 @@ import {
   serializeConnectorOverview,
   serializeConnectorSchema,
   serializeConnectors,
+  serializeCredentialGroups,
   serializeCredentials,
   serializeCustomTool,
   serializeDeployments,
@@ -82,15 +92,22 @@ import {
   serializeIntegrationSchema,
   serializeKBMeta,
   serializeMcpServer,
+  serializeOrganization,
+  serializeOrganizationCustomBlocks,
+  serializeOrganizationWorkspaces,
+  serializeOrgCustomBlockDetail,
+  serializePermissionGroupRoster,
   serializeRecentExecutions,
   serializeSandbox,
   serializeSandboxCatalog,
   serializeSkill,
   serializeTableMeta,
+  serializeTableViews,
   serializeTriggerOverview,
   serializeTriggerSchema,
   serializeVersions,
   serializeWorkflowMeta,
+  serializeWorkspaceForks,
 } from '@/lib/copilot/vfs/serializers'
 import type { BlockVisibilityState } from '@/lib/core/config/block-visibility'
 import {
@@ -98,6 +115,9 @@ import {
   isDocSandboxEnabled,
   isHosted,
 } from '@/lib/core/config/env-flags'
+import { isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
+import { listCredentialGroupEnrollments } from '@/lib/credential-groups/enrollments'
+import { listCredentialGroups } from '@/lib/credential-groups/service'
 import {
   getAccessibleEnvCredentials,
   getAccessibleOAuthCredentials,
@@ -109,6 +129,7 @@ import {
   listWorkspaceSandboxes,
 } from '@/lib/execution/remote-sandbox/workspace-sandboxes'
 import { runSandboxTask, SandboxUserCodeError } from '@/lib/execution/sandbox/run-task'
+import { listFoldersForWorkspace } from '@/lib/folders/queries'
 import {
   isIntegrationDeploymentAvailableForVisibility,
   isOAuthServiceDeploymentAvailable,
@@ -122,8 +143,19 @@ import {
 } from '@/lib/knowledge/application/knowledge-bases'
 import { validateMermaidSource } from '@/lib/mermaid/validate'
 import { isBlockTypeAccessControlExempt } from '@/lib/permission-groups/block-access'
+import { getActivePermissionGroupRestrictions } from '@/lib/permission-groups/features'
 import { intersectIntegrationAllowlists } from '@/lib/permission-groups/integration-allowlist'
+import {
+  listOrganizationWorkspaceRefs,
+  listPermissionGroupRoster,
+} from '@/lib/permission-groups/queries'
 import { listTables } from '@/lib/table/service'
+import {
+  listTableViewsByWorkspace,
+  normalizeStoredViewConfig,
+  pruneViewConfig,
+  viewConfigIdsToNames,
+} from '@/lib/table/views/service'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import { findWorkspaceFileRecord } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import type {
@@ -134,7 +166,10 @@ import { isImageFileType, resolveEffectiveMimeType } from '@/lib/uploads/utils/f
 import { listCustomBlocksWithInputsForWorkspace } from '@/lib/workflows/custom-blocks/operations'
 import { getCustomToolById } from '@/lib/workflows/custom-tools/operations'
 import { checkNeedsRedeployment } from '@/lib/workflows/deployment-status'
-import { loadWorkflowFromNormalizedTables } from '@/lib/workflows/persistence/utils'
+import {
+  loadDeployedWorkflowState,
+  loadWorkflowFromNormalizedTables,
+} from '@/lib/workflows/persistence/utils'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import { getSkillById } from '@/lib/workflows/skills/operations'
 import { listFolders, listWorkflows } from '@/lib/workflows/utils'
@@ -142,18 +177,27 @@ import { listAllWorkspaceFiles } from '@/lib/workspace-files/application/list-wo
 import { readWorkspaceFileContent } from '@/lib/workspace-files/application/read-workspace-file-content'
 import { listWorkspaceFileFoldersOperation } from '@/lib/workspace-files/application/workspace-file-folders'
 import { parseWorkspaceFileFolderDisplayPath } from '@/lib/workspace-files/folder-display-path'
+import { getWorkspaceHostContextForViewer } from '@/lib/workspaces/host-context'
 import {
   assertActiveWorkspaceAccess,
   getUsersWithPermissions,
   getWorkspaceWithOwner,
   hasWorkspaceAdminAccess,
 } from '@/lib/workspaces/permissions/utils'
+import { listAccessibleWorkspaceRowsForUser } from '@/lib/workspaces/utils'
 import { buildCustomBlockConfig, isCustomBlockType } from '@/blocks/custom/build-config'
 import { BLOCK_REGISTRY } from '@/blocks/registry-maps'
 import type { BlockConfig, BlockIcon } from '@/blocks/types'
 import { isHiddenUnder, overlayVisibility } from '@/blocks/visibility/context'
 import { CONNECTOR_REGISTRY } from '@/connectors/registry.server'
-import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-check'
+import {
+  getUserPermissionConfig,
+  resolveVerifiedUserAccessControlContext,
+} from '@/ee/access-control/utils/permission-check'
+import { isForkingAvailableForWorkspace } from '@/ee/workspace-forking/lib/lineage/authz'
+import { getForkChildren, getForkParent } from '@/ee/workspace-forking/lib/lineage/lineage'
+import { loadForkBlockMap } from '@/ee/workspace-forking/lib/mapping/block-map-store'
+import { getEdgeMappingRows } from '@/ee/workspace-forking/lib/mapping/mapping-store'
 import type { ToolConfig } from '@/tools/types'
 import { TRIGGER_REGISTRY } from '@/triggers/registry'
 
@@ -580,6 +624,14 @@ function getStaticComponentFiles(): Map<string, string> {
  *   custom-tools/{name}.json
  *   agent/sandboxes/README.md
  *   agent/sandboxes/{name}.json
+ *   account/workspace.json                           (this workspace + your role; always present)
+ *   account/workspaces.json                          (every workspace you can reach)
+ *   account/members.json                             (workspace members; emails admin-only)
+ *   account/billing.json                             (plan/usage/credits; lazy, read fresh)
+ *   organization/organization.json                   (org standing; only when org-hosted)
+ *   organization/access-control.json                 (your governing group + restrictions)
+ *   organization/custom-blocks.json                  (org-published block provenance)
+ *   organization/forks.json                          (fork topology; workspace admins only)
  *   environment/credentials.json
  *   environment/api-keys.json
  *   environment/variables.json
@@ -739,7 +791,13 @@ export class WorkspaceVFS {
       if (!scope || ops.pathWithinGrepScope(path, scope)) targets.push(path)
     }
     if (targets.length === 0) return
-    await Promise.all(targets.map((path) => this.resolveLazyPath(path)))
+    // One unmaterializable artifact (e.g. an over-limit knowledge base's
+    // documents.json) must not fail the whole sweep — that would make every
+    // unscoped grep on the workspace error on content the caller never asked
+    // about. Skip it: grep proceeds over everything that resolved, the loader
+    // stays re-armed, and reading the failing path directly still surfaces its
+    // own error (resolveLazyPath logs each failure).
+    await Promise.allSettled(targets.map((path) => this.resolveLazyPath(path)))
   }
 
   /**
@@ -811,6 +869,13 @@ export class WorkspaceVFS {
               'sandbox_entitlement',
               hasWorkspaceSandboxAccess(workspaceId)
             )
+            // Shared with the account/ and organization/ namespaces so the
+            // roster and host context are each read once per materialization.
+            const membersPromise = timed('members', getUsersWithPermissions(workspaceId))
+            const hostContextPromise = timed(
+              'host_context',
+              getWorkspaceHostContextForViewer(workspaceId, userId).catch(() => null)
+            )
             const [
               wfSummary,
               kbSummary,
@@ -852,10 +917,19 @@ export class WorkspaceVFS {
                 )
               ),
               timed('workspace_row', getWorkspaceWithOwner(workspaceId)),
-              timed('members', getUsersWithPermissions(workspaceId)),
+              membersPromise,
               permissionConfigPromise,
               sandboxEntitlementPromise,
             ])
+
+            // account/ and organization/ describe the viewer's standing rather
+            // than workspace resources, so they are materialized after the
+            // resource pass and contribute nothing to WORKSPACE.md.
+            const hostContext = await hostContextPromise
+            await Promise.all([
+              timed('account', this.materializeAccount(workspaceId, userId, hostContext, members)),
+              timed('organization', this.materializeOrganization(workspaceId, userId, hostContext)),
+            ])
             const workspaceMdData: WorkspaceMdData = {
               workspace: wsRow,
               members,
@@ -1018,9 +1092,18 @@ export class WorkspaceVFS {
     const normalized = path.replace(/^\/+/, '')
     // Prefer the path verbatim when it is itself a file leaf (e.g. a file literally
     // named "content"); otherwise drop a trailing "/content" read suffix.
-    const leaf = this.files.has(normalized) ? normalized : normalized.replace(/\/content$/, '')
+    let leaf = this.files.has(normalized) ? normalized : normalized.replace(/\/content$/, '')
 
-    const isWorkspaceFilePath = /^(recently-deleted\/)?files(\/|$)/.test(leaf)
+    let isWorkspaceFilePath = /^(recently-deleted\/)?files(\/|$)/.test(leaf)
+    if (isWorkspaceFilePath && !this.files.has(leaf)) {
+      // Same encoding tolerance as vfs_read: a decoded display form that maps
+      // to exactly one canonical key resolves instead of erroring.
+      const decodedEquivalent = this.resolveDecodedEquivalent(leaf)
+      if (decodedEquivalent) {
+        leaf = decodedEquivalent
+        isWorkspaceFilePath = /^(recently-deleted\/)?files(\/|$)/.test(leaf)
+      }
+    }
     if (!isWorkspaceFilePath || !this.files.has(leaf)) {
       const suggestions = this.suggestSimilar(leaf)
       const hint =
@@ -1037,6 +1120,9 @@ export class WorkspaceVFS {
     if (!result) {
       throw new ops.WorkspaceFileGrepError(`Workspace file content not found for "${path}".`)
     }
+    if (result.value.placeholder === 'oversized') {
+      throw new ops.WorkspaceFileGrepError(`File is too large to search: ${result.value.content}`)
+    }
 
     return {
       value: ops.grepReadResult(leaf, result.value, pattern, contentPath, options),
@@ -1064,6 +1150,25 @@ export class WorkspaceVFS {
     return ops.suggestSimilar(this.keyView(true), missingPath, max)
   }
 
+  /**
+   * Resolves a missing path to an existing one when the two differ ONLY by
+   * percent-encoding (the model typed the decoded display form — spaces
+   * instead of %20). Returns the canonical existing path when exactly one key
+   * decodes to the same segments; ambiguity or a genuine miss returns null so
+   * the not-found error (with suggestions) still fires. Never fuzzy: same
+   * name, different bytes only.
+   */
+  resolveDecodedEquivalent(missingPath: string): string | null {
+    const target = decodeVfsPathSegmentsSafe(missingPath)
+    let match: string | null = null
+    for (const key of this.keyView(true).keys()) {
+      if (decodeVfsPathSegmentsSafe(key) !== target) continue
+      if (match !== null) return null
+      match = key
+    }
+    return match
+  }
+
   private async resolveWorkspaceFileForDynamicRead(
     path: string,
     suffix: 'style' | 'compiled-check' | 'compiled' | 'render' | 'extract'
@@ -1557,6 +1662,8 @@ export class WorkspaceVFS {
 
     const scope = deletedMatch ? 'archived' : 'active'
 
+    let sizeCappedRecord: WorkspaceFileRecord | undefined
+    let sizeCap = MAX_TEXT_READ_BYTES
     try {
       const { files } = await listAllWorkspaceFiles.execute({
         principal: this.requireFilePrincipal(),
@@ -1564,15 +1671,17 @@ export class WorkspaceVFS {
       })
       const record = findWorkspaceFileRecord(files, fileReference)
       if (!record) return null
+      sizeCappedRecord = record
+      sizeCap = isImageFileType(resolveEffectiveMimeType(record.type, record.name))
+        ? MAX_IMAGE_SOURCE_BYTES
+        : MAX_TEXT_READ_BYTES
       const { file, content } = await readWorkspaceFileContent.execute({
         principal: this.requireFilePrincipal(),
         input: {
           fileId: record.id,
           assertedWorkspaceId: this._workspaceId,
           includeDeleted: scope === 'archived',
-          maxBytes: isImageFileType(resolveEffectiveMimeType(record.type, record.name))
-            ? MAX_IMAGE_SOURCE_BYTES
-            : MAX_TEXT_READ_BYTES,
+          maxBytes: sizeCap,
         },
       })
       const result = await readFileRecord(file, content)
@@ -1584,6 +1693,15 @@ export class WorkspaceVFS {
           )
         : null
     } catch (err) {
+      // A cap breach is an answer, not a lookup failure: returning null here
+      // reported multi-MB files as "content not found". The oversized
+      // placeholder tells the model the file exists and why it can't be read.
+      if (isPayloadSizeLimitError(err) && sizeCappedRecord) {
+        return bindWorkspaceFileResult(
+          sizeCappedRecord,
+          readPlaceholder.fileTooLarge(sizeCappedRecord.name, sizeCappedRecord.size ?? 0, sizeCap)
+        )
+      }
       logger.warn('Failed to list workspace files for readFileContent', {
         workspaceId: this._workspaceId,
         path,
@@ -1603,6 +1721,26 @@ export class WorkspaceVFS {
     return buildVfsFolderPathMap(folders)
   }
 
+  /**
+   * Folder paths for a non-workflow resource tree (tables, knowledge bases),
+   * plus `.folder` markers so empty folders are discoverable via glob — the
+   * same contract workflows/ has. Returns folderId → encoded folder path.
+   */
+  private async registerResourceFolders(
+    workspaceId: string,
+    resourceType: 'table' | 'knowledge_base',
+    rootSegment: 'tables' | 'knowledgebases'
+  ): Promise<Map<string, string>> {
+    const folders = await listFoldersForWorkspace(workspaceId, 'active', resourceType)
+    const paths = buildVfsFolderPathMap(
+      folders.map((f) => ({ folderId: f.id, folderName: f.name, parentId: f.parentId }))
+    )
+    for (const folderPath of paths.values()) {
+      this.files.set(`${rootSegment}/${folderPath}/.folder`, '')
+    }
+    return paths
+  }
+
   /**
    * Resolve the set of folder IDs that are effectively locked — locked directly
    * or via a locked ancestor folder. A workflow inside any of these folders is
@@ -1772,11 +1910,24 @@ export class WorkspaceVFS {
           })
         }
 
+        // deployment.json exists for EVERY workflow: "is it deployed?" is a
+        // question with an answer either way, and a not-found error here was a
+        // recurring red herring — agents probing an undeployed workflow read a
+        // failure instead of the fact. Versions stay gated: they genuinely
+        // don't exist before the first deploy.
+        this.registerLazy(`${prefix}deployment.json`, async () => {
+          if (!versionedWorkflowIds.has(wf.id)) {
+            return JSON.stringify({
+              deployed: false,
+              note: 'This workflow has never been deployed.',
+            })
+          }
+          const deploymentData = await this.loadDeployments(wf.id)
+          return deploymentData
+            ? serializeDeployments(deploymentData)
+            : JSON.stringify({ deployed: false, note: 'This workflow has never been deployed.' })
+        })
         if (versionedWorkflowIds.has(wf.id)) {
-          this.registerLazy(`${prefix}deployment.json`, async () => {
-            const deploymentData = await this.loadDeployments(wf.id)
-            return deploymentData ? serializeDeployments(deploymentData) : null
-          })
           this.registerLazy(`${prefix}versions.json`, async () => {
             const deploymentData = await this.loadDeployments(wf.id)
             return deploymentData?.versions && deploymentData.versions.length > 0
@@ -1805,10 +1956,18 @@ export class WorkspaceVFS {
       input: { workspaceId },
     })
     const kbs = knowledgeBases.map(({ knowledgeBase }) => knowledgeBase)
+    const folderPaths = await this.registerResourceFolders(
+      workspaceId,
+      'knowledge_base',
+      'knowledgebases'
+    )
 
     for (const { knowledgeBase: kb, tagDefinitions } of knowledgeBases) {
       const safeName = sanitizeName(kb.name)
-      const prefix = `knowledgebases/${safeName}/`
+      const folderPath = kb.folderId ? folderPaths.get(kb.folderId) : undefined
+      const prefix = folderPath
+        ? `knowledgebases/${folderPath}/${safeName}/`
+        : `knowledgebases/${safeName}/`
 
       this.files.set(
         `${prefix}meta.json`,
@@ -1824,6 +1983,7 @@ export class WorkspaceVFS {
           documentCount: kb.docCount,
           connectorTypes: kb.connectorTypes,
           tagDefinitions: tagDefinitions.map((definition) => ({
+            id: definition.id,
             tagName: definition.displayName,
             tagSlot: definition.tagSlot,
             fieldType: definition.fieldType,
@@ -1903,12 +2063,45 @@ export class WorkspaceVFS {
    */
   private async materializeTables(workspaceId: string): Promise<WorkspaceMdData['tables']> {
     try {
-      const tables = await listTables(workspaceId)
+      const [tables, folderPaths, viewsByTable] = await Promise.all([
+        listTables(workspaceId),
+        this.registerResourceFolders(workspaceId, 'table', 'tables'),
+        listTableViewsByWorkspace(workspaceId),
+      ])
 
       for (const table of tables) {
         const safeName = sanitizeName(table.name)
+        const folderPath = table.folderId ? folderPaths.get(table.folderId) : undefined
+        const prefix = folderPath ? `tables/${folderPath}/${safeName}` : `tables/${safeName}`
+        const viewRows = viewsByTable.get(table.id) ?? []
+        if (viewRows.length > 0) {
+          const columns = table.schema.columns
+          this.files.set(
+            `${prefix}/views.json`,
+            serializeTableViews(
+              viewRows.map((row) => {
+                const config = viewConfigIdsToNames(
+                  pruneViewConfig(
+                    normalizeStoredViewConfig(row.config as Record<string, unknown>),
+                    columns
+                  ),
+                  columns
+                )
+                return {
+                  id: row.id,
+                  name: row.name,
+                  isDefault: row.isDefault,
+                  filter: config.filter ?? null,
+                  sort: config.sort ?? null,
+                  hiddenColumns: config.hiddenColumns,
+                  updatedAt: row.updatedAt,
+                }
+              })
+            )
+          )
+        }
         this.files.set(
-          `tables/${safeName}/meta.json`,
+          `${prefix}/meta.json`,
           serializeTableMeta({
             id: table.id,
             name: table.name,
@@ -2018,6 +2211,10 @@ export class WorkspaceVFS {
           authType: chatTable.authType,
           customizations: chatTable.customizations,
           isActive: chatTable.isActive,
+          allowedEmails: chatTable.allowedEmails,
+          outputConfigs: chatTable.outputConfigs,
+          includeThinking: chatTable.includeThinking,
+          includeToolCalls: chatTable.includeToolCalls,
         })
         .from(chatTable)
         .where(and(eq(chatTable.workflowId, workflowId), isNull(chatTable.archivedAt))),
@@ -2028,6 +2225,7 @@ export class WorkspaceVFS {
           toolId: workflowMcpTool.id,
           toolName: workflowMcpTool.toolName,
           toolDescription: workflowMcpTool.toolDescription,
+          parameterDescriptionOverrides: workflowMcpTool.parameterDescriptionOverrides,
         })
         .from(workflowMcpTool)
         .innerJoin(workflowMcpServer, eq(workflowMcpTool.serverId, workflowMcpServer.id))
@@ -2192,6 +2390,368 @@ export class WorkspaceVFS {
     }
   }
 
+  /**
+   * Materialize `account/` — the acting user's vantage: this workspace and
+   * their role in it, the workspaces they can reach, who else is here, and
+   * their live plan.
+   *
+   * Read-only and always mounted. `billing.json` is registered lazily because
+   * usage ticks between requests: materializing it would freeze the numbers at
+   * snapshot time and pay for a billing read on every turn that never asks.
+   * Membership reuses the roster already loaded for WORKSPACE.md rather than
+   * issuing a second query.
+   */
+  private async materializeAccount(
+    workspaceId: string,
+    userId: string,
+    hostContext: Awaited<ReturnType<typeof getWorkspaceHostContextForViewer>>,
+    members: Awaited<ReturnType<typeof getUsersWithPermissions>>
+  ): Promise<void> {
+    try {
+      const [rows, entitlements] = await Promise.all([
+        listAccessibleWorkspaceRowsForUser(userId).catch(() => []),
+        computeWorkspaceEntitlements(workspaceId, userId).catch(() => [] as string[]),
+      ])
+
+      const current = rows.find((row) => row.workspace.id === workspaceId)
+      const parentId = current?.workspace.forkedFromWorkspaceId ?? null
+      // Name the parent only when the viewer can reach it; otherwise the id
+      // stands alone rather than leaking a workspace name they cannot open.
+      const parentRow = parentId ? rows.find((row) => row.workspace.id === parentId) : undefined
+      const isAdmin = hostContext?.viewer.permission === 'admin'
+
+      this.files.set(
+        'account/workspace.json',
+        serializeAccountWorkspace({
+          workspace: {
+            id: workspaceId,
+            name: hostContext?.workspace.name ?? current?.workspace.name ?? '',
+            workspaceMode: hostContext?.workspace.workspaceMode ?? null,
+          },
+          viewer: {
+            permission: hostContext?.viewer.permission ?? current?.permissionType ?? null,
+            organizationRole: hostContext?.viewer.organizationRole ?? null,
+          },
+          organization: hostContext?.hostOrganizationId
+            ? { id: hostContext.hostOrganizationId }
+            : null,
+          forkedFrom: parentId
+            ? { id: parentId, name: parentRow?.workspace.name ?? parentId }
+            : null,
+          entitlements,
+        })
+      )
+
+      this.files.set(
+        'account/workspaces.json',
+        serializeAccountWorkspaces(
+          rows.map((row) => ({
+            id: row.workspace.id,
+            name: row.workspace.name,
+            role: row.permissionType,
+            organizationId: row.workspace.organizationId,
+            forkedFromWorkspaceId: row.workspace.forkedFromWorkspaceId,
+            isCurrent: row.workspace.id === workspaceId,
+          }))
+        )
+      )
+
+      this.files.set(
+        'account/members.json',
+        serializeAccountMembers(members, { includeContactDetails: isAdmin })
+      )
+
+      this.registerLazy('account/billing.json', async () => {
+        try {
+          return serializeAccountBilling(await getAccountBillingSnapshot(userId))
+        } catch (err) {
+          logger.warn('Failed to load account billing', {
+            workspaceId,
+            error: toError(err).message,
+          })
+          return null
+        }
+      })
+    } catch (err) {
+      logger.warn('Failed to materialize account namespace', {
+        workspaceId,
+        error: toError(err).message,
+      })
+    }
+  }
+
+  /**
+   * Materialize `organization/` — org standing, the access-control rules that
+   * actually bind this viewer, org-published block provenance, and fork
+   * topology.
+   *
+   * The namespace exists only when the workspace belongs to an organization, so
+   * its absence is itself the answer for a personal workspace. Fork detail is
+   * mounted only for a workspace admin of a forking-enabled org, matching the
+   * gate the fork routes apply.
+   */
+  private async materializeOrganization(
+    workspaceId: string,
+    userId: string,
+    hostContext: Awaited<ReturnType<typeof getWorkspaceHostContextForViewer>>
+  ): Promise<void> {
+    const organizationId = hostContext?.hostOrganizationId
+    if (!hostContext || !organizationId) return
+
+    try {
+      this.files.set(
+        'organization/organization.json',
+        serializeOrganization({
+          organization: {
+            id: organizationId,
+            relationship: hostContext.viewer.isHostOrganizationMember ? 'internal' : 'external',
+            role: hostContext.viewer.organizationRole ?? null,
+          },
+          capabilities: {
+            canManageOrganization: hostContext.viewer.isHostOrganizationAdmin,
+            canManageBilling: hostContext.viewer.isHostOrganizationAdmin,
+          },
+          plan: hostContext.ownerBilling.plan,
+          isEnterprise: hostContext.ownerBilling.isEnterprise,
+        })
+      )
+
+      this.registerLazy('organization/access-control.json', async () => {
+        try {
+          const accessControl = await resolveVerifiedUserAccessControlContext(
+            userId,
+            workspaceId,
+            organizationId
+          )
+          return serializeAccessControl({
+            entitled: accessControl.entitled,
+            permissionGroup: accessControl.permissionGroup,
+            restrictions: getActivePermissionGroupRestrictions(accessControl.config),
+          })
+        } catch (err) {
+          logger.warn('Failed to load access control context', {
+            workspaceId,
+            error: toError(err).message,
+          })
+          return null
+        }
+      })
+
+      // The block list is fetched at materialize time (one indexed query, the
+      // same one the components pass already ran) because the README and the
+      // names-only index need it, and each block's detail path must exist in
+      // the key view for glob to list. Only the deployed graph stays lazy —
+      // it is the expensive part and most turns never read it.
+      const orgBlocks = await listCustomBlocksWithInputsForWorkspace(workspaceId).catch((err) => {
+        logger.warn('Failed to list org custom blocks', {
+          workspaceId,
+          error: toError(err).message,
+        })
+        return []
+      })
+      if (orgBlocks.length > 0) {
+        this.files.set(
+          'organization/custom-blocks.json',
+          serializeOrganizationCustomBlocks(orgBlocks)
+        )
+        // The names index matches editor visibility: anyone who can open the
+        // workspace sees the block in the toolbar. The deployed GRAPH is org
+        // implementation internals, so an external collaborator — workspace
+        // access without org membership — gets the interface (components/
+        // schema) but not the graph; for them the detail files simply do not
+        // exist.
+        if (hostContext.viewer.isHostOrganizationMember)
+          for (const orgBlock of orgBlocks) {
+            this.registerLazy(`organization/custom-blocks/${orgBlock.type}.json`, async () => {
+              try {
+                const deployed = await loadDeployedWorkflowState(
+                  orgBlock.workflowId,
+                  orgBlock.workspaceId ?? undefined
+                )
+                return serializeOrgCustomBlockDetail(orgBlock, deployed)
+              } catch (err) {
+                logger.warn('Failed to load deployed state for org custom block', {
+                  workspaceId,
+                  blockType: orgBlock.type,
+                  error: toError(err).message,
+                })
+                return null
+              }
+            })
+          }
+      }
+
+      // Everything below is registered LAZILY: the paths appear in the key
+      // view (so glob lists them) but no query runs until something reads
+      // one. Registration itself is the permission gate — an unpermitted
+      // viewer's file simply does not exist.
+      if (hostContext.viewer.isHostOrganizationMember) {
+        this.registerLazy('organization/workspaces.json', async () => {
+          try {
+            const [refs, accessible] = await Promise.all([
+              listOrganizationWorkspaceRefs(organizationId),
+              listAccessibleWorkspaceRowsForUser(userId).catch(() => []),
+            ])
+            const accessibleIds = new Set(accessible.map((row) => row.workspace.id))
+            const forkParents = new Map(
+              accessible.map((row) => [row.workspace.id, row.workspace.forkedFromWorkspaceId])
+            )
+            return serializeOrganizationWorkspaces(
+              refs.map((ref) => ({
+                id: ref.id,
+                name: ref.name,
+                hasAccess: accessibleIds.has(ref.id),
+                forkedFromWorkspaceId: forkParents.get(ref.id) ?? null,
+              }))
+            )
+          } catch (err) {
+            logger.warn('Failed to load org workspaces', {
+              workspaceId,
+              error: toError(err).message,
+            })
+            return null
+          }
+        })
+      }
+
+      if (hostContext.viewer.isHostOrganizationAdmin) {
+        this.registerLazy('organization/permission-groups.json', async () => {
+          try {
+            const roster = await listPermissionGroupRoster(organizationId)
+            if (roster.length === 0) return null
+            return serializePermissionGroupRoster(roster)
+          } catch (err) {
+            logger.warn('Failed to load permission-group roster', {
+              workspaceId,
+              error: toError(err).message,
+            })
+            return null
+          }
+        })
+      }
+
+      const credentialGroupsAvailable = hostContext.features?.credentialGroups === true
+      if (credentialGroupsAvailable) {
+        const includeEmails = hostContext.viewer.permission === 'admin'
+        this.registerLazy('organization/credential-groups.json', async () => {
+          try {
+            const records = await listCredentialGroups(workspaceId)
+            if (records.length === 0) return null
+            const groups = await Promise.all(
+              records.map(async (record) => {
+                const enrollmentCounts: Record<string, number> = {}
+                let people: Array<{ email: string; status: string }> | undefined
+                let truncated = false
+                try {
+                  const page = await listCredentialGroupEnrollments(workspaceId, record.id, 100)
+                  truncated = page.nextCursor !== null
+                  for (const enrollment of page.enrollments) {
+                    enrollmentCounts[enrollment.status] =
+                      (enrollmentCounts[enrollment.status] ?? 0) + 1
+                  }
+                  if (includeEmails) {
+                    people = page.enrollments.map((enrollment) => ({
+                      email: enrollment.email,
+                      status: enrollment.status,
+                    }))
+                  }
+                } catch {
+                  // Counts degrade to empty; the group itself still lists.
+                }
+                return {
+                  id: record.id,
+                  name: record.name,
+                  description: record.description,
+                  status: record.status,
+                  options: record.options.map((option) => ({
+                    provider: option.provider,
+                    label: 'label' in option ? option.label : undefined,
+                    required: 'required' in option ? option.required : undefined,
+                    configurationStatus: option.configurationStatus,
+                  })),
+                  enrollmentCounts,
+                  enrollmentsTruncated: truncated,
+                  ...(people ? { people } : {}),
+                }
+              })
+            )
+            return serializeCredentialGroups(groups, { includeEmails })
+          } catch (err) {
+            logger.warn('Failed to load credential groups', {
+              workspaceId,
+              error: toError(err).message,
+            })
+            return null
+          }
+        })
+      }
+
+      const forksAvailable =
+        hostContext.viewer.permission === 'admin' &&
+        (await isForkingAvailableForWorkspace(organizationId, userId).catch(() => false))
+
+      this.files.set(
+        'organization/README.md',
+        buildOrganizationReadme({
+          organizationId,
+          isEnterprise: hostContext.ownerBilling.isEnterprise,
+          customBlocks: orgBlocks,
+          forksMounted: forksAvailable,
+          permissionGroupsMounted: hostContext.viewer.isHostOrganizationAdmin,
+          credentialGroupsMounted: credentialGroupsAvailable,
+        })
+      )
+
+      if (!forksAvailable) return
+
+      this.registerLazy('organization/forks.json', async () => {
+        try {
+          const [parent, children] = await Promise.all([
+            getForkParent(workspaceId),
+            getForkChildren(workspaceId),
+          ])
+          if (!parent && children.length === 0) return null
+
+          const resourceMappingCounts: Record<string, number> = {}
+          let blockMappingCount = 0
+          if (parent) {
+            const [resourceRows, blockMap] = await Promise.all([
+              getEdgeMappingRows(db, workspaceId),
+              loadForkBlockMap(db, workspaceId),
+            ])
+            for (const row of resourceRows) {
+              resourceMappingCounts[row.resourceType] =
+                (resourceMappingCounts[row.resourceType] ?? 0) + 1
+            }
+            blockMappingCount = blockMap.parentToChild.size
+          }
+
+          return serializeWorkspaceForks({
+            parent: parent ? { id: parent.id, name: parent.name } : null,
+            children: children.map((child) => ({
+              id: child.id,
+              name: child.name,
+              createdAt: child.createdAt,
+            })),
+            resourceMappingCounts,
+            blockMappingCount,
+          })
+        } catch (err) {
+          logger.warn('Failed to load fork topology', {
+            workspaceId,
+            error: toError(err).message,
+          })
+          return null
+        }
+      })
+    } catch (err) {
+      logger.warn('Failed to materialize organization namespace', {
+        workspaceId,
+        error: toError(err).message,
+      })
+    }
+  }
+
   /**
    * Materialize external MCP server connections using the mcpServers table.
    */
@@ -2601,3 +3161,10 @@ export type { FileReadResult } from '@/lib/copilot/vfs/file-reader'
 export function sanitizeName(name: string): string {
   return normalizeVfsSegment(name)
 }
+
+function decodeVfsPathSegmentsSafe(path: string): string {
+  return path
+    .split('/')
+    .map((segment) => decodeVfsSegmentSafe(segment))
+    .join('/')
+}
diff --git a/apps/sim/lib/core/config/feature-flags.ts b/apps/sim/lib/core/config/feature-flags.ts
index 3a19f2ee36..9376d2031e 100644
--- a/apps/sim/lib/core/config/feature-flags.ts
+++ b/apps/sim/lib/core/config/feature-flags.ts
@@ -118,7 +118,8 @@ const FEATURE_FLAGS = {
   'tables-v2-api': {
     description:
       'Gate the internal predicate-grammar table query route (POST /api/table/[tableId]/query), ' +
-      'its only caller. When off, that route returns 404 as if it does not exist. Despite the ' +
+      'its only caller. When off, that route returns 403 naming the gate (post-authz, so the ' +
+      'masquerade 404 served nobody and broke the table_v2 block confusingly). Despite the ' +
       'name it does NOT gate any /api/v2/tables route — the public v2 tables surface is gated ' +
       'by v2-api alone. Gated by userId/orgId/admins via AppConfig; off-AppConfig falls back to ' +
       'TABLES_V2_API.',
diff --git a/apps/sim/lib/core/utils/with-route-handler.ts b/apps/sim/lib/core/utils/with-route-handler.ts
index 0b38c86467..86e41967ad 100644
--- a/apps/sim/lib/core/utils/with-route-handler.ts
+++ b/apps/sim/lib/core/utils/with-route-handler.ts
@@ -73,6 +73,19 @@ function applyResponseHeaders(
   }
 }
 
+/**
+ * Extracts the 32-hex trace id from a W3C `traceparent` header
+ * (`00-<trace-id>-<span-id>-<flags>`) so cross-service log lines can be
+ * grepped by the same trace id the Go copilot logs. Returns undefined for
+ * absent or malformed headers and the all-zero (invalid) trace id.
+ */
+function traceIdFromTraceparent(header: string | null | undefined): string | undefined {
+  if (!header) return undefined
+  const match = /^[0-9a-f]{2}-([0-9a-f]{32})-[0-9a-f]{16}-[0-9a-f]{2}$/.exec(header.trim())
+  if (!match || match[1] === '00000000000000000000000000000000') return undefined
+  return match[1]
+}
+
 /**
  * Wraps a Next.js API route handler with centralized error reporting.
  *
@@ -96,8 +109,9 @@ export function withRouteHandler<T>(
     const method = request?.method ?? 'UNKNOWN'
     const path =
       request?.nextUrl?.pathname ?? new URL(request?.url ?? '/', 'http://localhost').pathname
+    const traceId = traceIdFromTraceparent(request?.headers?.get?.('traceparent'))
 
-    return runWithRequestContext({ requestId, method, path }, async () => {
+    return runWithRequestContext({ requestId, method, path, traceId }, async () => {
       let response: NextResponse | Response
       try {
         response = await handler(request, context)
diff --git a/apps/sim/lib/desktop/index.test.ts b/apps/sim/lib/desktop/index.test.ts
index 5bf4ea6e45..86b97985eb 100644
--- a/apps/sim/lib/desktop/index.test.ts
+++ b/apps/sim/lib/desktop/index.test.ts
@@ -3,6 +3,7 @@
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import {
+  getDesktopChatCapabilities,
   hasBrowserAgent,
   hasTerminal,
   isBrowserAgentEnabled,
@@ -64,4 +65,41 @@ describe('desktop surface availability', () => {
     expect(isBrowserAgentEnabled()).toBe(false)
     expect(isTerminalEnabled()).toBe(false)
   })
+
+  it('bounds terminal hints before adding them to a chat request', async () => {
+    const oversizedValue = 'x'.repeat(1100)
+    installBridge({
+      terminal: {
+        getTabs: vi.fn(async () => ({
+          scopeId: 'chat-1',
+          activeTerminalId: '1',
+          tabs: [
+            {
+              terminalId: '1',
+              title: 'Terminal',
+              cwd: oversizedValue,
+              running: oversizedValue,
+              interactive: false,
+              active: true,
+            },
+          ],
+        })),
+      },
+    })
+    setDesktopPreferencesSnapshot({
+      ...ENABLED_PREFERENCES,
+      browserEnabled: false,
+    })
+
+    const capabilities = await getDesktopChatCapabilities('chat-1')
+
+    expect(capabilities.desktopCapabilities?.terminals).toEqual([
+      {
+        id: '1',
+        cwd: 'x'.repeat(1024),
+        running: 'x'.repeat(1024),
+        active: true,
+      },
+    ])
+  })
 })
diff --git a/apps/sim/lib/desktop/index.ts b/apps/sim/lib/desktop/index.ts
index f902743f02..4f31f79c83 100644
--- a/apps/sim/lib/desktop/index.ts
+++ b/apps/sim/lib/desktop/index.ts
@@ -23,6 +23,11 @@
  */
 import type { BrowserKnownSession } from '@sim/browser-protocol'
 import type { DesktopPreferences, SimDesktopApi } from '@sim/desktop-bridge'
+import { truncate } from '@sim/utils/string'
+import {
+  DESKTOP_TERMINAL_HINT_ID_MAX_LENGTH,
+  DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH,
+} from '@/lib/copilot/chat/desktop-capabilities'
 
 /** The preload bridge, or undefined outside the desktop app (and on the server). */
 export function getDesktopBridge(): SimDesktopApi | undefined {
@@ -172,13 +177,21 @@ export async function getDesktopChatCapabilities(
       ? await bridge.terminal
           .getTabs(scopeId)
           .then((state) =>
-            state.tabs.map((tab) => ({
-              id: tab.terminalId,
-              ...(tab.cwd ? { cwd: tab.cwd } : {}),
-              ...(tab.running ? { running: tab.running } : {}),
-              ...(tab.interactive ? { interactive: true as const } : {}),
-              ...(tab.active ? { active: true as const } : {}),
-            }))
+            state.tabs
+              .filter((tab) => tab.terminalId.length <= DESKTOP_TERMINAL_HINT_ID_MAX_LENGTH)
+              .map((tab) => ({
+                id: tab.terminalId,
+                ...(tab.cwd
+                  ? { cwd: truncate(tab.cwd, DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH, '') }
+                  : {}),
+                ...(tab.running
+                  ? {
+                      running: truncate(tab.running, DESKTOP_TERMINAL_HINT_TEXT_MAX_LENGTH, ''),
+                    }
+                  : {}),
+                ...(tab.interactive ? { interactive: true as const } : {}),
+                ...(tab.active ? { active: true as const } : {}),
+              }))
           )
           .catch(() => [])
       : []
diff --git a/apps/sim/lib/folders/application/resource-vfs.ts b/apps/sim/lib/folders/application/resource-vfs.ts
new file mode 100644
index 0000000000..30ef3e2729
--- /dev/null
+++ b/apps/sim/lib/folders/application/resource-vfs.ts
@@ -0,0 +1,438 @@
+import type { FolderResourceType } from '@/lib/api/contracts/folders'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
+import {
+  createFolderAtPath,
+  deleteFolderByPath,
+  relocateFolderByPath,
+} from '@/lib/folders/orchestration'
+import { buildFolderPath } from '@/lib/folders/paths'
+import { listFoldersForWorkspace } from '@/lib/folders/queries'
+
+/**
+ * Shared VFS folder semantics for flat-row resources (tables, knowledge
+ * bases): both are a single DB row with a `folderId`, so mkdir/mv/rm over
+ * their `{root}/{...folders}/{name}` paths is identical logic parameterized
+ * by how rows are listed, moved, and renamed. Folder mutations delegate to
+ * `lib/folders/orchestration`, which owns naming invariants, tree locks, and
+ * delete cascades — this module only resolves paths and moves rows.
+ *
+ * Authorization is deliberately NOT here: every entry point is called from a
+ * per-resource authorized use case (table-vfs / knowledge-vfs), the same
+ * layering workflow-vfs uses.
+ */
+export interface FolderedResourceRow {
+  id: string
+  name: string
+  folderId: string | null
+}
+
+export interface FolderedResourceAdapter {
+  resourceType: Extract<FolderResourceType, 'table' | 'knowledge_base'>
+  rootSegment: 'tables' | 'knowledgebases'
+  /** Human label for error messages, e.g. "table" / "knowledge base". */
+  label: string
+  listRows(workspaceId: string): Promise<FolderedResourceRow[]>
+  moveRow(row: FolderedResourceRow, folderId: string | null, workspaceId: string): Promise<void>
+  renameRow(
+    row: FolderedResourceRow,
+    newName: string,
+    workspaceId: string
+  ): Promise<{ id: string; name: string }>
+}
+
+export interface ResourceVfsOutcome {
+  source: string
+  /** Path segments under the resource root the item landed at (folders + leaf). */
+  targetSegments?: string[]
+  kind: 'resource' | 'folder'
+  resourceId?: string
+  error?: string
+}
+
+interface FolderNode {
+  id: string
+  name: string
+  parentId: string | null
+}
+
+interface FolderIndex {
+  byId: Map<string, FolderNode>
+  /** parentKey(parentId) + "\u0000" + name → folderId */
+  byParentAndName: Map<string, string>
+}
+
+const ROOT_PARENT_KEY = ''
+
+function parentKey(parentId: string | null): string {
+  return parentId ?? ROOT_PARENT_KEY
+}
+
+function childKey(parentId: string | null, name: string): string {
+  return `${parentKey(parentId)}\u0000${name}`
+}
+
+async function loadFolderIndex(
+  workspaceId: string,
+  resourceType: FolderResourceType
+): Promise<FolderIndex> {
+  const folders = await listFoldersForWorkspace(workspaceId, 'active', resourceType)
+  const byId = new Map<string, FolderNode>()
+  const byParentAndName = new Map<string, string>()
+  for (const folder of folders) {
+    byId.set(folder.id, { id: folder.id, name: folder.name, parentId: folder.parentId })
+    byParentAndName.set(childKey(folder.parentId, folder.name), folder.id)
+  }
+  return { byId, byParentAndName }
+}
+
+function folderSegments(index: FolderIndex, folderId: string | null): string[] {
+  const segments: string[] = []
+  let current = folderId
+  const visited = new Set<string>()
+  while (current && !visited.has(current)) {
+    visited.add(current)
+    const node = index.byId.get(current)
+    if (!node) break
+    segments.unshift(node.name)
+    current = node.parentId
+  }
+  return segments
+}
+
+/** Resolves an existing folder path to its id; null = root; undefined = missing. */
+function resolveFolderId(
+  index: FolderIndex,
+  segments: readonly string[]
+): string | null | undefined {
+  let current: string | null = null
+  for (const segment of segments) {
+    const next = index.byParentAndName.get(childKey(current, segment))
+    if (!next) return undefined
+    current = next
+  }
+  return current
+}
+
+/**
+ * mkdir -p: creates every missing folder along each path. Ancestors created by
+ * an earlier path in the same batch are found via the reloaded index.
+ */
+export async function createResourceVfsFolders(
+  adapter: FolderedResourceAdapter,
+  params: {
+    workspaceId: string
+    userId: string
+    paths: Array<{ source: string; segments: string[] }>
+  }
+): Promise<ResourceVfsOutcome[]> {
+  let index = await loadFolderIndex(params.workspaceId, adapter.resourceType)
+  const outcomes: ResourceVfsOutcome[] = []
+  for (const { source, segments } of params.paths) {
+    if (segments.length === 0) {
+      outcomes.push({
+        source,
+        kind: 'folder',
+        error: 'Path must include at least one folder segment',
+      })
+      continue
+    }
+    try {
+      const folderId = await ensureFolderPath(
+        adapter,
+        params.workspaceId,
+        params.userId,
+        index,
+        segments
+      )
+      index = await loadFolderIndex(params.workspaceId, adapter.resourceType)
+      outcomes.push({
+        source,
+        kind: 'folder',
+        resourceId: folderId ?? undefined,
+        targetSegments: [...segments],
+      })
+    } catch (error) {
+      outcomes.push({
+        source,
+        kind: 'folder',
+        error: messageFor(error, `${adapter.label} folder creation failed`),
+      })
+    }
+  }
+  return outcomes
+}
+
+async function ensureFolderPath(
+  adapter: FolderedResourceAdapter,
+  workspaceId: string,
+  userId: string,
+  index: FolderIndex,
+  segments: readonly string[]
+): Promise<string | null> {
+  let folderId: string | null = null
+  for (let position = 0; position < segments.length; position += 1) {
+    const existing = resolveFolderId(index, segments.slice(0, position + 1))
+    if (existing !== undefined) {
+      folderId = existing
+      continue
+    }
+    const result = await createFolderAtPath({
+      resourceType: adapter.resourceType,
+      workspaceId,
+      userId,
+      path: buildFolderPath(segments.slice(0, position + 1)),
+      effects: false,
+      throwInfrastructure: true,
+    })
+    if (!result.success || !result.folder) {
+      if (result.errorCode === 'conflict') {
+        index = await loadFolderIndex(workspaceId, adapter.resourceType)
+        const concurrent = resolveFolderId(index, segments.slice(0, position + 1))
+        if (concurrent !== undefined) {
+          folderId = concurrent
+          continue
+        }
+      }
+      throw new OrchestrationError(
+        result.errorCode === 'forbidden' ? 'forbidden' : 'validation',
+        result.error ?? `${adapter.label} folder creation failed`
+      )
+    }
+    folderId = result.folder.id
+    index.byId.set(folderId, {
+      id: folderId,
+      name: result.folder.name,
+      parentId: result.folder.parentId,
+    })
+    index.byParentAndName.set(childKey(result.folder.parentId, result.folder.name), folderId)
+  }
+  return folderId
+}
+
+type ResolvedSource =
+  | { kind: 'resource'; row: FolderedResourceRow }
+  | { kind: 'folder'; folderId: string }
+
+/**
+ * Resolves one source path: the leaf is preferred as a resource row inside the
+ * resolved parent folder; a folder of that name is the fallback. A bare leaf
+ * (no folder segments) also matches a uniquely-named resource anywhere in the
+ * tree, so pre-folders paths keep working after rows move into folders.
+ */
+function resolveSource(
+  adapter: FolderedResourceAdapter,
+  index: FolderIndex,
+  rows: FolderedResourceRow[],
+  segments: readonly string[]
+): ResolvedSource {
+  const root = adapter.rootSegment
+  if (segments.length === 0) {
+    throw new OrchestrationError(
+      'validation',
+      `Path must name a ${adapter.label} or folder under ${root}/`
+    )
+  }
+  const leaf = segments[segments.length - 1]
+  const parentSegments = segments.slice(0, -1)
+  const parentId = resolveFolderId(index, parentSegments)
+  if (parentId !== undefined) {
+    const inParent = rows.filter((row) => row.name === leaf && row.folderId === (parentId ?? null))
+    if (inParent.length === 1) return { kind: 'resource', row: inParent[0] }
+    const asFolder = resolveFolderId(index, segments)
+    if (asFolder !== undefined && asFolder !== null) return { kind: 'folder', folderId: asFolder }
+  }
+  if (parentSegments.length === 0) {
+    const anywhere = rows.filter((row) => row.name === leaf)
+    if (anywhere.length === 1) return { kind: 'resource', row: anywhere[0] }
+    if (anywhere.length > 1) {
+      throw new OrchestrationError(
+        'conflict',
+        `${root}/${leaf} is ambiguous — several ${adapter.label}s share that name. Use the full folder path.`
+      )
+    }
+  }
+  throw new OrchestrationError(
+    'not_found',
+    `No ${adapter.label} or folder found at ${root}/${segments.join('/')}`
+  )
+}
+
+/**
+ * mv: with a trailing-slash destination, moves every source (resource rows and
+ * whole folders) into that folder path, creating it as needed. Without one,
+ * exactly one source is renamed and/or moved to the destination's parent +
+ * leaf name. Mirrors the workflows/ contract.
+ */
+export async function transferResourceVfsItems(
+  adapter: FolderedResourceAdapter,
+  params: {
+    workspaceId: string
+    userId: string
+    sources: Array<{ source: string; segments: string[] }>
+    destination: { segments: string[]; trailingSlash: boolean }
+  }
+): Promise<ResourceVfsOutcome[]> {
+  const { workspaceId, userId } = params
+  let index = await loadFolderIndex(workspaceId, adapter.resourceType)
+  let rows = await adapter.listRows(workspaceId)
+  const outcomes: ResourceVfsOutcome[] = []
+
+  const moveIntoFolder = params.destination.trailingSlash
+  if (!moveIntoFolder && params.sources.length > 1) {
+    throw new OrchestrationError(
+      'validation',
+      `A rename destination takes exactly one source; to move several items, end the destination with "/" (a folder path).`
+    )
+  }
+
+  const destFolderSegments = moveIntoFolder
+    ? params.destination.segments
+    : params.destination.segments.slice(0, -1)
+  const renameTo = moveIntoFolder
+    ? null
+    : params.destination.segments[params.destination.segments.length - 1]
+  if (!moveIntoFolder && !renameTo) {
+    throw new OrchestrationError('validation', 'destination must include a name')
+  }
+
+  for (const { source, segments } of params.sources) {
+    try {
+      const resolved = resolveSource(adapter, index, rows, segments)
+      if (resolved.kind === 'resource') {
+        const targetFolderId = await ensureFolderPath(
+          adapter,
+          workspaceId,
+          userId,
+          index,
+          destFolderSegments
+        )
+        let row = resolved.row
+        if (row.folderId !== (targetFolderId ?? null)) {
+          await adapter.moveRow(row, targetFolderId ?? null, workspaceId)
+          row = { ...row, folderId: targetFolderId ?? null }
+        }
+        let finalName = row.name
+        if (renameTo && renameTo !== row.name) {
+          const renamed = await adapter.renameRow(row, renameTo, workspaceId)
+          finalName = renamed.name
+        }
+        rows = rows.map((r) => (r.id === row.id ? { ...row, name: finalName } : r))
+        outcomes.push({
+          source,
+          kind: 'resource',
+          resourceId: row.id,
+          targetSegments: [...destFolderSegments, finalName],
+        })
+        continue
+      }
+
+      const sourcePath = buildFolderPath(folderSegments(index, resolved.folderId))
+      const destinationPath = buildFolderPath(
+        moveIntoFolder
+          ? [...destFolderSegments, ...folderSegments(index, resolved.folderId).slice(-1)]
+          : [...destFolderSegments, renameTo as string]
+      )
+      const result = await relocateFolderByPath({
+        resourceType: adapter.resourceType,
+        workspaceId,
+        userId,
+        path: sourcePath,
+        destinationPath,
+        effects: false,
+        throwInfrastructure: true,
+      })
+      if (!result.success || !result.folder) {
+        throw new OrchestrationError(
+          result.errorCode === 'forbidden' ? 'forbidden' : 'validation',
+          result.error ?? `${adapter.label} folder move failed`
+        )
+      }
+      index = await loadFolderIndex(workspaceId, adapter.resourceType)
+      rows = await adapter.listRows(workspaceId)
+      outcomes.push({
+        source,
+        kind: 'folder',
+        resourceId: result.folder.id,
+        targetSegments: [...folderSegments(index, result.folder.id)],
+      })
+    } catch (error) {
+      outcomes.push({
+        source,
+        kind: 'resource',
+        error: messageFor(error, `${adapter.label} move failed`),
+      })
+    }
+  }
+  return outcomes
+}
+
+/** rm of folder paths: recursive delete through the shared cascade. */
+export async function deleteResourceVfsFolders(
+  adapter: FolderedResourceAdapter,
+  params: {
+    workspaceId: string
+    userId: string
+    paths: Array<{ source: string; segments: string[] }>
+  }
+): Promise<ResourceVfsOutcome[]> {
+  const outcomes: ResourceVfsOutcome[] = []
+  for (const { source, segments } of params.paths) {
+    try {
+      const index = await loadFolderIndex(params.workspaceId, adapter.resourceType)
+      const folderId = resolveFolderId(index, segments)
+      if (folderId === undefined || folderId === null) {
+        throw new OrchestrationError(
+          'not_found',
+          `No ${adapter.label} folder found at ${adapter.rootSegment}/${segments.join('/')}`
+        )
+      }
+      const result = await deleteFolderByPath({
+        resourceType: adapter.resourceType,
+        workspaceId: params.workspaceId,
+        userId: params.userId,
+        path: buildFolderPath(segments),
+        recursive: true,
+        effects: false,
+        throwInfrastructure: true,
+      })
+      if (!result.success) {
+        throw new OrchestrationError(
+          result.errorCode === 'forbidden' ? 'forbidden' : 'validation',
+          result.error ?? `${adapter.label} folder deletion failed`
+        )
+      }
+      outcomes.push({ source, kind: 'folder', resourceId: folderId })
+    } catch (error) {
+      outcomes.push({
+        source,
+        kind: 'folder',
+        error: messageFor(error, `${adapter.label} folder deletion failed`),
+      })
+    }
+  }
+  return outcomes
+}
+
+/** Resolves a resource (never a folder) for the segments-aware rename/delete paths. */
+export async function resolveResourceRowBySegments(
+  adapter: FolderedResourceAdapter,
+  workspaceId: string,
+  segments: readonly string[]
+): Promise<FolderedResourceRow> {
+  const index = await loadFolderIndex(workspaceId, adapter.resourceType)
+  const rows = await adapter.listRows(workspaceId)
+  const resolved = resolveSource(adapter, index, rows, segments)
+  if (resolved.kind !== 'resource') {
+    throw new OrchestrationError(
+      'validation',
+      `${adapter.rootSegment}/${segments.join('/')} is a folder; this operation takes a ${adapter.label}.`
+    )
+  }
+  return resolved.row
+}
+
+function messageFor(error: unknown, fallback: string): string {
+  if (error instanceof OrchestrationError) return error.message
+  if (error instanceof Error && error.message) return error.message
+  return fallback
+}
diff --git a/apps/sim/lib/knowledge/application/documents.test.ts b/apps/sim/lib/knowledge/application/documents.test.ts
index 122f478895..73bb11249a 100644
--- a/apps/sim/lib/knowledge/application/documents.test.ts
+++ b/apps/sim/lib/knowledge/application/documents.test.ts
@@ -27,6 +27,7 @@ const mocks = vi.hoisted(() => ({
   recordKnowledgeBaseFileOwnership: vi.fn(),
   recordAudit: vi.fn(),
   captureServerEvent: vi.fn(),
+  getDocumentTagDefinitions: vi.fn(),
 }))
 
 vi.mock('@sim/audit', () => ({
@@ -71,6 +72,10 @@ vi.mock('@/lib/knowledge/documents/service', () => ({
   getProcessingConfig: mocks.getProcessingConfig,
 }))
 
+vi.mock('@/lib/knowledge/tags/service', () => ({
+  getDocumentTagDefinitions: mocks.getDocumentTagDefinitions,
+}))
+
 vi.mock('@/lib/knowledge/orchestration/documents', () => ({
   performUploadKnowledgeDocument: mocks.performSingleUpload,
   performUploadKnowledgeDocuments: mocks.performBulkUpload,
@@ -548,6 +553,123 @@ describe('knowledge document application use cases', () => {
     )
   })
 
+  it('resolves typed tag-definition assignments into document tag slots', async () => {
+    mocks.getDocumentTagDefinitions.mockResolvedValueOnce([
+      {
+        id: 'category-tag',
+        knowledgeBaseId: 'knowledge-1',
+        tagSlot: 'tag1',
+        displayName: 'Category',
+        fieldType: 'text',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: 'priority-tag',
+        knowledgeBaseId: 'knowledge-1',
+        tagSlot: 'number1',
+        displayName: 'Priority',
+        fieldType: 'number',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: 'reviewed-tag',
+        knowledgeBaseId: 'knowledge-1',
+        tagSlot: 'boolean1',
+        displayName: 'Reviewed',
+        fieldType: 'boolean',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    ])
+
+    await updateKnowledgeDocument.execute({
+      principal: {
+        kind: 'delegated',
+        serviceId: 'copilot',
+        subjectUserId: 'shared-user',
+        workspaceId: 'workspace-1',
+        delegationId: 'tool-call-1',
+        audience: 'sim:knowledge',
+        issuedAt: new Date(),
+        expiresAt: new Date(Date.now() + 60_000),
+        resourceScope: {},
+      },
+      input: {
+        knowledgeBaseId: 'knowledge-1',
+        documentId: 'document-1',
+        assertedWorkspaceId: 'workspace-1',
+        tagValues: [
+          { tagDefinitionId: 'category-tag', value: 'support' },
+          { tagDefinitionId: 'priority-tag', value: 2 },
+          { tagDefinitionId: 'reviewed-tag', value: false },
+        ],
+        source: 'agent',
+      },
+    })
+
+    expect(mocks.updateDocument).toHaveBeenCalledWith(
+      'document-1',
+      {
+        filename: undefined,
+        enabled: undefined,
+        tag1: 'support',
+        number1: '2',
+        boolean1: 'false',
+      },
+      expect.any(String)
+    )
+    expect(mocks.recordAudit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        metadata: expect.objectContaining({
+          tagDefinitionIds: ['category-tag', 'priority-tag', 'reviewed-tag'],
+        }),
+      })
+    )
+  })
+
+  it('rejects a tag value that does not match its definition type', async () => {
+    mocks.getDocumentTagDefinitions.mockResolvedValueOnce([
+      {
+        id: 'priority-tag',
+        knowledgeBaseId: 'knowledge-1',
+        tagSlot: 'number1',
+        displayName: 'Priority',
+        fieldType: 'number',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+    ])
+
+    await expect(
+      updateKnowledgeDocument.execute({
+        principal: {
+          kind: 'delegated',
+          serviceId: 'copilot',
+          subjectUserId: 'shared-user',
+          workspaceId: 'workspace-1',
+          delegationId: 'tool-call-1',
+          audience: 'sim:knowledge',
+          issuedAt: new Date(),
+          expiresAt: new Date(Date.now() + 60_000),
+          resourceScope: {},
+        },
+        input: {
+          knowledgeBaseId: 'knowledge-1',
+          documentId: 'document-1',
+          assertedWorkspaceId: 'workspace-1',
+          tagValues: [{ tagDefinitionId: 'priority-tag', value: 'urgent' }],
+        },
+      })
+    ).rejects.toMatchObject({
+      code: 'validation',
+      message: 'Tag "Priority" expects a number value, but received "urgent"',
+    })
+
+    expect(mocks.updateDocument).not.toHaveBeenCalled()
+  })
+
   it('propagates document infrastructure failures without audit', async () => {
     const failure = new Error('storage ledger unavailable')
     mocks.createDocument.mockRejectedValueOnce(failure)
diff --git a/apps/sim/lib/knowledge/application/documents.ts b/apps/sim/lib/knowledge/application/documents.ts
index 2d8136678a..a2faed4ba8 100644
--- a/apps/sim/lib/knowledge/application/documents.ts
+++ b/apps/sim/lib/knowledge/application/documents.ts
@@ -33,7 +33,11 @@ import {
   resolveCanonicalActiveKnowledgeDocumentContext,
 } from '@/lib/knowledge/application/contexts'
 import { knowledgeOperations } from '@/lib/knowledge/application/operations'
-import { MAX_KNOWLEDGE_DOCUMENTS_PER_CREATE } from '@/lib/knowledge/constants'
+import {
+  ALL_TAG_SLOTS,
+  type AllTagSlot,
+  MAX_KNOWLEDGE_DOCUMENTS_PER_CREATE,
+} from '@/lib/knowledge/constants'
 import {
   bulkDocumentOperation,
   bulkDocumentOperationByFilter,
@@ -62,6 +66,7 @@ import {
   toKnowledgeTagFilterConditions,
 } from '@/lib/knowledge/tags/filter-resolution'
 import { getDocumentTagDefinitions } from '@/lib/knowledge/tags/service'
+import { validateTagValue } from '@/lib/knowledge/tags/utils'
 import { StorageService } from '@/lib/uploads'
 import { generateKnowledgeBaseFileKey } from '@/lib/uploads/contexts/knowledge-base/knowledge-base-file-manager'
 import { recordKnowledgeBaseFileOwnership } from '@/lib/uploads/server/metadata'
@@ -180,6 +185,7 @@ type BulkDeleteKnowledgeDocumentsContext = ActiveKnowledgeResourceBaseContext &
 export interface UpdateKnowledgeDocumentInput extends ReadKnowledgeDocumentInput {
   filename?: string
   enabled?: boolean
+  tagValues?: KnowledgeDocumentTagValueAssignment[]
   updates?: Parameters<typeof updateDocument>[1]
   markFailedDueToTimeout?: boolean
   retryProcessing?: boolean
@@ -187,6 +193,68 @@ export interface UpdateKnowledgeDocumentInput extends ReadKnowledgeDocumentInput
   source?: string
 }
 
+export interface KnowledgeDocumentTagValueAssignment {
+  tagDefinitionId: string
+  value: string | number | boolean | null
+}
+
+type KnowledgeDocumentUpdates = Parameters<typeof updateDocument>[1]
+
+function isAllTagSlot(tagSlot: string): tagSlot is AllTagSlot {
+  return (ALL_TAG_SLOTS as readonly string[]).includes(tagSlot)
+}
+
+async function resolveKnowledgeDocumentTagValueUpdates(
+  knowledgeBaseId: string,
+  tagValues: readonly KnowledgeDocumentTagValueAssignment[]
+): Promise<KnowledgeDocumentUpdates> {
+  const definitions = await getDocumentTagDefinitions(knowledgeBaseId)
+  const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]))
+  const seenDefinitionIds = new Set<string>()
+  const updates: KnowledgeDocumentUpdates = {}
+
+  for (const assignment of tagValues) {
+    if (seenDefinitionIds.has(assignment.tagDefinitionId)) {
+      throw new OrchestrationError(
+        'validation',
+        `Duplicate tag definition ID: ${assignment.tagDefinitionId}`
+      )
+    }
+    seenDefinitionIds.add(assignment.tagDefinitionId)
+
+    const definition = definitionsById.get(assignment.tagDefinitionId)
+    if (!definition) {
+      throw new OrchestrationError(
+        'validation',
+        `Tag definition ${assignment.tagDefinitionId} does not belong to this knowledge base`
+      )
+    }
+    if (!isAllTagSlot(definition.tagSlot)) {
+      throw new Error(`Tag definition ${definition.id} has an unsupported slot`)
+    }
+
+    if (assignment.value === null) {
+      updates[definition.tagSlot] = ''
+      continue
+    }
+
+    const value = String(assignment.value).trim()
+    if (!value) {
+      throw new OrchestrationError(
+        'validation',
+        `Tag "${definition.displayName}" requires a value; use null to clear it`
+      )
+    }
+    const validationError = validateTagValue(definition.displayName, value, definition.fieldType)
+    if (validationError) {
+      throw new OrchestrationError('validation', validationError)
+    }
+    updates[definition.tagSlot] = value
+  }
+
+  return updates
+}
+
 export interface BulkKnowledgeDocumentsInput extends UploadKnowledgeDocumentAdmissionInput {
   operation: 'enable' | 'disable' | 'delete'
   documentIds?: string[]
@@ -828,7 +896,15 @@ export const updateKnowledgeDocument = defineAuthorizedKnowledgeUseCase({
         message: outcome.message,
       }
     }
-    const updates = input.updates ?? { filename: input.filename, enabled: input.enabled }
+    const updates: KnowledgeDocumentUpdates = input.updates
+      ? { ...input.updates }
+      : { filename: input.filename, enabled: input.enabled }
+    if (input.tagValues !== undefined) {
+      Object.assign(
+        updates,
+        await resolveKnowledgeDocumentTagValueUpdates(context.knowledgeBaseId, input.tagValues)
+      )
+    }
     const updatedFields = Object.keys(updates).filter(
       (key) => updates[key as keyof typeof updates] !== undefined
     )
@@ -857,6 +933,9 @@ export const updateKnowledgeDocument = defineAuthorizedKnowledgeUseCase({
         fileName: result.document.filename,
         updatedFields: result.updatedFields,
         ...(input.enabled !== undefined && { enabled: input.enabled }),
+        ...(input.tagValues !== undefined && {
+          tagDefinitionIds: input.tagValues.map((assignment) => assignment.tagDefinitionId),
+        }),
       },
     }
   },
diff --git a/apps/sim/lib/knowledge/application/knowledge-bases.ts b/apps/sim/lib/knowledge/application/knowledge-bases.ts
index 8884d926d0..4b8f7fbca3 100644
--- a/apps/sim/lib/knowledge/application/knowledge-bases.ts
+++ b/apps/sim/lib/knowledge/application/knowledge-bases.ts
@@ -97,6 +97,7 @@ export interface ListArchivedKnowledgeBasesResult {
 }
 
 export interface KnowledgeBaseCatalogTagDefinition {
+  id: string
   knowledgeBaseId: string
   tagSlot: string
   displayName: string
@@ -393,6 +394,7 @@ export const listKnowledgeBaseCatalog = defineAuthorizedKnowledgeUseCase({
         ? []
         : await db
             .select({
+              id: knowledgeBaseTagDefinitions.id,
               knowledgeBaseId: knowledgeBaseTagDefinitions.knowledgeBaseId,
               tagSlot: knowledgeBaseTagDefinitions.tagSlot,
               displayName: knowledgeBaseTagDefinitions.displayName,
diff --git a/apps/sim/lib/knowledge/application/knowledge-vfs.ts b/apps/sim/lib/knowledge/application/knowledge-vfs.ts
index 1f5444394d..8c9dd09e1d 100644
--- a/apps/sim/lib/knowledge/application/knowledge-vfs.ts
+++ b/apps/sim/lib/knowledge/application/knowledge-vfs.ts
@@ -1,6 +1,14 @@
 import { AuditAction, AuditResourceType } from '@sim/audit'
+import { resolvePrincipalAttribution } from '@sim/auth/principal'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { generateRequestId } from '@/lib/core/utils/request'
+import {
+  createResourceVfsFolders,
+  deleteResourceVfsFolders,
+  type FolderedResourceAdapter,
+  resolveResourceRowBySegments,
+  transferResourceVfsItems,
+} from '@/lib/folders/application/resource-vfs'
 import { defineAuthorizedKnowledgeUseCase } from '@/lib/knowledge/application/authorized-knowledge-use-case'
 import {
   type KnowledgeWorkspaceContext,
@@ -10,6 +18,7 @@ import { knowledgeOperations } from '@/lib/knowledge/application/operations'
 import {
   deleteKnowledgeBase,
   findActiveKnowledgeBasesByExactName,
+  getWorkspaceKnowledgeBases,
   updateKnowledgeBase,
 } from '@/lib/knowledge/service'
 import type { KnowledgeBaseWithCounts } from '@/lib/knowledge/types'
@@ -17,6 +26,29 @@ import type { KnowledgeBaseWithCounts } from '@/lib/knowledge/types'
 interface KnowledgeVfsReferenceInput {
   workspaceId: string
   sourceName: string
+  /** Folder segments + leaf name; when present the nested-aware resolver is used. */
+  sourceSegments?: string[]
+}
+
+const knowledgeVfsAdapter: FolderedResourceAdapter = {
+  resourceType: 'knowledge_base',
+  rootSegment: 'knowledgebases',
+  label: 'knowledge base',
+  async listRows(workspaceId) {
+    const { data: rows } = await getWorkspaceKnowledgeBases(workspaceId, 'active', {})
+    return rows.map((kb) => ({ id: kb.id, name: kb.name, folderId: kb.folderId ?? null }))
+  },
+  async moveRow(row, folderId, workspaceId) {
+    await updateKnowledgeBase(row.id, { folderId }, generateRequestId(), {
+      assertedWorkspaceId: workspaceId,
+    })
+  },
+  async renameRow(row, newName, workspaceId) {
+    const updated = await updateKnowledgeBase(row.id, { name: newName }, generateRequestId(), {
+      assertedWorkspaceId: workspaceId,
+    })
+    return { id: updated.id, name: updated.name }
+  },
 }
 
 export interface RenameKnowledgeBaseByVfsPathInput extends KnowledgeVfsReferenceInput {
@@ -27,8 +59,32 @@ export type DeleteKnowledgeBaseByVfsPathInput = KnowledgeVfsReferenceInput
 
 async function resolveKnowledgeBaseByVfsName(
   context: KnowledgeWorkspaceContext,
-  sourceName: string
+  sourceName: string,
+  sourceSegments?: string[]
 ): Promise<Omit<KnowledgeBaseWithCounts, 'connectorTypes'>> {
+  if (sourceSegments && sourceSegments.length > 1) {
+    const row = await resolveResourceRowBySegments(
+      knowledgeVfsAdapter,
+      context.workspaceId,
+      sourceSegments
+    )
+    /**
+     * Resolved by folder path, so the name may be shared with knowledge bases in
+     * other folders. The exact-name lookup caps its result set, so the full list
+     * is read here and narrowed by id instead.
+     */
+    const { data: rows } = await getWorkspaceKnowledgeBases(context.workspaceId, 'active', {
+      search: row.name,
+    })
+    const match = rows.find((kb) => kb.id === row.id)
+    if (!match) {
+      throw new OrchestrationError(
+        'not_found',
+        `Knowledge base not found at knowledgebases/${sourceSegments.join('/')}`
+      )
+    }
+    return match
+  }
   const matches = await findActiveKnowledgeBasesByExactName(context.workspaceId, sourceName)
   if (matches.length > 1) {
     throw new OrchestrationError(
@@ -51,7 +107,11 @@ export const renameKnowledgeBaseByVfsPath = defineAuthorizedKnowledgeUseCase({
   resolveContext: ({ input }: { input: RenameKnowledgeBaseByVfsPathInput }) =>
     resolveKnowledgeWorkspaceContext(input),
   async execute({ input, context }) {
-    const knowledgeBase = await resolveKnowledgeBaseByVfsName(context, input.sourceName)
+    const knowledgeBase = await resolveKnowledgeBaseByVfsName(
+      context,
+      input.sourceName,
+      input.sourceSegments
+    )
     const updated = await updateKnowledgeBase(
       knowledgeBase.id,
       { name: input.newName },
@@ -80,7 +140,11 @@ export const deleteKnowledgeBaseByVfsPath = defineAuthorizedKnowledgeUseCase({
   resolveContext: ({ input }: { input: DeleteKnowledgeBaseByVfsPathInput }) =>
     resolveKnowledgeWorkspaceContext(input),
   async execute({ input, context }) {
-    const knowledgeBase = await resolveKnowledgeBaseByVfsName(context, input.sourceName)
+    const knowledgeBase = await resolveKnowledgeBaseByVfsName(
+      context,
+      input.sourceName,
+      input.sourceSegments
+    )
     await deleteKnowledgeBase(knowledgeBase.id, generateRequestId(), {
       assertedWorkspaceId: context.workspaceId,
     })
@@ -100,3 +164,93 @@ export const deleteKnowledgeBaseByVfsPath = defineAuthorizedKnowledgeUseCase({
     metadata: { source: 'copilot_vfs', knowledgeBaseName: result.name },
   }),
 })
+
+export interface KnowledgeVfsPathsInput {
+  workspaceId: string
+  paths: Array<{ source: string; segments: string[] }>
+}
+
+export interface TransferKnowledgeVfsItemsInput {
+  workspaceId: string
+  sources: Array<{ source: string; segments: string[] }>
+  destination: { segments: string[]; trailingSlash: boolean }
+}
+
+/** mkdir -p under knowledgebases/ — folder invariants live in lib/folders. */
+export const createKnowledgeVfsFolders = defineAuthorizedKnowledgeUseCase({
+  operation: knowledgeOperations.manageVfsFolders,
+  resolveContext: ({ input }: { input: KnowledgeVfsPathsInput }) =>
+    resolveKnowledgeWorkspaceContext(input),
+  async execute({ principal, input, context }) {
+    const userId = resolvePrincipalAttribution(principal, {
+      workspaceBillingOwnerUserId: context.billedAccountUserId,
+    }).attributedUserId
+    const outcomes = await createResourceVfsFolders(knowledgeVfsAdapter, {
+      workspaceId: context.workspaceId,
+      userId,
+      paths: input.paths,
+    })
+    return { outcomes, workspaceId: context.workspaceId }
+  },
+  projectAudit: ({ result }) => ({
+    action: AuditAction.KNOWLEDGE_BASE_UPDATED,
+    resourceType: AuditResourceType.KNOWLEDGE_BASE,
+    resourceId: result.workspaceId,
+    resourceName: 'knowledgebases',
+    description: 'Created knowledge base folders',
+    metadata: { op: 'vfs_mkdir', count: result.outcomes.length, source: 'copilot_vfs' },
+  }),
+})
+
+/** mv under knowledgebases/: rows into folders, folder moves/renames, leaf renames. */
+export const transferKnowledgeVfsItems = defineAuthorizedKnowledgeUseCase({
+  operation: knowledgeOperations.moveByVfsPath,
+  resolveContext: ({ input }: { input: TransferKnowledgeVfsItemsInput }) =>
+    resolveKnowledgeWorkspaceContext(input),
+  async execute({ principal, input, context }) {
+    const userId = resolvePrincipalAttribution(principal, {
+      workspaceBillingOwnerUserId: context.billedAccountUserId,
+    }).attributedUserId
+    const outcomes = await transferResourceVfsItems(knowledgeVfsAdapter, {
+      workspaceId: context.workspaceId,
+      userId,
+      sources: input.sources,
+      destination: input.destination,
+    })
+    return { outcomes, workspaceId: context.workspaceId }
+  },
+  projectAudit: ({ result }) => ({
+    action: AuditAction.KNOWLEDGE_BASE_UPDATED,
+    resourceType: AuditResourceType.KNOWLEDGE_BASE,
+    resourceId: result.workspaceId,
+    resourceName: 'knowledgebases',
+    description: 'Moved knowledge base VFS items',
+    metadata: { op: 'vfs_mv', count: result.outcomes.length, source: 'copilot_vfs' },
+  }),
+})
+
+/** rm of knowledgebases/ folder paths — recursive via the shared cascade. */
+export const deleteKnowledgeVfsFolders = defineAuthorizedKnowledgeUseCase({
+  operation: knowledgeOperations.manageVfsFolders,
+  resolveContext: ({ input }: { input: KnowledgeVfsPathsInput }) =>
+    resolveKnowledgeWorkspaceContext(input),
+  async execute({ principal, input, context }) {
+    const userId = resolvePrincipalAttribution(principal, {
+      workspaceBillingOwnerUserId: context.billedAccountUserId,
+    }).attributedUserId
+    const outcomes = await deleteResourceVfsFolders(knowledgeVfsAdapter, {
+      workspaceId: context.workspaceId,
+      userId,
+      paths: input.paths,
+    })
+    return { outcomes, workspaceId: context.workspaceId }
+  },
+  projectAudit: ({ result }) => ({
+    action: AuditAction.KNOWLEDGE_BASE_DELETED,
+    resourceType: AuditResourceType.KNOWLEDGE_BASE,
+    resourceId: result.workspaceId,
+    resourceName: 'knowledgebases',
+    description: 'Deleted knowledge base folders',
+    metadata: { op: 'vfs_rm_folder', count: result.outcomes.length, source: 'copilot_vfs' },
+  }),
+})
diff --git a/apps/sim/lib/knowledge/application/operations.test.ts b/apps/sim/lib/knowledge/application/operations.test.ts
index 69b9fb11f8..a37819c0a9 100644
--- a/apps/sim/lib/knowledge/application/operations.test.ts
+++ b/apps/sim/lib/knowledge/application/operations.test.ts
@@ -20,6 +20,8 @@ describe('knowledge operation registry', () => {
       'knowledge.bulk_delete_items',
       'knowledge.bulk_delete',
       'knowledge.vfs.rename',
+      'knowledge.vfs.move',
+      'knowledge.vfs.folders.manage',
       'knowledge.vfs.delete',
       'knowledge.search',
       'knowledge.folders.list',
diff --git a/apps/sim/lib/knowledge/application/operations.ts b/apps/sim/lib/knowledge/application/operations.ts
index e093146007..d811885302 100644
--- a/apps/sim/lib/knowledge/application/operations.ts
+++ b/apps/sim/lib/knowledge/application/operations.ts
@@ -89,6 +89,18 @@ export const knowledgeOperations = {
     workspaceApiKey: 'deny',
     ...COPILOT_PRINCIPAL_POLICY,
   }),
+  moveByVfsPath: defineWorkspaceOperation({
+    id: 'knowledge.vfs.move',
+    minimumRole: 'write',
+    workspaceApiKey: 'deny',
+    ...COPILOT_PRINCIPAL_POLICY,
+  }),
+  manageVfsFolders: defineWorkspaceOperation({
+    id: 'knowledge.vfs.folders.manage',
+    minimumRole: 'write',
+    workspaceApiKey: 'deny',
+    ...COPILOT_PRINCIPAL_POLICY,
+  }),
   deleteByVfsPath: defineWorkspaceOperation({
     id: 'knowledge.vfs.delete',
     minimumRole: 'write',
diff --git a/apps/sim/lib/knowledge/documents/unreadable-document.test.ts b/apps/sim/lib/knowledge/documents/unreadable-document.test.ts
index 84b880902f..24e85ccb3c 100644
--- a/apps/sim/lib/knowledge/documents/unreadable-document.test.ts
+++ b/apps/sim/lib/knowledge/documents/unreadable-document.test.ts
@@ -10,10 +10,16 @@
  */
 import { describe, expect, it, vi } from 'vitest'
 
-const { mockParseBuffer, mockDownload } = vi.hoisted(() => ({
-  mockParseBuffer: vi.fn(),
-  mockDownload: vi.fn(),
-}))
+const { mockParseBuffer, mockDownload } = vi.hoisted(() => {
+  // A developer's .env MISTRAL_API_KEY would route the empty-parse case into
+  // the OCR/cloud-upload branch and fail on unmocked uploads; CI has no key.
+  // Pin the keyless path so the test is hermetic.
+  process.env.MISTRAL_API_KEY = ''
+  return {
+    mockParseBuffer: vi.fn(),
+    mockDownload: vi.fn(),
+  }
+})
 
 vi.mock('@/lib/file-parsers', () => ({
   parseBuffer: mockParseBuffer,
diff --git a/apps/sim/lib/knowledge/orchestration/connectors.ts b/apps/sim/lib/knowledge/orchestration/connectors.ts
index 750c2a41bc..3071f5287c 100644
--- a/apps/sim/lib/knowledge/orchestration/connectors.ts
+++ b/apps/sim/lib/knowledge/orchestration/connectors.ts
@@ -178,7 +178,11 @@ export async function performCreateKnowledgeConnector(
 
   const configValidation = await connectorConfig.validateConfig(accessToken, sourceConfig)
   if (!configValidation.valid) {
-    return fail(configValidation.error || 'Invalid source configuration', 'validation')
+    return fail(
+      configValidation.error ||
+        `The ${connectorType} connector rejected sourceConfig without a reason — re-check its required fields in knowledgebases/connectors/${connectorType}.json before retrying; the same config will fail again.`,
+      'validation'
+    )
   }
 
   if (connectorConfig.auth.mode === 'apiKey' && apiKey) {
diff --git a/apps/sim/lib/knowledge/service.ts b/apps/sim/lib/knowledge/service.ts
index 16c710d481..d0de80faee 100644
--- a/apps/sim/lib/knowledge/service.ts
+++ b/apps/sim/lib/knowledge/service.ts
@@ -45,7 +45,10 @@ const logger = createLogger('KnowledgeBaseService')
  */
 export class KnowledgeBaseConflictError extends OrchestrationError {
   constructor(name: string) {
-    super('conflict', `A knowledge base named "${name}" already exists in this workspace`)
+    super(
+      'conflict',
+      `A knowledge base named "${name}" already exists in this workspace. Names are unique across the whole workspace — folders do not namespace them — so pick a different name, or rename/delete the existing knowledge base first.`
+    )
     this.name = 'KnowledgeBaseConflictError'
   }
 }
diff --git a/apps/sim/lib/logs/list-logs.ts b/apps/sim/lib/logs/list-logs.ts
index c98b0e564f..4a682260ce 100644
--- a/apps/sim/lib/logs/list-logs.ts
+++ b/apps/sim/lib/logs/list-logs.ts
@@ -174,6 +174,10 @@ export async function listLogs(params: ListLogsParams, userId: string): Promise<
   const commonFilters = buildFilterConditions(p, { useSimpleLevelFilter: false })
   if (commonFilters) workflowConditions.push(commonFilters)
 
+  // Snapshot the filter-only conditions (no pagination cursor) so an
+  // `includeTotal` count runs over the whole filtered set, not the tail.
+  const workflowFilterConditions = [...workflowConditions]
+
   const workflowCursorCond = buildCursorCondition(workflowSortExpr, workflowExecutionLogs.id)
   if (workflowCursorCond) workflowConditions.push(workflowCursorCond)
 
@@ -233,6 +237,7 @@ export async function listLogs(params: ListLogsParams, userId: string): Promise<
     .limit(fetchSize)
 
   const jobConditions: SQL[] = [eq(jobExecutionLogs.workspaceId, p.workspaceId)]
+  let jobFilterConditions: SQL[] = jobConditions
 
   if (includeJobLogs) {
     if (p.level && p.level !== 'all') {
@@ -303,6 +308,8 @@ export async function listLogs(params: ListLogsParams, userId: string): Promise<
       if (durationCond) jobConditions.push(durationCond)
     }
 
+    jobFilterConditions = [...jobConditions]
+
     const jobCursorCond = buildCursorCondition(jobSortExpr, jobExecutionLogs.id)
     if (jobCursorCond) jobConditions.push(jobCursorCond)
   }
@@ -451,8 +458,34 @@ export async function listLogs(params: ListLogsParams, userId: string): Promise<
     nextCursor = encodeCursor({ v: cursorV, id: last.id })
   }
 
+  let total: number | undefined
+  if (p.includeTotal) {
+    const workflowCountQuery = dbReplica
+      .select({ count: sql<number>`COUNT(*)` })
+      .from(workflowExecutionLogs)
+      .leftJoin(
+        pausedExecutions,
+        eq(pausedExecutions.executionId, workflowExecutionLogs.executionId)
+      )
+      .leftJoin(
+        workflowDeploymentVersion,
+        eq(workflowDeploymentVersion.id, workflowExecutionLogs.deploymentVersionId)
+      )
+      .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+      .where(and(...workflowFilterConditions))
+    const jobCountQuery = includeJobLogs
+      ? dbReplica
+          .select({ count: sql<number>`COUNT(*)` })
+          .from(jobExecutionLogs)
+          .where(and(...jobFilterConditions))
+      : Promise.resolve([{ count: 0 }])
+    const [workflowCount, jobCount] = await Promise.all([workflowCountQuery, jobCountQuery])
+    total = Number(workflowCount[0]?.count ?? 0) + Number(jobCount[0]?.count ?? 0)
+  }
+
   return {
     data: page.map((row) => row.summary),
     nextCursor,
+    ...(total !== undefined ? { total } : {}),
   }
 }
diff --git a/apps/sim/lib/logs/log-views.test.ts b/apps/sim/lib/logs/log-views.test.ts
index de444485ad..5d79f1b1d0 100644
--- a/apps/sim/lib/logs/log-views.test.ts
+++ b/apps/sim/lib/logs/log-views.test.ts
@@ -34,7 +34,7 @@ vi.mock('@/lib/execution/payloads/store', () => ({
 
 import { sleep } from '@sim/utils/helpers'
 import type { TraceSpan } from '@/lib/logs/types'
-import { grepSpans, type LogViewContext, toFull, toOverview } from './log-views'
+import { grepSpans, type LogViewContext, toFull, toOverview, toTrace } from './log-views'
 
 const ctx: LogViewContext = {
   workspaceId: 'ws-1',
@@ -286,3 +286,74 @@ describe('grepSpans', () => {
     expect(result.truncated).toBe(false)
   })
 })
+
+describe('toTrace', () => {
+  it('collapses loop iterations into one per-block digest line with status counts', () => {
+    const spans: TraceSpan[] = [
+      span({
+        id: 'loop',
+        blockId: 'blk-loop',
+        name: 'Loop',
+        type: 'loop',
+        children: [
+          span({ id: 'i1', blockId: 'blk-agent', name: 'Agent', status: 'success', duration: 10 }),
+          span({ id: 'i2', blockId: 'blk-agent', name: 'Agent', status: 'success', duration: 20 }),
+          span({ id: 'i3', blockId: 'blk-agent', name: 'Agent', status: 'error', duration: 5 }),
+        ],
+      }),
+    ]
+
+    const digest = toTrace(spans)
+
+    expect(digest).toHaveLength(2)
+    expect(digest[1]).toMatchObject({
+      blockId: 'blk-agent',
+      name: 'Agent',
+      executions: 3,
+      statuses: { success: 2, error: 1 },
+      totalDurationMs: 35,
+    })
+  })
+
+  it('never materializes refs', () => {
+    toTrace([span({ output: ref('big') as unknown as Record<string, unknown> })])
+    expect(materializeLargeValueRefMock).not.toHaveBeenCalled()
+  })
+})
+
+describe('toFull field projection', () => {
+  it('narrows spans to whole payload keys', async () => {
+    const out = await toFull(
+      [span({ input: { a: 1 }, output: { b: 2 }, errorMessage: 'boom' })],
+      ctx,
+      undefined,
+      ['output', 'error']
+    )
+    expect(out[0]).toMatchObject({ output: { b: 2 }, error: 'boom' })
+    expect(out[0]).not.toHaveProperty('input')
+  })
+
+  it('extracts dotted paths under selected', async () => {
+    const out = await toFull(
+      [span({ output: { result: { rows: [1, 2, 3], meta: 'big' } } })],
+      ctx,
+      undefined,
+      ['output.result.rows']
+    )
+    expect(out[0]).not.toHaveProperty('output')
+    expect((out[0] as { selected?: Record<string, unknown> }).selected).toEqual({
+      'output.result.rows': [1, 2, 3],
+    })
+  })
+
+  it('supports blockIds multi-select with field projection', async () => {
+    const spans: TraceSpan[] = [
+      span({ id: 's1', blockId: 'blk-a', name: 'A', output: { keep: 1 } }),
+      span({ id: 's2', blockId: 'blk-b', name: 'B', output: { keep: 2 } }),
+      span({ id: 's3', blockId: 'blk-c', name: 'C', output: { drop: true } }),
+    ]
+    const out = await toFull(spans, ctx, { blockIds: ['blk-a', 'blk-b'] }, ['output'])
+    expect(out.map((s) => s.blockId)).toEqual(['blk-a', 'blk-b'])
+    expect(out[0].output).toEqual({ keep: 1 })
+  })
+})
diff --git a/apps/sim/lib/logs/log-views.ts b/apps/sim/lib/logs/log-views.ts
index db8cfaa404..da306b9ed0 100644
--- a/apps/sim/lib/logs/log-views.ts
+++ b/apps/sim/lib/logs/log-views.ts
@@ -75,6 +75,57 @@ export function toOverview(spans: TraceSpan[]): OverviewSpan[] {
   })
 }
 
+// ---------------------------------------------------------------------------
+// Trace (Level 1.5): condensed per-block digest — names, statuses, counts.
+// ---------------------------------------------------------------------------
+
+export interface TraceDigestEntry {
+  /** Block id when the spans carry one; the drill-in key for `full` blockIds. */
+  blockId?: string
+  name: string
+  type: string
+  /** How many spans (loop iterations included) this block produced. */
+  executions: number
+  /** Span count per status, e.g. { success: 498, error: 2 }. */
+  statuses: Record<string, number>
+  totalDurationMs: number
+}
+
+/**
+ * Project trace spans to a flat per-block digest in first-execution order.
+ * Every span in the tree is counted (loop iterations collapse into their
+ * block's entry), so a 500-iteration loop is one line, not 500. Never
+ * materializes refs.
+ */
+export function toTrace(spans: TraceSpan[]): TraceDigestEntry[] {
+  const byKey = new Map<string, TraceDigestEntry>()
+  const walk = (list: TraceSpan[]): void => {
+    for (const s of list) {
+      const key = s.blockId ?? `${s.type}:${s.name}`
+      let entry = byKey.get(key)
+      if (!entry) {
+        entry = {
+          ...(s.blockId ? { blockId: s.blockId } : {}),
+          name: s.name,
+          type: s.type,
+          executions: 0,
+          statuses: {},
+          totalDurationMs: 0,
+        }
+        byKey.set(key, entry)
+      }
+      entry.executions++
+      const status = s.status ?? 'unknown'
+      entry.statuses[status] = (entry.statuses[status] ?? 0) + 1
+      entry.totalDurationMs += s.duration ?? 0
+      if (s.children && s.children.length > 0) walk(s.children)
+    }
+  }
+  walk(spans)
+  return Array.from(byKey.values())
+}
+
+// ---------------------------------------------------------------------------
 // Full (Level 3): block tree WITH materialized input/output.
 
 export interface FullSpan extends OverviewSpan {
@@ -88,6 +139,8 @@ export interface FullSpan extends OverviewSpan {
 
 export interface BlockSelector {
   blockId?: string
+  /** Multiple drill-in targets at once (ids from the trace digest). */
+  blockIds?: string[]
   blockName?: string
 }
 
@@ -100,19 +153,76 @@ export interface BlockSelector {
 export async function toFull(
   spans: TraceSpan[],
   ctx: LogViewContext,
-  selector?: BlockSelector
+  selector?: BlockSelector,
+  fields?: string[]
 ): Promise<FullSpan[]> {
   const roots = selectSpans(spans, selector)
-  return Promise.all(roots.map((s) => fullSpan(s, ctx)))
+  const full = await Promise.all(roots.map((s) => fullSpan(s, ctx)))
+  if (!fields || fields.length === 0) return full
+  return full.map((s) => projectSpanFields(s, fields))
+}
+
+/**
+ * Narrows a full span to the requested fields so the caller loads only what it
+ * needs. A field is either a whole payload key (`input` / `output` / `error`)
+ * or a dotted path into one (`output.result.rows`); dotted selections land
+ * under `selected` keyed by the full path. Span identity/status/timing always
+ * stay, and children are projected recursively.
+ */
+function projectSpanFields(span: FullSpan, fields: string[]): FullSpan {
+  const node: FullSpan = {
+    id: span.id,
+    blockId: span.blockId,
+    name: span.name,
+    type: span.type,
+    status: span.status,
+    durationMs: span.durationMs,
+    startTime: span.startTime,
+    endTime: span.endTime,
+  }
+  if (span.cost) node.cost = span.cost
+  const selected: Record<string, unknown> = {}
+  let hasSelected = false
+  for (const field of fields) {
+    if (field === 'input' || field === 'output' || field === 'error') {
+      if (span[field] !== undefined) node[field] = span[field] as never
+      continue
+    }
+    const [head, ...rest] = field.split('.')
+    if ((head === 'input' || head === 'output') && rest.length > 0) {
+      let value: unknown = span[head]
+      for (const key of rest) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+          value = (value as Record<string, unknown>)[key]
+        } else if (Array.isArray(value) && /^\d+$/.test(key)) {
+          value = value[Number(key)]
+        } else {
+          value = undefined
+          break
+        }
+      }
+      selected[field] = value
+      hasSelected = true
+    }
+  }
+  if (hasSelected) (node as FullSpan & { selected?: Record<string, unknown> }).selected = selected
+  if (span.children && span.children.length > 0) {
+    node.children = span.children.map((c) => projectSpanFields(c, fields))
+  }
+  return node
 }
 
 function selectSpans(spans: TraceSpan[], selector?: BlockSelector): TraceSpan[] {
-  if (!selector || (!selector.blockId && !selector.blockName)) return spans
+  if (!selector || (!selector.blockId && !selector.blockIds?.length && !selector.blockName)) {
+    return spans
+  }
+  const idSet = new Set<string>(selector.blockIds ?? [])
+  if (selector.blockId !== undefined) idSet.add(selector.blockId)
   const out: TraceSpan[] = []
   const walk = (list: TraceSpan[]): void => {
     for (const s of list) {
       const matches =
-        (selector.blockId !== undefined && s.blockId === selector.blockId) ||
+        (s.blockId !== undefined && idSet.has(s.blockId)) ||
         (selector.blockName !== undefined && s.name === selector.blockName)
       if (matches) {
         out.push(s)
diff --git a/apps/sim/lib/logs/stats-logs.ts b/apps/sim/lib/logs/stats-logs.ts
new file mode 100644
index 0000000000..6a8abc1c6a
--- /dev/null
+++ b/apps/sim/lib/logs/stats-logs.ts
@@ -0,0 +1,214 @@
+import { dbReplica } from '@sim/db'
+import { workflow, workflowExecutionLogs } from '@sim/db/schema'
+import { and, eq, sql } from 'drizzle-orm'
+import { buildFilterConditions } from '@/lib/logs/filters'
+import { expandFolderIdsWithDescendants } from '@/lib/logs/folder-expansion'
+import { checkWorkspaceAccess } from '@/lib/workspaces/permissions/utils'
+
+/**
+ * Server-side aggregation over workflow execution logs for the copilot
+ * `query_logs` stats view: per-workflow, optionally calendar-bucketed counts by
+ * status, under the same filter set as the list view. Exists so a model never
+ * has to paginate the list and count client-side. Job (Sim-agent) executions
+ * are not included — same scope as the Logs dashboard stats.
+ */
+
+export interface StatsLogsParams {
+  workspaceId: string
+  level?: string
+  workflowIds?: string
+  folderIds?: string
+  triggers?: string
+  startDate?: string
+  endDate?: string
+  search?: string
+  workflowName?: string
+  folderName?: string
+  /** Calendar bucketing for the per-workflow series; omit for totals only. */
+  bucket?: 'day' | 'hour'
+  /** IANA timezone the buckets are computed in. Defaults to UTC. */
+  timezone?: string
+}
+
+export interface LogStatsBucket {
+  /** Bucket start in the requested timezone (naive local timestamp). */
+  start: string
+  executions: number
+  byStatus: Record<string, number>
+  avgDurationMs: number
+}
+
+export interface WorkflowLogStats {
+  workflowId: string
+  workflowName: string
+  executions: number
+  byStatus: Record<string, number>
+  avgDurationMs: number
+  buckets?: LogStatsBucket[]
+}
+
+export interface LogStatsResponse {
+  bucket: 'day' | 'hour' | null
+  timezone: string
+  totals: { executions: number; byStatus: Record<string, number>; avgDurationMs: number }
+  workflows: WorkflowLogStats[]
+  /** Set when more workflows matched than are returned (ordered by executions). */
+  workflowsTruncated?: boolean
+}
+
+const MAX_WORKFLOWS = 100
+
+function assertValidTimezone(timezone: string): void {
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: timezone })
+  } catch {
+    throw new Error(`Invalid timezone: ${timezone}. Use an IANA name like "America/Los_Angeles".`)
+  }
+}
+
+interface StatsAccumulator {
+  executions: number
+  byStatus: Record<string, number>
+  durationSumMs: number
+  durationCount: number
+}
+
+function newAccumulator(): StatsAccumulator {
+  return { executions: 0, byStatus: {}, durationSumMs: 0, durationCount: 0 }
+}
+
+function accumulate(acc: StatsAccumulator, status: string, row: RawStatsRow): void {
+  acc.executions += Number(row.executions)
+  acc.byStatus[status] = (acc.byStatus[status] ?? 0) + Number(row.executions)
+  acc.durationSumMs += Number(row.durationSumMs)
+  acc.durationCount += Number(row.durationCount)
+}
+
+function avgOf(acc: StatsAccumulator): number {
+  return acc.durationCount > 0 ? Math.round(acc.durationSumMs / acc.durationCount) : 0
+}
+
+interface RawStatsRow {
+  workflowId: string
+  workflowName: string
+  bucketStart: string | null
+  status: string | null
+  executions: number
+  durationSumMs: number
+  durationCount: number
+}
+
+export async function statsLogs(
+  params: StatsLogsParams,
+  userId: string
+): Promise<LogStatsResponse> {
+  const timezone = params.timezone ?? 'UTC'
+  assertValidTimezone(timezone)
+  const bucket = params.bucket ?? null
+
+  const access = await checkWorkspaceAccess(params.workspaceId, userId)
+  if (!access.hasAccess) {
+    return {
+      bucket,
+      timezone,
+      totals: { executions: 0, byStatus: {}, avgDurationMs: 0 },
+      workflows: [],
+    }
+  }
+
+  const folderIds = params.folderIds
+    ? await expandFolderIdsWithDescendants(params.workspaceId, params.folderIds)
+    : params.folderIds
+  const p = { ...params, folderIds }
+
+  const workspaceFilter = eq(workflowExecutionLogs.workspaceId, p.workspaceId)
+  const commonFilters = buildFilterConditions(p, { useSimpleLevelFilter: true })
+  const whereCondition = commonFilters ? and(workspaceFilter, commonFilters) : workspaceFilter
+
+  const bucketExpr = bucket
+    ? sql<
+        string | null
+      >`to_char(date_trunc(${bucket}, ${workflowExecutionLogs.startedAt} AT TIME ZONE ${timezone}), 'YYYY-MM-DD"T"HH24:MI:SS')`
+    : sql<string | null>`NULL`
+
+  const rows = (await dbReplica
+    .select({
+      workflowId: sql<string>`COALESCE(${workflowExecutionLogs.workflowId}, 'deleted')`,
+      workflowName: sql<string>`COALESCE(${workflow.name}, 'Deleted Workflow')`,
+      bucketStart: bucketExpr.as('bucket_start'),
+      status: workflowExecutionLogs.status,
+      executions: sql<number>`COUNT(*)`,
+      durationSumMs: sql<number>`COALESCE(SUM(${workflowExecutionLogs.totalDurationMs}) FILTER (WHERE ${workflowExecutionLogs.totalDurationMs} > 0), 0)`,
+      durationCount: sql<number>`COUNT(*) FILTER (WHERE ${workflowExecutionLogs.totalDurationMs} > 0)`,
+    })
+    .from(workflowExecutionLogs)
+    .leftJoin(workflow, eq(workflowExecutionLogs.workflowId, workflow.id))
+    .where(whereCondition)
+    .groupBy(
+      sql`COALESCE(${workflowExecutionLogs.workflowId}, 'deleted')`,
+      sql`COALESCE(${workflow.name}, 'Deleted Workflow')`,
+      sql`bucket_start`,
+      workflowExecutionLogs.status
+    )) as RawStatsRow[]
+
+  const totals = newAccumulator()
+  const byWorkflow = new Map<
+    string,
+    { workflowName: string; overall: StatsAccumulator; buckets: Map<string, StatsAccumulator> }
+  >()
+
+  for (const row of rows) {
+    const status = row.status ?? 'unknown'
+    accumulate(totals, status, row)
+    let wf = byWorkflow.get(row.workflowId)
+    if (!wf) {
+      wf = { workflowName: row.workflowName, overall: newAccumulator(), buckets: new Map() }
+      byWorkflow.set(row.workflowId, wf)
+    }
+    accumulate(wf.overall, status, row)
+    if (bucket && row.bucketStart) {
+      let bucketAcc = wf.buckets.get(row.bucketStart)
+      if (!bucketAcc) {
+        bucketAcc = newAccumulator()
+        wf.buckets.set(row.bucketStart, bucketAcc)
+      }
+      accumulate(bucketAcc, status, row)
+    }
+  }
+
+  const workflows: WorkflowLogStats[] = Array.from(byWorkflow.entries())
+    .map(([workflowId, wf]) => ({
+      workflowId,
+      workflowName: wf.workflowName,
+      executions: wf.overall.executions,
+      byStatus: wf.overall.byStatus,
+      avgDurationMs: avgOf(wf.overall),
+      ...(bucket
+        ? {
+            buckets: Array.from(wf.buckets.entries())
+              .sort(([a], [b]) => a.localeCompare(b))
+              .map(([start, acc]) => ({
+                start,
+                executions: acc.executions,
+                byStatus: acc.byStatus,
+                avgDurationMs: avgOf(acc),
+              })),
+          }
+        : {}),
+    }))
+    .sort((a, b) => b.executions - a.executions)
+
+  const truncated = workflows.length > MAX_WORKFLOWS
+
+  return {
+    bucket,
+    timezone,
+    totals: {
+      executions: totals.executions,
+      byStatus: totals.byStatus,
+      avgDurationMs: avgOf(totals),
+    },
+    workflows: truncated ? workflows.slice(0, MAX_WORKFLOWS) : workflows,
+    ...(truncated ? { workflowsTruncated: true } : {}),
+  }
+}
diff --git a/apps/sim/lib/mcp/application/workflow-deployments.ts b/apps/sim/lib/mcp/application/workflow-deployments.ts
index b0543432e1..04c52e29a7 100644
--- a/apps/sim/lib/mcp/application/workflow-deployments.ts
+++ b/apps/sim/lib/mcp/application/workflow-deployments.ts
@@ -281,7 +281,7 @@ export const deployWorkflowMcpTool = defineAuthorizedWorkspaceUseCase({
     if (!context.workflow.isDeployed) {
       throw new OrchestrationError(
         'validation',
-        'Workflow must be deployed before adding as an MCP tool. Use deploy_api first.'
+        'Workflow must be deployed before adding as an MCP tool. Use deploy_as_api first.'
       )
     }
     if (
diff --git a/apps/sim/lib/mcp/workflow-mcp-sync.ts b/apps/sim/lib/mcp/workflow-mcp-sync.ts
index 1c3d5c597f..8918d0c86f 100644
--- a/apps/sim/lib/mcp/workflow-mcp-sync.ts
+++ b/apps/sim/lib/mcp/workflow-mcp-sync.ts
@@ -134,7 +134,7 @@ export async function generateParameterSchemaForWorkflow(
 
 /**
  * Load a workflow's active deployed state and return its start-trigger input
- * format fields. Shared so callers (e.g. the copilot `deploy_mcp` tool) can
+ * format fields. Shared so callers (e.g. the copilot `deploy_as_mcp` tool) can
  * build a parameter schema from the same input source the deploy modal uses.
  */
 export async function getDeployedWorkflowInputFormat(
diff --git a/apps/sim/lib/organizations/settings-access.test.ts b/apps/sim/lib/organizations/settings-access.test.ts
index 3ac741ff69..f598c09fd8 100644
--- a/apps/sim/lib/organizations/settings-access.test.ts
+++ b/apps/sim/lib/organizations/settings-access.test.ts
@@ -46,6 +46,14 @@ describe('organization settings access', () => {
     })
   })
 
+  it('fails closed when a stored membership has a non-canonical role', async () => {
+    queueTableRows(member, [{ role: 'billing-owner' }])
+
+    await expect(getOrganizationSettingsAccess('organization-route', 'viewer')).rejects.toThrow(
+      'Invalid role'
+    )
+  })
+
   it('allows members to view the roster but reserves control-plane sections for admins', async () => {
     queueTableRows(member, [{ role: 'member' }])
     await expect(
diff --git a/apps/sim/lib/organizations/settings-access.ts b/apps/sim/lib/organizations/settings-access.ts
index 3281a11a93..db374c716d 100644
--- a/apps/sim/lib/organizations/settings-access.ts
+++ b/apps/sim/lib/organizations/settings-access.ts
@@ -7,11 +7,12 @@ import {
   type OrganizationSettingsSection,
   resolveOrganizationSectionAccess,
 } from '@/components/settings/navigation'
+import { type OrganizationRole, organizationRoleSchema } from '@/lib/api/contracts/primitives'
 
 interface OrganizationSettingsAccess {
   isAdmin: boolean
   isMember: boolean
-  role: string | null
+  role: OrganizationRole | null
 }
 
 /**
@@ -28,7 +29,7 @@ async function resolveOrganizationSettingsAccess(
     .where(and(eq(member.organizationId, organizationId), eq(member.userId, userId)))
     .limit(1)
 
-  const role = membership?.role ?? null
+  const role = membership ? organizationRoleSchema.parse(membership.role) : null
   return {
     role,
     isMember: role !== null,
diff --git a/apps/sim/lib/permission-groups/features.test.ts b/apps/sim/lib/permission-groups/features.test.ts
new file mode 100644
index 0000000000..c7496830cd
--- /dev/null
+++ b/apps/sim/lib/permission-groups/features.test.ts
@@ -0,0 +1,97 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  getActivePermissionGroupRestrictions,
+  PLATFORM_FEATURES,
+} from '@/lib/permission-groups/features'
+import {
+  DEFAULT_PERMISSION_GROUP_CONFIG,
+  type PermissionGroupConfig,
+} from '@/lib/permission-groups/types'
+
+describe('getActivePermissionGroupRestrictions', () => {
+  it('returns no restrictions for an absent or unrestricted config', () => {
+    expect(getActivePermissionGroupRestrictions(null)).toEqual([])
+    expect(getActivePermissionGroupRestrictions(DEFAULT_PERMISSION_GROUP_CONFIG)).toEqual([])
+  })
+
+  it.each([
+    {
+      key: 'allowedIntegrations',
+      emptyValue: [],
+      limitedValue: ['slack'],
+      emptyDescription: 'No non-exempt integrations or blocks are allowed.',
+      limitedDescription:
+        'Integrations and blocks are limited to effectiveConfig.allowedIntegrations.',
+    },
+    {
+      key: 'allowedModelProviders',
+      emptyValue: [],
+      limitedValue: ['openai'],
+      emptyDescription: 'No model providers are allowed.',
+      limitedDescription: 'Model providers are limited to effectiveConfig.allowedModelProviders.',
+    },
+    {
+      key: 'allowedFileShareAuthTypes',
+      emptyValue: [],
+      limitedValue: ['password'],
+      emptyDescription: 'No public file-share authentication modes are allowed.',
+      limitedDescription:
+        'Public file-share authentication is limited to effectiveConfig.allowedFileShareAuthTypes.',
+    },
+    {
+      key: 'allowedChatDeployAuthTypes',
+      emptyValue: [],
+      limitedValue: ['sso'],
+      emptyDescription: 'No chat deployment authentication modes are allowed.',
+      limitedDescription:
+        'Chat deployment authentication is limited to effectiveConfig.allowedChatDeployAuthTypes.',
+    },
+  ] as const)(
+    'describes empty and limited $key allowlists',
+    ({ key, emptyValue, limitedValue, emptyDescription, limitedDescription }) => {
+      const emptyConfig = { ...DEFAULT_PERMISSION_GROUP_CONFIG, [key]: emptyValue }
+      const limitedConfig = { ...DEFAULT_PERMISSION_GROUP_CONFIG, [key]: limitedValue }
+
+      expect(getActivePermissionGroupRestrictions(emptyConfig)).toEqual([
+        { key, description: emptyDescription },
+      ])
+      expect(getActivePermissionGroupRestrictions(limitedConfig)).toEqual([
+        { key, description: limitedDescription },
+      ])
+    }
+  )
+
+  it.each([
+    {
+      key: 'deniedModels',
+      value: ['gpt-4o'],
+      description: 'Models listed in effectiveConfig.deniedModels are blocked.',
+    },
+    {
+      key: 'deniedTools',
+      value: ['slack_delete_message'],
+      description: 'Integration tools listed in effectiveConfig.deniedTools are blocked.',
+    },
+  ] as const)('describes a populated $key denylist', ({ key, value, description }) => {
+    const config = { ...DEFAULT_PERMISSION_GROUP_CONFIG, [key]: value }
+
+    expect(getActivePermissionGroupRestrictions(config)).toEqual([{ key, description }])
+  })
+
+  it.each(PLATFORM_FEATURES)(
+    'uses the shared prose for $configKey when enabled',
+    ({ configKey, hint }) => {
+      const config: PermissionGroupConfig = {
+        ...DEFAULT_PERMISSION_GROUP_CONFIG,
+        [configKey]: true,
+      }
+
+      expect(getActivePermissionGroupRestrictions(config)).toEqual([
+        { key: configKey, description: hint },
+      ])
+    }
+  )
+})
diff --git a/apps/sim/lib/permission-groups/features.ts b/apps/sim/lib/permission-groups/features.ts
new file mode 100644
index 0000000000..78aa4f7954
--- /dev/null
+++ b/apps/sim/lib/permission-groups/features.ts
@@ -0,0 +1,228 @@
+import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
+
+type BooleanPermissionGroupConfigKey = {
+  [Key in keyof PermissionGroupConfig]: PermissionGroupConfig[Key] extends boolean ? Key : never
+}[keyof PermissionGroupConfig]
+
+export interface PermissionGroupPlatformFeature {
+  id: string
+  label: string
+  category: string
+  configKey: BooleanPermissionGroupConfigKey
+  hint: string
+}
+
+export interface ActivePermissionGroupRestriction {
+  key: keyof PermissionGroupConfig
+  description: string
+}
+
+/** Render order for the platform-feature category sections; unlisted ones follow. */
+export const PLATFORM_CATEGORY_ORDER: readonly string[] = [
+  'Sidebar',
+  'Deploy Tabs',
+  'Chat',
+  'Collaboration',
+  'Workflow Panel',
+  'Tools',
+  'Features',
+  'Settings Tabs',
+  'Logs',
+  'Files',
+] as const
+
+/** User-facing descriptions shared by the Access Control editor and live permission context. */
+export const PLATFORM_FEATURES = [
+  {
+    id: 'hide-knowledge-base',
+    label: 'Knowledge Base',
+    category: 'Sidebar',
+    configKey: 'hideKnowledgeBaseTab',
+    hint: 'Hide the Knowledge Base module from the sidebar.',
+  },
+  {
+    id: 'hide-tables',
+    label: 'Tables',
+    category: 'Sidebar',
+    configKey: 'hideTablesTab',
+    hint: 'Hide the Tables module from the sidebar.',
+  },
+  {
+    id: 'hide-copilot',
+    label: 'Chat',
+    category: 'Workflow Panel',
+    configKey: 'hideCopilot',
+    hint: 'Hide the Chat panel so users cannot build or edit with natural language.',
+  },
+  {
+    id: 'hide-integrations',
+    label: 'Integrations',
+    category: 'Settings Tabs',
+    configKey: 'hideIntegrationsTab',
+    hint: 'Hide the Integrations settings tab (OAuth connections).',
+  },
+  {
+    id: 'hide-secrets',
+    label: 'Secrets',
+    category: 'Settings Tabs',
+    configKey: 'hideSecretsTab',
+    hint: 'Hide the Secrets (environment variables) settings tab.',
+  },
+  {
+    id: 'hide-api-keys',
+    label: 'API Keys',
+    category: 'Settings Tabs',
+    configKey: 'hideApiKeysTab',
+    hint: 'Hide the API Keys settings tab.',
+  },
+  {
+    id: 'hide-files',
+    label: 'Files',
+    category: 'Settings Tabs',
+    configKey: 'hideFilesTab',
+    hint: 'Hide the Files settings tab.',
+  },
+  {
+    id: 'hide-deploy-api',
+    label: 'API',
+    category: 'Deploy Tabs',
+    configKey: 'hideDeployApi',
+    hint: 'Hide the API deployment option.',
+  },
+  {
+    id: 'hide-deploy-mcp',
+    label: 'MCP',
+    category: 'Deploy Tabs',
+    configKey: 'hideDeployMcp',
+    hint: 'Hide the MCP server deployment option.',
+  },
+  {
+    id: 'disable-mcp',
+    label: 'MCP Tools',
+    category: 'Tools',
+    configKey: 'disableMcpTools',
+    hint: 'Block agents from calling MCP tools.',
+  },
+  {
+    id: 'disable-custom-tools',
+    label: 'Custom Tools',
+    category: 'Tools',
+    configKey: 'disableCustomTools',
+    hint: 'Block agents from calling user-defined custom tools.',
+  },
+  {
+    id: 'disable-skills',
+    label: 'Skills',
+    category: 'Tools',
+    configKey: 'disableSkills',
+    hint: 'Block agents from loading skills.',
+  },
+  {
+    id: 'hide-trace-spans',
+    label: 'Trace Spans',
+    category: 'Logs',
+    configKey: 'hideTraceSpans',
+    hint: 'Hide per-block trace spans in logs.',
+  },
+  {
+    id: 'disable-invitations',
+    label: 'Invitations',
+    category: 'Collaboration',
+    configKey: 'disableInvitations',
+    hint: 'Prevent users from inviting others to workspaces.',
+  },
+  {
+    id: 'hide-inbox',
+    label: 'Sim Mailer',
+    category: 'Features',
+    configKey: 'hideInboxTab',
+    hint: 'Hide the Sim Mailer inbox.',
+  },
+  {
+    id: 'disable-public-api',
+    label: 'Public API',
+    category: 'Features',
+    configKey: 'disablePublicApi',
+    hint: 'Disable public API access to deployed workflows.',
+  },
+  {
+    id: 'hide-deploy-chatbot',
+    label: 'Deployment',
+    category: 'Chat',
+    configKey: 'hideDeployChatbot',
+    hint: 'Hide the chat deployment option.',
+  },
+  {
+    id: 'disable-public-file-sharing',
+    label: 'Public Sharing',
+    category: 'Files',
+    configKey: 'disablePublicFileSharing',
+    hint: 'Disable public file-share links.',
+  },
+] as const satisfies readonly PermissionGroupPlatformFeature[]
+
+/** Returns only restrictions that actively constrain the current user. */
+export function getActivePermissionGroupRestrictions(
+  config: PermissionGroupConfig | null
+): ActivePermissionGroupRestriction[] {
+  if (!config) return []
+
+  const restrictions: ActivePermissionGroupRestriction[] = []
+
+  if (config.allowedIntegrations !== null) {
+    restrictions.push({
+      key: 'allowedIntegrations',
+      description:
+        config.allowedIntegrations.length > 0
+          ? 'Integrations and blocks are limited to effectiveConfig.allowedIntegrations.'
+          : 'No non-exempt integrations or blocks are allowed.',
+    })
+  }
+  if (config.allowedModelProviders !== null) {
+    restrictions.push({
+      key: 'allowedModelProviders',
+      description:
+        config.allowedModelProviders.length > 0
+          ? 'Model providers are limited to effectiveConfig.allowedModelProviders.'
+          : 'No model providers are allowed.',
+    })
+  }
+  if (config.deniedModels.length > 0) {
+    restrictions.push({
+      key: 'deniedModels',
+      description: 'Models listed in effectiveConfig.deniedModels are blocked.',
+    })
+  }
+  if (config.deniedTools.length > 0) {
+    restrictions.push({
+      key: 'deniedTools',
+      description: 'Integration tools listed in effectiveConfig.deniedTools are blocked.',
+    })
+  }
+  if (config.allowedFileShareAuthTypes !== null) {
+    restrictions.push({
+      key: 'allowedFileShareAuthTypes',
+      description:
+        config.allowedFileShareAuthTypes.length > 0
+          ? 'Public file-share authentication is limited to effectiveConfig.allowedFileShareAuthTypes.'
+          : 'No public file-share authentication modes are allowed.',
+    })
+  }
+  if (config.allowedChatDeployAuthTypes !== null) {
+    restrictions.push({
+      key: 'allowedChatDeployAuthTypes',
+      description:
+        config.allowedChatDeployAuthTypes.length > 0
+          ? 'Chat deployment authentication is limited to effectiveConfig.allowedChatDeployAuthTypes.'
+          : 'No chat deployment authentication modes are allowed.',
+    })
+  }
+
+  for (const feature of PLATFORM_FEATURES) {
+    if (config[feature.configKey]) {
+      restrictions.push({ key: feature.configKey, description: feature.hint })
+    }
+  }
+
+  return restrictions
+}
diff --git a/apps/sim/lib/permission-groups/queries.ts b/apps/sim/lib/permission-groups/queries.ts
new file mode 100644
index 0000000000..06bc3e96eb
--- /dev/null
+++ b/apps/sim/lib/permission-groups/queries.ts
@@ -0,0 +1,107 @@
+import { db } from '@sim/db'
+import {
+  permissionGroup,
+  permissionGroupMember,
+  permissionGroupWorkspace,
+  workspace,
+} from '@sim/db/schema'
+import { asc, count, desc, eq, inArray } from 'drizzle-orm'
+import { getActivePermissionGroupRestrictions } from '@/lib/permission-groups/features'
+import type { PermissionGroupConfig } from '@/lib/permission-groups/types'
+
+/** A workspace reference (id + display name). */
+export interface OrgWorkspaceRef {
+  id: string
+  name: string
+}
+
+/**
+ * List an organization's workspaces ({id, name}), ordered by name.
+ *
+ * Lifted from the permission-groups route utils so non-route surfaces (the
+ * copilot VFS) can read the org's workspace map without importing app/api.
+ */
+export async function listOrganizationWorkspaceRefs(
+  organizationId: string
+): Promise<OrgWorkspaceRef[]> {
+  return db
+    .select({ id: workspace.id, name: workspace.name })
+    .from(workspace)
+    .where(eq(workspace.organizationId, organizationId))
+    .orderBy(asc(workspace.name))
+}
+
+export interface PermissionGroupRosterEntry {
+  id: string
+  name: string
+  description: string | null
+  isDefault: boolean
+  memberCount: number
+  workspaces: OrgWorkspaceRef[]
+  activeRestrictions: Array<{ key: string; description: string }>
+}
+
+/**
+ * The org-admin roster: every permission group with its member count, the
+ * workspaces it targets, and the restrictions its config actually activates.
+ * The same joins the settings surface runs, without the route envelope.
+ */
+export async function listPermissionGroupRoster(
+  organizationId: string
+): Promise<PermissionGroupRosterEntry[]> {
+  const groups = await db
+    .select({
+      id: permissionGroup.id,
+      name: permissionGroup.name,
+      description: permissionGroup.description,
+      config: permissionGroup.config,
+      isDefault: permissionGroup.isDefault,
+    })
+    .from(permissionGroup)
+    .where(eq(permissionGroup.organizationId, organizationId))
+    .orderBy(desc(permissionGroup.createdAt))
+
+  const groupIds = groups.map((group) => group.id)
+  const memberCounts = groupIds.length
+    ? await db
+        .select({
+          permissionGroupId: permissionGroupMember.permissionGroupId,
+          count: count(),
+        })
+        .from(permissionGroupMember)
+        .where(inArray(permissionGroupMember.permissionGroupId, groupIds))
+        .groupBy(permissionGroupMember.permissionGroupId)
+    : []
+  const countByGroupId = new Map(memberCounts.map((row) => [row.permissionGroupId, row.count]))
+
+  const workspaceRows = groupIds.length
+    ? await db
+        .select({
+          groupId: permissionGroupWorkspace.permissionGroupId,
+          id: workspace.id,
+          name: workspace.name,
+        })
+        .from(permissionGroupWorkspace)
+        .innerJoin(workspace, eq(permissionGroupWorkspace.workspaceId, workspace.id))
+        .where(inArray(permissionGroupWorkspace.permissionGroupId, groupIds))
+        .orderBy(asc(workspace.name))
+    : []
+  const workspacesByGroupId = new Map<string, OrgWorkspaceRef[]>()
+  for (const row of workspaceRows) {
+    const list = workspacesByGroupId.get(row.groupId) ?? []
+    list.push({ id: row.id, name: row.name })
+    workspacesByGroupId.set(row.groupId, list)
+  }
+
+  return groups.map((group) => ({
+    id: group.id,
+    name: group.name,
+    description: group.description,
+    isDefault: group.isDefault,
+    memberCount: countByGroupId.get(group.id) ?? 0,
+    workspaces: workspacesByGroupId.get(group.id) ?? [],
+    activeRestrictions: getActivePermissionGroupRestrictions(
+      (group.config as PermissionGroupConfig | null) ?? null
+    ),
+  }))
+}
diff --git a/apps/sim/lib/platform-context/application/authorization.ts b/apps/sim/lib/platform-context/application/authorization.ts
new file mode 100644
index 0000000000..11fe1a00bf
--- /dev/null
+++ b/apps/sim/lib/platform-context/application/authorization.ts
@@ -0,0 +1,12 @@
+import type { DelegatedPrincipal } from '@sim/auth/principal'
+import type { ActiveWorkspaceApplicationContext } from '@/lib/workspaces/application/workspace-context'
+
+export const PLATFORM_CONTEXT_DELEGATION_AUDIENCE = 'sim:platform-context'
+
+export const platformContextDelegationPolicy = {
+  audience: PLATFORM_CONTEXT_DELEGATION_AUDIENCE,
+  isWithinScope: (
+    principal: DelegatedPrincipal,
+    context: ActiveWorkspaceApplicationContext
+  ): boolean => principal.workspaceId === context.workspaceId,
+} as const
diff --git a/apps/sim/lib/platform-context/application/context.ts b/apps/sim/lib/platform-context/application/context.ts
new file mode 100644
index 0000000000..f25cc85b88
--- /dev/null
+++ b/apps/sim/lib/platform-context/application/context.ts
@@ -0,0 +1,14 @@
+import { OrchestrationError } from '@/lib/core/orchestration/types'
+import {
+  type ActiveWorkspaceApplicationContext,
+  loadActiveWorkspaceApplicationContext,
+} from '@/lib/workspaces/application/workspace-context'
+
+/** Loads canonical active workspace state before authorizing a live platform-context read. */
+export async function resolvePlatformContextWorkspace(
+  workspaceId: string
+): Promise<ActiveWorkspaceApplicationContext> {
+  const context = await loadActiveWorkspaceApplicationContext(workspaceId)
+  if (!context) throw new OrchestrationError('not_found', 'Workspace not found')
+  return context
+}
diff --git a/apps/sim/lib/platform-context/application/operations.ts b/apps/sim/lib/platform-context/application/operations.ts
new file mode 100644
index 0000000000..36c650a064
--- /dev/null
+++ b/apps/sim/lib/platform-context/application/operations.ts
@@ -0,0 +1,24 @@
+import { defineWorkspaceOperation } from '@/lib/core/application'
+
+const LIVE_PLATFORM_CONTEXT_PRINCIPAL_POLICY = {
+  principalKinds: ['delegated'],
+  delegatedServices: ['copilot'],
+} as const
+
+export const platformContextOperations = {
+  readAccountBilling: defineWorkspaceOperation({
+    id: 'platform_context.account_billing.read',
+    minimumRole: 'read',
+    workspaceApiKey: 'deny',
+    ...LIVE_PLATFORM_CONTEXT_PRINCIPAL_POLICY,
+  }),
+  readEnterpriseContext: defineWorkspaceOperation({
+    id: 'platform_context.enterprise.read',
+    minimumRole: 'read',
+    workspaceApiKey: 'deny',
+    ...LIVE_PLATFORM_CONTEXT_PRINCIPAL_POLICY,
+  }),
+} as const
+
+export type PlatformContextOperation =
+  (typeof platformContextOperations)[keyof typeof platformContextOperations]
diff --git a/apps/sim/lib/platform-context/application/platform-context-use-cases.test.ts b/apps/sim/lib/platform-context/application/platform-context-use-cases.test.ts
new file mode 100644
index 0000000000..64319782d7
--- /dev/null
+++ b/apps/sim/lib/platform-context/application/platform-context-use-cases.test.ts
@@ -0,0 +1,221 @@
+/**
+ * @vitest-environment node
+ */
+import type { DelegatedPrincipal } from '@sim/auth/principal'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  loadWorkspace: vi.fn(),
+  resolvePermission: vi.fn(),
+  getAccountBillingSnapshot: vi.fn(),
+  getWorkspaceHostContextForViewer: vi.fn(),
+  resolveVerifiedUserAccessControlContext: vi.fn(),
+}))
+
+vi.mock('@sim/platform-authz/workspace', () => ({
+  permissionSatisfies: (actual: string | null, required: string) => {
+    const rank = { read: 1, write: 2, admin: 3 } as const
+    return (
+      actual !== null && rank[actual as keyof typeof rank] >= rank[required as keyof typeof rank]
+    )
+  },
+  resolveEffectiveWorkspacePermission: mocks.resolvePermission,
+}))
+
+vi.mock('@/lib/workspaces/application/workspace-context', () => ({
+  loadActiveWorkspaceApplicationContext: mocks.loadWorkspace,
+}))
+
+vi.mock('@/lib/billing/core/account-billing-snapshot', () => ({
+  getAccountBillingSnapshot: mocks.getAccountBillingSnapshot,
+}))
+
+vi.mock('@/lib/workspaces/host-context', () => ({
+  getWorkspaceHostContextForViewer: mocks.getWorkspaceHostContextForViewer,
+}))
+
+vi.mock('@/ee/access-control/utils/permission-check', () => ({
+  resolveVerifiedUserAccessControlContext: mocks.resolveVerifiedUserAccessControlContext,
+}))
+
+import { DEFAULT_PERMISSION_GROUP_CONFIG } from '@/lib/permission-groups/types'
+import { readAccountBilling } from '@/lib/platform-context/application/read-account-billing'
+import { readEnterpriseContext } from '@/lib/platform-context/application/read-enterprise-context'
+
+const workspace = {
+  workspaceId: 'workspace-1',
+  workspaceOrganizationId: 'org-1',
+  allowPersonalApiKeys: true,
+  billedAccountUserId: 'owner-1',
+}
+
+function copilotPrincipal(): DelegatedPrincipal {
+  return {
+    kind: 'delegated',
+    serviceId: 'copilot',
+    subjectUserId: 'user-1',
+    workspaceId: 'workspace-1',
+    delegationId: 'delegation-1',
+    audience: 'sim:platform-context',
+    issuedAt: new Date(Date.now() - 1_000),
+    expiresAt: new Date(Date.now() + 60_000),
+  }
+}
+
+describe('platform context application use cases', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mocks.loadWorkspace.mockResolvedValue(workspace)
+    mocks.resolvePermission.mockResolvedValue('read')
+  })
+
+  it('authorizes a current Copilot subject before reading account billing', async () => {
+    const snapshot = {
+      plan: 'pro',
+      billingScope: 'user',
+      organizationId: null,
+      usage: {},
+      credits: {},
+    }
+    mocks.getAccountBillingSnapshot.mockResolvedValue(snapshot)
+
+    await expect(
+      readAccountBilling.execute({
+        principal: copilotPrincipal(),
+        input: { workspaceId: 'workspace-1' },
+      })
+    ).resolves.toBe(snapshot)
+
+    expect(mocks.resolvePermission).toHaveBeenCalledWith(
+      'user-1',
+      'workspace-1',
+      'org-1',
+      undefined,
+      { forUpdate: undefined }
+    )
+    expect(mocks.getAccountBillingSnapshot).toHaveBeenCalledWith('user-1')
+  })
+
+  it.each([
+    {
+      name: 'workspace API key',
+      principal: {
+        kind: 'workspace_api_key' as const,
+        workspaceId: 'workspace-1',
+        keyId: 'key-1',
+      },
+    },
+    {
+      name: 'executor delegation',
+      principal: { ...copilotPrincipal(), serviceId: 'executor' as const },
+    },
+  ])('rejects a $name before loading protected account context', async ({ principal }) => {
+    await expect(
+      readAccountBilling.execute({ principal, input: { workspaceId: 'workspace-1' } })
+    ).rejects.toMatchObject({ code: 'forbidden' })
+
+    expect(mocks.loadWorkspace).not.toHaveBeenCalled()
+    expect(mocks.getAccountBillingSnapshot).not.toHaveBeenCalled()
+  })
+
+  it('does not load enterprise context when current workspace access is absent', async () => {
+    mocks.resolvePermission.mockResolvedValue(null)
+
+    await expect(
+      readEnterpriseContext.execute({
+        principal: copilotPrincipal(),
+        input: { workspaceId: 'workspace-1' },
+      })
+    ).rejects.toMatchObject({ code: 'forbidden' })
+
+    expect(mocks.getWorkspaceHostContextForViewer).not.toHaveBeenCalled()
+    expect(mocks.resolveVerifiedUserAccessControlContext).not.toHaveBeenCalled()
+  })
+
+  it('projects enterprise context only after authorization', async () => {
+    mocks.getWorkspaceHostContextForViewer.mockResolvedValue({
+      workspace: {
+        id: 'workspace-1',
+        name: 'Customer Support',
+        workspaceMode: 'collaborative',
+      },
+      hostOrganizationId: 'org-1',
+      ownerBilling: { plan: 'enterprise', isEnterprise: true },
+      viewer: {
+        permission: 'admin',
+        isHostOrganizationMember: false,
+        isHostOrganizationAdmin: false,
+        organizationRole: null,
+      },
+    })
+    mocks.resolveVerifiedUserAccessControlContext.mockResolvedValue({
+      entitled: true,
+      permissionGroup: null,
+      config: DEFAULT_PERMISSION_GROUP_CONFIG,
+    })
+
+    await expect(
+      readEnterpriseContext.execute({
+        principal: copilotPrincipal(),
+        input: { workspaceId: 'workspace-1' },
+      })
+    ).resolves.toMatchObject({
+      workspace: {
+        id: 'workspace-1',
+        capabilities: { canRead: true, canEdit: true, canDeploy: true },
+      },
+      organization: {
+        id: 'org-1',
+        relationship: 'external',
+        canManageOrganization: false,
+      },
+      accessControl: { entitled: true },
+    })
+    expect(mocks.getWorkspaceHostContextForViewer).toHaveBeenCalledWith('workspace-1', 'user-1')
+  })
+
+  it('allows read-role execution but hides deployment when every deploy surface is hidden', async () => {
+    mocks.getWorkspaceHostContextForViewer.mockResolvedValue({
+      workspace: {
+        id: 'workspace-1',
+        name: 'Customer Support',
+        workspaceMode: 'collaborative',
+      },
+      hostOrganizationId: 'org-1',
+      ownerBilling: { plan: 'enterprise', isEnterprise: true },
+      viewer: {
+        permission: 'read',
+        isHostOrganizationMember: true,
+        isHostOrganizationAdmin: false,
+        organizationRole: 'member',
+      },
+    })
+    mocks.resolveVerifiedUserAccessControlContext.mockResolvedValue({
+      entitled: true,
+      permissionGroup: null,
+      config: {
+        ...DEFAULT_PERMISSION_GROUP_CONFIG,
+        hideDeployApi: true,
+        hideDeployMcp: true,
+        hideDeployChatbot: true,
+      },
+    })
+
+    await expect(
+      readEnterpriseContext.execute({
+        principal: copilotPrincipal(),
+        input: { workspaceId: 'workspace-1' },
+      })
+    ).resolves.toMatchObject({
+      workspace: {
+        capabilities: {
+          canRead: true,
+          canEdit: false,
+          canRun: true,
+          canDeploy: false,
+          canManageWorkspace: false,
+        },
+      },
+    })
+  })
+})
diff --git a/apps/sim/lib/platform-context/application/read-account-billing.ts b/apps/sim/lib/platform-context/application/read-account-billing.ts
new file mode 100644
index 0000000000..ee3bd7ed69
--- /dev/null
+++ b/apps/sim/lib/platform-context/application/read-account-billing.ts
@@ -0,0 +1,22 @@
+import { requirePrincipalSubjectUserId } from '@sim/auth/principal'
+import {
+  type AccountBillingSnapshot,
+  getAccountBillingSnapshot,
+} from '@/lib/billing/core/account-billing-snapshot'
+import { defineAuthorizedWorkspaceUseCase } from '@/lib/core/application'
+import { platformContextDelegationPolicy } from '@/lib/platform-context/application/authorization'
+import { resolvePlatformContextWorkspace } from '@/lib/platform-context/application/context'
+import { platformContextOperations } from '@/lib/platform-context/application/operations'
+
+export interface ReadAccountBillingInput {
+  workspaceId: string
+}
+
+export const readAccountBilling = defineAuthorizedWorkspaceUseCase({
+  operation: platformContextOperations.readAccountBilling,
+  resolveContext: ({ input }: { input: ReadAccountBillingInput }) =>
+    resolvePlatformContextWorkspace(input.workspaceId),
+  authorizationOptions: { delegation: platformContextDelegationPolicy },
+  execute: async ({ principal }): Promise<AccountBillingSnapshot> =>
+    getAccountBillingSnapshot(requirePrincipalSubjectUserId(principal)),
+})
diff --git a/apps/sim/lib/platform-context/application/read-enterprise-context.ts b/apps/sim/lib/platform-context/application/read-enterprise-context.ts
new file mode 100644
index 0000000000..dab02b17e5
--- /dev/null
+++ b/apps/sim/lib/platform-context/application/read-enterprise-context.ts
@@ -0,0 +1,88 @@
+import { requirePrincipalSubjectUserId } from '@sim/auth/principal'
+import { permissionSatisfies } from '@sim/platform-authz/workspace'
+import { defineAuthorizedWorkspaceUseCase } from '@/lib/core/application'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
+import { getActivePermissionGroupRestrictions } from '@/lib/permission-groups/features'
+import { platformContextDelegationPolicy } from '@/lib/platform-context/application/authorization'
+import { resolvePlatformContextWorkspace } from '@/lib/platform-context/application/context'
+import { platformContextOperations } from '@/lib/platform-context/application/operations'
+import { getWorkspaceHostContextForViewer } from '@/lib/workspaces/host-context'
+import { resolveVerifiedUserAccessControlContext } from '@/ee/access-control/utils/permission-check'
+
+const ENTERPRISE_PERMISSION_DOCUMENTATION = [
+  {
+    title: 'Roles and permissions',
+    path: 'docs/platform/permissions.mdx',
+    url: 'https://docs.sim.ai/platform/permissions',
+  },
+  {
+    title: 'Enterprise Access Control',
+    path: 'docs/platform/enterprise/access-control.mdx',
+    url: 'https://docs.sim.ai/platform/enterprise/access-control',
+  },
+] as const
+
+export interface ReadEnterpriseContextInput {
+  workspaceId: string
+}
+
+export const readEnterpriseContext = defineAuthorizedWorkspaceUseCase({
+  operation: platformContextOperations.readEnterpriseContext,
+  resolveContext: ({ input }: { input: ReadEnterpriseContextInput }) =>
+    resolvePlatformContextWorkspace(input.workspaceId),
+  authorizationOptions: { delegation: platformContextDelegationPolicy },
+  async execute({ principal, context }) {
+    const userId = requirePrincipalSubjectUserId(principal)
+    const hostContext = await getWorkspaceHostContextForViewer(context.workspaceId, userId)
+    if (!hostContext) {
+      throw new OrchestrationError('not_found', 'Workspace not found or you do not have access.')
+    }
+
+    const accessControl = await resolveVerifiedUserAccessControlContext(
+      userId,
+      context.workspaceId,
+      hostContext.hostOrganizationId
+    )
+    const canWrite = permissionSatisfies(hostContext.viewer.permission, 'write')
+    const canAdmin = permissionSatisfies(hostContext.viewer.permission, 'admin')
+    const allDeploymentSurfacesHidden =
+      accessControl.config?.hideDeployApi === true &&
+      accessControl.config.hideDeployMcp === true &&
+      accessControl.config.hideDeployChatbot === true
+
+    return {
+      workspace: {
+        id: hostContext.workspace.id,
+        name: hostContext.workspace.name,
+        mode: hostContext.workspace.workspaceMode,
+        permission: hostContext.viewer.permission,
+        capabilities: {
+          canRead: true,
+          canEdit: canWrite,
+          canRun: true,
+          canDeploy: canAdmin && !allDeploymentSurfacesHidden,
+          canManageWorkspace: canAdmin,
+        },
+      },
+      organization: hostContext.hostOrganizationId
+        ? {
+            id: hostContext.hostOrganizationId,
+            relationship: hostContext.viewer.isHostOrganizationMember ? 'internal' : 'external',
+            role: hostContext.viewer.organizationRole ?? null,
+            canManageOrganization: hostContext.viewer.isHostOrganizationAdmin,
+            canManageBilling: hostContext.viewer.isHostOrganizationAdmin,
+            plan: hostContext.ownerBilling.plan,
+            isEnterprise: hostContext.ownerBilling.isEnterprise,
+          }
+        : null,
+      accessControl: {
+        entitled: accessControl.entitled,
+        governingPermissionGroup: accessControl.permissionGroup,
+        effectiveConfig: accessControl.config,
+        activeRestrictions: getActivePermissionGroupRestrictions(accessControl.config),
+      },
+      documentation: ENTERPRISE_PERMISSION_DOCUMENTATION,
+      resolvedAt: new Date().toISOString(),
+    }
+  },
+})
diff --git a/apps/sim/lib/pptx-renderer/renderer/chart-renderer.ts b/apps/sim/lib/pptx-renderer/renderer/chart-renderer.ts
index a3a3abf300..a13f43121b 100644
--- a/apps/sim/lib/pptx-renderer/renderer/chart-renderer.ts
+++ b/apps/sim/lib/pptx-renderer/renderer/chart-renderer.ts
@@ -9,6 +9,7 @@ const logger = createLogger('PptxChartRenderer')
 import * as echarts from 'echarts'
 import type { ChartNodeData } from '../model/nodes/chart-node'
 import type { SafeXmlNode } from '../parser/xml-parser'
+import { cssFontStack } from '../utils/font-stack'
 import type { RenderContext } from './render-context'
 import { resolveColor } from './style-resolver'
 
@@ -737,7 +738,7 @@ function extractTxPrStyle(
     const eaTypeface = defRPr.child('ea').attr('typeface')
     const csTypeface = defRPr.child('cs').attr('typeface')
     if (latinTypeface || eaTypeface || csTypeface) {
-      style.fontFamily = latinTypeface || eaTypeface || csTypeface
+      style.fontFamily = cssFontStack(latinTypeface || eaTypeface || csTypeface || '')
     }
 
     if (
@@ -752,13 +753,12 @@ function extractTxPrStyle(
 }
 
 function getChartThemeFontFamily(ctx: RenderContext): string | undefined {
-  return (
+  const family =
     ctx.theme.minorFont.latin ||
     ctx.theme.minorFont.ea ||
     ctx.theme.majorFont.latin ||
-    ctx.theme.majorFont.ea ||
-    undefined
-  )
+    ctx.theme.majorFont.ea
+  return family ? cssFontStack(family) : undefined
 }
 
 // Legend
diff --git a/apps/sim/lib/pptx-renderer/renderer/text-renderer.ts b/apps/sim/lib/pptx-renderer/renderer/text-renderer.ts
index 28c73270d1..c211d0e478 100644
--- a/apps/sim/lib/pptx-renderer/renderer/text-renderer.ts
+++ b/apps/sim/lib/pptx-renderer/renderer/text-renderer.ts
@@ -9,6 +9,7 @@ import type { PlaceholderInfo } from '../model/nodes/base-node'
 import type { TextBody } from '../model/nodes/shape-node'
 import { angleToDeg, emuToPx, pctToDecimal } from '../parser/units'
 import { SafeXmlNode } from '../parser/xml-parser'
+import { cssFontStack } from '../utils/font-stack'
 import type { RenderContext } from './render-context'
 import { resolveColor, resolveColorToCss } from './style-resolver'
 
@@ -640,7 +641,7 @@ export function renderTextBody(
       const bulletSpan = document.createElement('span')
       bulletSpan.textContent = `${bulletPrefix} `
       if (merged.bulletFont) {
-        bulletSpan.style.fontFamily = merged.bulletFont
+        bulletSpan.style.fontFamily = cssFontStack(merged.bulletFont)
       }
       // Bullet color: 1) explicit buClr from list style, 2) paragraph defRPr, 3) first run's color (so bullet matches text), 4) cell/fallback
       let bulletColor: string | undefined
@@ -891,12 +892,12 @@ export function renderTextBody(
         ? runStyle.fontFamily
         : (options?.cellTextFontFamily ?? runStyle.fontFamily)
       if (effectiveFont) {
-        element.style.fontFamily = `"${effectiveFont}"`
+        element.style.fontFamily = cssFontStack(effectiveFont)
       } else {
         // Fallback to theme minor font
         const fallback = ctx.theme.minorFont.latin || ctx.theme.minorFont.ea
         if (fallback) {
-          element.style.fontFamily = `"${fallback}"`
+          element.style.fontFamily = cssFontStack(fallback)
         }
       }
 
diff --git a/apps/sim/lib/pptx-renderer/utils/font-stack.test.ts b/apps/sim/lib/pptx-renderer/utils/font-stack.test.ts
new file mode 100644
index 0000000000..540b867551
--- /dev/null
+++ b/apps/sim/lib/pptx-renderer/utils/font-stack.test.ts
@@ -0,0 +1,43 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import { cssFontStack } from '@/lib/pptx-renderer/utils/font-stack'
+
+describe('cssFontStack', () => {
+  it('appends metric-compatible substitutes and a generic family', () => {
+    expect(cssFontStack('Calibri')).toBe(
+      '"Calibri", "Carlito", "Helvetica Neue", "Arial", sans-serif'
+    )
+  })
+
+  it('classifies serif and monospace families', () => {
+    expect(cssFontStack('Times New Roman')).toBe(
+      '"Times New Roman", "Liberation Serif", "Times", serif'
+    )
+    expect(cssFontStack('Consolas')).toBe('"Consolas", "Menlo", "Liberation Mono", monospace')
+    expect(cssFontStack('Playfair Display')).toBe('"Playfair Display", serif')
+  })
+
+  it('leaves CSS keywords unquoted', () => {
+    expect(cssFontStack('Segoe UI')).toBe('"Segoe UI", system-ui, "Helvetica Neue", sans-serif')
+  })
+
+  it('defaults unknown families to sans-serif', () => {
+    expect(cssFontStack('Some Brand Font')).toBe('"Some Brand Font", sans-serif')
+  })
+
+  it('sends explicitly sans-named serif-suffixed families to sans-serif', () => {
+    expect(cssFontStack('Open Sans')).toBe('"Open Sans", sans-serif')
+    expect(cssFontStack('Liberation Serif')).toBe('"Liberation Serif", serif')
+  })
+
+  it('passes an existing stack through unchanged', () => {
+    const stacked = cssFontStack('Calibri')
+    expect(cssFontStack(stacked)).toBe(stacked)
+  })
+
+  it('returns empty for blank input', () => {
+    expect(cssFontStack('  ')).toBe('')
+  })
+})
diff --git a/apps/sim/lib/pptx-renderer/utils/font-stack.ts b/apps/sim/lib/pptx-renderer/utils/font-stack.ts
new file mode 100644
index 0000000000..a1fa0b47a4
--- /dev/null
+++ b/apps/sim/lib/pptx-renderer/utils/font-stack.ts
@@ -0,0 +1,69 @@
+/**
+ * Builds a CSS font-family stack for a typeface named inside a pptx. Deck
+ * fonts frequently exist only on the machine that authored the file (Office's
+ * Calibri/Cambria ship with Windows, brand fonts with a designer), and a bare
+ * one-name font-family silently falls back to the page default — every deck
+ * then previews in the same face. Appending metric-compatible substitutes and
+ * a generic family keeps the preview faithful to the deck's intent on
+ * machines without the exact font.
+ */
+
+const CSS_FONT_KEYWORDS = new Set(['system-ui', 'sans-serif', 'serif', 'monospace'])
+
+/** Metric-compatible or visually close substitutes, keyed by lowercase name. */
+const FONT_SUBSTITUTES: Record<string, readonly string[]> = {
+  calibri: ['Carlito', 'Helvetica Neue', 'Arial'],
+  'calibri light': ['Carlito', 'Helvetica Neue', 'Arial'],
+  cambria: ['Caladea', 'Georgia'],
+  'segoe ui': ['system-ui', 'Helvetica Neue'],
+  arial: ['Helvetica Neue', 'Liberation Sans'],
+  helvetica: ['Helvetica Neue', 'Arial'],
+  'times new roman': ['Liberation Serif', 'Times'],
+  'courier new': ['Liberation Mono', 'Courier'],
+  consolas: ['Menlo', 'Liberation Mono'],
+  candara: ['Trebuchet MS'],
+  constantia: ['Georgia'],
+}
+
+const MONO_HINTS = ['mono', 'courier', 'consolas', 'menlo', 'code']
+const SERIF_HINTS = [
+  'times',
+  'georgia',
+  'garamond',
+  'cambria',
+  'caladea',
+  'palatino',
+  'antiqua',
+  'baskerville',
+  'didot',
+  'bodoni',
+  'playfair',
+  'merriweather',
+  'charter',
+  'minion',
+  'serif',
+]
+
+function genericFamilyFor(family: string): string {
+  const lower = family.toLowerCase()
+  if (lower.includes('sans')) return 'sans-serif'
+  if (MONO_HINTS.some((hint) => lower.includes(hint))) return 'monospace'
+  if (SERIF_HINTS.some((hint) => lower.includes(hint))) return 'serif'
+  return 'sans-serif'
+}
+
+export function cssFontStack(family: string): string {
+  const trimmed = family.trim()
+  if (!trimmed) return ''
+  // Already a stack (or the output of this function) — pass through unchanged.
+  if (trimmed.includes(',')) return trimmed
+  const names = [trimmed, ...(FONT_SUBSTITUTES[trimmed.toLowerCase()] ?? [])]
+  const parts: string[] = []
+  for (const name of names) {
+    const css = CSS_FONT_KEYWORDS.has(name) ? name : `"${name}"`
+    if (!parts.includes(css)) parts.push(css)
+  }
+  const generic = genericFamilyFor(trimmed)
+  if (!parts.includes(generic)) parts.push(generic)
+  return parts.join(', ')
+}
diff --git a/apps/sim/lib/table/application/context.test.ts b/apps/sim/lib/table/application/context.test.ts
index 5a41c4a48c..9989379e87 100644
--- a/apps/sim/lib/table/application/context.test.ts
+++ b/apps/sim/lib/table/application/context.test.ts
@@ -122,7 +122,10 @@ describe('table application context', () => {
   it('conceals an asserted cross-workspace table as not found', async () => {
     await expect(
       resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-2' })
-    ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+    ).rejects.toMatchObject({
+      code: 'not_found',
+      message: expect.stringContaining('not found in this workspace'),
+    })
   })
 
   it('conceals a table that does not exist at all', async () => {
@@ -130,7 +133,10 @@ describe('table application context', () => {
 
     await expect(
       resolveActiveTableContext({ tableId: 'missing', assertedWorkspaceId: 'workspace-1' })
-    ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+    ).rejects.toMatchObject({
+      code: 'not_found',
+      message: expect.stringContaining('not found in this workspace'),
+    })
   })
 
   it('conceals a missing table with no asserted workspace', async () => {
@@ -138,7 +144,7 @@ describe('table application context', () => {
 
     await expect(resolveActiveTableContext({ tableId: 'missing' })).rejects.toMatchObject({
       code: 'not_found',
-      message: 'Table not found',
+      message: expect.stringContaining('not found in this workspace'),
     })
     expect(loadWorkspace).not.toHaveBeenCalled()
   })
@@ -150,7 +156,10 @@ describe('table application context', () => {
     const unhandled = await withUnhandledRejectionWatch(async () => {
       await expect(
         resolveActiveTableContext({ tableId: 'table-1', assertedWorkspaceId: 'workspace-2' })
-      ).rejects.toMatchObject({ code: 'not_found', message: 'Table not found' })
+      ).rejects.toMatchObject({
+        code: 'not_found',
+        message: expect.stringContaining('not found in this workspace'),
+      })
     })
 
     expect(unhandled).toEqual([])
diff --git a/apps/sim/lib/table/application/context.ts b/apps/sim/lib/table/application/context.ts
index 7bedaa7bfa..3fb9266467 100644
--- a/apps/sim/lib/table/application/context.ts
+++ b/apps/sim/lib/table/application/context.ts
@@ -27,7 +27,10 @@ export async function resolveTableWorkspaceContext(
 async function requireTable(tableId: string, workspaceId: string | undefined) {
   const table = await getTableById(tableId)
   if (!table || (workspaceId !== undefined && table.workspaceId !== workspaceId)) {
-    throw new OrchestrationError('not_found', 'Table not found')
+    throw new OrchestrationError(
+      'not_found',
+      `Table "${tableId}" not found in this workspace — it may not exist or may belong to a different workspace. Run glob("tables/*") to list the tables you can use here.`
+    )
   }
   return table
 }
diff --git a/apps/sim/lib/table/application/operations.ts b/apps/sim/lib/table/application/operations.ts
index dfc7fc8e69..dcd5879f74 100644
--- a/apps/sim/lib/table/application/operations.ts
+++ b/apps/sim/lib/table/application/operations.ts
@@ -97,6 +97,12 @@ export const tableOperations = {
     workspaceApiKey: 'deny',
     ...COPILOT_PRINCIPAL_POLICY,
   }),
+  moveByVfsPath: defineWorkspaceOperation({
+    id: 'tables.vfs.move',
+    minimumRole: 'write',
+    workspaceApiKey: 'deny',
+    ...COPILOT_PRINCIPAL_POLICY,
+  }),
   deleteByVfsPath: defineWorkspaceOperation({
     id: 'tables.vfs.delete',
     minimumRole: 'write',
diff --git a/apps/sim/lib/table/application/table-vfs.ts b/apps/sim/lib/table/application/table-vfs.ts
index cba5c91866..2e61a3b057 100644
--- a/apps/sim/lib/table/application/table-vfs.ts
+++ b/apps/sim/lib/table/application/table-vfs.ts
@@ -1,16 +1,52 @@
 import { AuditAction, AuditResourceType } from '@sim/audit'
+import { resolvePrincipalAttribution } from '@sim/auth/principal'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { generateRequestId } from '@/lib/core/utils/request'
+import {
+  createResourceVfsFolders,
+  deleteResourceVfsFolders,
+  type FolderedResourceAdapter,
+  resolveResourceRowBySegments,
+  transferResourceVfsItems,
+} from '@/lib/folders/application/resource-vfs'
 import { notifyWorkspaceTablesChanged } from '@/lib/realtime/notify'
 import { defineAuthorizedTableUseCase } from '@/lib/table/application/authorized-table-use-case'
 import { resolveTableWorkspaceContext } from '@/lib/table/application/context'
 import { tableOperations } from '@/lib/table/application/operations'
-import { deleteTable, findActiveTablesByExactName, renameTable } from '@/lib/table/service'
+import {
+  deleteTable,
+  findActiveTablesByExactName,
+  listTables,
+  moveTableToFolder,
+  renameTable,
+} from '@/lib/table/service'
 import type { TableDefinition } from '@/lib/table/types'
 
 interface TableVfsReferenceInput {
   workspaceId: string
   sourceName: string
+  /** Folder segments + leaf name; when present the nested-aware resolver is used. */
+  sourceSegments?: string[]
+}
+
+const tableVfsAdapter: FolderedResourceAdapter = {
+  resourceType: 'table',
+  rootSegment: 'tables',
+  label: 'table',
+  async listRows(workspaceId) {
+    const tables = await listTables(workspaceId)
+    return tables.map((t) => ({ id: t.id, name: t.name, folderId: t.folderId ?? null }))
+  },
+  async moveRow(row, folderId, workspaceId) {
+    await moveTableToFolder(row.id, workspaceId, folderId, generateRequestId())
+  },
+  async renameRow(row, newName, workspaceId) {
+    const renamed = await renameTable(row.id, newName, generateRequestId(), {
+      expectedWorkspaceId: workspaceId,
+      skipNotify: true,
+    })
+    return { id: renamed.id, name: renamed.name }
+  },
 }
 
 export interface RenameTableByVfsPathInput extends TableVfsReferenceInput {
@@ -21,8 +57,20 @@ export type DeleteTableByVfsPathInput = TableVfsReferenceInput
 
 async function resolveTableByVfsName(
   workspaceId: string,
-  sourceName: string
+  sourceName: string,
+  sourceSegments?: string[]
 ): Promise<TableDefinition> {
+  if (sourceSegments && sourceSegments.length > 1) {
+    const row = await resolveResourceRowBySegments(tableVfsAdapter, workspaceId, sourceSegments)
+    const matches = await findActiveTablesByExactName(workspaceId, row.name)
+    const table = matches.find((t) => t.id === row.id)
+    if (!table)
+      throw new OrchestrationError(
+        'not_found',
+        `Table not found at tables/${sourceSegments.join('/')}`
+      )
+    return table
+  }
   const matches = await findActiveTablesByExactName(workspaceId, sourceName)
   if (matches.length > 1) {
     throw new OrchestrationError('conflict', `Table path is ambiguous: tables/${sourceName}`)
@@ -37,7 +85,11 @@ export const renameTableByVfsPath = defineAuthorizedTableUseCase({
   resolveContext: ({ input }: { input: RenameTableByVfsPathInput }) =>
     resolveTableWorkspaceContext(input.workspaceId),
   async execute({ input, context }) {
-    const table = await resolveTableByVfsName(context.workspaceId, input.sourceName)
+    const table = await resolveTableByVfsName(
+      context.workspaceId,
+      input.sourceName,
+      input.sourceSegments
+    )
     const renamed = await renameTable(table.id, input.newName, generateRequestId(), {
       expectedWorkspaceId: context.workspaceId,
       skipNotify: true,
@@ -65,7 +117,11 @@ export const deleteTableByVfsPath = defineAuthorizedTableUseCase({
   resolveContext: ({ input }: { input: DeleteTableByVfsPathInput }) =>
     resolveTableWorkspaceContext(input.workspaceId),
   async execute({ input, context }) {
-    const table = await resolveTableByVfsName(context.workspaceId, input.sourceName)
+    const table = await resolveTableByVfsName(
+      context.workspaceId,
+      input.sourceName,
+      input.sourceSegments
+    )
     const { archived } = await deleteTable(table.id, generateRequestId(), {
       expectedWorkspaceId: context.workspaceId,
       skipNotify: true,
@@ -89,3 +145,96 @@ export const deleteTableByVfsPath = defineAuthorizedTableUseCase({
   }),
   afterSuccess: ({ context }) => notifyWorkspaceTablesChanged(context.workspaceId),
 })
+
+export interface TableVfsPathsInput {
+  workspaceId: string
+  paths: Array<{ source: string; segments: string[] }>
+}
+
+export interface TransferTableVfsItemsInput {
+  workspaceId: string
+  sources: Array<{ source: string; segments: string[] }>
+  destination: { segments: string[]; trailingSlash: boolean }
+}
+
+/** mkdir -p under tables/ — folder invariants live in lib/folders. */
+export const createTableVfsFolders = defineAuthorizedTableUseCase({
+  operation: tableOperations.createFolder,
+  resolveContext: ({ input }: { input: TableVfsPathsInput }) =>
+    resolveTableWorkspaceContext(input.workspaceId),
+  async execute({ principal, input, context }) {
+    const userId = resolvePrincipalAttribution(principal, {
+      workspaceBillingOwnerUserId: context.billedAccountUserId,
+    }).attributedUserId
+    const outcomes = await createResourceVfsFolders(tableVfsAdapter, {
+      workspaceId: context.workspaceId,
+      userId,
+      paths: input.paths,
+    })
+    return { outcomes, workspaceId: context.workspaceId }
+  },
+  projectAudit: ({ result }) => ({
+    action: AuditAction.TABLE_UPDATED,
+    resourceType: AuditResourceType.TABLE,
+    resourceId: result.workspaceId,
+    resourceName: 'tables',
+    description: 'Created table folders',
+    metadata: { op: 'vfs_mkdir', count: result.outcomes.length, source: 'copilot_vfs' },
+  }),
+  afterSuccess: ({ context }) => notifyWorkspaceTablesChanged(context.workspaceId),
+})
+
+/** mv under tables/: rows into folders, folder moves/renames, leaf renames. */
+export const transferTableVfsItems = defineAuthorizedTableUseCase({
+  operation: tableOperations.moveByVfsPath,
+  resolveContext: ({ input }: { input: TransferTableVfsItemsInput }) =>
+    resolveTableWorkspaceContext(input.workspaceId),
+  async execute({ principal, input, context }) {
+    const userId = resolvePrincipalAttribution(principal, {
+      workspaceBillingOwnerUserId: context.billedAccountUserId,
+    }).attributedUserId
+    const outcomes = await transferResourceVfsItems(tableVfsAdapter, {
+      workspaceId: context.workspaceId,
+      userId,
+      sources: input.sources,
+      destination: input.destination,
+    })
+    return { outcomes, workspaceId: context.workspaceId }
+  },
+  projectAudit: ({ result }) => ({
+    action: AuditAction.TABLE_UPDATED,
+    resourceType: AuditResourceType.TABLE,
+    resourceId: result.workspaceId,
+    resourceName: 'tables',
+    description: 'Moved table VFS items',
+    metadata: { op: 'vfs_mv', count: result.outcomes.length, source: 'copilot_vfs' },
+  }),
+  afterSuccess: ({ context }) => notifyWorkspaceTablesChanged(context.workspaceId),
+})
+
+/** rm of tables/ folder paths — recursive via the shared cascade. */
+export const deleteTableVfsFolders = defineAuthorizedTableUseCase({
+  operation: tableOperations.deleteFolder,
+  resolveContext: ({ input }: { input: TableVfsPathsInput }) =>
+    resolveTableWorkspaceContext(input.workspaceId),
+  async execute({ principal, input, context }) {
+    const userId = resolvePrincipalAttribution(principal, {
+      workspaceBillingOwnerUserId: context.billedAccountUserId,
+    }).attributedUserId
+    const outcomes = await deleteResourceVfsFolders(tableVfsAdapter, {
+      workspaceId: context.workspaceId,
+      userId,
+      paths: input.paths,
+    })
+    return { outcomes, workspaceId: context.workspaceId }
+  },
+  projectAudit: ({ result }) => ({
+    action: AuditAction.TABLE_DELETED,
+    resourceType: AuditResourceType.TABLE,
+    resourceId: result.workspaceId,
+    resourceName: 'tables',
+    description: 'Deleted table folders',
+    metadata: { op: 'vfs_rm_folder', count: result.outcomes.length, source: 'copilot_vfs' },
+  }),
+  afterSuccess: ({ context }) => notifyWorkspaceTablesChanged(context.workspaceId),
+})
diff --git a/apps/sim/lib/table/application/tables.ts b/apps/sim/lib/table/application/tables.ts
index 466463ddad..1cf4f0d5c8 100644
--- a/apps/sim/lib/table/application/tables.ts
+++ b/apps/sim/lib/table/application/tables.ts
@@ -219,7 +219,10 @@ export const updateTableUseCase = defineAuthorizedTableUseCase({
 
       const table = await getTableById(current.id)
       if (!table || table.workspaceId !== context.workspaceId) {
-        throw new OrchestrationError('not_found', 'Table not found')
+        throw new OrchestrationError(
+          'not_found',
+          'Table not found in this workspace — run glob("tables/*") to list valid tables'
+        )
       }
       const index =
         resolution?.index ??
@@ -290,7 +293,11 @@ export const deleteTableUseCase = defineAuthorizedTableUseCase({
     const { archived } = await deleteTable(context.table.id, generateRequestId(), {
       expectedWorkspaceId: context.workspaceId,
     })
-    if (!archived) throw new OrchestrationError('not_found', 'Table not found')
+    if (!archived)
+      throw new OrchestrationError(
+        'not_found',
+        'Table not found in this workspace — run glob("tables/*") to list valid tables'
+      )
     return {
       id: context.table.id,
       deleted: true as const,
diff --git a/apps/sim/lib/table/application/views.ts b/apps/sim/lib/table/application/views.ts
index 17326fa35a..97c6f560d6 100644
--- a/apps/sim/lib/table/application/views.ts
+++ b/apps/sim/lib/table/application/views.ts
@@ -40,7 +40,9 @@ export const listTableViewsUseCase = defineAuthorizedTableUseCase({
   async execute({ context }) {
     const columns = (context.table.schema as TableSchema).columns
     const views = await listTableViews(context.table.id, columns, context.workspaceId)
-    return { views, columns }
+    // Both result shapes are live: staging consumers read `columns`, the
+    // copilot table tools read `table`.
+    return { views, columns, table: context.table }
   },
 })
 
@@ -54,8 +56,12 @@ export const readTableViewUseCase = defineAuthorizedTableUseCase({
   async execute({ input, context }) {
     const columns = (context.table.schema as TableSchema).columns
     const view = await getTableView(input.viewId, context.table.id, columns, context.workspaceId)
-    if (!view) throw new OrchestrationError('not_found', 'View not found')
-    return { view, columns }
+    if (!view)
+      throw new OrchestrationError(
+        'not_found',
+        'View not found on this table — call table_views with operation "list_views" for valid view ids'
+      )
+    return { view, columns, table: context.table }
   },
 })
 
@@ -126,7 +132,11 @@ export const updateTableViewUseCase = defineAuthorizedTableUseCase({
         columns,
         context.workspaceId
       )
-      if (!existing) throw new OrchestrationError('not_found', 'View not found')
+      if (!existing)
+        throw new OrchestrationError(
+          'not_found',
+          'View not found on this table — call table_views with operation "list_views" for valid view ids'
+        )
       const view = await updateTableView({
         viewId: input.viewId,
         tableId: context.table.id,
@@ -138,7 +148,11 @@ export const updateTableViewUseCase = defineAuthorizedTableUseCase({
         columns,
         strictRefs: true,
       })
-      if (!view) throw new OrchestrationError('not_found', 'View not found')
+      if (!view)
+        throw new OrchestrationError(
+          'not_found',
+          'View not found on this table — call table_views with operation "list_views" for valid view ids'
+        )
       return {
         view,
         table: context.table,
@@ -179,10 +193,18 @@ export const deleteTableViewUseCase = defineAuthorizedTableUseCase({
       (context.table.schema as TableSchema).columns,
       context.workspaceId
     )
-    if (!existing) throw new OrchestrationError('not_found', 'View not found')
+    if (!existing)
+      throw new OrchestrationError(
+        'not_found',
+        'View not found on this table — call table_views with operation "list_views" for valid view ids'
+      )
     try {
       const deleted = await deleteTableView(input.viewId, context.table.id, context.workspaceId)
-      if (!deleted) throw new OrchestrationError('not_found', 'View not found')
+      if (!deleted)
+        throw new OrchestrationError(
+          'not_found',
+          'View not found on this table — call table_views with operation "list_views" for valid view ids'
+        )
       return { viewId: input.viewId, viewName: existing.name, table: context.table }
     } catch (error) {
       rethrowViewError(error)
diff --git a/apps/sim/lib/table/application/workspace-file-imports.ts b/apps/sim/lib/table/application/workspace-file-imports.ts
index f0e710a066..83fa556ad7 100644
--- a/apps/sim/lib/table/application/workspace-file-imports.ts
+++ b/apps/sim/lib/table/application/workspace-file-imports.ts
@@ -144,7 +144,7 @@ async function resolveSafeSourceFile(
     if (reference.replace(/^\/+/, '').startsWith('uploads/')) {
       throw new OrchestrationError(
         'validation',
-        `Cannot import "${reference}": chat uploads are not workspace files. Use materialize_file to save it to a files/... path first, then pass that canonical path.`
+        `Cannot import "${reference}": chat uploads are not workspace files. Use save_upload to save it to a files/... path first, then pass that canonical path.`
       )
     }
     throw new OrchestrationError(
diff --git a/apps/sim/lib/table/events.attribution.test.ts b/apps/sim/lib/table/events.attribution.test.ts
index e116b737fc..d2616fa917 100644
--- a/apps/sim/lib/table/events.attribution.test.ts
+++ b/apps/sim/lib/table/events.attribution.test.ts
@@ -3,7 +3,12 @@
  */
 import { readdir, readFile } from 'node:fs/promises'
 import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
+
+// Structurally slow — it scans call sites across the repo — so under a fully-parallel local run this file
+// blows the default timeout while passing in isolation and on CI. Give it a
+// real budget instead of letting machine load decide the verdict.
+vi.setConfig({ testTimeout: 30_000 })
 
 /**
  * `signalTableRowsChangedByActor` lets the acting tab skip its own refetch, which is only sound
diff --git a/apps/sim/lib/table/views/service.test.ts b/apps/sim/lib/table/views/service.test.ts
index 438092d39f..5740cb43ae 100644
--- a/apps/sim/lib/table/views/service.test.ts
+++ b/apps/sim/lib/table/views/service.test.ts
@@ -4,6 +4,7 @@
 import { tableViews } from '@sim/db/schema'
 import { dbChainMockFns, queueTableRows, resetDbChainMock } from '@sim/testing'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { TABLE_LIMITS } from '@/lib/table/constants'
 import type { ColumnDefinition, TableViewConfig } from '@/lib/table/types'
 
 const { mockSignalTableViewsChanged } = vi.hoisted(() => ({
@@ -13,7 +14,6 @@ vi.mock('@/lib/table/events', () => ({
   signalTableViewsChanged: mockSignalTableViewsChanged,
 }))
 
-import { TABLE_LIMITS } from '@/lib/table/constants'
 import {
   createTableView,
   deleteTableView,
@@ -141,7 +141,6 @@ describe('table-view mutations signal collaborators', () => {
   })
 
   it('createTableView signals the table after inserting', async () => {
-    queueTableRows(tableViews, [{ total: 0 }]) // the in-lock view-count check
     dbChainMockFns.returning.mockResolvedValueOnce([viewRow])
 
     await createTableView({
@@ -292,11 +291,55 @@ describe('getTableView', () => {
   })
 })
 
-/**
- * `GET /tables/{id}/views` returns every view in one unpaginated page and
- * declares the set bounded. Nothing made that true, so the ceiling is asserted
- * on the write that could cross it.
- */
+describe('view config name/id translation', () => {
+  const columns = [
+    { id: 'col_a', name: 'status', type: 'string' },
+    { id: 'col_b', name: 'due', type: 'date' },
+  ] as never[]
+
+  it('round-trips a config between id and name domains', async () => {
+    const { viewConfigIdsToNames, viewConfigNamesToIds } = await import('@/lib/table/views/service')
+    const stored = {
+      filter: {
+        any: [
+          { field: 'col_a', op: 'eq', value: 'Open' },
+          { all: [{ field: 'col_b', op: 'isNotNull' }] },
+        ],
+      },
+      sort: [{ field: 'col_b', direction: 'desc' }],
+      hiddenColumns: ['col_a'],
+    } as never
+    const named = viewConfigIdsToNames(stored, columns as never)
+    expect(named.filter).toEqual({
+      any: [
+        { field: 'status', op: 'eq', value: 'Open' },
+        { all: [{ field: 'due', op: 'isNotNull' }] },
+      ],
+    })
+    expect(named.sort).toEqual([{ field: 'due', direction: 'desc' }])
+    expect(named.hiddenColumns).toEqual(['status'])
+    expect(viewConfigNamesToIds(named, columns as never)).toEqual(stored)
+  })
+
+  it('passes stale ids through on read but rejects unknown names on write', async () => {
+    const { viewConfigIdsToNames, viewConfigNamesToIds } = await import('@/lib/table/views/service')
+    const withStale = { filter: { all: [{ field: 'col_gone', op: 'isNull' }] } } as never
+    expect(
+      (
+        viewConfigIdsToNames(withStale, columns as never).filter as never as {
+          all: { field: string }[]
+        }
+      ).all[0].field
+    ).toBe('col_gone')
+    expect(() =>
+      viewConfigNamesToIds(
+        { filter: { all: [{ field: 'nope', op: 'isNull' }] } } as never,
+        columns as never
+      )
+    ).toThrow(/Unknown column/)
+  })
+})
+
 describe('saved-view ceiling', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -342,12 +385,6 @@ describe('saved-view ceiling', () => {
   })
 })
 
-/**
- * A saved config's column references are stored as stable column ids, but the
- * v2 wire is column-NAME-keyed like every other v2 row/data surface. The write
- * path translates; anything it cannot resolve is a caller mistake and must be
- * refused rather than stored and quietly dropped on the next read.
- */
 describe('view config column-reference normalization', () => {
   const columns: ColumnDefinition[] = [
     { id: 'col_a', name: 'Name', type: 'text' },
diff --git a/apps/sim/lib/table/views/service.ts b/apps/sim/lib/table/views/service.ts
index 030ac25e91..dfa4f339b1 100644
--- a/apps/sim/lib/table/views/service.ts
+++ b/apps/sim/lib/table/views/service.ts
@@ -668,3 +668,85 @@ export async function deleteTableView(
   }
   return deleted
 }
+
+/**
+ * All of a workspace's views in one query, keyed by tableId — the snapshot
+ * materializer's shape (per-table listTableViews would be N queries). Configs
+ * are returned RAW (id-domain, unpruned); callers translate/prune with each
+ * table's own columns.
+ */
+export async function listTableViewsByWorkspace(
+  workspaceId: string
+): Promise<Map<string, Array<typeof tableViews.$inferSelect>>> {
+  const rows = await db
+    .select()
+    .from(tableViews)
+    .where(eq(tableViews.workspaceId, workspaceId))
+    .orderBy(asc(tableViews.createdAt), asc(tableViews.id))
+  const byTable = new Map<string, Array<typeof tableViews.$inferSelect>>()
+  for (const row of rows) {
+    const list = byTable.get(row.tableId) ?? []
+    list.push(row)
+    byTable.set(row.tableId, list)
+  }
+  return byTable
+}
+
+function mapPredicateFields(
+  node: PredicateNode,
+  mapField: (field: string) => string
+): PredicateNode {
+  if ('all' in node) return { all: node.all.map((child) => mapPredicateFields(child, mapField)) }
+  if ('any' in node) return { any: node.any.map((child) => mapPredicateFields(child, mapField)) }
+  const leaf = node as Predicate
+  return { ...leaf, field: mapField(leaf.field) }
+}
+
+/**
+ * Stored (id-domain) view config → the column-NAME domain agents speak.
+ * Unknown ids pass through unchanged, mirroring pruneViewConfig's philosophy
+ * for filters: surfacing a stale reference beats silently widening the view.
+ */
+export function viewConfigIdsToNames(
+  config: TableViewConfig,
+  columns: ColumnDefinition[]
+): TableViewConfig {
+  const nameById = new Map(columns.map((col) => [getColumnId(col), col.name]))
+  const toName = (field: string) => nameById.get(field) ?? field
+  const out: TableViewConfig = { ...config }
+  if (config.filter) out.filter = mapPredicateFields(config.filter, toName) as typeof config.filter
+  if (config.sort) out.sort = config.sort.map((s) => ({ ...s, field: toName(s.field) }))
+  if (config.hiddenColumns) out.hiddenColumns = config.hiddenColumns.map(toName)
+  return out
+}
+
+/**
+ * Agent-supplied (name-domain) view config → the id-domain stored shape.
+ * Unknown column names are an error — a saved view with a dangling reference
+ * is exactly the artifact this translation exists to prevent.
+ */
+export function viewConfigNamesToIds(
+  config: TableViewConfig,
+  columns: ColumnDefinition[]
+): TableViewConfig {
+  const idByName = new Map(columns.map((col) => [col.name, getColumnId(col)]))
+  const unknown = new Set<string>()
+  const toId = (field: string) => {
+    const id = idByName.get(field)
+    if (!id) {
+      unknown.add(field)
+      return field
+    }
+    return id
+  }
+  const out: TableViewConfig = { ...config }
+  if (config.filter) out.filter = mapPredicateFields(config.filter, toId) as typeof config.filter
+  if (config.sort) out.sort = config.sort.map((s) => ({ ...s, field: toId(s.field) }))
+  if (config.hiddenColumns) out.hiddenColumns = config.hiddenColumns.map(toId)
+  if (unknown.size > 0) {
+    throw new TableViewValidationError(
+      `Unknown column(s): ${[...unknown].join(', ')}. Use exact column names from get_schema.`
+    )
+  }
+  return out
+}
diff --git a/apps/sim/lib/uploads/archive.test.ts b/apps/sim/lib/uploads/archive.test.ts
index d3b807e0c7..4668605fae 100644
--- a/apps/sim/lib/uploads/archive.test.ts
+++ b/apps/sim/lib/uploads/archive.test.ts
@@ -525,7 +525,7 @@ describe('decompressArchiveBufferToWorkspaceFiles', () => {
   })
 
   it('rolls back the folders it created when an upload fails mid-extraction', async () => {
-    // `materialize_file` refuses to re-extract into a root folder that still has any
+    // `save_upload` refuses to re-extract into a root folder that still has any
     // child, so a folder left behind by a failed run turns every retry into
     // "already extracted" until a human deletes the tree by hand.
     const buffer = await buildZip({ 'a/one.txt': 'first', 'b/two.txt': 'second' })
diff --git a/apps/sim/lib/uploads/archive.ts b/apps/sim/lib/uploads/archive.ts
index 2a6b4ff138..cb449efa7b 100644
--- a/apps/sim/lib/uploads/archive.ts
+++ b/apps/sim/lib/uploads/archive.ts
@@ -443,7 +443,7 @@ export async function decompressArchiveBufferToWorkspaceFiles(
   // Uploads themselves can still fail mid-loop (storage/DB errors, quota crossed
   // by another writer), so a failure rolls back every file written so far *and*
   // every folder this call materialized — callers and their retries must never
-  // observe a partial tree. Leftover folders are not cosmetic: `materialize_file`
+  // observe a partial tree. Leftover folders are not cosmetic: `save_upload`
   // refuses to re-extract into a root folder that still has any child, so a
   // half-extracted tree would make every retry fail until a human deletes it.
   const folderIdCache = new Map<string, string | null>()
diff --git a/apps/sim/lib/uploads/contexts/workspace/track-chat-upload.test.ts b/apps/sim/lib/uploads/contexts/workspace/track-chat-upload.test.ts
index 50d1571246..24750a15f7 100644
--- a/apps/sim/lib/uploads/contexts/workspace/track-chat-upload.test.ts
+++ b/apps/sim/lib/uploads/contexts/workspace/track-chat-upload.test.ts
@@ -417,7 +417,7 @@ describe('trackChatUpload', () => {
 
     /**
      * The ownership lookup and the write are separate statements, so a
-     * concurrent `materialize_file` can flip the row to context='workspace'
+     * concurrent `save_upload` can flip the row to context='workspace'
      * in between. The UPDATE must re-assert every ownership predicate rather
      * than matching on the captured row id alone, or it would drag a saved
      * workspace file back into chat scope.
diff --git a/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts b/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts
index 2b67cf0189..78a1a642ce 100644
--- a/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts
+++ b/apps/sim/lib/uploads/contexts/workspace/workspace-file-manager.ts
@@ -943,7 +943,7 @@ export async function trackChatUpload(
           if (updated.length === 0) {
             // The ownership lookup is a separate statement, so re-assert every
             // predicate here — this UPDATE is the atomic check. A concurrent
-            // `materialize_file` flips the same row to context='workspace' and
+            // `save_upload` flips the same row to context='workspace' and
             // clears chatId; matching on id alone would drag that saved file back
             // into chat scope, hiding it from the Files listing and re-exposing it
             // to the chat-delete cascade.
diff --git a/apps/sim/lib/uploads/contexts/workspace/workspace-file-secret-provenance.ts b/apps/sim/lib/uploads/contexts/workspace/workspace-file-secret-provenance.ts
index f1034b8261..913011c750 100644
--- a/apps/sim/lib/uploads/contexts/workspace/workspace-file-secret-provenance.ts
+++ b/apps/sim/lib/uploads/contexts/workspace/workspace-file-secret-provenance.ts
@@ -625,8 +625,10 @@ export async function getBoundWorkspaceFileSecretProvenance(
         eq(workspaceFiles.id, identity.fileId),
         eq(workspaceFiles.key, identity.key),
         eq(workspaceFiles.workspaceId, workspaceId),
-        eq(workspaceFiles.context, identity.context),
-        isNull(workspaceFiles.deletedAt)
+        eq(workspaceFiles.context, identity.context)
+        // Deliberately no deletedAt filter: `id` alone pins the exact row, and
+        // recently-deleted/ reads are a real surface — excluding soft-deleted
+        // rows made every archived file read as provenance-unknown and refused.
       )
     )
     .limit(1)
diff --git a/apps/sim/lib/uploads/utils/file-utils.server.ts b/apps/sim/lib/uploads/utils/file-utils.server.ts
index 34d91991a4..e20b1900b4 100644
--- a/apps/sim/lib/uploads/utils/file-utils.server.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.server.ts
@@ -13,6 +13,9 @@ import {
 } from '@/lib/core/utils/stream-limits'
 import { StorageService } from '@/lib/uploads'
 import { isExecutionFile } from '@/lib/uploads/contexts/execution/utils'
+// This file is lazily imported back by workspace-file-manager, so that edge
+// stays dynamic on their side; these statics do not close a load-time cycle.
+import { parseWorkspaceFileKey } from '@/lib/uploads/contexts/workspace/workspace-file-manager'
 import {
   isModelSafeWorkspaceFileKey,
   MODEL_UNSAFE_WORKSPACE_FILE_ERROR_MESSAGE,
@@ -30,6 +33,8 @@ import {
   type RawFileInput,
   resolveTrustedFileContext,
 } from '@/lib/uploads/utils/file-utils'
+import { isSimPageSource, SIM_PAGE_CONTENT_TYPE } from '@/lib/workspace-files/page-compile'
+import { renderSimPageDocumentWithAssets } from '@/lib/workspace-files/page-document.server'
 import { verifyFileAccess } from '@/app/api/files/authorization'
 import type { UserFile } from '@/executor/types'
 
@@ -415,6 +420,23 @@ export async function downloadServableFileFromStorage(
     maxBytes: options.maxBytes,
   })
 
+  // The pdf model for pages: a page file stores its source and downloads
+  // resolve to the fully styled compiled document, like a .pdf key resolving
+  // to its binary. Sim pages store an extensionless name (the record type
+  // marks them); legacy pages still carry .html.
+  if (userFile.name.toLowerCase().endsWith('.html') || userFile.type === SIM_PAGE_CONTENT_TYPE) {
+    const text = buffer.toString('utf8')
+    if (isSimPageSource(text)) {
+      const workspaceId = userFile.key
+        ? (parseWorkspaceFileKey(userFile.key) ?? undefined)
+        : undefined
+      return {
+        buffer: Buffer.from(await renderSimPageDocumentWithAssets(text, { workspaceId }), 'utf8'),
+        contentType: 'text/html',
+      }
+    }
+  }
+
   // Cheap pre-filter so only generated-doc candidates pay for the heavier resolver
   // import below.
   if (!isRenderableDocumentName(userFile.name)) {
@@ -422,9 +444,6 @@ export async function downloadServableFileFromStorage(
     return { buffer, contentType: userFile.type || getMimeTypeFromExtension(ext) }
   }
 
-  const { parseWorkspaceFileKey } = await import(
-    '@/lib/uploads/contexts/workspace/workspace-file-manager'
-  )
   const workspaceId = userFile.key
     ? (parseWorkspaceFileKey(userFile.key) ??
       extractWorkspaceIdFromExecutionKey(userFile.key) ??
diff --git a/apps/sim/lib/uploads/utils/file-utils.ts b/apps/sim/lib/uploads/utils/file-utils.ts
index 98914498af..cc549e2640 100644
--- a/apps/sim/lib/uploads/utils/file-utils.ts
+++ b/apps/sim/lib/uploads/utils/file-utils.ts
@@ -286,7 +286,7 @@ export function isArchiveFileName(filename: string): boolean {
  * `files/`, so this points at the explicit one-time extract step.
  */
 export function buildArchiveExtractGuidance(name: string): string {
-  return `"${name}" is a .zip archive — its contents can't be read directly. Extract it once with materialize_file(fileNames: ["${name}"], operation: "extract"), then read the unpacked files under files/ (e.g. glob("files/<archive>/**") then read("files/<archive>/<path>/content")).`
+  return `"${name}" is a .zip archive — its contents can't be read directly. Extract it once with save_upload(fileNames: ["${name}"], operation: "extract"), then read the unpacked files under files/ (e.g. glob("files/<archive>/**") then read("files/<archive>/<path>/content")).`
 }
 
 const EXTENSION_TO_MIME: Record<string, string> = {
diff --git a/apps/sim/lib/uploads/utils/validation.ts b/apps/sim/lib/uploads/utils/validation.ts
index ce41ca2053..e9b21adb81 100644
--- a/apps/sim/lib/uploads/utils/validation.ts
+++ b/apps/sim/lib/uploads/utils/validation.ts
@@ -78,6 +78,7 @@ export const SUPPORTED_CODE_EXTENSIONS = [
   'prettierrc',
   'eslintrc',
   'mmd',
+  'chart',
 ] as const
 
 export type SupportedCodeExtension = (typeof SUPPORTED_CODE_EXTENSIONS)[number]
@@ -97,7 +98,7 @@ export const SUPPORTED_VIDEO_EXTENSIONS = ['mp4', 'mov', 'avi', 'mkv', 'webm'] a
 
 /**
  * Archive formats accepted as chat attachments. A `.zip` is stored once in
- * uploads/; the agent must extract it (materialize_file operation "extract") to
+ * uploads/; the agent must extract it (save_upload operation "extract") to
  * decompress it into workspace files/ before reading its contents.
  */
 export const SUPPORTED_ARCHIVE_EXTENSIONS = ['zip'] as const
@@ -223,7 +224,7 @@ export const CHAT_ACCEPT_ATTRIBUTE = [
 /**
  * Accept attribute for the mothership copilot input only. Archives are scoped
  * here — NOT in {@link CHAT_ACCEPT_ATTRIBUTE} — because only the copilot flow
- * has zip handling (materialize_file "extract"); a zip picked in a workflow or
+ * has zip handling (save_upload "extract"); a zip picked in a workflow or
  * deployed chat would flow into execution, where no parser exists.
  */
 export const MOTHERSHIP_ACCEPT_ATTRIBUTE = [
diff --git a/apps/sim/lib/workflows/application/run-workflow-from-copilot.test.ts b/apps/sim/lib/workflows/application/run-workflow-from-copilot.test.ts
index dcec0fdb8a..90d3bf6a3b 100644
--- a/apps/sim/lib/workflows/application/run-workflow-from-copilot.test.ts
+++ b/apps/sim/lib/workflows/application/run-workflow-from-copilot.test.ts
@@ -148,6 +148,71 @@ describe('Copilot workflow run application commands', () => {
     )
   })
 
+  it('runs under a caller-claimed execution id and stamps its copilot correlation', async () => {
+    // Set when the request handler wins the workflow-tool claim and runs the
+    // tool server-side. The claimed id must BE the child execution id, and the
+    // log row must carry the tool-call correlation, or a server-run tool call
+    // is unattributable where a browser-run one is not.
+    await runWorkflowFromCopilot.execute({
+      principal,
+      input: {
+        workflowId: 'workflow-1',
+        assertedWorkspaceId: 'workspace-1',
+        useDraftState: true,
+        lifecycle: {
+          ...lifecycle,
+          boundExecution: {
+            executionId: 'claimed-execution-1',
+            copilotToolCallId: 'tool-call-1',
+          },
+        },
+        hasWorkflowInput: false,
+        useMockPayload: true,
+      },
+    })
+
+    expect(mocks.admission).toHaveBeenCalledWith(
+      { userId: 'user-1', billingAttribution: undefined },
+      'workspace-1',
+      'claimed-execution-1'
+    )
+    expect(mocks.executeWorkflow).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'workflow-1' }),
+      'request-1',
+      { source: 'mock' },
+      'user-1',
+      expect.objectContaining({
+        trustedExecutionCorrelation: {
+          executionId: 'claimed-execution-1',
+          requestId: 'request-1',
+          source: 'workflow',
+          workflowId: 'workflow-1',
+          triggerType: 'copilot',
+          copilotToolCallId: 'tool-call-1',
+        },
+      }),
+      'claimed-execution-1'
+    )
+  })
+
+  it('does not stamp a correlation for an ordinary browser-routed run', async () => {
+    await runWorkflowFromCopilot.execute({
+      principal,
+      input: {
+        workflowId: 'workflow-1',
+        assertedWorkspaceId: 'workspace-1',
+        useDraftState: true,
+        lifecycle,
+        hasWorkflowInput: false,
+        useMockPayload: true,
+      },
+    })
+
+    expect(mocks.executeWorkflow.mock.calls.at(-1)?.[4]).not.toHaveProperty(
+      'trustedExecutionCorrelation'
+    )
+  })
+
   it('rechecks current permission before loading execution state', async () => {
     mocks.permission.mockResolvedValueOnce(null)
 
diff --git a/apps/sim/lib/workflows/application/run-workflow-from-copilot.ts b/apps/sim/lib/workflows/application/run-workflow-from-copilot.ts
index cfb818c1cc..b9ab1322b5 100644
--- a/apps/sim/lib/workflows/application/run-workflow-from-copilot.ts
+++ b/apps/sim/lib/workflows/application/run-workflow-from-copilot.ts
@@ -34,6 +34,20 @@ export interface CopilotWorkflowRunLifecycle {
   billingAttribution?: BillingAttributionSnapshot
   resolvedSecretTraceRegistry?: ResolvedSecretTraceRegistry
   abortSignal?: AbortSignal
+  /**
+   * Execution identity the caller already claimed for this Copilot tool call.
+   *
+   * Set only when the copilot request handler runs a workflow tool server-side
+   * because no browser picked it up. Using the claimed id as the child
+   * execution id — and stamping the matching trusted correlation — keeps a
+   * server-run tool call as attributable in `workflow_execution_logs` as a
+   * browser-routed one, which `/api/workflows/[id]/execute` does for its own
+   * claim at the equivalent point.
+   */
+  boundExecution?: {
+    executionId: string
+    copilotToolCallId: string
+  }
 }
 
 interface BaseCopilotRunInput {
@@ -207,7 +221,11 @@ async function executeCopilotRun(params: {
   }
 }): Promise<ExecutionResult> {
   const actorUserId = requirePrincipalSubjectUserId(params.principal)
-  const childExecutionId = generateId()
+  const boundExecution = params.input.lifecycle.boundExecution
+  // Reuse the caller's already-claimed execution id so the claim and the log
+  // row describe the same run; otherwise mint our own as before.
+  const childExecutionId = boundExecution?.executionId ?? generateId()
+  const requestId = generateRequestId()
   const admission = await prepareWorkflowExecutionAdmission(
     {
       userId: actorUserId,
@@ -229,7 +247,7 @@ async function executeCopilotRun(params: {
         workspaceId: params.context.workspaceId,
         variables: params.context.workflow.variables || {},
       },
-      generateRequestId(),
+      requestId,
       params.executionInput,
       actorUserId,
       {
@@ -246,6 +264,18 @@ async function executeCopilotRun(params: {
         ...(trustedInitialResolvedSecretTraceProvenance
           ? { trustedInitialResolvedSecretTraceProvenance }
           : {}),
+        ...(boundExecution
+          ? {
+              trustedExecutionCorrelation: {
+                executionId: childExecutionId,
+                requestId,
+                source: 'workflow' as const,
+                workflowId: params.context.workflowId,
+                triggerType: 'copilot',
+                copilotToolCallId: boundExecution.copilotToolCallId,
+              },
+            }
+          : {}),
       },
       childExecutionId
     )
diff --git a/apps/sim/lib/workflows/custom-blocks/operations.ts b/apps/sim/lib/workflows/custom-blocks/operations.ts
index b934d6428b..041a08db68 100644
--- a/apps/sim/lib/workflows/custom-blocks/operations.ts
+++ b/apps/sim/lib/workflows/custom-blocks/operations.ts
@@ -244,7 +244,7 @@ export async function listCustomBlocksWithInputs(
 /**
  * The custom block bound to a workflow (with live-derived input fields), or `null`
  * when the workflow isn't published as a block. One block per workflow is enforced
- * at publish time. Used by the copilot deploy_custom_block tool.
+ * at publish time. Used by the copilot publish_custom_block tool.
  */
 export async function getCustomBlockWithInputsByWorkflowId(
   workflowId: string
diff --git a/apps/sim/lib/workflows/orchestration/chat-deploy.test.ts b/apps/sim/lib/workflows/orchestration/chat-deploy.test.ts
index 098305930d..612ae65b3e 100644
--- a/apps/sim/lib/workflows/orchestration/chat-deploy.test.ts
+++ b/apps/sim/lib/workflows/orchestration/chat-deploy.test.ts
@@ -46,7 +46,7 @@ describe('performChatDeploy password guards', () => {
   })
 
   /**
-   * The copilot `deploy_chat` tool reaches this function without a route
+   * The copilot `deploy_as_chat` tool reaches this function without a route
    * contract, so these guards are the only thing standing between an agent and
    * a deployment nobody can log into.
    */
diff --git a/apps/sim/lib/workflows/orchestration/chat-deploy.ts b/apps/sim/lib/workflows/orchestration/chat-deploy.ts
index 6a28925145..923b0ee346 100644
--- a/apps/sim/lib/workflows/orchestration/chat-deploy.ts
+++ b/apps/sim/lib/workflows/orchestration/chat-deploy.ts
@@ -60,28 +60,16 @@ export interface PerformChatDeployResult {
  * Deploys a chat: deploys the underlying workflow via `performFullDeploy`,
  * encrypts passwords, creates or updates the chat record, fires telemetry,
  * and records an audit entry. Both the chat API route and the copilot
- * `deploy_chat` tool must use this function.
+ * `deploy_as_chat` tool must use this function.
  */
 export async function performChatDeploy(
   params: ChatDeployPayload
 ): Promise<PerformChatDeployResult> {
-  const {
-    workflowId,
-    userId,
-    identifier,
-    title,
-    description = '',
-    authType = 'public',
-    password,
-    allowedEmails = [],
-    outputConfigs = [],
-    includeThinking = false,
-    includeToolCalls = false,
-  } = params
+  const { workflowId, userId, identifier, title, password } = params
 
   /**
    * Validate the password here rather than only at the HTTP boundary. The
-   * copilot `deploy_chat` tool reaches this function without going through a
+   * copilot `deploy_as_chat` tool reaches this function without going through a
    * route contract, so a whitespace-only or over-long password would otherwise
    * be encrypted and stored — and neither can ever be submitted through the
    * chat login form, permanently locking visitors out of the deployment.
@@ -93,10 +81,60 @@ export async function performChatDeploy(
     }
   }
 
+  /**
+   * Redeploys merge: any field the caller omitted keeps the existing chat's
+   * value instead of being reset to a default. Before this, a copilot
+   * `deploy_as_chat` call that changed only the title silently flipped an
+   * email/sso-protected chat back to public, wiped its allowlist and output
+   * configuration, and reset the welcome customizations — the caller had no
+   * way to know, because none of those fields were readable back. Defaults
+   * apply only when there is no existing deployment to preserve.
+   */
+  const [existingDeployment] = await db
+    .select()
+    .from(chat)
+    .where(and(eq(chat.workflowId, workflowId), isNull(chat.archivedAt)))
+    .limit(1)
+
+  const authType =
+    params.authType ??
+    (existingDeployment?.authType as ChatDeployPayload['authType'] | undefined) ??
+    'public'
+  const description =
+    params.description !== undefined ? params.description : (existingDeployment?.description ?? '')
+  const allowedEmails =
+    params.allowedEmails ?? (existingDeployment?.allowedEmails as string[] | null) ?? []
+  const outputConfigs =
+    params.outputConfigs ??
+    (existingDeployment?.outputConfigs as Array<{ blockId: string; path: string }> | null) ??
+    []
+  const includeThinking = params.includeThinking ?? existingDeployment?.includeThinking ?? false
+  const includeToolCalls = params.includeToolCalls ?? existingDeployment?.includeToolCalls ?? false
+
+  // Per-field merge (params over existing over defaults): callers routinely
+  // send a customizations object with only some fields set, and a hard default
+  // for the rest silently reset the chat's colors and welcome message.
+  const existingCustomizations =
+    existingDeployment?.customizations &&
+    typeof existingDeployment.customizations === 'object' &&
+    !Array.isArray(existingDeployment.customizations)
+      ? (existingDeployment.customizations as {
+          primaryColor?: string
+          welcomeMessage?: string
+          imageUrl?: string
+        })
+      : undefined
+  const mergedImageUrl = params.customizations?.imageUrl || existingCustomizations?.imageUrl
   const customizations = {
-    primaryColor: params.customizations?.primaryColor || 'var(--brand-hover)',
-    welcomeMessage: params.customizations?.welcomeMessage || 'Hi there! How can I help you today?',
-    ...(params.customizations?.imageUrl ? { imageUrl: params.customizations.imageUrl } : {}),
+    primaryColor:
+      params.customizations?.primaryColor ||
+      existingCustomizations?.primaryColor ||
+      'var(--brand-hover)',
+    welcomeMessage:
+      params.customizations?.welcomeMessage ||
+      existingCustomizations?.welcomeMessage ||
+      'Hi there! How can I help you today?',
+    ...(mergedImageUrl ? { imageUrl: mergedImageUrl } : {}),
   }
 
   /**
@@ -162,16 +200,10 @@ export async function performChatDeploy(
     encryptedPassword = encrypted
   }
 
-  const [existingDeployment] = await db
-    .select()
-    .from(chat)
-    .where(and(eq(chat.workflowId, workflowId), isNull(chat.archivedAt)))
-    .limit(1)
-
   /**
    * A password-protected chat must end up with a stored password. Both HTTP
    * routes already reject this; without the same guard here a copilot
-   * `deploy_chat` call could create one with no password, which fails closed at
+   * `deploy_as_chat` call could create one with no password, which fails closed at
    * login with an opaque "Authentication configuration error".
    */
   if (authType === 'password' && !encryptedPassword && !existingDeployment?.password) {
@@ -309,7 +341,7 @@ export interface PerformChatUndeployResult {
 
 /**
  * Undeploys a chat: deletes the chat record and records an audit entry.
- * Both the chat manage DELETE route and the copilot `deploy_chat` undeploy
+ * Both the chat manage DELETE route and the copilot `deploy_as_chat` undeploy
  * action must use this function.
  */
 export async function performChatUndeploy(
diff --git a/apps/sim/lib/workflows/sanitization/json-sanitizer.test.ts b/apps/sim/lib/workflows/sanitization/json-sanitizer.test.ts
index 4ac13e4a49..2e8ff1b59d 100644
--- a/apps/sim/lib/workflows/sanitization/json-sanitizer.test.ts
+++ b/apps/sim/lib/workflows/sanitization/json-sanitizer.test.ts
@@ -5,7 +5,7 @@ import { resetUrlsMock, urlsMockFns } from '@sim/testing'
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import type { WorkflowState } from '@/stores/workflows/workflow/types'
-import { TRIGGER_WEBHOOK_URL_FIELD } from '@/triggers/constants'
+import { TRIGGER_ROUTING_FIELD, TRIGGER_WEBHOOK_URL_FIELD } from '@/triggers/constants'
 
 beforeAll(() => {
   urlsMockFns.mockGetBaseUrl.mockReturnValue('https://sim.test')
@@ -282,3 +282,45 @@ describe('sanitizeForCopilot webhook trigger URL', () => {
     expect(result.blocks['gh-1'].inputs ?? {}).not.toHaveProperty(TRIGGER_WEBHOOK_URL_FIELD)
   })
 })
+
+describe('sanitizeForCopilot credential-routed trigger routing', () => {
+  it('synthesizes the read-only routing note for a slack_v2 block in trigger mode', () => {
+    const result = sanitizeForCopilot(
+      makeSingleBlockWorkflow('slack-1', {
+        type: 'slack_v2',
+        name: 'Slack Trigger',
+        enabled: true,
+        triggerMode: true,
+        subBlocks: {
+          selectedTriggerId: { id: 'selectedTriggerId', type: 'short-input', value: 'slack_oauth' },
+          customBotCredential: {
+            id: 'customBotCredential',
+            type: 'oauth-input',
+            value: 'cred-123',
+          },
+        },
+      })
+    )
+
+    const routing = result.blocks['slack-1'].inputs?.[TRIGGER_ROUTING_FIELD] as
+      | Record<string, unknown>
+      | undefined
+    expect(routing?.model).toBe('credential-routed')
+    expect(routing?.selectedCredentialId).toBe('cred-123')
+    expect(String(routing?.note)).toContain('no per-workflow webhook URL')
+    expect(result.blocks['slack-1'].inputs ?? {}).not.toHaveProperty(TRIGGER_WEBHOOK_URL_FIELD)
+  })
+
+  it('omits the routing note when the block is not in trigger mode', () => {
+    const result = sanitizeForCopilot(
+      makeSingleBlockWorkflow('slack-1', {
+        type: 'slack_v2',
+        name: 'Slack Action',
+        enabled: true,
+        subBlocks: {},
+      })
+    )
+
+    expect(result.blocks['slack-1'].inputs ?? {}).not.toHaveProperty(TRIGGER_ROUTING_FIELD)
+  })
+})
diff --git a/apps/sim/lib/workflows/sanitization/json-sanitizer.ts b/apps/sim/lib/workflows/sanitization/json-sanitizer.ts
index 5a63706a44..bd4f2377b1 100644
--- a/apps/sim/lib/workflows/sanitization/json-sanitizer.ts
+++ b/apps/sim/lib/workflows/sanitization/json-sanitizer.ts
@@ -12,8 +12,8 @@ import type {
   WorkflowState,
 } from '@/stores/workflows/workflow/types'
 import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
-import { TRIGGER_WEBHOOK_URL_FIELD } from '@/triggers/constants'
-import { blockAdvertisesWebhookUrl } from '@/triggers/webhook-url'
+import { TRIGGER_ROUTING_FIELD, TRIGGER_WEBHOOK_URL_FIELD } from '@/triggers/constants'
+import { blockAdvertisesWebhookUrl, resolveBlockTriggerId } from '@/triggers/webhook-url'
 
 /**
  * Sanitized workflow state for copilot (removes all UI-specific data)
@@ -364,6 +364,35 @@ function resolveTriggerWebhookUrl(blockId: string, block: BlockState): string |
   }
 }
 
+/** Trigger ids that deliver by credential routing — no per-workflow URL exists. */
+const CREDENTIAL_ROUTED_TRIGGER_IDS = new Set(['slack_oauth'])
+
+/**
+ * Derived routing note for trigger blocks that have NO per-workflow webhook URL
+ * (credential-routed delivery, e.g. Slack v2's `slack_oauth`). Mirrors what the
+ * setup wizard shows: events arrive at the selected credential's endpoint — a
+ * custom bot's per-credential Request URL (surfaced as `requestUrl` on that
+ * credential in environment/credentials.json) or the shared Sim-app endpoint
+ * routed by Slack workspace. Surfaced as the read-only
+ * {@link TRIGGER_ROUTING_FIELD} input; rejected on write by `edit_workflow`.
+ */
+function resolveTriggerRouting(block: BlockState): Record<string, unknown> | null {
+  const triggerId = resolveBlockTriggerId(block)
+  if (!triggerId || !CREDENTIAL_ROUTED_TRIGGER_IDS.has(triggerId)) return null
+  const selected =
+    block.subBlocks?.customBotCredential?.value ?? block.subBlocks?.manualBotCredential?.value
+  const selectedCredentialId = typeof selected === 'string' && selected.length > 0 ? selected : null
+  return {
+    model: 'credential-routed',
+    note:
+      'This trigger has no per-workflow webhook URL. Events are delivered via the selected Slack credential: ' +
+      'a custom bot posts to its per-credential Request URL (the requestUrl field on that credential in ' +
+      'environment/credentials.json — the same URL the setup wizard shows for Slack Event Subscriptions); ' +
+      'a Sim-app connection routes by Slack workspace automatically. Derived at read time; not an editable field.',
+    ...(selectedCredentialId ? { selectedCredentialId } : {}),
+  }
+}
+
 /**
  * Convert internal condition handle (condition-{uuid}) to simple format (if, else-if-0, else)
  * Uses 0-indexed numbering for else-if conditions
@@ -587,6 +616,10 @@ export function sanitizeForCopilot(
       if (webhookUrl) {
         inputs[TRIGGER_WEBHOOK_URL_FIELD] = webhookUrl
       }
+      const triggerRouting = resolveTriggerRouting(block)
+      if (triggerRouting) {
+        inputs[TRIGGER_ROUTING_FIELD] = triggerRouting
+      }
     }
 
     // Check if this is a loop or parallel (has children)
diff --git a/apps/sim/lib/workflows/search-replace/indexer.test.ts b/apps/sim/lib/workflows/search-replace/indexer.test.ts
index 15039e4f68..7a6c3fe397 100644
--- a/apps/sim/lib/workflows/search-replace/indexer.test.ts
+++ b/apps/sim/lib/workflows/search-replace/indexer.test.ts
@@ -114,6 +114,46 @@ describe('indexWorkflowSearchMatches', () => {
     expect(blockNameMatches[0]?.fieldTitle).toBe('Block name')
   })
 
+  it('matches a block name containing a non-breaking space against a typed space', () => {
+    const workflow = {
+      blocks: {
+        'nbsp-1': {
+          id: 'nbsp-1',
+          type: 'function',
+          name: 'Load\u00a0Prompt',
+          position: { x: 0, y: 0 },
+          subBlocks: {},
+          outputs: {},
+          enabled: true,
+        },
+      },
+    } as ReturnType<typeof createSearchReplaceWorkflowFixture>
+
+    const matches = indexWorkflowSearchMatches({
+      workflow,
+      query: 'load prompt',
+      mode: 'text',
+      blockConfigs: SEARCH_REPLACE_BLOCK_CONFIGS,
+    })
+
+    const blockNameMatches = matches.filter((match) => match.target.kind === 'block-name')
+    // The raw value keeps the original characters so replacements stay exact.
+    expect(blockNameMatches.map((match) => match.rawValue)).toEqual(['Load\u00a0Prompt'])
+  })
+
+  it('ignores accidental leading/trailing whitespace in the query', () => {
+    const workflow = createSearchReplaceWorkflowFixture()
+
+    const matches = indexWorkflowSearchMatches({
+      workflow,
+      query: ' agent ',
+      mode: 'text',
+      blockConfigs: SEARCH_REPLACE_BLOCK_CONFIGS,
+    })
+
+    expect(matches.some((match) => match.target.kind === 'block-name')).toBe(true)
+  })
+
   it('does not include block-name matches in resource-only mode', () => {
     const workflow = createSearchReplaceWorkflowFixture()
 
diff --git a/apps/sim/lib/workflows/search-replace/indexer.ts b/apps/sim/lib/workflows/search-replace/indexer.ts
index 5fc1a9ffdf..18de77eca6 100644
--- a/apps/sim/lib/workflows/search-replace/indexer.ts
+++ b/apps/sim/lib/workflows/search-replace/indexer.ts
@@ -10,6 +10,7 @@ import {
 } from '@/lib/workflows/search-replace/json-value-fields'
 import {
   buildBlockNamesByReferencePrefix,
+  foldSearchWhitespace,
   getResourceKindForSubBlock,
   matchesSearchText,
   parseInlineReferences,
@@ -56,8 +57,14 @@ import {
   type ToolParameterConfig,
 } from '@/tools/params'
 
+/**
+ * Whitespace is folded before comparison (see {@link foldSearchWhitespace}):
+ * the fold is one-to-one, so ranges found in the normalized string index the
+ * original text correctly.
+ */
 function normalizeForSearch(value: string, caseSensitive: boolean): string {
-  return caseSensitive ? value : value.toLowerCase()
+  const folded = foldSearchWhitespace(value)
+  return caseSensitive ? folded : folded.toLowerCase()
 }
 
 function findTextRanges(value: string, query: string, caseSensitive: boolean) {
@@ -1241,7 +1248,7 @@ export function indexWorkflowSearchMatches(
 ): WorkflowSearchMatch[] {
   const {
     workflow,
-    query,
+    query: rawQuery,
     mode = 'all',
     caseSensitive = false,
     includeResourceMatchesWithoutQuery = false,
@@ -1256,6 +1263,10 @@ export function indexWorkflowSearchMatches(
     mcpToolNamesById,
   } = options
 
+  // Match on the trimmed query: an accidental leading/trailing space (easy to
+  // type, impossible to see in the search box) must not hide every match.
+  const query = rawQuery?.trim()
+
   const matches: WorkflowSearchMatch[] = []
   const resourceQueryEnabled = includeResourceMatchesWithoutQuery || Boolean(query)
   const blockNamesByReferencePrefix = buildBlockNamesByReferencePrefix(workflow.blocks)
diff --git a/apps/sim/lib/workflows/search-replace/resources/references.ts b/apps/sim/lib/workflows/search-replace/resources/references.ts
index 2f7b053e74..1adabcf9fa 100644
--- a/apps/sim/lib/workflows/search-replace/resources/references.ts
+++ b/apps/sim/lib/workflows/search-replace/resources/references.ts
@@ -140,13 +140,27 @@ export function parseStructuredResourceReferences(
   return parseWorkflowSearchSubBlockResources(value, subBlockConfig, selectorContext)
 }
 
+/**
+ * Maps every Unicode whitespace character to a plain space, one-to-one.
+ * Agent-authored block names and values routinely carry non-breaking or
+ * narrow spaces that render identically to " " but never equal a typed
+ * space, silently hiding matches. The replacement is length-preserving
+ * (every `\s` character is a single UTF-16 unit), so indexes into the
+ * folded string remain valid ranges into the original.
+ */
+export function foldSearchWhitespace(value: string): string {
+  return value.replace(/\s/g, ' ')
+}
+
 export function matchesSearchText(
   candidate: string,
   query: string | undefined,
   caseSensitive = false
 ): boolean {
   if (!query) return true
-  const source = caseSensitive ? candidate : candidate.toLowerCase()
-  const target = caseSensitive ? query : query.toLowerCase()
+  const foldedCandidate = foldSearchWhitespace(candidate)
+  const foldedQuery = foldSearchWhitespace(query)
+  const source = caseSensitive ? foldedCandidate : foldedCandidate.toLowerCase()
+  const target = caseSensitive ? foldedQuery : foldedQuery.toLowerCase()
   return source.includes(target)
 }
diff --git a/apps/sim/lib/workflows/search-replace/resources/resolvers.ts b/apps/sim/lib/workflows/search-replace/resources/resolvers.ts
index 96464f3bd8..29368d4185 100644
--- a/apps/sim/lib/workflows/search-replace/resources/resolvers.ts
+++ b/apps/sim/lib/workflows/search-replace/resources/resolvers.ts
@@ -1,3 +1,4 @@
+import { foldSearchWhitespace } from '@/lib/workflows/search-replace/resources/references'
 import type {
   WorkflowSearchMatch,
   WorkflowSearchMatchKind,
@@ -241,7 +242,10 @@ export function workflowSearchMatchMatchesQuery(
   if (!trimmedQuery) return false
   if (match.kind === 'text') return true
 
-  const normalize = (value: string) => (caseSensitive ? value : value.toLowerCase())
+  const normalize = (value: string) => {
+    const folded = foldSearchWhitespace(value)
+    return caseSensitive ? folded : folded.toLowerCase()
+  }
   const searchable =
     match.resource?.kind === 'workflow-reference' || match.resource?.kind === 'environment'
       ? [match.displayLabel, match.rawValue, match.searchText]
diff --git a/apps/sim/lib/workspace-files/artifact-stylesheet.test.ts b/apps/sim/lib/workspace-files/artifact-stylesheet.test.ts
new file mode 100644
index 0000000000..5c5d133961
--- /dev/null
+++ b/apps/sim/lib/workspace-files/artifact-stylesheet.test.ts
@@ -0,0 +1,299 @@
+/**
+ * @vitest-environment node
+ */
+
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import {
+  ARTIFACT_TOKENS,
+  SIM_ARTIFACT_SHELL,
+  SIM_ARTIFACT_STYLESHEET,
+  simTokenOverrides,
+  usesSimArtifactStyles,
+} from '@/lib/workspace-files/artifact-stylesheet'
+import { buildHtmlPreviewDocument } from '@/app/workspace/[workspaceId]/files/components/file-viewer/preview-panel'
+
+const MARKED =
+  '<!DOCTYPE html><html><head><meta name="sim-artifact"><title>T</title></head><body><div class="page"></div></body></html>'
+const PLAIN = '<!DOCTYPE html><html><head><title>T</title></head><body><p>hi</p></body></html>'
+
+describe('usesSimArtifactStyles', () => {
+  it('detects the opt-in marker regardless of quoting and attribute order', () => {
+    expect(usesSimArtifactStyles(MARKED)).toBe(true)
+    expect(usesSimArtifactStyles("<meta content='x' name='sim-artifact'>")).toBe(true)
+  })
+
+  it('leaves a page that never asked for it alone', () => {
+    expect(usesSimArtifactStyles(PLAIN)).toBe(false)
+  })
+})
+
+describe('buildHtmlPreviewDocument', () => {
+  it('injects the stylesheet only for a page that opted in', () => {
+    expect(buildHtmlPreviewDocument(MARKED)).toContain('--surface-active')
+    expect(buildHtmlPreviewDocument(PLAIN)).not.toContain('--surface-active')
+  })
+
+  // The page keys off [data-theme]; prefers-color-scheme inside an opaque-origin
+  // frame follows the OS, so without this the page and the app disagree.
+  it('stamps the app theme onto the document root', () => {
+    expect(buildHtmlPreviewDocument(PLAIN, 'dark')).toContain('<html data-theme="dark">')
+    expect(buildHtmlPreviewDocument(PLAIN, 'light')).toContain('<html data-theme="light">')
+  })
+
+  it('preserves attributes the page already set on <html>', () => {
+    const withLang = buildHtmlPreviewDocument(
+      '<html lang="en"><head></head><body></body></html>',
+      'dark'
+    )
+    expect(withLang).toContain('data-theme="dark"')
+    expect(withLang).toContain('lang="en"')
+  })
+
+  it('never overrides a theme the page pinned itself', () => {
+    const pinned = buildHtmlPreviewDocument(
+      '<html data-theme="light"><head></head><body></body></html>',
+      'dark'
+    )
+    expect(pinned).toContain('data-theme="light"')
+    expect(pinned).not.toContain('data-theme="dark"')
+  })
+
+  it('keeps the sandbox guarantees on every path', () => {
+    for (const doc of [MARKED, PLAIN, '<p>bare fragment</p>']) {
+      const built = buildHtmlPreviewDocument(doc)
+      expect(built).toContain("default-src 'none'")
+      expect(built).toContain('about:srcdoc')
+    }
+  })
+
+  // The stylesheet is a floor, not a ceiling: a page that wants its own design
+  // still wins, so it must land before the page's own <style>.
+  it('injects the stylesheet ahead of the page styles', () => {
+    const built = buildHtmlPreviewDocument(
+      '<html><head><meta name="sim-artifact"><style>body{color:red}</style></head><body></body></html>'
+    )
+    expect(built.indexOf('--surface-active')).toBeLessThan(built.indexOf('body{color:red}'))
+  })
+})
+
+describe('docs shell', () => {
+  it('ships the heading-derived chrome only to pages that opted in', () => {
+    expect(buildHtmlPreviewDocument(MARKED)).toContain('art-cols')
+    expect(buildHtmlPreviewDocument(PLAIN)).not.toContain('art-cols')
+  })
+
+  // Rails and search are generated from the document's own headings, so a page
+  // never hand-writes nav that can fall out of step with them.
+  it('derives both rails from headings rather than authored markup', () => {
+    expect(SIM_ARTIFACT_SHELL).toContain("querySelectorAll('h2, h3')")
+    expect(SIM_ARTIFACT_SHELL).toContain('On this page')
+  })
+
+  it('does nothing to a page that did not ask for the docs layout', () => {
+    expect(SIM_ARTIFACT_SHELL).toContain('.page[data-layout="docs"]')
+  })
+
+  // The sandbox blocks the network; a box implying it searched the workspace
+  // would be lying about what it does.
+  it('has no left sidebar or filter chrome', () => {
+    expect(SIM_ARTIFACT_SHELL).not.toContain('Filter sections')
+    expect(SIM_ARTIFACT_SHELL).not.toContain("dataset.rail = 'nav'")
+  })
+
+  // The clerk TOC: a track threaded through the items and a full-strength copy
+  // clipped to the active range — the clip window is what animates on scroll.
+  it('draws the clerk track and animates the active segment via the clip window', () => {
+    expect(SIM_ARTIFACT_SHELL).toContain('toc-track')
+    expect(SIM_ARTIFACT_SHELL).toContain('--track-top')
+    expect(SIM_ARTIFACT_SHELL).toContain('--track-bottom')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('clip-path: polygon(0 var(--track-top')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('transition: clip-path')
+  })
+
+  // fumadocs clerk geometry: h2 lines at 8px, h3 at 16px, items indented 20/32.
+  it('indents TOC items and track lines by heading depth', () => {
+    expect(SIM_ARTIFACT_SHELL).toContain("depth === '2' ? 8 : 16")
+    expect(SIM_ARTIFACT_STYLESHEET).toContain(
+      '.toc-items a[data-depth="2"] { padding-left: 20px; }'
+    )
+    expect(SIM_ARTIFACT_STYLESHEET).toContain(
+      '.toc-items a[data-depth="3"] { padding-left: 32px; }'
+    )
+  })
+})
+
+describe('docs fidelity', () => {
+  it('keeps every grid template at equal specificity so wider tiers win', () => {
+    // The 560px tier selects .art-cols:not(.no-side-nav) (0,2,0); a wider
+    // tier written as bare .art-cols (0,1,0) loses despite its media query,
+    // leaving the 2-column template active and wrapping the TOC to the next
+    // grid row. Every template rule must carry the same specificity.
+    const templates = SIM_ARTIFACT_STYLESHEET.split('\n').filter((line) =>
+      line.includes('grid-template-columns:')
+    )
+    expect(templates.length).toBeGreaterThanOrEqual(2)
+    for (const line of templates) {
+      const selector = (line.trim().split('{')[0] ?? '').trim()
+      if (!selector.startsWith('.art-cols')) continue
+      // Every template rule uses the same bare selector, so the widest
+      // media query always wins the cascade.
+      expect(selector).toBe('.art-cols')
+    }
+  })
+
+  // The docs table treatment: header rule on --border, row rules on
+  // --surface-active, no outer chrome.
+  it('styles tables as the docs divider tables', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain(
+      'thead th { font-weight: 600; color: var(--text-primary); border-bottom: 1px solid var(--border)'
+    )
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('border-bottom: 1px solid var(--surface-active)')
+  })
+
+  // The card/stat vocabulary is retired — a figure worth stating is a sentence
+  // or a table row, and legacy pages fall back to plain prose.
+  it('carries no card or stat chrome', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('.card')
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('.stat')
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('.grid')
+  })
+
+  // The sidebar left the shell; nothing should keep its pill styles alive.
+  it('carries no sidebar rail styles', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('data-rail="nav"')
+  })
+
+  // Set navigation is the docs' top tab row. A long set must scroll
+  // sideways — never wrap or truncate — with no scrollbar chrome; and the
+  // retired prev/next arrows must stay gone.
+  it('keeps the tab row one scrollable line and carries no arrow chrome', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('overflow-x: auto; scrollbar-width: none;')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('.page-tabs::-webkit-scrollbar { display: none; }')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('.page-tab.is-active')
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('.page-nav')
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('.pa-nav')
+    expect(SIM_ARTIFACT_SHELL).not.toContain('page-actions')
+  })
+
+  // Pages live inside the app: the PLATFORM stack, not the docs' webfont —
+  // Inter next to emcn/sim chrome read as foreign.
+  it('uses the platform font stack', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('--font-sans: ui-sans-serif, -apple-system')
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain('"Inter"')
+  })
+
+  // The docs' prose anchor: 500 weight, 1.5px underline offset 3.5px, hover
+  // fades to 80% — with chrome links reset back to plain navigation.
+  it('styles content links as the docs prose anchors', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('text-decoration-thickness: 1.5px')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('text-underline-offset: 3.5px')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('a:hover { opacity: 0.8; }')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('.rail a { font-weight: 400')
+  })
+
+  // The docs' figure.shiki shell and Code.Viewer metrics.
+  it('frames fenced code like the docs', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('background: var(--code-surface)')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('line-height: 21px')
+    expect(SIM_ARTIFACT_STYLESHEET).toContain(
+      '.codeblock-copy.is-copied { color: var(--brand-accent); }'
+    )
+    expect(SIM_ARTIFACT_SHELL).toContain('M14.25 0.75H2.75') // emcn Duplicate
+    expect(SIM_ARTIFACT_SHELL).toContain('M18.25 2.75L7.25 15.75') // emcn Check
+  })
+
+  // The docs' inline chip: no border, color unset so linked code keeps the
+  // link color.
+  it('keeps the inline code chip borderless and color-neutral', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain('padding: 0.125rem 0.375rem')
+    expect(SIM_ARTIFACT_STYLESHEET).not.toContain(
+      'code {\n  font-family: var(--font-mono);\n  font-size: 0.84em'
+    )
+  })
+
+  it('carries the platform selection color', () => {
+    expect(SIM_ARTIFACT_STYLESHEET).toContain(
+      '::selection { background-color: var(--selection-bg); }'
+    )
+  })
+})
+
+describe('simTokenOverrides', () => {
+  it('emits nothing off the browser, leaving the sheet fallbacks in place', () => {
+    expect(simTokenOverrides('light')).toBe('')
+  })
+})
+
+/** Extracts the body of the first block whose opening selector matches. */
+function cssBlock(css: string, start: RegExp): string {
+  const match = start.exec(css)
+  if (!match) throw new Error(`selector not found: ${start}`)
+  const open = css.indexOf('{', match.index) + 1
+  let depth = 1
+  let end = open
+  while (depth > 0) {
+    const ch = css[end]
+    if (ch === '{') depth += 1
+    if (ch === '}') depth -= 1
+    end += 1
+  }
+  return css.slice(open, end - 1)
+}
+
+/** First declaration per token, comments stripped, whitespace normalized. */
+function tokenMap(block: string): Map<string, string> {
+  const map = new Map<string, string>()
+  for (const decl of block.matchAll(/(--[\w-]+)\s*:\s*([^;]+);/g)) {
+    const value = decl[2]
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/\s+/g, ' ')
+      .trim()
+      .toLowerCase()
+    if (!map.has(decl[1])) map.set(decl[1], value)
+  }
+  return map
+}
+
+// The sheet's token values are MIRRORS of globals.css — the surfaces the live
+// overrides cannot reach (downloaded/shared/standalone documents, and the
+// theme the app is not currently in) render from them. A silent retune of
+// globals.css is invisible until a shared page looks off-brand; this makes it
+// a named test failure instead.
+describe('token mirrors stay in sync with globals.css', () => {
+  const globals = readFileSync(join(process.cwd(), 'app/_styles/globals.css'), 'utf8')
+  const appLight = tokenMap(cssBlock(globals, /:root,\s*\n\s*\.light\s*\{/))
+  const appDark = tokenMap(cssBlock(globals, /\n {2}\.dark\s*\{/))
+  const sheetLight = tokenMap(cssBlock(SIM_ARTIFACT_STYLESHEET, /^:root \{/))
+  const sheetMediaDark = tokenMap(
+    cssBlock(SIM_ARTIFACT_STYLESHEET, /:root:not\(\[data-theme="light"\]\)\s*\{/)
+  )
+  const sheetAttrDark = tokenMap(
+    cssBlock(SIM_ARTIFACT_STYLESHEET, /:root\[data-theme="dark"\]\s*\{/)
+  )
+
+  it('mirrors every consumed token in both themes', () => {
+    const drift: string[] = []
+    for (const token of ARTIFACT_TOKENS) {
+      const appLightValue = appLight.get(token)
+      const appDarkValue = appDark.get(token)
+      if (!appLightValue || !appDarkValue) {
+        drift.push(
+          `${token}: not defined in globals.css (light=${appLightValue}, dark=${appDarkValue})`
+        )
+        continue
+      }
+      if (sheetLight.get(token) !== appLightValue) {
+        drift.push(`${token} light: sheet=${sheetLight.get(token)} app=${appLightValue}`)
+      }
+      if (sheetMediaDark.get(token) !== appDarkValue) {
+        drift.push(`${token} dark(media): sheet=${sheetMediaDark.get(token)} app=${appDarkValue}`)
+      }
+      if (sheetAttrDark.get(token) !== appDarkValue) {
+        drift.push(`${token} dark(stamp): sheet=${sheetAttrDark.get(token)} app=${appDarkValue}`)
+      }
+    }
+    expect(drift).toEqual([])
+  })
+})
diff --git a/apps/sim/lib/workspace-files/artifact-stylesheet.ts b/apps/sim/lib/workspace-files/artifact-stylesheet.ts
new file mode 100644
index 0000000000..0a34163ee9
--- /dev/null
+++ b/apps/sim/lib/workspace-files/artifact-stylesheet.ts
@@ -0,0 +1,948 @@
+/**
+ * The stylesheet Sim injects into an agent-authored page that opts in.
+ *
+ * A faithful port of the docs site's look, verified against the real chrome:
+ * apps/docs/app/global.css (tokens, sidebar item metrics, heading scale, the
+ * divider-based table treatment, clerk TOC colors/weights) and the installed
+ * fumadocs-ui@16.8.5 (dist/components/toc/clerk.js for the TOC track
+ * geometry and its animated active segment, dist/components/callout.js for
+ * the callout shape, dist/layouts/docs/page/slots/toc.js for the TOC column).
+ * A page opting in renders as a page of the Sim docs, not a third design
+ * system.
+ *
+ * Never written into the stored file: the preview injects it live and
+ * page-document.ts bakes it into standalone/share/download documents, so
+ * restyling every existing page is a change to this constant.
+ */
+
+/** Marker a page carries to request {@link SIM_ARTIFACT_STYLESHEET}. */
+const ARTIFACT_MARKER = /<meta[^>]+name=["']sim-artifact["'][^>]*>/i
+
+export function usesSimArtifactStyles(content: string): boolean {
+  return ARTIFACT_MARKER.test(content)
+}
+
+/**
+ * The app tokens the sheet consumes, under their platform names. The frame has
+ * an opaque origin and inherits no CSS, so values must be carried across — but
+ * hand-copying them is how the docs app already drifted (its global.css mirrors
+ * these under a "keep in sync" comment). Reading the computed values at render
+ * time keeps `globals.css` the single definition: change it and every page
+ * follows on next render, with no build step and nothing for CI to check.
+ */
+export const ARTIFACT_TOKENS = [
+  '--bg',
+  '--surface-1',
+  '--surface-2',
+  '--surface-3',
+  '--surface-4',
+  '--surface-5',
+  '--surface-hover',
+  '--surface-active',
+  '--border',
+  '--text-primary',
+  '--text-secondary',
+  '--text-body',
+  '--text-muted',
+  '--text-icon',
+  '--text-error',
+  '--brand-accent',
+  '--brand-secondary',
+  '--warning',
+  '--badge-success-bg',
+  '--badge-success-text',
+  '--badge-orange-bg',
+  '--badge-orange-text',
+  '--badge-error-bg',
+  '--badge-error-text',
+  '--badge-gray-bg',
+  '--badge-gray-text',
+  '--badge-blue-bg',
+  '--badge-blue-text',
+  '--badge-purple-bg',
+  '--badge-purple-text',
+  '--text-icon-muted',
+  '--code-bg',
+  '--selection-bg',
+] as const
+
+/**
+ * A block rebinding the tokens to the app's live values, or empty off the
+ * browser (SSR, tests) where the sheet's own mirrors stand in. Scoped to the
+ * app's CURRENT theme only: the computed values ARE that theme's palette, so
+ * pinning them under both `[data-theme]` states would freeze the page's own
+ * theme toggle — flipping the attribute must fall back to the sheet's palette
+ * for the other theme. `:root[data-theme=...]` outranks the sheet's bare
+ * `:root` block, so injection order relative to the sheet does not matter.
+ */
+export function simTokenOverrides(theme: 'dark' | 'light'): string {
+  if (typeof window === 'undefined' || typeof document === 'undefined') return ''
+  const computed = getComputedStyle(document.documentElement)
+  const declarations = ARTIFACT_TOKENS.map((token) => {
+    const value = computed.getPropertyValue(token).trim()
+    return value ? `${token}:${value}` : ''
+  }).filter(Boolean)
+  if (declarations.length === 0) return ''
+  return `:root[data-theme="${theme}"]{${declarations.join(';')}}`
+}
+
+/**
+ * Token mirrors first (light on bare `:root`, dark under the guarded media
+ * query and again under `[data-theme="dark"]` so an explicit stamp wins both
+ * ways), then base elements, then the docs chrome. A colour defined solely
+ * inside a media or `[data-theme]` block would be undefined in the other theme
+ * — the classic unreadable-page bug — so everything lands on `:root` first.
+ *
+ * Docs-verified values, with their sources:
+ * - headings: global.css "Content typography" (1.5rem/550, 1.25rem/500,
+ *   16px/470 on --text-body), body prose on --text-secondary at 1rem/1.75.
+ * - tables: global.css "Tables — clean divider-based style" (no outer chrome,
+ *   th 600 on --text-primary over a --border rule, td on --text-secondary
+ *   over --surface-active rules, last row bare, 0.5rem 0.75rem cells, 14px).
+ * - clerk TOC: global.css #nd-toc overrides (13px links, muted, primary when
+ *   active) over fumadocs' clerk geometry.
+ * - callout: fumadocs callout.js (rounded-xl bordered card, 14px, a rounded
+ *   2px color bar down the start edge) with the docs' shadow removal.
+ * - layout: global.css --spacing-fd-container 1400px, TOC column 268px,
+ *   --content-gap 2.25rem. There is no left sidebar — the TOC is the page's
+ *   only navigation rail.
+ * The face is the PLATFORM's, not the docs' webfont: --font-sans is the
+ * system stack (pages live inside the app, and Inter read as foreign next to
+ * emcn/sim chrome). The docs' geometry survives; only the face differs.
+ */
+/**
+ * The dark palette, mirrored from globals.css and emitted under BOTH dark
+ * selectors (the prefers-color-scheme fallback and the explicit
+ * data-theme="dark" stamp) from this single constant — two hand-maintained
+ * copies is how the badge colors already diverged between them. The
+ * mirror-vs-app sync is enforced by artifact-stylesheet.test.ts, which parses
+ * globals.css and fails naming any token that drifts.
+ */
+const DARK_TOKEN_DECLARATIONS = `
+  --bg: #1b1b1b;
+  --surface-1: #1e1e1e;
+  --surface-2: #232323;
+  --surface-3: #242424;
+  --surface-4: #292929;
+  --surface-5: #363636;
+  --surface-hover: #262626;
+  --surface-active: #2c2c2c;
+  --border: #444444;
+  --text-primary: #e6e6e6;
+  --text-secondary: #cccccc;
+  --text-body: #c1c1c1;
+  --text-muted: #6e6e6e;
+  --text-icon: #969696;
+  --text-error: #ef4444;
+  --brand-accent: #33c482;
+  --brand-secondary: #33b4ff;
+  --warning: #ff6600;
+  --badge-success-bg: rgba(34, 197, 94, 0.2);
+  --badge-success-text: #86efac;
+  --badge-orange-bg: rgba(249, 115, 22, 0.2);
+  --badge-orange-text: #fdba74;
+  --badge-error-bg: #551a1a;
+  --badge-error-text: #fca5a5;
+  --badge-gray-bg: #3a3a3a;
+  --badge-gray-text: #a8a8a8;
+  --badge-blue-bg: rgba(59, 130, 246, 0.2);
+  --badge-blue-text: #93c5fd;
+  --badge-purple-bg: rgba(168, 85, 247, 0.2);
+  --badge-purple-text: #d8b4fe;
+  --text-icon-muted: #949494;
+  --code-bg: #1f1f1f;
+  --code-surface: var(--code-bg);
+  --selection-bg: #264f78;`
+
+export const SIM_ARTIFACT_STYLESHEET = `
+:root {
+  --bg: #fefefe;
+  --surface-1: #fbfbfb;
+  --surface-2: #ffffff;
+  --surface-3: #f7f7f7;
+  --surface-4: #f5f5f5;
+  --surface-5: #f3f3f3;
+  --surface-hover: #f2f2f2;
+  --surface-active: #ececec;
+  --border: #d8d8d8;
+  --text-primary: #1a1a1a;
+  --text-secondary: #525252;
+  --text-body: #434343;
+  --text-muted: #7a7a7a;
+  --text-icon: #5a5a5a;
+  --text-error: #ef4444;
+  --brand-accent: #33c482;
+  --brand-secondary: #33b4ff;
+  --warning: #ea580c;
+  --badge-success-bg: #bbf7d0;
+  --badge-success-text: #15803d;
+  --badge-orange-bg: #fed7aa;
+  --badge-orange-text: #c2410c;
+  --badge-error-bg: #fecaca;
+  --badge-error-text: #dc2626;
+  --badge-gray-bg: #e7e5e4;
+  --badge-gray-text: #57534e;
+  --badge-blue-bg: #bfdbfe;
+  --badge-blue-text: #1d4ed8;
+  --badge-purple-bg: #e9d5ff;
+  --badge-purple-text: #7c3aed;
+  --text-icon-muted: #5c5c5c;
+  --code-bg: #f5f5f5;
+  --code-surface: var(--surface-5);
+  --selection-bg: #add6ff;
+  /* The PLATFORM stack, not the docs' webfont: pages live inside the app,
+     and emcn/sim render the system face — Inter here read as foreign. The
+     docs' geometry survives; the face is the platform's. */
+  --font-sans: ui-sans-serif, -apple-system, system-ui, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  --text-caption: 12px;
+  --text-small: 13px;
+  --text-sm: 14px;
+  --text-md: 16px;
+}
+@media (prefers-color-scheme: dark) {
+  :root:not([data-theme="light"]) {${DARK_TOKEN_DECLARATIONS}
+  }
+}
+:root[data-theme="dark"] {${DARK_TOKEN_DECLARATIONS}
+}
+
+* { box-sizing: border-box; scrollbar-width: thin; }
+/* scrollbar-gutter keeps the centered column from shifting when content
+   length toggles the viewport scrollbar (e.g. switching between a long and a
+   short tab). */
+html { scroll-behavior: smooth; scroll-padding-top: 72px; scrollbar-gutter: stable; }
+@media (prefers-reduced-motion: reduce) {
+  html { scroll-behavior: auto; }
+  * { transition: none !important; animation: none !important; }
+}
+body {
+  margin: 0;
+  background: var(--bg);
+  color: var(--text-secondary);
+  font-family: var(--font-sans);
+  font-size: 1rem;
+  line-height: 1.75;
+  -webkit-font-smoothing: antialiased;
+}
+h1, h2, h3, h4 { text-wrap: balance; }
+h1 { font-size: 1.5rem; font-weight: 600; letter-spacing: -0.02em; color: var(--text-primary); line-height: 1.25; margin: 0 0 0.75rem; }
+h2 { font-size: 1.25rem; font-weight: 500; letter-spacing: -0.015em; color: var(--text-primary); margin: 2.5rem 0 0.9rem; }
+h3, h4 { font-size: var(--text-md); font-weight: 500; letter-spacing: -0.01em; color: var(--text-body); margin: 1.75rem 0 0.5rem; }
+p, li { max-width: 70ch; }
+p { margin: 0 0 1rem; }
+/* Content links — the docs' prose anchor (fumadocs prose, compiled): 500
+   weight, 1.5px underline offset 3.5px in the text color, 80% opacity on
+   hover. Chrome links (rails, TOC, pagination, copy) reset this below. */
+a {
+  color: var(--text-primary);
+  font-weight: 500;
+  text-decoration: underline;
+  text-decoration-color: var(--text-primary);
+  text-decoration-thickness: 1.5px;
+  text-underline-offset: 3.5px;
+  transition: opacity 0.2s;
+}
+a:hover { opacity: 0.8; }
+strong { color: var(--text-primary); font-weight: 600; }
+hr { border: 0; border-top: 1px solid var(--border); margin: 3em 0; }
+hr + * { margin-top: 0; }
+/* Lists — the docs' prose metrics: 1rem/1.625em indents, muted markers. */
+ul { padding-inline-start: 1rem; list-style-type: disc; margin: 1.25em 0; }
+ol { padding-inline-start: 1.625em; list-style-type: decimal; margin: 1.25em 0; }
+li { margin: 0.5em 0; }
+ol > li { padding-inline-start: 0.375em; }
+ul ul, ul ol, ol ul, ol ol { margin: 0.75em 0; }
+ol > li::marker { font-weight: 400; color: var(--text-muted); }
+ul > li::marker { color: var(--text-muted); }
+/* Blockquote — the docs' prose quote: 500 italic in the heading color over a
+   4px border, with real quote marks. */
+blockquote {
+  margin: 1.6em 0;
+  padding-inline-start: 1em;
+  font-weight: 500;
+  font-style: italic;
+  color: var(--text-primary);
+  border-inline-start: 0.25rem solid var(--border);
+}
+blockquote p:first-of-type::before { content: open-quote; }
+blockquote p:last-of-type::after { content: close-quote; }
+blockquote code { color: inherit; }
+/* Inline code chip — the docs' exact chip: no border, color unset so code
+   inside a link keeps the link color instead of sitting on it. */
+code {
+  font-family: var(--font-mono);
+  font-size: 0.875em;
+  font-weight: 400;
+  background-color: var(--surface-5);
+  border-radius: 4px;
+  padding: 0.125rem 0.375rem;
+}
+/* Fenced code — the docs' figure.shiki shell and Code.Viewer metrics: 13px
+   on a 21px line box over --code-surface, no shadow. The shell upgrades
+   these into .codeblock frames with a copy control; bare pre (report
+   layout) carries the same shell itself. */
+pre {
+  background: var(--code-surface);
+  border: 1px solid var(--border);
+  border-radius: 0.5rem;
+  padding: 0.875rem 1rem;
+  overflow: auto;
+  max-height: 600px;
+  font-size: var(--text-small);
+  line-height: 21px;
+  tab-size: 2;
+  -webkit-overflow-scrolling: touch;
+}
+pre code { background: none; padding: 0; border-radius: 0; font-size: inherit; display: block; width: fit-content; min-width: 100%; }
+::selection { background-color: var(--selection-bg); }
+
+/* Tables — the docs' divider-based treatment: no outer chrome, a --border
+   rule under the header, --surface-active rules between rows, bare last row. */
+table { border-collapse: collapse; border-spacing: 0; width: 100%; font-size: var(--text-sm); }
+th, td { text-align: left; padding: 0.5rem 0.75rem; line-height: 1.5; }
+/* The docs' tables read their first column as the row's label. */
+tbody td:first-child { font-weight: 500; color: var(--text-primary); }
+thead th { font-weight: 600; color: var(--text-primary); border-bottom: 1px solid var(--border); white-space: nowrap; }
+td { color: var(--text-secondary); border-bottom: 1px solid var(--surface-active); }
+tbody tr:last-child td { border-bottom: none; }
+td.num, th.num { text-align: right; font-variant-numeric: tabular-nums; }
+figure { margin: 2rem 0; }
+figure svg { display: block; width: 100%; height: auto; color: var(--text-body); }
+figcaption { font-size: 0.875em; line-height: 1.4285714; color: var(--text-primary); margin-top: 0.8571429em; max-width: 70ch; }
+:focus-visible { outline: 2px solid var(--brand-secondary); outline-offset: 2px; }
+
+/* Layout — the docs frame: a 1400px container, 300px sidebar, 268px TOC. */
+.page { max-width: 1400px; margin: 0 auto; padding: 2.5rem 1.5rem 4rem; }
+.page[data-layout="report"] { max-width: 760px; }
+.page[data-layout="docs"] { padding-top: 0; }
+
+.scroll { overflow-x: auto; }
+
+/* Components ---------------------------------------------------------------- */
+.eyebrow {
+  font-size: var(--text-caption);
+  color: var(--text-muted);
+  margin: 0 0 0.75rem;
+}
+.lede { font-size: 1.05rem; color: var(--text-secondary); max-width: 64ch; margin: 0 0 1.75rem; }
+/* The emcn Badge, verbatim: status colors on rounded-md, md-size metrics. */
+.pill {
+  display: inline-flex;
+  align-items: center;
+  font-size: var(--text-caption);
+  line-height: 1.35;
+  padding: 2px 9px;
+  border-radius: 6px;
+  background: var(--badge-gray-bg);
+  color: var(--badge-gray-text);
+}
+.pill--ok { background: var(--badge-success-bg); color: var(--badge-success-text); }
+.pill--warn { background: var(--badge-orange-bg); color: var(--badge-orange-text); }
+.pill--bad { background: var(--badge-error-bg); color: var(--badge-error-text); }
+
+/* Expanding question rows — the accordion, as native <details>, no scripts. */
+.faq {
+  border: 1px solid var(--border);
+  border-radius: 0.75rem;
+  background: var(--surface-2);
+  overflow: hidden;
+}
+.faq > details { border-bottom: 1px solid var(--border); }
+.faq > details:last-child { border-bottom: none; }
+.faq summary {
+  list-style: none;
+  cursor: pointer;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+  padding: 0.7rem 1rem;
+  font-size: var(--text-sm);
+  font-weight: 500;
+  color: var(--text-primary);
+}
+.faq summary::-webkit-details-marker { display: none; }
+.faq summary::after {
+  content: "";
+  width: 8px;
+  height: 8px;
+  flex-shrink: 0;
+  border-right: 1.5px solid var(--text-icon);
+  border-bottom: 1.5px solid var(--text-icon);
+  transform: rotate(45deg);
+  transition: transform 0.15s;
+  margin-top: -3px;
+}
+.faq details[open] summary::after { transform: rotate(225deg); margin-top: 3px; }
+.faq summary:hover { background: var(--surface-hover); }
+.faq details > :not(summary) { padding: 0 1rem; }
+.faq details > :last-child { padding-bottom: 0.9rem; margin-bottom: 0; }
+
+/* The fumadocs callout: a rounded-xl bordered card at 14px with a rounded
+   2px color bar down the start edge (the docs strip its shadow). */
+.callout {
+  position: relative;
+  background: var(--surface-2);
+  border: 1px solid var(--border);
+  border-radius: 0.75rem;
+  padding: 0.75rem 1rem 0.75rem 1.5rem;
+  margin: 1.5rem 0;
+  font-size: var(--text-sm);
+}
+.callout::before {
+  content: "";
+  position: absolute;
+  left: 8px;
+  top: 12px;
+  bottom: 12px;
+  width: 2px;
+  border-radius: 2px;
+  background: var(--text-muted);
+  opacity: 0.5;
+}
+.callout > :last-child { margin-bottom: 0; }
+.rows { list-style: none; margin: 1.25rem 0 0; padding: 0; border-top: 1px solid var(--surface-active); }
+.rows > li {
+  display: grid;
+  gap: 0.1rem 1.5rem;
+  grid-template-columns: 1fr;
+  padding: 0.55rem 0;
+  border-bottom: 1px solid var(--surface-active);
+  font-size: var(--text-sm);
+}
+@media (min-width: 720px) { .rows > li { grid-template-columns: 240px minmax(0, 1fr); } }
+.rows .key {
+  /* A label, not code — the docs' th treatment. Backticks in the source opt
+     a code-like key (a path, an env var) into the inline-code chip. */
+  font-weight: 500;
+  color: var(--text-primary);
+  font-size: var(--text-sm);
+}
+
+/* Docs chrome --------------------------------------------------------------- */
+.art-bar {
+  position: sticky;
+  top: 0;
+  z-index: 5;
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  height: 52px;
+  margin-bottom: 0.5rem;
+  background: var(--bg);
+  border-bottom: 1px solid var(--border);
+}
+.art-bar-title { font-size: var(--text-sm); font-weight: 500; color: var(--text-primary); margin-right: auto; }
+/* With a chrome tab row directly beneath, the row's hairline is the divider. */
+.art-bar--tabs { border-bottom-color: transparent; }
+
+/* Multi-page set tabs — the docs' top tab row: muted labels, the current
+   page in primary with a 2px underline riding the row's hairline. The row
+   scrolls horizontally (no scrollbar chrome) when the set outgrows the
+   column, so a long set never wraps or truncates. */
+.page-tabs {
+  display: flex; gap: 1.75rem;
+  margin: 0 0 2rem;
+  border-bottom: 1px solid var(--border);
+  overflow-x: auto; scrollbar-width: none;
+}
+.page-tabs::-webkit-scrollbar { display: none; }
+.page-tab {
+  flex-shrink: 0; white-space: nowrap;
+  padding: 0 0 0.65rem;
+  font-size: var(--text-sm); color: var(--text-muted);
+  text-decoration: none;
+  border-bottom: 2px solid transparent; margin-bottom: -1px;
+}
+a.page-tab:hover { color: var(--text-body); opacity: 1; }
+.page-tab.is-active { color: var(--text-primary); font-weight: 500; border-bottom-color: var(--text-primary); }
+/* In the docs layout the tab row is chrome under the sticky top bar (the
+   shell repositions it out of the content column): it sticks with the bar so
+   tabs stay reachable deep in a page. The negative margin consumes the bar's
+   own margin so the two sticky rows sit flush; the padded background keeps
+   scrolled content from showing through the seam. */
+.page[data-layout="docs"] > .page-tabs {
+  position: sticky; top: 52px; z-index: 4;
+  margin: -0.5rem 0 0; padding-top: 0.65rem;
+  background: var(--bg);
+}
+/* In-document tabs render as buttons (client-side switch, one file) — same
+   chrome as the linked set tabs. */
+button.page-tab { background: none; border-top: 0; border-left: 0; border-right: 0; font: inherit; font-size: var(--text-sm); cursor: pointer; }
+button.page-tab:hover { color: var(--text-body); }
+.doc-tab-panel { display: none; }
+.doc-tab-panel.is-active { display: block; }
+/* The panel's leading heading otherwise stacks its section margin on the tab
+   row's own gap. */
+.doc-tab-panel > :first-child { margin-top: 0; }
+
+/* The docs' theme toggle: 30px, rounded-lg, --text-icon, --surface-active hover. */
+.art-theme {
+  display: inline-flex; align-items: center; justify-content: center;
+  width: 30px; height: 30px; margin-left: 0.5rem; flex-shrink: 0;
+  color: var(--text-icon); background: none; border: none; border-radius: 0.5rem;
+  cursor: pointer; transition: background-color 0.15s;
+}
+.art-theme:hover { background: var(--surface-active); }
+.art-cols { display: grid; gap: 2.25rem; grid-template-columns: 1fr; }
+.art-cols > .art-main {
+  padding-top: 1.5rem;
+  min-width: 0;
+  width: 100%;
+}
+/* One layout: the content column at reading width with the TOC beside it,
+   the pair centered. A narrow pane collapses to a single column; there is no
+   left sidebar — the TOC is the page's only navigation rail. */
+.art-cols > .rail { display: none; }
+@media (min-width: 800px) {
+  .art-cols { grid-template-columns: minmax(0, 760px) fit-content(268px); justify-content: center; }
+  /* Fixed width, not content-sized: in a tabbed doc the longest TOC entry
+     differs per tab, and a column that resizes re-centers the whole grid on
+     every switch. */
+  .art-cols > .rail[data-rail="toc"] { display: block; position: sticky; top: 68px; align-self: start; max-height: calc(100vh - 6rem); overflow-y: auto; width: 268px; }
+}
+/* Rails scroll invisibly, like the docs — no scrollbar chrome beside the
+   TOC; the absolutely-positioned clerk track SVGs also can't tip the box
+   into showing one. */
+.art-cols > .rail { scrollbar-width: none; }
+.art-cols > .rail::-webkit-scrollbar { display: none; }
+.toc-track, .toc-thumb { display: block; }
+.rail ol, .rail ul { list-style: none; margin: 0; padding: 0; }
+/* Chrome links are navigation, not prose: no underline weight or hover fade. */
+.rail a { font-weight: 400; transition: none; }
+.rail a:hover { opacity: 1; }
+
+.rail[data-rail="toc"] { min-width: 150px; }
+
+/* Right rail: the clerk TOC. Title at 13px/480 with the text glyph; links at
+   13px/430 muted, hover body, active primary at 470 — the docs' #nd-toc
+   overrides on fumadocs' clerk geometry (20px/32px item indents). */
+.rail[data-rail="toc"] { padding-top: 48px; padding-right: 1rem; }
+.rail[data-rail="toc"] .rail-title {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-size: var(--text-small);
+  font-weight: 500;
+  color: var(--text-muted);
+  margin: 0 0 0.5rem;
+}
+.rail[data-rail="toc"] .rail-title svg { width: 16px; height: 16px; }
+.toc-items { position: relative; display: flex; flex-direction: column; }
+.toc-items a {
+  position: relative;
+  display: block;
+  padding-top: 6px;
+  padding-bottom: 6px;
+  font-size: var(--text-small);
+  font-weight: 400;
+  line-height: 1.4;
+  color: var(--text-muted);
+  text-decoration: none;
+  overflow-wrap: anywhere;
+  transition: color 0.2s;
+}
+.toc-items a:first-of-type { padding-top: 0; }
+.toc-items a:last-of-type { padding-bottom: 0; }
+.toc-items a[data-depth="2"] { padding-left: 20px; }
+.toc-items a[data-depth="3"] { padding-left: 32px; }
+.toc-items a:hover { color: var(--text-body); }
+/* Color-only active state: a weight flip re-measures the fit-content
+   column (widen or wrap) — primary-vs-muted is the docs' real signal
+   anyway, the clerk thumb carries the emphasis. */
+.toc-items a.is-active { color: var(--text-primary); }
+/* The track: the full outline path in foreground at 10%, and the same path in
+   full foreground clipped to the active range — fumadocs animates the clip
+   window, which is the "black segment" that slides as you scroll. */
+.toc-track, .toc-thumb { position: absolute; top: 0; left: 0; pointer-events: none; }
+.toc-track path { stroke: var(--text-primary); stroke-opacity: 0.1; stroke-width: 1; fill: none; }
+.toc-thumb path { stroke: var(--text-primary); stroke-width: 1; fill: none; }
+.toc-thumb {
+  clip-path: polygon(0 var(--track-top, 0), 100% var(--track-top, 0), 100% var(--track-bottom, 0), 0 var(--track-bottom, 0));
+  transition: clip-path 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+/* Images — content-width, docs card radius; figures already carry captions. */
+.page img { max-width: 100%; height: auto; border-radius: 0.5rem; }
+
+/* Code blocks — the docs' framed treatment: the shell wraps each pre in a
+   .codeblock with a header bar carrying the language label and a copy
+   button, so the bare pre border above only applies to unwrapped blocks. */
+/* Fenced code frame — the docs' figure.shiki shell (global.css: 0.5rem
+   radius, --border hairline, --code-surface fill, no shadow) with the docs'
+   copy control: emcn's quiet icon Button (20px, rounded, --text-icon-muted,
+   --surface-active hover) floating top-right, Duplicate flipping to a
+   brand-accent Check while copied. Untitled fences carry no header row,
+   exactly like the docs' prose fences. */
+.codeblock { position: relative; border: 1px solid var(--border); border-radius: 0.5rem; margin: 1rem 0; overflow: hidden; background: var(--code-surface); box-shadow: none; }
+.codeblock-copy {
+  position: absolute; top: 8px; right: 8px; z-index: 1;
+  display: inline-flex; align-items: center; justify-content: center;
+  width: 20px; height: 20px; padding: 0;
+  color: var(--text-icon-muted); background: none; border: none; border-radius: 0.25rem;
+  cursor: pointer;
+}
+.codeblock-copy:hover { background: var(--surface-active); }
+.codeblock-copy svg { stroke-width: 1.25; }
+.codeblock-copy.is-copied { color: var(--brand-accent); }
+.codeblock pre { border: none; border-radius: 0; margin: 0; background: transparent; }
+
+/* Steps — the docs' numbered timeline: a muted numbered circle per step,
+   ONE continuous hairline rail behind the circles, title + content beside.
+   Per-step segments with gaps around each circle read as a broken line the
+   moment step bodies vary in height; a full-height rail that the opaque
+   circles paint over is what the docs render. */
+.steps { list-style: none; margin: 1.25rem 0; padding: 0; }
+/* Explicit margin/padding resets: the prose list rules (ol > li's inline-start
+   indent, li's vertical margins) otherwise leak in — the indent shifts the
+   circles off the absolutely-positioned rail, and inter-item margins cut gaps
+   into it. */
+.step { --step-marker: 28px; position: relative; display: flex; gap: 1rem; margin: 0; padding: 0 0 1.75rem; }
+.step:last-child { padding-bottom: 0.25rem; }
+/* The rail spans the whole step, dead-centered under the circle; the last
+   step draws none, so the line ends AT the final circle. */
+.step::before {
+  content: ''; position: absolute; left: calc(var(--step-marker) / 2 - 0.5px);
+  top: 0; bottom: 0;
+  width: 1px; background: var(--border);
+}
+.step:last-child::before { display: none; }
+.step-marker {
+  /* Positioned so it paints OVER the rail; opaque fill is what hides the
+     line passing behind the circle. */
+  position: relative;
+  flex-shrink: 0; width: var(--step-marker); height: var(--step-marker); border-radius: 50%;
+  display: flex; align-items: center; justify-content: center;
+  background: var(--surface-5); color: var(--text-muted);
+  font-size: var(--text-small); font-weight: 500;
+}
+/* 3px optically centers the title's ~22px line box on the 28px circle. */
+.step-body { min-width: 0; padding-top: 3px; }
+.step-title { font-weight: 500; color: var(--text-primary); margin-bottom: 0.4rem; }
+/* The body's trailing paragraph margin would compound with the step's own
+   padding into an oversized gap. */
+.step-body > :last-child { margin-bottom: 0; }
+
+/* Code tabs — the docs' grouped code block: mono tab chips in the header,
+   one pane visible at a time. */
+.codetabs-head { display: flex; align-items: center; gap: 2px; padding: 0.3rem 0.4rem; }
+.codetab {
+  font-family: var(--font-mono); font-size: var(--text-small);
+  color: var(--text-muted); background: none; border: none;
+  border-radius: 0.375rem; padding: 0.2rem 0.6rem; cursor: pointer;
+}
+.codetab:hover { background: var(--surface-hover); color: var(--text-body); }
+.codetab.is-active { background: var(--surface-active); color: var(--text-primary); }
+.codetabs-head .codetabs-copy { position: static; margin-left: auto; }
+
+`.trim()
+
+/**
+ * Builds the docs chrome from the document's own headings.
+ *
+ * Left rail lists the `h2` sections styled as the docs sidebar, right rail is
+ * the clerk TOC: every `h2`/`h3` with fumadocs' depth indents, a curved track
+ * drawn through the items, and the active range highlighted by clipping a
+ * full-strength copy of the track — the clip window animates on scroll, which
+ * is the docs' signature moving black segment. Geometry follows
+ * fumadocs-ui@16.8.5 clerk.js: line x at 8px (h2) / 16px (h3) + 0.5, item
+ * spans from offsetTop+paddingTop to offsetTop+height-paddingBottom, adjacent
+ * items joined by a cubic that eases across depth changes. The docs hide
+ * clerk's traveling dot, so none is drawn here.
+ *
+ * The top bar carries the title and a filter box for the section rail. The
+ * filter is in-page only; the sandbox blocks the network, and a box that
+ * looked like it searched the workspace would lie.
+ *
+ * No-ops unless the page asked for `data-layout="docs"`.
+ */
+export const SIM_ARTIFACT_SHELL = `<script>
+(() => {
+  const build = () => {
+    const page = document.querySelector('.page[data-layout="docs"]')
+    if (!page || page.dataset.shell === 'ready') return
+    const main = page.querySelector('main') || page
+    if (main.querySelectorAll('h2, h3').length === 0) return
+    page.dataset.shell = 'ready'
+
+    // In a multi-tab document each tab is its own page: the TOC is built from
+    // the ACTIVE panel's headings only and rebuilt on every tab switch.
+    const tocScope = () => main.querySelector('[data-tab-panel].is-active') || main
+    let headings = []
+    let tocLinks = []
+
+    const ICON_ATTRS = 'viewBox="-1 -2 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.55" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"'
+    const slug = (text, i) =>
+      (text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'section') + '-' + i
+
+    // Right rail — the clerk TOC.
+    const right = document.createElement('nav')
+    right.className = 'rail'
+    right.dataset.rail = 'toc'
+    right.setAttribute('aria-label', 'On this page')
+    const rightTitle = document.createElement('div')
+    rightTitle.className = 'rail-title'
+    rightTitle.innerHTML =
+      '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true">' +
+      '<path d="M17 6.1H3"/><path d="M21 12.1H3"/><path d="M15.1 18H3"/></svg>' +
+      '<span>On this page</span>'
+    const tocItems = document.createElement('div')
+    tocItems.className = 'toc-items'
+    const SVG_NS = 'http://www.w3.org/2000/svg'
+    const track = document.createElementNS(SVG_NS, 'svg')
+    track.setAttribute('class', 'toc-track')
+    track.setAttribute('aria-hidden', 'true')
+    const trackPath = document.createElementNS(SVG_NS, 'path')
+    track.appendChild(trackPath)
+    const thumb = document.createElementNS(SVG_NS, 'svg')
+    thumb.setAttribute('class', 'toc-thumb')
+    thumb.setAttribute('aria-hidden', 'true')
+    const thumbPath = document.createElementNS(SVG_NS, 'path')
+    thumb.appendChild(thumbPath)
+    tocItems.append(track, thumb)
+    right.append(rightTitle, tocItems)
+
+    // Top bar with the page title and the theme toggle.
+    const bar = document.createElement('div')
+    bar.className = 'art-bar'
+    const title = document.createElement('span')
+    title.className = 'art-bar-title'
+    title.textContent = document.title
+
+    // Theme toggle, top right — the docs' exact control (components/ui/
+    // theme-toggle.tsx): a 30px rounded-lg ghost button, --surface-active on
+    // hover, showing the emcn Sun icon in light and Moon in dark at 14px.
+    // data-theme wins over the prefers-color-scheme fallback in every
+    // stylesheet block, so flipping the attribute is the whole mechanism.
+    // Storage is unavailable in the sandboxed preview, so the choice lives
+    // for the page view.
+    const SUN = '<svg ' + ICON_ATTRS + '><circle cx="10.25" cy="9.75" r="4"/><path d="M10.25 3.75V1.25M16.25 9.75H18.75M10.25 15.75V18.25M4.25 9.75H1.75"/><path d="M14.49 5.51L16.26 3.74M14.49 13.99L16.26 15.76M6.01 13.99L4.24 15.76M6.01 5.51L4.24 3.74"/></svg>'
+    const MOON = '<svg ' + ICON_ATTRS + '><path d="M10.25 1.5A5.84 5.84 0 0 0 18.5 9.75A8.25 8.25 0 1 1 10.25 1.5Z"/></svg>'
+    const themeButton = document.createElement('button')
+    themeButton.className = 'art-theme'
+    themeButton.type = 'button'
+    themeButton.setAttribute('aria-label', 'Toggle theme')
+    const resolvedTheme = () =>
+      document.documentElement.dataset.theme ||
+      (matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light')
+    const paintThemeButton = () => {
+      themeButton.innerHTML = resolvedTheme() === 'dark' ? MOON : SUN
+    }
+    themeButton.addEventListener('click', () => {
+      document.documentElement.dataset.theme = resolvedTheme() === 'dark' ? 'light' : 'dark'
+      paintThemeButton()
+    })
+    paintThemeButton()
+    bar.append(title, themeButton)
+
+    // Code blocks get the docs frame: like the docs' prose fences, an
+    // untitled block has no header row — just the floating copy control,
+    // emcn's Duplicate icon flipping to a brand-accent Check while copied.
+    const COPY_ICON = '<svg ' + ICON_ATTRS + '><path d="M14.25 0.75H2.75C1.64543 0.75 0.75 1.64543 0.75 2.75V14.25"/><rect x="5.25" y="5.25" width="14" height="14" rx="2"/></svg>'
+    const COPIED_ICON = '<svg ' + ICON_ATTRS + '><path d="M18.25 2.75L7.25 15.75L1.75 10.25"/></svg>'
+    for (const pre of [...main.querySelectorAll('pre')]) {
+      if (pre.closest('.codeblock')) continue
+      const codeEl = pre.querySelector('code')
+      const frame = document.createElement('figure')
+      frame.className = 'codeblock'
+      const copy = document.createElement('button')
+      copy.className = 'codeblock-copy'
+      copy.type = 'button'
+      copy.setAttribute('aria-label', 'Copy Text')
+      copy.innerHTML = COPY_ICON
+      let copyResetTimer
+      copy.addEventListener('click', async () => {
+        const text = (codeEl || pre).textContent || ''
+        try {
+          await navigator.clipboard.writeText(text)
+          copy.innerHTML = COPIED_ICON
+          copy.classList.add('is-copied')
+          copy.setAttribute('aria-label', 'Copied Text')
+          clearTimeout(copyResetTimer)
+          copyResetTimer = setTimeout(() => {
+            copy.innerHTML = COPY_ICON
+            copy.classList.remove('is-copied')
+            copy.setAttribute('aria-label', 'Copy Text')
+          }, 1500)
+        } catch {}
+      })
+      pre.replaceWith(frame)
+      frame.append(copy, pre)
+    }
+
+    // Code-tab groups: switch panes; the docs' icon copy control targets the
+    // visible pane.
+    for (const group of [...main.querySelectorAll('.codetabs')]) {
+      const head = group.querySelector('.codetabs-head')
+      if (!head) continue
+      const groupCopy = document.createElement('button')
+      groupCopy.className = 'codeblock-copy codetabs-copy'
+      groupCopy.type = 'button'
+      groupCopy.setAttribute('aria-label', 'Copy Text')
+      groupCopy.innerHTML = COPY_ICON
+      let groupResetTimer
+      groupCopy.addEventListener('click', async () => {
+        const pane = group.querySelector('pre:not([hidden])')
+        try {
+          await navigator.clipboard.writeText((pane && pane.textContent) || '')
+          groupCopy.innerHTML = COPIED_ICON
+          groupCopy.classList.add('is-copied')
+          clearTimeout(groupResetTimer)
+          groupResetTimer = setTimeout(() => {
+            groupCopy.innerHTML = COPY_ICON
+            groupCopy.classList.remove('is-copied')
+          }, 1500)
+        } catch {}
+      })
+      head.appendChild(groupCopy)
+      head.addEventListener('click', (event) => {
+        const origin = event.target
+        const btn = origin && origin.closest ? origin.closest('.codetab') : null
+        if (!btn) return
+        const tabs = [...head.querySelectorAll('.codetab')]
+        const panes = [...group.querySelectorAll('pre')]
+        const index = tabs.indexOf(btn)
+        tabs.forEach((tab, i) => tab.classList.toggle('is-active', i === index))
+        panes.forEach((pane, i) => { pane.hidden = i !== index })
+      })
+    }
+
+    const cols = document.createElement('div')
+    cols.className = 'art-cols'
+    const mid = document.createElement('div')
+    mid.className = 'art-main'
+    page.insertBefore(bar, page.firstChild)
+    page.insertBefore(cols, bar.nextSibling)
+    if (main === page) {
+      while (cols.nextSibling) mid.appendChild(cols.nextSibling)
+    } else {
+      mid.appendChild(main)
+    }
+    cols.append(mid, right)
+
+    // The tab row is chrome, not article content: it sits full-width under
+    // the top bar (the docs' own placement), not inside the content column
+    // above the h1.
+    const pageTabs = page.querySelector('.page-tabs')
+    if (pageTabs) {
+      page.insertBefore(pageTabs, cols)
+      // One divider, not two: the tab row's own bottom hairline is the
+      // chrome's edge, so the bar sheds its border.
+      bar.classList.add('art-bar--tabs')
+    }
+
+    // Clerk track geometry (fumadocs clerk.js): one path threading every item,
+    // vertical through each and a cubic easing across depth changes.
+    const lineOffset = (depth) => (depth === '2' ? 8 : 16)
+    let positions = []
+    const measure = () => {
+      positions = []
+      let w = 0
+      let h = 0
+      let d = ''
+      for (let i = 0; i < tocLinks.length; i++) {
+        const a = tocLinks[i]
+        const styles = getComputedStyle(a)
+        const x = lineOffset(a.dataset.depth) + 0.5
+        const top = a.offsetTop + parseFloat(styles.paddingTop)
+        const bottom = a.offsetTop + a.clientHeight - parseFloat(styles.paddingBottom)
+        w = Math.max(w, x + 8)
+        h = Math.max(h, bottom)
+        if (i === 0) d += ' M' + x + ' ' + top + ' L' + x + ' ' + bottom
+        else {
+          const prev = positions[i - 1]
+          d += ' C ' + prev[2] + ' ' + (top - 4) + ' ' + x + ' ' + (prev[1] + 4) + ' ' + x + ' ' + top + ' L' + x + ' ' + bottom
+        }
+        positions.push([top, bottom, x])
+      }
+      for (const svg of [track, thumb]) {
+        svg.setAttribute('viewBox', '0 0 ' + w + ' ' + h)
+        svg.setAttribute('width', String(w))
+        svg.setAttribute('height', String(h))
+      }
+      trackPath.setAttribute('d', d.trim())
+      thumbPath.setAttribute('d', d.trim())
+    }
+
+    // Scroll-spy. The TOC marks the RANGE of headings whose sections touch the
+    // viewport (fumadocs behavior) and slides the clip window over it.
+    const spy = () => {
+      const viewTop = 96
+      const viewBottom = window.innerHeight
+      const rects = headings.map((h) => h.getBoundingClientRect().top)
+      let first = -1
+      let last = -1
+      for (let i = 0; i < headings.length; i++) {
+        const sectionTop = rects[i]
+        const sectionBottom = i + 1 < headings.length ? rects[i + 1] : Infinity
+        if (sectionBottom > viewTop && sectionTop < viewBottom) {
+          if (first === -1) first = i
+          last = i
+        }
+      }
+      for (const a of tocLinks) a.classList.remove('is-active')
+      if (first === -1 || positions.length === 0) {
+        thumb.style.setProperty('--track-top', '0')
+        thumb.style.setProperty('--track-bottom', '0')
+        return
+      }
+      for (let i = first; i <= last; i++) tocLinks[i].classList.add('is-active')
+      thumb.style.setProperty('--track-top', positions[first][0] + 'px')
+      thumb.style.setProperty('--track-bottom', positions[last][1] + 'px')
+    }
+
+    const refresh = () => { measure(); spy() }
+    new ResizeObserver(refresh).observe(tocItems)
+    document.addEventListener('scroll', spy, { passive: true })
+    window.addEventListener('resize', refresh)
+
+    // (Re)builds the TOC from the active scope — the whole page, or the
+    // active tab's panel. Each tab switch produces a fresh rail, so every
+    // tab reads as its own page.
+    let slugSeq = 0
+    const populateToc = () => {
+      headings = [...tocScope().querySelectorAll('h2, h3')]
+      headings.forEach((h) => { if (!h.id) h.id = slug(h.textContent || '', slugSeq++) })
+      for (const a of [...tocItems.querySelectorAll('a')]) a.remove()
+      tocLinks = []
+      for (const h of headings) {
+        const a = document.createElement('a')
+        a.href = '#' + h.id
+        a.textContent = h.textContent
+        a.dataset.depth = h.tagName === 'H2' ? '2' : '3'
+        tocItems.appendChild(a)
+        tocLinks.push(a)
+      }
+      // In a tabbed doc an empty rail stays (its fixed column holds the grid
+      // steady across switches); only an untabbed page drops it entirely.
+      const tabbed = main.querySelector('[data-tab-panel]') !== null
+      right.style.display = headings.length === 0 && !tabbed ? 'none' : ''
+      refresh()
+    }
+    document.addEventListener('sim-tab-change', populateToc)
+    populateToc()
+  }
+
+  // In-page anchors must scroll, never navigate. Under the preview's
+  // about:srcdoc base a default '#' click is a real navigation in Electron —
+  // it escapes the document and lands on the app's sign-in page (the
+  // sandboxed frame carries no cookies).
+  document.addEventListener(
+    'click',
+    (event) => {
+      const origin = event.target
+      const anchor = origin && origin.closest ? origin.closest('a[href^="#"]') : null
+      if (!anchor) return
+      event.preventDefault()
+      const id = decodeURIComponent((anchor.getAttribute('href') || '').slice(1))
+      const target = id ? document.getElementById(id) : null
+      if (target) target.scrollIntoView({ behavior: 'smooth', block: 'start' })
+    },
+    true
+  )
+
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', build)
+  else build()
+})()
+</script>`
diff --git a/apps/sim/lib/workspace-files/page-compile.test.ts b/apps/sim/lib/workspace-files/page-compile.test.ts
new file mode 100644
index 0000000000..7e9f3a0d86
--- /dev/null
+++ b/apps/sim/lib/workspace-files/page-compile.test.ts
@@ -0,0 +1,328 @@
+/**
+ * @vitest-environment node
+ */
+import { describe, expect, it } from 'vitest'
+import {
+  collectSimPageDiagnostics,
+  compileSimPage,
+  isHandWrittenCompiledPage,
+  isSimPageSource,
+  SIM_PAGE_MARKER,
+} from '@/lib/workspace-files/page-compile'
+
+const SOURCE = `---
+title: Workspace Overview
+eyebrow: Snapshot · 18 August 2026
+lede: A concise inventory.
+---
+
+## Summary
+
+An experimentation workspace, **not** a production estate.
+
+\`\`\`sim:table
+columns: [Name, Status, "Blocks:num"]
+rows:
+  - [default-agent, Draft, 2]
+  - [forceful-arm, Deployed, 4]
+\`\`\`
+`
+
+describe('isSimPageSource', () => {
+  it('recognises source by its titled frontmatter', () => {
+    expect(isSimPageSource(SOURCE)).toBe(true)
+  })
+
+  // Raw HTML is the bespoke escape hatch and must render as-is everywhere.
+  it('is false for bespoke raw HTML', () => {
+    expect(isSimPageSource('<!DOCTYPE html><html><body>custom</body></html>')).toBe(false)
+  })
+
+  // Files stored by the retired write-time compiler stay renderable as-is.
+  it('is false for legacy stored-compiled pages', () => {
+    expect(isSimPageSource(`<!DOCTYPE html>\n${SIM_PAGE_MARKER}\n<h1>x</h1>`)).toBe(false)
+  })
+
+  it('is false for plain markdown without frontmatter', () => {
+    expect(isSimPageSource('# Title\n\nBody.')).toBe(false)
+  })
+})
+
+describe('compileSimPage', () => {
+  it('emits a complete document from frontmatter, closers included', () => {
+    const html = compileSimPage(SOURCE)
+    expect(html).toContain('<!DOCTYPE html>')
+    expect(html).toContain('<meta name="sim-artifact">')
+    expect(html).toContain('<title>Workspace Overview</title>')
+    expect(html).toContain('<div class="page" data-layout="docs">')
+    expect(html).toContain('<h1>Workspace Overview</h1>')
+    expect(html).toContain('<p class="lede">A concise inventory.</p>')
+    expect(html).toContain('</body>')
+    expect(html).toContain('</html>')
+    // The write-time compiler's signature is retired: never emitted anew.
+    expect(html).not.toContain(SIM_PAGE_MARKER)
+  })
+
+  it('compiles markdown prose and headings through GFM', () => {
+    const html = compileSimPage(SOURCE)
+    expect(html).toContain('<h2>Summary</h2>')
+    expect(html).toContain('<strong>not</strong>')
+  })
+
+  it('compiles sim:table with numeric column alignment', () => {
+    const html = compileSimPage(SOURCE)
+    expect(html).toContain('<div class="scroll"><table>')
+    expect(html).toContain('<th class="num">Blocks</th>')
+    expect(html).toContain('<td class="num">4</td>')
+  })
+
+  it('compiles kv fences into key rows', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\n```sim:kv\n- { key: "panel.ts:646", value: Reveal returns early. }\n```'
+    )
+    expect(html).toContain('<span class="key">panel.ts:646</span>')
+  })
+
+  it('compiles faq fences into native details rows', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\n```sim:faq\n- { q: What is this?, markdown: A compiled page. }\n```'
+    )
+    expect(html).toContain('<div class="faq">')
+    expect(html).toContain('<summary>What is this?</summary>')
+  })
+
+  it('passes a diagram svg through inside a figure with its caption', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\n```sim:diagram The loop.\n<svg viewBox="0 0 10 10"><rect width="10" height="10"/></svg>\n```'
+    )
+    expect(html).toContain('<figure><svg viewBox="0 0 10 10">')
+    expect(html).toContain('<figcaption>The loop.</figcaption>')
+  })
+
+  // Authoring mistakes surface on the page the author reads, not in a log.
+  // A malformed block renders NOTHING for the reader; the skip is reported
+  // only through diagnostics, which apply_file_edit hands back to the agent.
+  it('omits a malformed structured fence and reports it as a diagnostic', () => {
+    const source = '---\ntitle: T\n---\n```sim:kv\n- { key: }\n```'
+    expect(compileSimPage(source)).not.toContain('was skipped')
+    expect(collectSimPageDiagnostics(source)).toEqual([
+      'sim:kv block skipped: its payload did not match the expected shape',
+    ])
+  })
+
+  it('omits retired fence kinds and reports them as diagnostics', () => {
+    const source = '---\ntitle: T\n---\n```sim:cards\n- title: X\n```'
+    expect(compileSimPage(source)).not.toContain('sim:cards')
+    expect(collectSimPageDiagnostics(source)).toEqual([
+      'sim:cards block skipped: its payload did not match the expected shape',
+    ])
+  })
+
+  it('reports nothing for a fully valid page', () => {
+    expect(
+      collectSimPageDiagnostics('---\ntitle: T\n---\n```sim:kv\n- key: A\n  value: B\n```')
+    ).toEqual([])
+  })
+
+  it('renders inline markdown in table cells and resolves sim links', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\n```sim:table\ncolumns: [Name]\nrows:\n  - ["[gateway](sim:workflow/wf1)"]\n```',
+      { workspaceId: 'ws1' }
+    )
+    expect(html).toContain('<a href="/workspace/ws1/w/wf1" data-sim-link="">gateway</a>')
+  })
+
+  it('sends external links to a new tab on every surface', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\nSee the [Sim docs](https://docs.sim.ai/start).'
+    )
+    expect(html).toContain(
+      '<a href="https://docs.sim.ai/start" target="_blank" rel="noopener noreferrer">'
+    )
+  })
+
+  it('resolves workspace image refs to the authed byte route', () => {
+    const html = compileSimPage('---\ntitle: T\n---\n![diagram](sim:file/img9)')
+    expect(html).toContain('src="/api/files/view/img9"')
+  })
+
+  it('renders the tabs frontmatter as the docs tab row above the title', () => {
+    const html = compileSimPage(
+      '---\ntitle: Overview\ntabs:\n  - "Overview"\n  - "[API Reference](sim:file/b)"\n  - "[CLI](sim:file/c)"\n---\nBody.',
+      { workspaceId: 'ws1' }
+    )
+    expect(html).toContain('<nav class="page-tabs" aria-label="Pages">')
+    // The bare-label entry IS this page: the active, unlinked tab.
+    expect(html).toContain('<span class="page-tab is-active">Overview</span>')
+    // Linked entries resolve through the normal sim: link pass.
+    expect(html).toContain(
+      '<a class="page-tab" href="/workspace/ws1/files/b" data-sim-link="">API Reference</a>'
+    )
+    // Tabs precede the title, the docs' top-row placement.
+    expect(html.indexOf('page-tabs')).toBeLessThan(html.indexOf('<h1>'))
+  })
+
+  it('renders no tab row for a single page', () => {
+    expect(compileSimPage('---\ntitle: T\n---\nBody.')).not.toContain('page-tabs')
+  })
+
+  it('tolerates prev/next frontmatter without rendering pagination', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\nprev: "[Getting Started](sim:file/a)"\nnext: "[API Reference](sim:file/b)"\n---\nBody.',
+      { workspaceId: 'ws1' }
+    )
+    expect(html).not.toContain('page-nav')
+    expect(html).toContain('Body.')
+  })
+
+  it('tolerates nav frontmatter without rendering a sidebar', () => {
+    const html = compileSimPage(
+      '---\ntitle: Overview\nnav:\n  - label: Get Started\n    pages:\n      - "[Overview](sim:file/a)"\n      - "[API Reference](sim:file/b)"\n---\nBody.',
+      { workspaceId: 'ws1' }
+    )
+    expect(html).not.toContain('set-nav')
+    expect(html).toContain('Body.')
+  })
+
+  it('renders sim:accordion like sim:faq with title keys', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\n```sim:accordion\n- title: Advanced options\n  markdown: The details.\n```'
+    )
+    expect(html).toContain('<div class="faq">')
+    expect(html).toContain('<summary>Advanced options</summary>')
+  })
+
+  it('escapes html in yaml-derived values', () => {
+    const html = compileSimPage(
+      '---\ntitle: T\n---\n```sim:kv\n- { key: "<script>", value: "<img src=x>" }\n```'
+    )
+    expect(html).toContain('&lt;script&gt;')
+    expect(html).not.toContain('<img src=x>')
+  })
+})
+
+describe('isHandWrittenCompiledPage', () => {
+  it('rejects content carrying the compiler signature', () => {
+    expect(isHandWrittenCompiledPage(`<!DOCTYPE html>\n${SIM_PAGE_MARKER}\n<h1>x</h1>`)).toBe(true)
+  })
+
+  it('rejects an artifact-opted document with no styles of its own', () => {
+    expect(
+      isHandWrittenCompiledPage(
+        '<!DOCTYPE html><html><head><meta name="sim-artifact"></head><body><h1>x</h1></body></html>'
+      )
+    ).toBe(true)
+  })
+
+  it('allows a genuine bespoke page with inline styles', () => {
+    expect(
+      isHandWrittenCompiledPage(
+        '<!DOCTYPE html><html><head><style>body{color:#111}</style></head><body>custom</body></html>'
+      )
+    ).toBe(false)
+  })
+
+  it('allows page source', () => {
+    expect(isHandWrittenCompiledPage(SOURCE)).toBe(false)
+  })
+})
+
+describe('in-document tabs', () => {
+  const TABBED = `---
+title: API Guide
+---
+
+Shared intro paragraph.
+
+# Overview
+
+## Getting started
+
+Overview body.
+
+# Reference
+
+## Endpoints
+
+Reference body.
+`
+
+  it('turns two top-level headings into tab buttons and panels', () => {
+    const html = compileSimPage(TABBED)
+    expect(html).toContain('data-doc-tabs')
+    expect(html).toContain('data-tab-target="doc-tab-0"')
+    expect(html).toContain('>Overview</button>')
+    expect(html).toContain('>Reference</button>')
+    expect(html).toContain('id="doc-tab-0" data-tab-panel')
+    expect(html).toContain('id="doc-tab-1" data-tab-panel')
+    expect(html.match(/doc-tab-panel is-active/g)).toHaveLength(1)
+    expect(html).toContain('Overview body.')
+    expect(html).toContain('Reference body.')
+  })
+
+  it('renders content before the first heading outside the panels', () => {
+    const html = compileSimPage(TABBED)
+    const intro = html.indexOf('Shared intro paragraph.')
+    const firstPanel = html.indexOf('data-tab-panel')
+    expect(intro).toBeGreaterThan(-1)
+    expect(intro).toBeLessThan(firstPanel)
+  })
+
+  it('includes the client-side switcher script', () => {
+    expect(compileSimPage(TABBED)).toContain('data-doc-tabs] .page-tab')
+  })
+
+  it('ignores # lines inside code fences', () => {
+    const html = compileSimPage(`---
+title: One Pager
+---
+
+# Only Tab
+
+\`\`\`bash
+# a comment, not a tab
+echo hi
+\`\`\`
+
+# Second Tab
+
+Body.
+`)
+    expect(html).toContain('data-doc-tabs')
+    expect(html).not.toContain('>a comment, not a tab</button>')
+    expect(html.match(/data-tab-target/g)).toHaveLength(2)
+  })
+
+  it('leaves a single top-level heading untabbed', () => {
+    const html = compileSimPage(`---
+title: Plain
+---
+
+# Just A Heading
+
+Body text.
+`)
+    expect(html).not.toContain('data-doc-tabs')
+    expect(html).toContain('Body text.')
+  })
+
+  it('prefers in-file tabs over the frontmatter set tabs', () => {
+    const html = compileSimPage(`---
+title: Guide
+tabs:
+  - Guide
+  - "[Other](sim:file/abc)"
+---
+
+# First
+
+A.
+
+# Second
+
+B.
+`)
+    expect(html).toContain('data-doc-tabs')
+    expect(html).not.toContain('sim:file/abc')
+  })
+})
diff --git a/apps/sim/lib/workspace-files/page-compile.ts b/apps/sim/lib/workspace-files/page-compile.ts
new file mode 100644
index 0000000000..fe053569f7
--- /dev/null
+++ b/apps/sim/lib/workspace-files/page-compile.ts
@@ -0,0 +1,524 @@
+import { JSON_SCHEMA, load } from 'js-yaml'
+import { marked } from 'marked'
+import { z } from 'zod'
+
+/**
+ * Compiler for agent-authored `.html` pages.
+ *
+ * The stored `.html` file holds the agent's SOURCE — YAML frontmatter, GFM
+ * prose, and `sim:` fences — the way a `.pdf` file stores its generating
+ * script. Rendering surfaces (the preview panel, the share view, download)
+ * call {@link compileSimPage} to produce the complete docs-styled HTML
+ * document on demand. The source is never mutated at write time, so agent
+ * appends stay plain concatenation and the raw editor view IS the source
+ * view, mirroring the pdf source/rendered duality.
+ *
+ * Content starting `<!DOCTYPE`/`<html` is a bespoke page and passes through
+ * every surface untouched — except a hand-written imitation of compiled
+ * output, which {@link isHandWrittenCompiledPage} rejects at write time.
+ */
+
+/**
+ * The retired write-time compiler's signature. New compiles no longer emit
+ * it, but legacy stored-compiled files carry it and an agent copying one
+ * would too — it stays recognized purely to reject imitations.
+ */
+export const SIM_PAGE_MARKER = '<!--sim-page-->'
+
+/**
+ * The INTERNAL content type stamped onto a page file's record when the write
+ * path detects page source. The file stays `.html` to the user (serving and
+ * downloads emit text/html); the record type is how surfaces know the file's
+ * nature before any content loads — force the rendered view, hide the code
+ * toggle, expect source.
+ */
+export const SIM_PAGE_CONTENT_TYPE = 'text/x-sim-page'
+
+const frontmatterSchema = z.object({
+  title: z.string().min(1),
+  /** Tolerated for old sources; no longer rendered — the docs have no eyebrow. */
+  eyebrow: z.string().optional(),
+  lede: z.string().optional(),
+  layout: z.enum(['docs', 'report']).optional(),
+  /** Tolerated for old sources; no longer rendered — sets navigate by tabs. */
+  prev: z.string().optional(),
+  next: z.string().optional(),
+  /**
+   * Multi-page set navigation, the docs' top tab row: every page of a set
+   * carries the SAME ordered list. Each entry is a markdown link
+   * (`"[API Reference](sim:file/<id>)"`) to a sibling page; the CURRENT
+   * page's entry is its bare label (`"Overview"`), rendered as the active
+   * tab. The row scrolls horizontally when the set outgrows the column.
+   */
+  tabs: z.array(z.string()).min(1).optional(),
+  /**
+   * The SET's sidebar, docs-style: groups of pages under muted labels. Each
+   * page entry is a markdown link; every page of a set carries the same nav.
+   */
+  /** Tolerated for old sources; no longer rendered — there is no sidebar. */
+  nav: z
+    .array(
+      z.object({
+        label: z.string().optional(),
+        pages: z.array(z.string()).min(1),
+      })
+    )
+    .optional(),
+})
+
+/**
+ * The set navigation as real (hidden) markup, so sim: hrefs resolve through
+ * the normal link pass and the shell can lift it into the left rail —
+ * grouped page links with the current page's sections nested beneath it.
+ */
+
+const MD_LINK = /^\s*\[([^\]]+)\]\(([^)]+)\)\s*$/
+
+/**
+ * The set's tab row above the title — the docs' own top tabs: linked entries
+ * navigate to sibling pages, the bare-label entry IS this page and renders as
+ * the active tab. sim: hrefs resolve through the normal link pass.
+ */
+function tabBar(tabs: string[] | undefined): string {
+  if (!tabs || tabs.length === 0) return ''
+  const items = tabs
+    .map((entry) => {
+      const match = entry.match(MD_LINK)
+      if (match) {
+        return `<a class="page-tab" href="${escapeHtml(match[2])}">${escapeHtml(match[1])}</a>`
+      }
+      return `<span class="page-tab is-active">${escapeHtml(entry.trim())}</span>`
+    })
+    .join('')
+  return `<nav class="page-tabs" aria-label="Pages">${items}</nav>`
+}
+
+interface DocTab {
+  title: string
+  body: string
+}
+
+/**
+ * Splits a page body at top-level `# ` headings — each starts an in-document
+ * tab. Fence contents are opaque: a `# ` line inside a ``` or ~~~ block stays
+ * content. With fewer than two headings the body is not tabbed at all, so a
+ * stray single H1 never eats content.
+ */
+function splitDocTabs(body: string): { intro: string; tabs: DocTab[] } {
+  const intro: string[] = []
+  const tabs: Array<{ title: string; lines: string[] }> = []
+  let fenceChar: string | null = null
+  for (const line of body.split('\n')) {
+    const fence = line.match(/^\s*(`{3,}|~{3,})/)
+    if (fence) {
+      const char = fence[1][0]
+      if (!fenceChar) fenceChar = char
+      else if (char === fenceChar) fenceChar = null
+    }
+    const heading = fenceChar ? null : line.match(/^# +(.+?)\s*$/)
+    if (heading) {
+      tabs.push({ title: heading[1], lines: [] })
+      continue
+    }
+    ;(tabs.length > 0 ? tabs[tabs.length - 1].lines : intro).push(line)
+  }
+  return {
+    intro: intro.join('\n'),
+    tabs: tabs.map((tab) => ({ title: tab.title, body: tab.lines.join('\n') })),
+  }
+}
+
+/** The in-document tab row — same chrome as the set tab bar, but buttons. */
+function docTabBar(tabs: DocTab[]): string {
+  const items = tabs
+    .map(
+      (tab, i) =>
+        `<button type="button" class="page-tab${i === 0 ? ' is-active' : ''}" data-tab-target="doc-tab-${i}">${escapeHtml(tab.title)}</button>`
+    )
+    .join('')
+  return `<nav class="page-tabs" data-doc-tabs aria-label="Pages">${items}</nav>`
+}
+
+/**
+ * The in-document tab switcher: toggles panels and announces the change. The
+ * shell rebuilds its "On this page" rail from the newly active panel on the
+ * sim-tab-change event, so each tab reads as its own page.
+ */
+const DOC_TABS_SCRIPT = `<script>
+(() => {
+  const tabs = [...document.querySelectorAll('[data-doc-tabs] .page-tab')]
+  const panels = [...document.querySelectorAll('[data-tab-panel]')]
+  if (tabs.length === 0) return
+  const activate = (target) => {
+    for (const t of tabs) t.classList.toggle('is-active', t.dataset.tabTarget === target)
+    for (const p of panels) p.classList.toggle('is-active', p.id === target)
+    window.scrollTo({ top: 0 })
+    document.dispatchEvent(new Event('sim-tab-change'))
+  }
+  for (const t of tabs) t.addEventListener('click', () => activate(t.dataset.tabTarget))
+})()
+</script>`
+
+/** YAML leaves unquoted scalars typed; reject null/objects rather than stringify them. */
+const textCell = z.union([z.string(), z.number(), z.boolean()]).transform((value) => String(value))
+
+const tablePayloadSchema = z.object({
+  columns: z
+    .array(
+      z.union([
+        textCell.transform((header) =>
+          header.endsWith(':num')
+            ? { header: header.slice(0, -4), align: 'num' as const }
+            : { header, align: 'text' as const }
+        ),
+        z.object({ header: textCell, align: z.enum(['text', 'num']).optional() }),
+      ])
+    )
+    .min(1),
+  rows: z.array(z.array(textCell)).min(1),
+})
+const kvItemsSchema = z.array(z.object({ key: textCell, value: textCell })).min(1)
+const stepsItemsSchema = z
+  .array(z.object({ title: textCell, markdown: textCell.optional() }))
+  .min(1)
+const tabsItemsSchema = z
+  .array(z.object({ label: textCell, lang: textCell.optional(), code: textCell }))
+  .min(1)
+const accordionItemsSchema = z
+  .array(
+    z
+      .object({ q: textCell.optional(), title: textCell.optional(), markdown: textCell })
+      .refine((item) => item.q !== undefined || item.title !== undefined, {
+        message: 'each item needs a q or title',
+      })
+  )
+  .min(1)
+
+const FENCE_OPEN = /^```(\S*)[ \t]*(.*)$/
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+}
+
+function renderMarkdown(markdown: string): string {
+  return marked.parse(markdown, { gfm: true, async: false }) as string
+}
+
+/**
+ * Inline markdown for structured-block text (table cells, kv values, faq
+ * questions): links, `code`, and emphasis render; raw HTML stays escaped
+ * because the text is escaped BEFORE the inline pass.
+ */
+function renderInlineMarkdown(text: string): string {
+  return marked.parseInline(escapeHtml(text), { gfm: true, async: false }) as string
+}
+
+const SIM_RESOURCE_ROUTES: Record<string, (workspaceId: string, id: string) => string> = {
+  workflow: (workspaceId, id) => `/workspace/${workspaceId}/w/${id}`,
+  table: (workspaceId, id) => `/workspace/${workspaceId}/tables/${id}`,
+  knowledge: (workspaceId, id) => `/workspace/${workspaceId}/knowledge/${id}`,
+  // The normal Files page with the file open — the same in-app navigation a
+  // markdown link performs (the fullscreen /view route is only for the
+  // standalone surface, not for links).
+  file: (workspaceId, id) => `/workspace/${workspaceId}/files/${id}`,
+}
+
+/**
+ * Rewrites `sim:` resource links (`[Name](sim:workflow/<id>)` in source) into
+ * real workspace routes. Applied when the rendering surface knows its
+ * workspace; without one the sim: hrefs stay put and render inert.
+ * `data-sim-link` marks them so the preview sandbox can bridge clicks to the
+ * app router instead of cancelling them.
+ */
+export function resolveSimResourceLinks(html: string, workspaceId: string, baseUrl = ''): string {
+  return html.replace(
+    /href="sim:(workflow|table|knowledge|file)\/([^"]+)"/g,
+    (match, type: string, id: string) => {
+      const route = SIM_RESOURCE_ROUTES[type]
+      return route ? `href="${baseUrl}${route(workspaceId, id)}" data-sim-link=""` : match
+    }
+  )
+}
+
+function loadYaml(body: string): unknown {
+  return load(body, { schema: JSON_SCHEMA })
+}
+
+type FenceRenderer = (payload: unknown) => string | null
+
+const FENCE_RENDERERS: Record<string, FenceRenderer> = {
+  table: (payload) => {
+    const parsed = tablePayloadSchema.safeParse(payload)
+    if (!parsed.success) return null
+    const { columns, rows } = parsed.data
+    const head = columns
+      .map(
+        (column) =>
+          `<th${column.align === 'num' ? ' class="num"' : ''}>${escapeHtml(column.header)}</th>`
+      )
+      .join('')
+    const body = rows
+      .map(
+        (row) =>
+          `<tr>${row
+            .map(
+              (cell, index) =>
+                `<td${columns[index]?.align === 'num' ? ' class="num"' : ''}>${renderInlineMarkdown(cell)}</td>`
+            )
+            .join('')}</tr>`
+      )
+      .join('')
+    return `<div class="scroll"><table><thead><tr>${head}</tr></thead><tbody>${body}</tbody></table></div>`
+  },
+  kv: (payload) => {
+    const parsed = kvItemsSchema.safeParse(payload)
+    if (!parsed.success) return null
+    const rows = parsed.data
+      .map(
+        (item) =>
+          `<li><span class="key">${renderInlineMarkdown(item.key)}</span><span>${renderInlineMarkdown(item.value)}</span></li>`
+      )
+      .join('')
+    return `<ul class="rows">${rows}</ul>`
+  },
+  faq: renderAccordion,
+  accordion: renderAccordion,
+  steps: (payload) => {
+    const parsed = stepsItemsSchema.safeParse(payload)
+    if (!parsed.success) return null
+    const items = parsed.data
+      .map(
+        (step, index) =>
+          `<li class="step"><div class="step-marker">${index + 1}</div><div class="step-body"><div class="step-title">${renderInlineMarkdown(step.title)}</div>${step.markdown ? renderMarkdown(step.markdown) : ''}</div></li>`
+      )
+      .join('')
+    return `<ol class="steps">${items}</ol>`
+  },
+  tabs: (payload) => {
+    const parsed = tabsItemsSchema.safeParse(payload)
+    if (!parsed.success) return null
+    const buttons = parsed.data
+      .map(
+        (tab, index) =>
+          `<button type="button" class="codetab${index === 0 ? ' is-active' : ''}">${escapeHtml(tab.label)}</button>`
+      )
+      .join('')
+    const panes = parsed.data
+      .map(
+        (tab, index) =>
+          `<pre${index === 0 ? '' : ' hidden'}><code${tab.lang ? ` class="language-${escapeHtml(tab.lang)}"` : ''}>${escapeHtml(tab.code)}</code></pre>`
+      )
+      .join('')
+    return `<figure class="codeblock codetabs"><div class="codeblock-head codetabs-head">${buttons}</div>${panes}</figure>`
+  },
+}
+
+/** `sim:faq` and `sim:accordion` share the docs' expandable-rows treatment. */
+function renderAccordion(payload: unknown): string | null {
+  const parsed = accordionItemsSchema.safeParse(payload)
+  if (!parsed.success) return null
+  const items = parsed.data
+    .map(
+      (item) =>
+        `<details><summary>${renderInlineMarkdown(item.q ?? item.title ?? '')}</summary>${renderMarkdown(item.markdown)}</details>`
+    )
+    .join('')
+  return `<div class="faq">${items}</div>`
+}
+
+export const HAND_WRITTEN_PAGE_MESSAGE =
+  'Rejected: this content imitates the compiled page output (hand-written page HTML). Never write the page HTML yourself. Write page SOURCE instead — YAML frontmatter with a title, markdown prose, and sim: fences — and Sim renders it as the styled page. Raw HTML is only for a bespoke one-off page that carries its own complete inline <style>.'
+
+/**
+ * True when agent-authored content imitates the compiler's OUTPUT instead of
+ * being page source or a genuine bespoke page. The marker is the retired
+ * write-time compiler's signature — nothing may hand-write it — and an
+ * artifact-opted page without its own <style> can only have been copied from
+ * compiled output, since a bespoke page must carry its styles inline to
+ * render in the sandbox.
+ */
+export function isHandWrittenCompiledPage(content: string): boolean {
+  if (content.includes(SIM_PAGE_MARKER)) return true
+  const trimmed = content.trimStart()
+  if (!/^<!doctype\b/i.test(trimmed) && !/^<html\b/i.test(trimmed)) return false
+  return /<meta\s+name=["']sim-artifact["']/i.test(content) && !/<style[\s>]/i.test(content)
+}
+
+/**
+ * True when `.html` content is Sim page source: it announces itself with
+ * YAML frontmatter carrying a valid title. Raw HTML (bespoke pages and
+ * legacy stored-compiled files) returns false and renders as-is.
+ */
+export function isSimPageSource(content: string): boolean {
+  const trimmed = content.trimStart()
+  if (!trimmed.startsWith('---\n')) return false
+  const end = trimmed.indexOf('\n---', 3)
+  if (end === -1) return false
+  try {
+    return frontmatterSchema.safeParse(loadYaml(trimmed.slice(4, end)) ?? {}).success
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Compiles the body portion — prose, fences — of the source. A malformed
+ * sim: block renders NOTHING for the reader (an error card in a finished
+ * page helps nobody); the skip is reported through `diagnostics` instead,
+ * which the file-editing tool surfaces back to the authoring agent.
+ */
+function compileBody(source: string, diagnostics?: string[]): string {
+  const lines = source.split('\n')
+  const html: string[] = []
+  let prose: string[] = []
+  const flushProse = () => {
+    const markdown = prose.join('\n').trim()
+    prose = []
+    if (markdown) html.push(renderMarkdown(markdown))
+  }
+
+  let index = 0
+  while (index < lines.length) {
+    const line = lines[index]
+    const fence = line.match(FENCE_OPEN)
+    if (fence?.[1].startsWith('sim:')) {
+      const kind = fence[1].slice(4)
+      const caption = fence[2].trim()
+      const bodyStart = index + 1
+      let bodyEnd = bodyStart
+      while (bodyEnd < lines.length && !lines[bodyEnd].startsWith('```')) bodyEnd++
+      const body = lines.slice(bodyStart, bodyEnd).join('\n')
+      flushProse()
+
+      if (kind === 'callout') {
+        if (body.trim()) html.push(`<div class="callout">${renderMarkdown(body.trim())}</div>`)
+      } else if (kind === 'diagram') {
+        if (/^\s*<svg[\s>]/i.test(body)) {
+          const figcaption = caption ? `<figcaption>${escapeHtml(caption)}</figcaption>` : ''
+          html.push(`<figure>${body.trim()}${figcaption}</figure>`)
+        } else {
+          diagnostics?.push('sim:diagram block skipped: its body must be a complete <svg> element')
+        }
+      } else {
+        const renderer = FENCE_RENDERERS[kind]
+        let payload: unknown
+        let rendered: string | null = null
+        if (renderer) {
+          try {
+            payload = loadYaml(body)
+            rendered = renderer(payload)
+          } catch {
+            rendered = null
+          }
+        }
+        if (rendered !== null) {
+          html.push(rendered)
+        } else {
+          diagnostics?.push(
+            `sim:${kind} block skipped: its payload did not match the expected shape`
+          )
+        }
+      }
+      index = bodyEnd + 1
+      continue
+    }
+    prose.push(line)
+    index++
+  }
+  flushProse()
+  return html.join('\n')
+}
+
+/**
+ * Compiles page source into the complete HTML document a rendering surface
+ * serves. Pure and stateless — the same call backs the live preview, the
+ * share view, and download, so all three always agree. When the surface
+ * knows its workspace, `sim:` resource links resolve to real routes.
+ */
+export function compileSimPage(
+  source: string,
+  options?: { workspaceId?: string; baseUrl?: string; diagnostics?: string[] }
+): string {
+  // Workspace images (`![alt](sim:file/<id>)`) resolve to the authed byte
+  // route regardless of surface; deep links additionally need the workspace.
+  // A baseUrl absolutizes both — a DOWNLOADED page opened outside the app
+  // must reach Sim the way an absolute link in a downloaded .md does,
+  // instead of resolving dead against file:// or a foreign host.
+  const origin = options?.baseUrl?.replace(/\/$/, '') ?? ''
+  const compiled = compileSimPageDocument(source, options?.diagnostics)
+    .replace(/src="sim:file\/([^"]+)"/g, `src="${origin}/api/files/view/$1"`)
+    // External links leave the page in a new tab on every surface; in the
+    // sandboxed preview the bootstrap bridges the click to the host instead.
+    .replace(
+      /<a href="(https?:\/\/[^"]+)"/g,
+      '<a href="$1" target="_blank" rel="noopener noreferrer"'
+    )
+  return options?.workspaceId
+    ? resolveSimResourceLinks(compiled, options.workspaceId, origin)
+    : compiled
+}
+
+/**
+ * Compiles the source solely to collect authoring diagnostics — one line per
+ * skipped sim: block. Empty means every block rendered. The reader-facing
+ * render never shows these; the file agent gets them in its tool result.
+ */
+export function collectSimPageDiagnostics(source: string): string[] {
+  const diagnostics: string[] = []
+  compileSimPageDocument(source, diagnostics)
+  return diagnostics
+}
+
+function compileSimPageDocument(source: string, diagnostics?: string[]): string {
+  const trimmed = source.trimStart()
+  const end = trimmed.indexOf('\n---', 3)
+  const frontmatterText = trimmed.slice(4, end)
+  const rest = trimmed.slice(end + 4).replace(/^-*\n?/, '')
+  let meta: z.infer<typeof frontmatterSchema>
+  try {
+    meta = frontmatterSchema.parse(loadYaml(frontmatterText) ?? {})
+  } catch {
+    // isSimPageSource gates on parseable frontmatter; this is a safety net.
+    return compileBody(source, diagnostics)
+  }
+
+  // Two or more top-level `# ` headings turn the body into IN-DOCUMENT tabs:
+  // one file, one tab per heading, switched client-side. Content before the
+  // first heading renders above the panels on every tab. In-file tabs win
+  // over the legacy frontmatter `tabs` (cross-file set links).
+  const { intro, tabs: docTabs } = splitDocTabs(rest)
+  const multiTab = docTabs.length >= 2
+
+  return [
+    '<!DOCTYPE html>',
+    '<html lang="en">',
+    '<head>',
+    '<meta charset="utf-8">',
+    '<meta name="viewport" content="width=device-width, initial-scale=1">',
+    '<meta name="sim-artifact">',
+    `<title>${escapeHtml(meta.title)}</title>`,
+    '</head>',
+    '<body>',
+    `<div class="page" data-layout="${meta.layout ?? 'docs'}">`,
+    ...(multiTab ? [docTabBar(docTabs)] : meta.tabs ? [tabBar(meta.tabs)] : []),
+    `<h1>${escapeHtml(meta.title)}</h1>`,
+    ...(meta.lede ? [`<p class="lede">${escapeHtml(meta.lede)}</p>`] : []),
+    ...(multiTab
+      ? [
+          ...(intro.trim() ? [compileBody(intro, diagnostics)] : []),
+          ...docTabs.map(
+            (tab, i) =>
+              `<section class="doc-tab-panel${i === 0 ? ' is-active' : ''}" id="doc-tab-${i}" data-tab-panel>${compileBody(tab.body, diagnostics)}</section>`
+          ),
+          DOC_TABS_SCRIPT,
+        ]
+      : [compileBody(rest, diagnostics)]),
+    '</div>',
+    '</body>',
+    '</html>',
+  ].join('\n')
+}
diff --git a/apps/sim/lib/workspace-files/page-document.server.ts b/apps/sim/lib/workspace-files/page-document.server.ts
new file mode 100644
index 0000000000..d0e2d5a7c2
--- /dev/null
+++ b/apps/sim/lib/workspace-files/page-document.server.ts
@@ -0,0 +1,50 @@
+import { downloadFile } from '@/lib/uploads/core/storage-service'
+import { getFileMetadataById } from '@/lib/uploads/server/metadata'
+import { renderSimPageDocument } from '@/lib/workspace-files/page-document'
+
+/** Images past this size stay as URL references rather than bloating the document. */
+const MAX_INLINE_IMAGE_BYTES = 8 * 1024 * 1024
+
+const IMAGE_SRC = /src="[^"]*\/api\/files\/view\/([^"]+)"/g
+
+/**
+ * The full pdf model for the standalone document: like a pdf carrying its
+ * images, the served page inlines every workspace image it references as a
+ * data: URI. Absolute link URLs already survive a download, but an embedded
+ * image request from a downloaded file is cross-site and carries no session
+ * cookie, so only baked-in bytes render everywhere. Images must live in the
+ * page's own workspace — a reference into another workspace stays a URL and
+ * renders only where the viewer's own session authorizes it.
+ */
+export async function renderSimPageDocumentWithAssets(
+  source: string,
+  options: { workspaceId?: string }
+): Promise<string> {
+  const documentHtml = renderSimPageDocument(source, options)
+  const ids = [...new Set([...documentHtml.matchAll(IMAGE_SRC)].map((match) => match[1]))]
+  if (ids.length === 0 || !options.workspaceId) return documentHtml
+
+  const inlined = new Map<string, string>()
+  await Promise.all(
+    ids.map(async (id) => {
+      try {
+        const record = await getFileMetadataById(id)
+        if (!record || record.context !== 'workspace' || record.workspaceId !== options.workspaceId)
+          return
+        const bytes = await downloadFile({ key: record.key, context: 'workspace' })
+        if (bytes.length > MAX_INLINE_IMAGE_BYTES) return
+        const mime = record.contentType?.startsWith('image/')
+          ? record.contentType
+          : 'application/octet-stream'
+        inlined.set(id, `data:${mime};base64,${bytes.toString('base64')}`)
+      } catch {
+        // A missing or unreadable image keeps its URL reference.
+      }
+    })
+  )
+  if (inlined.size === 0) return documentHtml
+  return documentHtml.replace(IMAGE_SRC, (match, id: string) => {
+    const dataUri = inlined.get(id)
+    return dataUri ? `src="${dataUri}"` : match
+  })
+}
diff --git a/apps/sim/lib/workspace-files/page-document.ts b/apps/sim/lib/workspace-files/page-document.ts
new file mode 100644
index 0000000000..34621f720d
--- /dev/null
+++ b/apps/sim/lib/workspace-files/page-document.ts
@@ -0,0 +1,25 @@
+import { getBaseUrl } from '@/lib/core/utils/urls'
+import {
+  SIM_ARTIFACT_SHELL,
+  SIM_ARTIFACT_STYLESHEET,
+} from '@/lib/workspace-files/artifact-stylesheet'
+import { compileSimPage } from '@/lib/workspace-files/page-compile'
+
+/**
+ * Renders page source as a fully self-contained styled document for the
+ * surfaces that serve bytes without the app around them — `/api/files/serve`
+ * (standalone viewer), public share links, and downloads. The preview panel
+ * injects the same stylesheet/shell itself (plus the live token bridge), so
+ * every surface shows the identical docs-styled page; this bakes them in so
+ * the document also stands alone in a plain browser tab.
+ */
+export function renderSimPageDocument(source: string, options?: { workspaceId?: string }): string {
+  // Absolute app URLs: the standalone document is also what a user
+  // downloads, and a downloaded page's links and images must reach Sim
+  // the way an absolute link in a downloaded .md does.
+  const compiled = compileSimPage(source, { ...options, baseUrl: getBaseUrl() })
+  return compiled.replace(
+    '</head>',
+    `<style>${SIM_ARTIFACT_STYLESHEET}</style>${SIM_ARTIFACT_SHELL}</head>`
+  )
+}
diff --git a/apps/sim/lib/workspace-files/page-tabs-rail.test.ts b/apps/sim/lib/workspace-files/page-tabs-rail.test.ts
new file mode 100644
index 0000000000..d6b6237e40
--- /dev/null
+++ b/apps/sim/lib/workspace-files/page-tabs-rail.test.ts
@@ -0,0 +1,129 @@
+/**
+ * @vitest-environment node
+ */
+import { sleep } from '@sim/utils/helpers'
+import { JSDOM } from 'jsdom'
+import { describe, expect, it } from 'vitest'
+import { renderSimPageDocument } from '@/lib/workspace-files/page-document'
+
+const SOURCE = `---
+title: Elder Architecture
+---
+
+# Skills & Connections
+
+## Evidence
+
+alpha
+
+## Delegation
+
+beta
+
+# Slack Gateway
+
+## Transport
+
+gamma
+`
+
+const domOptions = {
+  runScripts: 'dangerously' as const,
+  pretendToBeVisual: true,
+  beforeParse(window: any) {
+    // jsdom gaps, present in every real browser the page renders in.
+    window.matchMedia = () => ({ matches: false, addEventListener() {}, removeEventListener() {} })
+    window.ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    }
+  },
+}
+
+const tick = () => sleep(60)
+
+describe('in-document tabs drive the on-this-page rail', () => {
+  it('scopes the rail to the active tab and rebuilds it on switch', async () => {
+    const dom = new JSDOM(renderSimPageDocument(SOURCE), domOptions)
+    const { document } = dom.window
+    await tick()
+
+    const railLinks = () =>
+      [...document.querySelectorAll('.rail[data-rail="toc"] a')].map((a) => a.textContent)
+    const buttons = [...document.querySelectorAll('[data-doc-tabs] .page-tab')]
+
+    expect(buttons.map((b) => b.textContent)).toEqual(['Skills & Connections', 'Slack Gateway'])
+    expect(railLinks()).toEqual(['Evidence', 'Delegation'])
+
+    buttons[1].dispatchEvent(new dom.window.Event('click', { bubbles: true }))
+    await tick()
+    expect(document.querySelector('[data-tab-panel].is-active')?.id).toBe('doc-tab-1')
+    expect(railLinks()).toEqual(['Transport'])
+
+    buttons[0].dispatchEvent(new dom.window.Event('click', { bubbles: true }))
+    await tick()
+    expect(railLinks()).toEqual(['Evidence', 'Delegation'])
+  })
+
+  it('repositions the tab row as chrome between the bar and the columns', async () => {
+    const dom = new JSDOM(renderSimPageDocument(SOURCE), domOptions)
+    const { document } = dom.window
+    await tick()
+
+    const nav = document.querySelector('.page-tabs')
+    expect(nav?.parentElement?.classList.contains('page')).toBe(true)
+    expect(nav?.previousElementSibling?.classList.contains('art-bar')).toBe(true)
+    expect(nav?.nextElementSibling?.classList.contains('art-cols')).toBe(true)
+  })
+})
+
+describe('older page shapes keep their rail', () => {
+  it('builds the rail for a plain untabbed page', async () => {
+    const dom = new JSDOM(
+      renderSimPageDocument(`---
+title: Plain Doc
+---
+
+## First
+
+a
+
+## Second
+
+b
+`),
+      domOptions
+    )
+    await tick()
+    const links = [...dom.window.document.querySelectorAll('.rail[data-rail="toc"] a')].map(
+      (a) => a.textContent
+    )
+    expect(links).toEqual(['First', 'Second'])
+  })
+
+  it('builds the whole-page rail for a legacy cross-file tabs page', async () => {
+    const dom = new JSDOM(
+      renderSimPageDocument(`---
+title: Overview
+tabs:
+  - "Overview"
+  - "[API](sim:file/abc)"
+---
+
+## Intro
+
+x
+`),
+      domOptions
+    )
+    await tick()
+    const { document } = dom.window
+    const links = [...document.querySelectorAll('.rail[data-rail="toc"] a')].map(
+      (a) => a.textContent
+    )
+    expect(links).toEqual(['Intro'])
+    const nav = document.querySelector('.page-tabs')
+    expect(nav?.previousElementSibling?.classList.contains('art-bar')).toBe(true)
+  })
+})
diff --git a/apps/sim/lib/workspace-files/shell-layout.test.ts b/apps/sim/lib/workspace-files/shell-layout.test.ts
new file mode 100644
index 0000000000..493cabb462
--- /dev/null
+++ b/apps/sim/lib/workspace-files/shell-layout.test.ts
@@ -0,0 +1,58 @@
+/** @vitest-environment jsdom */
+import { describe, expect, it } from 'vitest'
+import { SIM_ARTIFACT_SHELL, simTokenOverrides } from '@/lib/workspace-files/artifact-stylesheet'
+import { compileSimPage } from '@/lib/workspace-files/page-compile'
+
+function runShell(source: string) {
+  window.matchMedia ??= (() =>
+    ({ matches: false, addEventListener() {}, removeEventListener() {} }) as never) as never
+  ;(globalThis as { matchMedia?: unknown }).matchMedia = window.matchMedia
+  ;(globalThis as { ResizeObserver?: unknown }).ResizeObserver ??= class {
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  }
+  const compiled = compileSimPage(source)
+  document.documentElement.innerHTML = compiled
+    .replace(/^<!DOCTYPE html>\n<html lang="en">/, '')
+    .replace(/<\/html>$/, '')
+  const script = SIM_ARTIFACT_SHELL.replace(/^<script>/, '').replace(/<\/script>$/, '')
+  // biome-ignore lint: test harness executes the shell inline
+  new Function(script)()
+}
+
+describe('shell layout decisions', () => {
+  it('renders only the right TOC rail, however many sections', () => {
+    runShell('---\ntitle: T\n---\n## A\n\nx\n\n## B\n\ny\n\n## C\n\nz')
+    expect(document.querySelector('.rail[data-rail="nav"]')).toBeNull()
+    expect(document.querySelector('.art-search')).toBeNull()
+    const toc = [...document.querySelectorAll('.rail[data-rail="toc"] .toc-items a')]
+    expect(toc.map((a) => a.textContent)).toEqual(['A', 'B', 'C'])
+  })
+
+  it('keeps the set tabs in place and adds no arrow chrome', () => {
+    runShell('---\ntitle: T\ntabs:\n  - "T"\n  - "[Reference](sim:file/b)"\n---\n## Only\n\nx')
+    const tabs = [...document.querySelectorAll('.page-tabs .page-tab')]
+    expect(tabs.map((tab) => tab.textContent)).toEqual(['T', 'Reference'])
+    expect(document.querySelector('.page-tab.is-active')?.textContent).toBe('T')
+    expect(document.querySelector('.page-actions')).toBeNull()
+    expect(document.querySelector('.pa-nav')).toBeNull()
+  })
+})
+
+describe('simTokenOverrides', () => {
+  // The overrides pin the app's LIVE token values — which are one theme's
+  // palette. Scoping them to the app's current theme is what keeps the
+  // page's own light/dark toggle alive: pinning both `[data-theme]` states
+  // (the pre-fix behavior) froze the preview on the app's palette no matter
+  // what the toggle set.
+  it('pins the live tokens only under the current app theme', () => {
+    document.documentElement.style.setProperty('--bg', '#123456')
+    const block = simTokenOverrides('light')
+    expect(block).toContain(':root[data-theme="light"]')
+    expect(block).toContain('--bg:#123456')
+    expect(block).not.toContain('[data-theme="dark"]')
+    expect(block).not.toMatch(/(^|\{|,):root[,{]/)
+    document.documentElement.style.removeProperty('--bg')
+  })
+})
diff --git a/apps/sim/lib/workspaces/host-context.test.ts b/apps/sim/lib/workspaces/host-context.test.ts
index c08bb7d7d3..6c83a34867 100644
--- a/apps/sim/lib/workspaces/host-context.test.ts
+++ b/apps/sim/lib/workspaces/host-context.test.ts
@@ -85,6 +85,7 @@ describe('getWorkspaceHostContextForViewer', () => {
           permission: 'write',
           isHostOrganizationMember: true,
           isHostOrganizationAdmin: false,
+          organizationRole: 'member',
         },
       })
     )
@@ -104,6 +105,7 @@ describe('getWorkspaceHostContextForViewer', () => {
       permission: 'read',
       isHostOrganizationMember: false,
       isHostOrganizationAdmin: false,
+      organizationRole: null,
     })
     expect(context?.hostOrganizationId).toBe('org-host')
   })
@@ -125,6 +127,7 @@ describe('getWorkspaceHostContextForViewer', () => {
           permission: 'admin',
           isHostOrganizationMember: false,
           isHostOrganizationAdmin: false,
+          organizationRole: null,
         },
       })
     )
diff --git a/apps/sim/lib/workspaces/host-context.ts b/apps/sim/lib/workspaces/host-context.ts
index 4b01ec40ec..a9306e22dc 100644
--- a/apps/sim/lib/workspaces/host-context.ts
+++ b/apps/sim/lib/workspaces/host-context.ts
@@ -26,7 +26,7 @@ async function resolveWorkspaceHostContextForViewer(
     getWorkspaceOwnerSubscriptionAccess(workspaceId),
     hostOrganizationId
       ? getOrganizationSettingsAccess(hostOrganizationId, userId)
-      : Promise.resolve({ isMember: false, isAdmin: false }),
+      : Promise.resolve({ role: null, isMember: false, isAdmin: false }),
   ])
   const credentialGroupsAvailable = await isCredentialGroupsAvailable(ownerBilling)
 
@@ -43,6 +43,7 @@ async function resolveWorkspaceHostContextForViewer(
       permission: access.permission,
       isHostOrganizationMember: hostOrganizationAccess.isMember,
       isHostOrganizationAdmin: hostOrganizationAccess.isAdmin,
+      organizationRole: hostOrganizationAccess.role,
     },
     features: {
       credentialGroups: credentialGroupsAvailable,
diff --git a/apps/sim/package.json b/apps/sim/package.json
index 370279e327..76d53624ec 100644
--- a/apps/sim/package.json
+++ b/apps/sim/package.json
@@ -81,11 +81,13 @@
     "@modelcontextprotocol/sdk": "1.29.0",
     "@monaco-editor/react": "4.7.0",
     "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "0.219.0",
     "@opentelemetry/core": "2.8.0",
     "@opentelemetry/exporter-logs-otlp-http": "0.219.0",
     "@opentelemetry/exporter-metrics-otlp-http": "0.219.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.219.0",
     "@opentelemetry/resources": "2.8.0",
+    "@opentelemetry/sdk-logs": "0.219.0",
     "@opentelemetry/sdk-metrics": "2.8.0",
     "@opentelemetry/sdk-node": "0.219.0",
     "@opentelemetry/sdk-trace-base": "2.8.0",
@@ -190,6 +192,7 @@
     "lib0": "0.2.117",
     "lru-cache": "11.3.6",
     "mammoth": "^1.9.0",
+    "marked": "15.0.12",
     "mermaid": "11.16.1",
     "micromatch": "4.0.8",
     "monaco-editor": "0.55.1",
diff --git a/apps/sim/tools/index.ts b/apps/sim/tools/index.ts
index b2c6ce262d..bf0d217a6f 100644
--- a/apps/sim/tools/index.ts
+++ b/apps/sim/tools/index.ts
@@ -352,12 +352,26 @@ async function resolveCopilotEnvReferences(
     return
   }
 
-  const pending: Array<{ paramId: string; value: string }> = []
+  // Models improvise reference syntax: after `{{NAME}}`, the bare variable
+  // name is the common fallback — it previously went upstream as the literal
+  // credential and failed with an undiagnosable 401. `{{NAME}}` is the one
+  // explicit reference form, so a missing variable is a hard error. A bare
+  // name is a reference only when a variable by that exact name exists
+  // (`soft`): plenty of real API keys match the identifier pattern, and
+  // those must pass through verbatim. `$NAME` is deliberately NOT a
+  // reference — real credentials can start with `$`, and a secret must never
+  // be reinterpreted as a lookup.
+  const pending: Array<{ paramId: string; value: string; soft?: boolean }> = []
   for (const [paramId, paramDef] of Object.entries(tool.params || {})) {
     if (paramDef?.visibility !== 'user-only') continue
     const value = params[paramId]
-    if (typeof value === 'string' && value.startsWith('{{') && value.endsWith('}}')) {
+    if (typeof value !== 'string') continue
+    if (value.startsWith('{{') && value.endsWith('}}')) {
       pending.push({ paramId, value })
+      continue
+    }
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+      pending.push({ paramId, value: `{{${value}}}`, soft: true })
     }
   }
 
@@ -376,7 +390,7 @@ async function resolveCopilotEnvReferences(
     const { getEffectiveDecryptedEnv } = await import('@/lib/environment/utils')
     const envVars = await getEffectiveDecryptedEnv(scope.userId, scope.workspaceId)
 
-    for (const { paramId, value } of pending) {
+    for (const { paramId, value, soft } of pending) {
       const missingKeys: string[] = []
       const resolved = resolveEnvVarReferences(value, envVars, {
         allowEmbedded: false,
@@ -388,6 +402,9 @@ async function resolveCopilotEnvReferences(
         },
       })
       if (missingKeys.length > 0) {
+        // A bare name that matches no variable is treated as the literal
+        // credential it probably is; only explicit reference forms error.
+        if (soft) continue
         const scopeHint = scope.workspaceId
           ? ''
           : ' (no workspace context — only personal variables are available here)'
diff --git a/apps/sim/tools/params.ts b/apps/sim/tools/params.ts
index 08b3a8b31a..39dfa45557 100644
--- a/apps/sim/tools/params.ts
+++ b/apps/sim/tools/params.ts
@@ -615,6 +615,16 @@ export function createUserToolSchema(
         .filter(Boolean)
         .join(' ')
     }
+    // Copilot agents never see secret values, only names — so tell them the
+    // reference form works here, or they paste placeholders that fail upstream.
+    if (visibility === 'user-only' && surface === 'copilot') {
+      propertySchema.description = [
+        propertySchema.description,
+        'Accepts an environment-variable reference like {{VAR_NAME}} (see environment/variables.json), resolved server-side.',
+      ]
+        .filter(Boolean)
+        .join(' ')
+    }
     schema.properties[paramId] = propertySchema
 
     if (param.required && paramId !== hostedApiKeyParam) {
diff --git a/apps/sim/triggers/constants.ts b/apps/sim/triggers/constants.ts
index 64ed9a898a..94f2cf9c38 100644
--- a/apps/sim/triggers/constants.ts
+++ b/apps/sim/triggers/constants.ts
@@ -40,6 +40,16 @@ export const TRIGGER_RUNTIME_SUBBLOCK_IDS: string[] = [
  */
 export const TRIGGER_WEBHOOK_URL_FIELD = 'triggerWebhookUrl'
 
+/**
+ * Derived, read-only input surfaced on copilot reads of trigger blocks that
+ * route by CREDENTIAL rather than a per-workflow webhook URL (e.g. Slack v2's
+ * `slack_oauth`). Explains where events actually arrive — a custom bot's
+ * per-credential Request URL or the shared Sim-app endpoint — so the copilot
+ * can answer "where do I point Slack?" without inventing a field. Never
+ * stored; rejected on write like {@link TRIGGER_WEBHOOK_URL_FIELD}.
+ */
+export const TRIGGER_ROUTING_FIELD = 'triggerRouting'
+
 /**
  * Maximum number of consecutive failures before a trigger (schedule/webhook) is auto-disabled.
  * This prevents runaway errors from continuously executing failing workflows.
diff --git a/apps/sim/triggers/webhook-url.ts b/apps/sim/triggers/webhook-url.ts
index 289e928a9c..6f28289f08 100644
--- a/apps/sim/triggers/webhook-url.ts
+++ b/apps/sim/triggers/webhook-url.ts
@@ -12,6 +12,16 @@ export function buildWebhookTriggerUrl(path: string): string {
   return `${getBaseUrl()}/api/webhooks/trigger/${path}`
 }
 
+/**
+ * The Request URL a Slack custom-bot app posts events to. One URL per
+ * credential (not per workflow): the endpoint verifies with the credential's
+ * signing secret and fans out to every workflow whose trigger routes by this
+ * credential id. Uses the app's public base so Slack's servers can reach it.
+ */
+export function buildSlackCustomBotRequestUrl(credentialId: string): string {
+  return `${getBaseUrl()}/api/webhooks/slack/custom/${credentialId}`
+}
+
 function subBlockValue(block: BlockState, subBlockId: string): unknown {
   return block.subBlocks?.[subBlockId]?.value
 }
diff --git a/bun.lock b/bun.lock
index a3c25e1b56..85505faa98 100644
--- a/bun.lock
+++ b/bun.lock
@@ -1,6 +1,5 @@
 {
   "lockfileVersion": 1,
-  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "simstudio",
@@ -184,11 +183,13 @@
         "@modelcontextprotocol/sdk": "1.29.0",
         "@monaco-editor/react": "4.7.0",
         "@opentelemetry/api": "^1.9.0",
+        "@opentelemetry/api-logs": "0.219.0",
         "@opentelemetry/core": "2.8.0",
         "@opentelemetry/exporter-logs-otlp-http": "0.219.0",
         "@opentelemetry/exporter-metrics-otlp-http": "0.219.0",
         "@opentelemetry/exporter-trace-otlp-http": "0.219.0",
         "@opentelemetry/resources": "2.8.0",
+        "@opentelemetry/sdk-logs": "0.219.0",
         "@opentelemetry/sdk-metrics": "2.8.0",
         "@opentelemetry/sdk-node": "0.219.0",
         "@opentelemetry/sdk-trace-base": "2.8.0",
@@ -293,6 +294,7 @@
         "lib0": "0.2.117",
         "lru-cache": "11.3.6",
         "mammoth": "^1.9.0",
+        "marked": "15.0.12",
         "mermaid": "11.16.1",
         "micromatch": "4.0.8",
         "monaco-editor": "0.55.1",
@@ -537,6 +539,7 @@
       "name": "@sim/logger",
       "version": "0.1.0",
       "dependencies": {
+        "@opentelemetry/api-logs": "0.219.0",
         "@sim/utils": "workspace:*",
         "chalk": "5.6.2",
       },
@@ -1839,8 +1842,6 @@
 
     "@sim/security": ["@sim/security@workspace:packages/security"],
 
-    "sim-setup": ["sim-setup@workspace:packages/sim-setup"],
-
     "@sim/terminal-protocol": ["@sim/terminal-protocol@workspace:packages/terminal-protocol"],
 
     "@sim/testing": ["@sim/testing@workspace:packages/testing"],
@@ -4239,6 +4240,8 @@
 
     "sim": ["sim@workspace:packages/sim-cli"],
 
+    "sim-setup": ["sim-setup@workspace:packages/sim-setup"],
+
     "simple-update-notifier": ["simple-update-notifier@2.0.0", "", { "dependencies": { "semver": "^7.5.3" } }, "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w=="],
 
     "simstudio": ["simstudio@workspace:packages/cli"],
diff --git a/package.json b/package.json
index e33b648512..0807e5a744 100644
--- a/package.json
+++ b/package.json
@@ -82,6 +82,8 @@
     "metrics-contract:check": "bun run scripts/sync-metrics-contract.ts --check",
     "vfs-snapshot-contract:generate": "bun run scripts/sync-vfs-snapshot-contract.ts",
     "vfs-snapshot-contract:check": "bun run scripts/sync-vfs-snapshot-contract.ts --check",
+    "docs-manifest:generate": "bun run scripts/sync-docs-manifest.ts",
+    "docs-manifest:check": "bun run scripts/sync-docs-manifest.ts --check",
     "mship:generate": "bun run scripts/generate-mship-contracts.ts",
     "mship:check": "bun run scripts/generate-mship-contracts.ts --check",
     "library:covers": "bun run scripts/generate-library-covers.tsx",
diff --git a/packages/browser-protocol/src/index.ts b/packages/browser-protocol/src/index.ts
index 5158764dd0..ca7dd65cbd 100644
--- a/packages/browser-protocol/src/index.ts
+++ b/packages/browser-protocol/src/index.ts
@@ -33,11 +33,14 @@ export const BROWSER_TOOL_NAMES = [
   'browser_screenshot',
   'browser_extract',
   'browser_click',
+  'browser_click_at',
   'browser_type',
+  'browser_insert_text',
   'browser_press_key',
   'browser_scroll',
   'browser_select_option',
   'browser_hover',
+  'browser_drag',
   'browser_request_takeover',
 ] as const
 
diff --git a/packages/desktop-bridge/src/index.ts b/packages/desktop-bridge/src/index.ts
index c49a64ed35..694256f7ad 100644
--- a/packages/desktop-bridge/src/index.ts
+++ b/packages/desktop-bridge/src/index.ts
@@ -232,6 +232,11 @@ export interface SimDesktopBrowserAgentApi {
   getTabsState(scopeId: string): Promise<BrowserTabsState>
   /** Read a privacy-preserving hint of websites that may have a usable session. */
   getKnownSessions(): Promise<BrowserKnownSessionsState>
+  /**
+   * Live search completions for the omnibox. Optional while installed shells
+   * that predate search suggestions remain supported.
+   */
+  getSearchSuggestions?(query: string): Promise<string[]>
   /**
    * Erase browsing data from the dedicated profile and resolve the resulting
    * session list. Pass the kinds to clear; omit for all of them. Saved
@@ -833,6 +838,8 @@ export interface DesktopPreferences {
   trayEnabled: boolean
   /** Let Chat drive the built-in agent browser on this device. */
   browserEnabled: boolean
+  /** Whether typing in the omnibox may request live Google search completions. */
+  browserSearchSuggestionsEnabled?: boolean
   /** Let Chat run commands in local shells. */
   terminalEnabled: boolean
   /**
@@ -917,6 +924,11 @@ export interface SimDesktopSettingsApi {
     key: K,
     value: DesktopPreferences[K]
   ): Promise<DesktopPreferences>
+  /**
+   * Controls whether partial omnibox queries may be sent to Google. Optional
+   * for compatibility with installed shells that predate live suggestions.
+   */
+  setBrowserSearchSuggestionsEnabled?(enabled: boolean): Promise<DesktopPreferences>
   notify(payload: DesktopNotificationPayload): Promise<boolean>
   /** Overrides the appearance requested by browser pages. */
   setBrowserTheme(theme: DesktopAppearanceTheme): Promise<DesktopPreferences>
diff --git a/packages/logger/package.json b/packages/logger/package.json
index 0e8135a81c..59e4ce2bdf 100644
--- a/packages/logger/package.json
+++ b/packages/logger/package.json
@@ -25,6 +25,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
+    "@opentelemetry/api-logs": "0.219.0",
     "@sim/utils": "workspace:*",
     "chalk": "5.6.2"
   },
diff --git a/packages/logger/src/index.ts b/packages/logger/src/index.ts
index 0acda78e93..a906c246ab 100644
--- a/packages/logger/src/index.ts
+++ b/packages/logger/src/index.ts
@@ -4,6 +4,7 @@
  * Framework-agnostic logging utilities for the Sim platform.
  * Provides standardized console logging with environment-aware configuration.
  */
+import { logs, SeverityNumber } from '@opentelemetry/api-logs'
 import { filterUndefined, isRecordLike } from '@sim/utils/object'
 import chalk from 'chalk'
 import { getRequestContext } from './request-context'
@@ -394,6 +395,8 @@ export class Logger {
   private log(level: LogLevel, message: string, ...args: unknown[]) {
     if (!this.shouldLog(level)) return
 
+    emitOtelLogRecord(level, this.module, message, this.metadata, args)
+
     const timestamp = new Date().toISOString()
     const formattedArgs = this.formatArgs(args)
 
@@ -403,6 +406,7 @@ export class Logger {
           requestId: reqCtx.requestId,
           method: reqCtx.method,
           path: reqCtx.path,
+          traceId: reqCtx.traceId,
           ...this.metadata,
         }
       : this.metadata
@@ -523,4 +527,59 @@ export function createLogger(module: string, config?: LoggerConfig): Logger {
 }
 
 export type { RequestContext } from './request-context'
-export { getRequestContext, runWithRequestContext } from './request-context'
+export { getRequestContext, runWithRequestContext, setRequestTraceId } from './request-context'
+
+const OTEL_LOG_SEVERITY: Record<LogLevel, { number: SeverityNumber; text: string }> = {
+  [LogLevel.DEBUG]: { number: SeverityNumber.DEBUG, text: 'DEBUG' },
+  [LogLevel.INFO]: { number: SeverityNumber.INFO, text: 'INFO' },
+  [LogLevel.WARN]: { number: SeverityNumber.WARN, text: 'WARN' },
+  [LogLevel.ERROR]: { number: SeverityNumber.ERROR, text: 'ERROR' },
+}
+
+const OTEL_LOG_ARG_MAX_CHARS = 2000
+
+/**
+ * Fans every accepted log line out through the OTel Logs API. Until an
+ * application installs a global LoggerProvider (apps/sim does in
+ * instrumentation-node.ts), the api-logs global is a no-op delegate, so this
+ * costs nothing in browsers, tests, and services that do not export logs.
+ * The active trace context is attached by the SDK, which is what enables
+ * span → logs correlation in the backend. Never allowed to throw into the
+ * console write path.
+ */
+function emitOtelLogRecord(
+  level: LogLevel,
+  module: string,
+  message: string,
+  metadata: Record<string, unknown>,
+  args: unknown[]
+): void {
+  try {
+    const severity = OTEL_LOG_SEVERITY[level]
+    const attributes: Record<string, string> = { 'log.module': module }
+    for (const [key, value] of Object.entries(filterUndefined(metadata))) {
+      attributes[key] = String(value)
+    }
+    const firstError = args.find((arg) => arg instanceof Error) as Error | undefined
+    if (firstError) {
+      attributes['error.message'] = firstError.message
+      if (firstError.stack) attributes['error.stack'] = firstError.stack
+    }
+    const plainArgs = args.filter((arg) => !(arg instanceof Error))
+    if (plainArgs.length > 0) {
+      try {
+        attributes['log.args'] = JSON.stringify(plainArgs).slice(0, OTEL_LOG_ARG_MAX_CHARS)
+      } catch {
+        attributes['log.args'] = String(plainArgs).slice(0, OTEL_LOG_ARG_MAX_CHARS)
+      }
+    }
+    logs.getLogger('sim').emit({
+      severityNumber: severity.number,
+      severityText: severity.text,
+      body: message,
+      attributes,
+    })
+  } catch {
+    // Log export must never break the primary console write path.
+  }
+}
diff --git a/packages/logger/src/request-context.ts b/packages/logger/src/request-context.ts
index 698e243747..c2e5923e03 100644
--- a/packages/logger/src/request-context.ts
+++ b/packages/logger/src/request-context.ts
@@ -2,6 +2,13 @@ export interface RequestContext {
   requestId: string
   method?: string
   path?: string
+  /**
+   * The 32-hex OTel trace id correlating this request across services
+   * (the same value the Go copilot logs as trace_id/request_id). Seeded
+   * from an incoming `traceparent` header, or stamped mid-request via
+   * `setRequestTraceId` when the trace root is created locally.
+   */
+  traceId?: string
 }
 
 /**
@@ -44,3 +51,16 @@ export function runWithRequestContext<T>(context: RequestContext, fn: () => T):
 export function getRequestContext(): RequestContext | undefined {
   return storage.getStore()
 }
+
+/**
+ * Stamps the cross-service trace id onto the current request context so
+ * every subsequent log line in this request carries it. The trace root is
+ * often created after the route context (e.g. the copilot chat POST derives
+ * its trace id when it starts the OTel root), so this mutates the live
+ * store rather than requiring the id at `runWithRequestContext` time.
+ * No-op outside a request context.
+ */
+export function setRequestTraceId(traceId: string): void {
+  const store = storage.getStore()
+  if (store && traceId) store.traceId = traceId
+}
diff --git a/packages/testing/src/mocks/logger.mock.ts b/packages/testing/src/mocks/logger.mock.ts
index 291b91df5d..f7330cb2bc 100644
--- a/packages/testing/src/mocks/logger.mock.ts
+++ b/packages/testing/src/mocks/logger.mock.ts
@@ -39,6 +39,7 @@ export const loggerMock = {
   logger: createMockLogger(),
   runWithRequestContext: vi.fn(<T>(_ctx: unknown, fn: () => T): T => fn()),
   getRequestContext: vi.fn(() => undefined),
+  setRequestTraceId: vi.fn(),
 }
 
 /**
diff --git a/packages/testing/src/mocks/permissions.mock.ts b/packages/testing/src/mocks/permissions.mock.ts
index 9b38a9da1f..4d17a40c93 100644
--- a/packages/testing/src/mocks/permissions.mock.ts
+++ b/packages/testing/src/mocks/permissions.mock.ts
@@ -45,4 +45,9 @@ export const permissionsMock = {
   getWorkspaceMemberProfiles: permissionsMockFns.mockGetWorkspaceMemberProfiles,
   hasWorkspaceAdminAccess: permissionsMockFns.mockHasWorkspaceAdminAccess,
   getManageableWorkspaces: permissionsMockFns.mockGetManageableWorkspaces,
+  // Faithful to the real type guard without importing the class the mock
+  // replaces: the constructor stamps name = 'WorkspaceAccessDeniedError', so a
+  // test exercising the 403 projection throws an Error carrying that name.
+  isWorkspaceAccessDeniedError: (error: unknown): boolean =>
+    error instanceof Error && error.name === 'WorkspaceAccessDeniedError',
 }
diff --git a/scripts/check-api-validation-contracts.ts b/scripts/check-api-validation-contracts.ts
index 2cea676d15..6b41d63c67 100644
--- a/scripts/check-api-validation-contracts.ts
+++ b/scripts/check-api-validation-contracts.ts
@@ -9,8 +9,8 @@ const QUERY_HOOKS_DIR = path.join(ROOT, 'apps/sim/hooks/queries')
 const SELECTOR_HOOKS_DIR = path.join(ROOT, 'apps/sim/hooks/selectors')
 
 const BASELINE = {
-  totalRoutes: 1130,
-  zodRoutes: 1130,
+  totalRoutes: 1132,
+  zodRoutes: 1132,
   nonZodRoutes: 0,
 } as const
 
diff --git a/scripts/check-tool-registry-boundary.baseline.json b/scripts/check-tool-registry-boundary.baseline.json
index 50ca5edf2c..f20004b276 100644
--- a/scripts/check-tool-registry-boundary.baseline.json
+++ b/scripts/check-tool-registry-boundary.baseline.json
@@ -10,12 +10,12 @@
       "gateways": {}
     },
     "app/workspace/[workspaceId]/chat/[chatId]/page.tsx": {
-      "modules": 2996,
+      "modules": 3005,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/home/home.tsx": 1366,
-        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx": 1020,
-        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/index.ts": 885,
-        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/index.ts": 882,
+        "apps/sim/app/workspace/[workspaceId]/home/home.tsx": 1370,
+        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx": 1021,
+        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/index.ts": 882,
+        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/index.ts": 879,
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 311,
         "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx": 308,
@@ -23,34 +23,34 @@
       }
     },
     "app/workspace/[workspaceId]/files/[fileId]/page.tsx": {
-      "modules": 1990,
+      "modules": 2002,
       "gateways": {
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 334,
-        "apps/sim/app/workspace/[workspaceId]/files/files.tsx": 296,
+        "apps/sim/app/workspace/[workspaceId]/files/files.tsx": 300,
         "apps/sim/lib/auth/index.ts": 215,
-        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/index.ts": 144,
-        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx": 130,
+        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/index.ts": 148,
+        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx": 131,
         "apps/sim/lib/api/contracts/index.ts": 108,
         "apps/sim/lib/webhooks/providers/index.ts": 103
       }
     },
     "app/workspace/[workspaceId]/files/[fileId]/view/page.tsx": {
-      "modules": 59,
+      "modules": 60,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx": 58,
+        "apps/sim/app/workspace/[workspaceId]/files/[fileId]/view/file-viewer.tsx": 59,
         "apps/sim/hooks/queries/workspace-files.ts": 55
       }
     },
     "app/workspace/[workspaceId]/files/page.tsx": {
-      "modules": 1990,
+      "modules": 2002,
       "gateways": {
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 334,
-        "apps/sim/app/workspace/[workspaceId]/files/files.tsx": 298,
+        "apps/sim/app/workspace/[workspaceId]/files/files.tsx": 302,
         "apps/sim/lib/auth/index.ts": 215,
-        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/index.ts": 144,
-        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx": 130,
+        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/index.ts": 148,
+        "apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/file-viewer.tsx": 131,
         "apps/sim/lib/api/contracts/index.ts": 108,
         "apps/sim/lib/webhooks/providers/index.ts": 103
       }
@@ -60,12 +60,12 @@
       "gateways": {}
     },
     "app/workspace/[workspaceId]/home/page.tsx": {
-      "modules": 2996,
+      "modules": 3005,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/home/home.tsx": 1366,
-        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx": 1020,
-        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/index.ts": 885,
-        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/index.ts": 882,
+        "apps/sim/app/workspace/[workspaceId]/home/home.tsx": 1370,
+        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/mothership-view.tsx": 1021,
+        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/index.ts": 882,
+        "apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/index.ts": 879,
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 311,
         "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx": 308,
@@ -73,11 +73,11 @@
       }
     },
     "app/workspace/[workspaceId]/integrations/[block]/page.tsx": {
-      "modules": 1315,
+      "modules": 1320,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/integrations/[block]/integration-block-detail.tsx": 1289,
-        "apps/sim/blocks/registry.ts": 932,
+        "apps/sim/app/workspace/[workspaceId]/integrations/[block]/integration-block-detail.tsx": 1294,
         "apps/sim/triggers/index.ts": 489,
+        "apps/sim/blocks/registry.ts": 439,
         "apps/sim/lib/api/contracts/index.ts": 128,
         "apps/sim/blocks/blocks/credential-group.ts": 105,
         "apps/sim/stores/workflows/registry/store.ts": 80,
@@ -86,9 +86,9 @@
       }
     },
     "app/workspace/[workspaceId]/integrations/connected/[credentialId]/page.tsx": {
-      "modules": 1297,
+      "modules": 1299,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/integrations/connected/[credentialId]/connected-credential-detail.tsx": 1296,
+        "apps/sim/app/workspace/[workspaceId]/integrations/connected/[credentialId]/connected-credential-detail.tsx": 1298,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 341,
         "apps/sim/lib/api/contracts/index.ts": 134,
@@ -99,7 +99,7 @@
       }
     },
     "app/workspace/[workspaceId]/integrations/page.tsx": {
-      "modules": 1301,
+      "modules": 1305,
       "gateways": {
         "apps/sim/app/workspace/[workspaceId]/integrations/integrations.tsx": 1017,
         "apps/sim/blocks/registry.ts": 933,
@@ -112,68 +112,68 @@
       }
     },
     "app/workspace/[workspaceId]/knowledge/[id]/[documentId]/page.tsx": {
-      "modules": 1521,
+      "modules": 1523,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/document.tsx": 1234,
+        "apps/sim/app/workspace/[workspaceId]/knowledge/[id]/[documentId]/document.tsx": 1232,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 337,
         "apps/sim/blocks/registry-maps.ts": 334,
         "apps/sim/lib/api/contracts/index.ts": 120,
         "apps/sim/connectors/registry.ts": 61,
-        "apps/sim/lib/api/contracts/tools/index.ts": 60,
-        "apps/sim/app/workspace/[workspaceId]/components/index.ts": 57
+        "apps/sim/app/workspace/[workspaceId]/components/index.ts": 60,
+        "apps/sim/lib/api/contracts/tools/index.ts": 60
       }
     },
     "app/workspace/[workspaceId]/knowledge/[id]/page.tsx": {
-      "modules": 1536,
+      "modules": 1538,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/knowledge/[id]/base.tsx": 1249,
+        "apps/sim/app/workspace/[workspaceId]/knowledge/[id]/base.tsx": 1247,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 337,
         "apps/sim/blocks/registry-maps.ts": 334,
         "apps/sim/lib/api/contracts/index.ts": 120,
         "apps/sim/connectors/registry.ts": 61,
-        "apps/sim/lib/api/contracts/tools/index.ts": 60,
-        "apps/sim/app/workspace/[workspaceId]/components/index.ts": 57
+        "apps/sim/app/workspace/[workspaceId]/components/index.ts": 60,
+        "apps/sim/lib/api/contracts/tools/index.ts": 60
       }
     },
     "app/workspace/[workspaceId]/knowledge/page.tsx": {
-      "modules": 2203,
+      "modules": 2209,
       "gateways": {
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 332,
         "apps/sim/app/workspace/[workspaceId]/knowledge/prefetch.ts": 276,
         "apps/sim/lib/knowledge/application/knowledge-bases.ts": 220,
-        "apps/sim/app/workspace/[workspaceId]/knowledge/knowledge.tsx": 186,
+        "apps/sim/app/workspace/[workspaceId]/knowledge/knowledge.tsx": 184,
         "apps/sim/lib/auth/index.ts": 164,
         "apps/sim/lib/knowledge/orchestration/index.ts": 138,
         "apps/sim/lib/knowledge/orchestration/connectors.ts": 133
       }
     },
     "app/workspace/[workspaceId]/layout.tsx": {
-      "modules": 2045,
+      "modules": 2053,
       "gateways": {
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 333,
-        "apps/sim/app/workspace/[workspaceId]/components/workspace-chrome/index.ts": 304,
-        "apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx": 296,
-        "apps/sim/lib/auth/index.ts": 280,
-        "apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/index.ts": 203,
+        "apps/sim/app/workspace/[workspaceId]/components/workspace-chrome/index.ts": 306,
+        "apps/sim/app/workspace/[workspaceId]/w/components/sidebar/sidebar.tsx": 298,
+        "apps/sim/lib/auth/index.ts": 284,
+        "apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/index.ts": 205,
         "apps/sim/lib/api/contracts/index.ts": 109,
         "apps/sim/lib/webhooks/providers/index.ts": 103
       }
     },
     "app/workspace/[workspaceId]/logs/page.tsx": {
-      "modules": 1755,
+      "modules": 1760,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/logs/logs.tsx": 1470,
+        "apps/sim/app/workspace/[workspaceId]/logs/logs.tsx": 1471,
         "apps/sim/triggers/registry.ts": 488,
-        "apps/sim/app/workspace/[workspaceId]/logs/components/index.ts": 420,
-        "apps/sim/app/workspace/[workspaceId]/logs/components/log-details/components/execution-snapshot/index.ts": 366,
+        "apps/sim/app/workspace/[workspaceId]/logs/components/index.ts": 421,
+        "apps/sim/app/workspace/[workspaceId]/logs/components/log-details/components/execution-snapshot/index.ts": 367,
         "apps/sim/blocks/registry.ts": 328,
-        "apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-editor/index.ts": 322,
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/index.ts": 287,
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx": 255
+        "apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-editor/index.ts": 323,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/index.ts": 288,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx": 256
       }
     },
     "app/workspace/[workspaceId]/page.tsx": {
@@ -185,16 +185,16 @@
       "gateways": {}
     },
     "app/workspace/[workspaceId]/settings/[section]/page.tsx": {
-      "modules": 2062,
+      "modules": 2071,
       "gateways": {
         "apps/sim/triggers/registry.ts": 452,
-        "apps/sim/app/workspace/[workspaceId]/settings/[section]/settings.tsx": 440,
+        "apps/sim/app/workspace/[workspaceId]/settings/[section]/settings.tsx": 444,
         "apps/sim/blocks/registry.ts": 332,
-        "apps/sim/lib/auth/index.ts": 290,
+        "apps/sim/lib/auth/index.ts": 294,
         "apps/sim/lib/api/contracts/index.ts": 107,
         "apps/sim/lib/webhooks/providers/index.ts": 103,
         "apps/sim/lib/api/contracts/tools/index.ts": 59,
-        "apps/sim/app/workspace/[workspaceId]/settings/components/recently-deleted/recently-deleted.tsx": 42
+        "apps/sim/lib/uploads/utils/file-utils.server.ts": 46
       }
     },
     "app/workspace/[workspaceId]/settings/billing/credit-usage/layout.tsx": {
@@ -202,13 +202,13 @@
       "gateways": {}
     },
     "app/workspace/[workspaceId]/settings/billing/credit-usage/page.tsx": {
-      "modules": 1627,
+      "modules": 1632,
       "gateways": {
-        "apps/sim/lib/auth/index.ts": 1491,
-        "apps/sim/blocks/registry.ts": 621,
-        "apps/sim/blocks/registry-maps.ts": 618,
+        "apps/sim/lib/auth/index.ts": 1496,
+        "apps/sim/blocks/registry.ts": 622,
+        "apps/sim/blocks/registry-maps.ts": 619,
         "apps/sim/triggers/index.ts": 453,
-        "apps/sim/blocks/blocks/credential-group.ts": 269,
+        "apps/sim/blocks/blocks/credential-group.ts": 270,
         "apps/sim/stores/workflows/registry/store.ts": 252,
         "apps/sim/hooks/queries/deployments.ts": 244,
         "apps/sim/lib/workflows/comparison/compare.ts": 239
@@ -223,7 +223,7 @@
       "gateways": {}
     },
     "app/workspace/[workspaceId]/settings/secrets/[credentialId]/page.tsx": {
-      "modules": 1333,
+      "modules": 1337,
       "gateways": {
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 343,
@@ -232,13 +232,13 @@
         "apps/sim/stores/workflows/registry/store.ts": 75,
         "apps/sim/hooks/queries/deployments.ts": 72,
         "apps/sim/lib/workflows/comparison/compare.ts": 69,
-        "apps/sim/lib/workflows/comparison/resolve-values.ts": 66
+        "apps/sim/app/workspace/[workspaceId]/settings/secrets/[credentialId]/secret-detail.tsx": 68
       }
     },
     "app/workspace/[workspaceId]/skills/[skillId]/page.tsx": {
-      "modules": 1418,
+      "modules": 1422,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/skills/[skillId]/skill-detail.tsx": 1417,
+        "apps/sim/app/workspace/[workspaceId]/skills/[skillId]/skill-detail.tsx": 1421,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 342,
         "apps/sim/blocks/registry-maps.ts": 340,
@@ -249,9 +249,9 @@
       }
     },
     "app/workspace/[workspaceId]/skills/new/page.tsx": {
-      "modules": 1416,
+      "modules": 1420,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/skills/new/skill-create.tsx": 1415,
+        "apps/sim/app/workspace/[workspaceId]/skills/new/skill-create.tsx": 1419,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 342,
         "apps/sim/blocks/registry-maps.ts": 340,
@@ -262,7 +262,7 @@
       }
     },
     "app/workspace/[workspaceId]/skills/page.tsx": {
-      "modules": 1284,
+      "modules": 1288,
       "gateways": {
         "apps/sim/app/workspace/[workspaceId]/skills/skills.tsx": 1000,
         "apps/sim/app/workspace/[workspaceId]/integrations/components/showcase-with-explore/index.ts": 988,
@@ -275,35 +275,35 @@
       }
     },
     "app/workspace/[workspaceId]/tables/[tableId]/page.tsx": {
-      "modules": 2256,
+      "modules": 2264,
       "gateways": {
         "apps/sim/app/workspace/[workspaceId]/tables/[tableId]/table.tsx": 585,
         "apps/sim/triggers/registry.ts": 452,
-        "apps/sim/app/workspace/[workspaceId]/w/components/preview/index.ts": 336,
+        "apps/sim/app/workspace/[workspaceId]/w/components/preview/index.ts": 337,
+        "apps/sim/lib/auth/index.ts": 315,
         "apps/sim/blocks/registry.ts": 311,
-        "apps/sim/lib/auth/index.ts": 311,
-        "apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-editor/index.ts": 294,
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/index.ts": 266,
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx": 235
+        "apps/sim/app/workspace/[workspaceId]/w/components/preview/components/preview-editor/index.ts": 295,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/index.ts": 267,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/sub-block.tsx": 236
       }
     },
     "app/workspace/[workspaceId]/tables/page.tsx": {
-      "modules": 1849,
+      "modules": 1857,
       "gateways": {
         "apps/sim/triggers/registry.ts": 452,
         "apps/sim/blocks/registry.ts": 333,
-        "apps/sim/lib/auth/index.ts": 300,
+        "apps/sim/lib/auth/index.ts": 304,
         "apps/sim/app/workspace/[workspaceId]/tables/tables.tsx": 143,
         "apps/sim/lib/api/contracts/index.ts": 112,
         "apps/sim/lib/webhooks/providers/index.ts": 103,
         "apps/sim/lib/api/contracts/tools/index.ts": 60,
-        "apps/sim/app/workspace/[workspaceId]/components/index.ts": 55
+        "apps/sim/app/workspace/[workspaceId]/components/index.ts": 58
       }
     },
     "app/workspace/[workspaceId]/upgrade/page.tsx": {
-      "modules": 270,
+      "modules": 271,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/upgrade/upgrade.tsx": 263,
+        "apps/sim/app/workspace/[workspaceId]/upgrade/upgrade.tsx": 264,
         "apps/sim/app/workspace/[workspaceId]/upgrade/hooks/index.ts": 216,
         "apps/sim/lib/billing/client/upgrade.ts": 208,
         "apps/sim/hooks/queries/organization.ts": 204,
@@ -314,9 +314,9 @@
       }
     },
     "app/workspace/[workspaceId]/w/[workflowId]/layout.tsx": {
-      "modules": 2226,
+      "modules": 2230,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/error/index.tsx": 2225,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/error/index.tsx": 2229,
         "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/index.ts": 544,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/index.ts": 461,
@@ -327,9 +327,9 @@
       }
     },
     "app/workspace/[workspaceId]/w/[workflowId]/page.tsx": {
-      "modules": 2253,
+      "modules": 2257,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx": 2252,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx": 2256,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 328,
         "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/index.ts": 308,
@@ -340,9 +340,9 @@
       }
     },
     "app/workspace/[workspaceId]/w/page.tsx": {
-      "modules": 2226,
+      "modules": 2230,
       "gateways": {
-        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/index.ts": 947,
+        "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/index.ts": 950,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/index.ts": 461,
         "apps/sim/blocks/registry.ts": 328,
@@ -353,9 +353,9 @@
       }
     },
     "app/workspace/layout.tsx": {
-      "modules": 1233,
+      "modules": 1234,
       "gateways": {
-        "apps/sim/app/workspace/providers/socket-provider.tsx": 1223,
+        "apps/sim/app/workspace/providers/socket-provider.tsx": 1224,
         "apps/sim/triggers/registry.ts": 488,
         "apps/sim/blocks/registry.ts": 343,
         "apps/sim/blocks/registry-maps.ts": 340,
@@ -366,7 +366,7 @@
       }
     },
     "app/workspace/page.tsx": {
-      "modules": 1227,
+      "modules": 1228,
       "gateways": {
         "apps/sim/lib/auth/stale-session-recovery.ts": 993,
         "apps/sim/triggers/index.ts": 489,
diff --git a/scripts/sync-docs-manifest.ts b/scripts/sync-docs-manifest.ts
new file mode 100644
index 0000000000..35a240bd83
--- /dev/null
+++ b/scripts/sync-docs-manifest.ts
@@ -0,0 +1,113 @@
+/**
+ * Generate the static docs manifest the copilot's `docs/` VFS tree is built from.
+ *
+ * Source of truth: `apps/docs/content/docs/en/**\/*.mdx` — the English docs
+ * corpus, whose folder structure mirrors the public docs.sim.ai URL structure.
+ * The copilot never reads those files from disk (they are not deployed with
+ * `apps/sim`); it globs this manifest for structure and fetches page content
+ * from the live site on demand. That makes the manifest the one thing that can
+ * drift, hence `--check` in CI.
+ *
+ * Path derivation (each entry is BOTH the `docs/`-relative VFS path and the
+ * docs.sim.ai URL path, so a read is a plain fetch of `https://docs.sim.ai/<entry>`):
+ *   - `workflows/blocks/agent.mdx` → `workflows/blocks/agent.mdx`
+ *   - `workflows/index.mdx`        → `workflows.mdx`   (fumadocs folds index pages
+ *                                     into their parent URL; `/workflows/index.mdx`
+ *                                     is a 404 on the site)
+ *
+ * Excluded, and intentionally absent from the VFS: every section in
+ * `UNMOUNTED_DOCS_SECTIONS` (fetch those with the scrape tool if ever needed),
+ * the root `index.mdx` (its URL is `/`, which redirects), and every non-`en`
+ * locale.
+ *
+ * Usage:
+ *   bun run docs-manifest:generate   # write the manifest
+ *   bun run docs-manifest:check      # fail (exit 1) if the manifest is stale
+ */
+import { readdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { foldDocsIndexPath, UNMOUNTED_DOCS_SECTIONS } from '../apps/sim/lib/copilot/docs/docs-path'
+import { formatGeneratedSource } from './format-generated-source'
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url))
+const ROOT = resolve(SCRIPT_DIR, '..')
+const DOCS_CONTENT_DIR = resolve(ROOT, 'apps/docs/content/docs/en')
+const OUTPUT_PATH = resolve(ROOT, 'apps/sim/lib/copilot/generated/docs-manifest.ts')
+
+/**
+ * Top-level docs sections deliberately left out of the copilot's `docs/` tree.
+ * Shared with the vector search's unscoped filter so readability and
+ * findability cannot drift apart — see `UNMOUNTED_DOCS_SECTIONS`.
+ */
+const EXCLUDED_SECTIONS = new Set<string>(UNMOUNTED_DOCS_SECTIONS)
+
+/** Collect every `.mdx` file under `dir`, as paths relative to {@link DOCS_CONTENT_DIR}. */
+async function collectMdxPaths(dir: string, prefix = ''): Promise<string[]> {
+  const entries = await readdir(dir, { withFileTypes: true })
+  const paths: string[] = []
+  for (const entry of entries) {
+    const relative = prefix ? `${prefix}/${entry.name}` : entry.name
+    if (entry.isDirectory()) {
+      if (prefix === '' && EXCLUDED_SECTIONS.has(entry.name)) continue
+      paths.push(...(await collectMdxPaths(resolve(dir, entry.name), relative)))
+      continue
+    }
+    if (entry.isFile() && entry.name.endsWith('.mdx')) paths.push(relative)
+  }
+  return paths
+}
+
+/** Map an `en`-relative mdx file path to its docs.sim.ai URL path, or null to drop it. */
+function toDocsPath(mdxPath: string): string | null {
+  if (mdxPath === 'index.mdx') return null
+  return foldDocsIndexPath(mdxPath)
+}
+
+function render(paths: string[]): string {
+  const entries = paths.map((path) => `  '${path}',`).join('\n')
+  return `/**
+ * AUTO-GENERATED FILE. DO NOT EDIT.
+ * Generated from apps/docs/content/docs/en by scripts/sync-docs-manifest.ts.
+ * Run: bun run docs-manifest:generate.
+ *
+ * Every page in the copilot's read-only \`docs/\` VFS tree, as a path that is
+ * simultaneously the \`docs/\`-relative VFS path and the docs.sim.ai URL path
+ * (so \`docs/workflows/blocks/agent.mdx\` reads
+ * \`https://docs.sim.ai/workflows/blocks/agent.mdx\`). Sorted.
+ */
+export const DOCS_MANIFEST: readonly string[] = [
+${entries}
+]
+`
+}
+
+async function main() {
+  const checkOnly = process.argv.includes('--check')
+
+  const mdxPaths = await collectMdxPaths(DOCS_CONTENT_DIR)
+  const docsPaths = mdxPaths
+    .map(toDocsPath)
+    .filter((path): path is string => path !== null)
+    .sort()
+
+  if (docsPaths.length === 0) {
+    throw new Error(`No docs pages found under ${DOCS_CONTENT_DIR}`)
+  }
+
+  const rendered = formatGeneratedSource(render(docsPaths), OUTPUT_PATH, ROOT)
+
+  if (checkOnly) {
+    const existing = await readFile(OUTPUT_PATH, 'utf8').catch(() => null)
+    if (existing !== rendered) {
+      throw new Error(
+        'Generated docs manifest is stale — the docs tree changed (page added, removed, or renamed). Run: bun run docs-manifest:generate'
+      )
+    }
+    return
+  }
+
+  await writeFile(OUTPUT_PATH, rendered, 'utf8')
+}
+
+await main()