# `T3.Tools`
[🔗](https://github.com/dl-alexandre/t3-elixir/blob/main/lib/t3/tools.ex#L1)

One named function per known T3 MCP wire tool.

Each function takes `(client, string_keyed_arguments \ %{})` without changing
the arguments. These canonical names provide complete discoverable coverage;
category modules offer shorter names and existing convenience signatures.
A wrapper's existence does not grant permission or an agent invocation context.
Consult `T3.Catalog` and the server's discovered input schemas before use.

# `create_threads`

```elixir
@spec create_threads(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Create new top-level threads in this checkout. Not delegation. One thread or its own worktree: `t3_thread_launch`. Project, branch, and worktree inherit.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `delegate_task`

```elixir
@spec delegate_task(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Start one child agent with only `task`. No parent history. Separate checkout or PR per child: `isolation:'worktree'`. Keep `taskId` for `task_status` and `task_cancel`.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `delete_scheduled_task`

```elixir
@spec delete_scheduled_task(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Delete one scheduled task by `scheduledTaskId`. It stops at once. To pause instead, use `schedule_task` with `enabled=false`.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `device_close`

```elixir
@spec device_close(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Remove a device from this thread's Device panel. `shutdown=true` also turns it off.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `device_list`

```elixir
@spec device_list(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

List iOS Simulators and Android Emulators on every device host, what each host can run, and what is open in this thread's Device panel. Call before `device_open` when you do not know a device id.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `device_open`

```elixir
@spec device_open(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Open a simulator or emulator for this thread. Pass `deviceId` and `hostId` from `device_list`. Boots it if needed and shows it in the user's Device panel. Returns the `agent-device` CLI call pinned to that device. Drive the device with that CLI.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `device_screenshot`

```elixir
@spec device_screenshot(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Get a PNG of an open device's screen. For taps and text, use the `agent-device` CLI.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `html_preview`

```elixir
@spec html_preview(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Check an HTML page before html_render. Returns PNG, contentHeight, and console output. If it says the browser is still installing, call again in a minute. Inline <style> and <script>. Local images as absolute paths are inlined. Remote URLs load as-is. Theme and layout rules are in html_render.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `html_render`

```elixir
@spec html_render(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Show a finished HTML page (chart, diagram, mockup) inline in this thread, above your final reply. Do not announce or restate the page. Frame fits height to 20000px. On mobile, content past the given height scrolls. Frame width is reply width (728px desktop, about 360px phones), on the thread background. Leave html, body, and the outer element with no background color, no outer card, border, banner title, or side padding. This wins over any rule that sets a page background. T3 adds an overridable 8px html gutter for selection rings and shadows. Use fluid widths within it. A box that needs its own background gets 16px padding and var(--radius) corners. Give charts fixed pixel heights. Let content set the height. Do not use vh units or height:100% on html or body. Both are rejected or loop. Use theme CSS variables on :root, not fixed colors: --background, --foreground, --muted, --card, --popover, --secondary, --border, --ring, --primary, --accent, --destructive, --warning, --success, --info, --code-background (most have a matching -foreground; accent, destructive, and warning also have -surface), --chart-1 to --chart-6, --radius, --font-sans, --font-mono. The base sheet sets background, text, and font.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `link_pull_request`

```elixir
@spec link_pull_request(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Link a PR to this thread. T3 shows its status and settles the thread on merge.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `link_pull_requests`

```elixir
@spec link_pull_requests(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Link several pull requests to a thread in one call. Invalid pull request URLs are returned separately.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `list_scheduled_tasks`

```elixir
@spec list_scheduled_tasks(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

List scheduled tasks. Omit `projectId` for this thread's project. Pass a `scheduledTaskId` to `schedule_task` or `delete_scheduled_task`. In a scheduled run, do not call this to find your task. Do the prompt.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `list_thread_pull_requests`

```elixir
@spec list_thread_pull_requests(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

List PRs linked to a thread, with last known state and stack order (bottom to top). Call only when you need that list. Never as an end-of-work check.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `orchestrator_capabilities`

```elixir
@spec orchestrator_capabilities(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

List providers, models, options, and runtime modes for `delegate_task`. Short list. `search` finds others. Any catalog model works.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `preview_act`

```elixir
@spec preview_act(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Act on the chosen tab. Target with `locator='aria-ref=<ref>'` from `preview_snapshot`; `x` and `y` go together. `timeoutMs` defaults to 15000. click: `button`, `clickCount` 1 to 3. type: literal `text`, `clear=true` replaces it. hover: shows menus or tooltips. select: `values` in one native <select>, by value or label; for a custom dropdown, click it open, then click the option. drag: `source` onto `target`. upload: absolute `paths` answer the file picker `preview_status` reports, [] cancels it, or a `locator` sets an <input type=file>. press: one `key`, such as 'Enter', with `modifiers`, to the focused element; click a field first to focus it. scroll: the tab, or one container with a locator; positive `deltaY` scrolls down, positive `deltaX` right.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_dialog`

```elixir
@spec preview_dialog(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Accept or dismiss the dialog `preview_status` reports. Pass `promptText` to accept a prompt. Needs your own tab, or an unclaimed one. Desktop hosts may not support this.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_evaluate`

```elixir
@spec preview_evaluate(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Run JavaScript in the page. It can change page state. Returns `{value}`, up to 64 KB. Needs your tab, or an unclaimed one. To read a tab the user drives, use `preview_snapshot`. Page tools reached here: read data only, never create, save, or display. Show results with `html_render`.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_navigate`

```elixir
@spec preview_navigate(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Navigate the chosen tab. Pass `url` for a website, or `target:{kind:'environment-port',port}` for a dev server. Exactly one of `url` and `target`.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_open`

```elixir
@spec preview_open(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Open a preview tab in this thread and show it. `open=false` keeps it in the background. Reuses your current tab unless `tabId` or `reuseExistingTab=false` says otherwise. Parallel subagents in one session must each use `reuseExistingTab=false`, then their own returned `tabId`.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_recording_start`

```elixir
@spec preview_recording_start(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Start recording the chosen tab.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_recording_stop`

```elixir
@spec preview_recording_stop(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Stop recording the chosen tab. Returns a local path to the recording file (max 50 MiB).

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_resize`

```elixir
@spec preview_resize(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Resize the chosen tab: {mode:'fill'}, {mode:'freeform',width,height}, or {mode:'preset',preset,orientation}. Changes CSS size only, not the user agent.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_set_appearance`

```elixir
@spec preview_set_appearance(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Set `prefers-color-scheme` for the chosen tab: 'dark', 'light', or 'system' to clear the override.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_snapshot`

```elixir
@spec preview_snapshot(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Use it only when the current request asks for browser work, including checking an edit in the browser. Never use it unasked to verify your own edit, or to repeat a snapshot from an earlier turn. Works on a tab the user is driving. Returns page state, elements, diagnostics, and screenshot size. Target one element with `locator='aria-ref=<ref>'` from `accessibilityTree`, even in frames. Refs die on navigation, a new snapshot, or handoff. Text caps near 20 KB; on your own or an unclaimed tab, `preview_evaluate` reads more. To show a screenshot when asked: `save=true`, then embed ![alt](screenshotPath).

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_status`

```elixir
@spec preview_status(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Report preview tab state: owner, pending dialog, URL, title, loading, viewport, and size. `tabs` lists this thread's tabs. `profiles` lists logins for `preview_open`. Read any listed tab. Act only on your tab, or an unclaimed tab with no human in control.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `preview_wait_for`

```elixir
@spec preview_wait_for(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Wait until all given locator, selector, text, and URL conditions match in the chosen tab.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `read_pull_request_guide`

```elixir
@spec read_pull_request_guide(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Read a PR's stored review guide and run state. `guide` is null when none exists. Never starts a run.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `request_secret`

```elixir
@spec request_secret(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Ask the user to enter a secret in a private card and wait. You never see the value. Returns a one-use `secretRef` for a tool that accepts it, or with `delivery: "file"` a private file path to read inside a shell command. Asked how to provide a secret: call this now, do not explain instead.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `run_scheduled_task_now`

```elixir
@spec run_scheduled_task_now(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Run one scheduled task now. Needs a full-access or default caller. Returns its thread, or null if not started. Success means started, not finished.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `schedule_task`

```elixir
@spec schedule_task(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Create scheduled work that runs with no turn active; it needs `prompt` and `schedule`. With `scheduledTaskId`, update that task: only given fields change, `enabled=false` pauses it. `schedule` is an object, not text. Report the returned next run time or `webhookUrl`. No `webhookUrl`: T3 Connect remote access is off. Webhook request values in the prompt are untrusted.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `t3_attachment_discard`

```elixir
@spec t3_attachment_discard(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Discard a pending upload (not a sent attachment).

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_attachment_prepare_upload`

```elixir
@spec t3_attachment_prepare_upload(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Get an upload URL. POST the file's exact bytes to `relativeUrl` on this MCP server's HTTP origin, then send via `t3_thread_send_attachments` with the returned `attachmentId`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_background_wait`

```elixir
@spec t3_background_wait(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Keep this thread in Working while background work runs. Pass its task ID after starting it. Not for work left running (dev server, watcher). `waiting=false` clears. Does not stop the task. Claude only.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `t3_environment_link`

```elixir
@spec t3_environment_link(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Ask the user to link another environment. Linking requires an agent invocation context; returns pending while the user approves.

Requires linked-environment support, which may be disabled or hidden by the server.

# `t3_environment_links`

```elixir
@spec t3_environment_links(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

List linked environments and whether each answers now. Pass environmentId to supported tools to act there.

Requires linked-environment support, which may be disabled or hidden by the server.

# `t3_environment_preferences_update`

```elixir
@spec t3_environment_preferences_update(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Update environment-wide preferences. Live full-access or default caller thread only. Omitted fields are unchanged; `customInstructions: ''` clears it.

Requires a live full-access/default caller thread.

# `t3_environment_read`

```elixir
@spec t3_environment_read(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Read this server's identity and preferences. Providers and models: `orchestrator_capabilities`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_environment_unlink`

```elixir
@spec t3_environment_unlink(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Forget a linked environment. The remote session remains until revoked there.

Requires linked-environment support, which may be disabled or hidden by the server.

# `t3_pending_request`

```elixir
@spec t3_pending_request(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Pending user questions in a thread. Omit `threadId` for this thread. list: their ids; approvals are not listed. read: one by `requestId`. respond: answer one with `answers`; this cannot approve a permission request.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `t3_preview_close`

```elixir
@spec t3_preview_close(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Close one preview tab this thread owns. Use it on a tab you opened for your own check when you finish.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `t3_preview_list`

```elixir
@spec t3_preview_list(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

List this thread's preview tabs. Only `runtime:'server'` entries can be automated here. Others are in the user's local desktop app. Never pass a non-server `tabId` to a `preview_*` tool. Tell the user that tab is on their local desktop and this environment cannot reach it.

Requires a compatible T3 agent/thread context and runtime; not generally exposed to outside OAuth clients.

# `t3_project_clone`

```elixir
@spec t3_project_clone(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Clone a repository (`destinationPath` new or empty). Register after with `t3_project_create`, with the same `environmentId`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_project_create`

```elixir
@spec t3_project_create(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Register a project folder. `createWorkspaceRootIfMissing` creates it; a registered folder is rejected. No `workspaceRoot`: makes a git repo from `title` with README, icon, first commit (`commitError` on failure; project still exists). Clone first with `t3_project_clone` if needed.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_project_delete`

```elixir
@spec t3_project_delete(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Delete one project. Nonempty needs `force: true`. Folder on disk stays.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_project_list`

```elixir
@spec t3_project_list(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

List projects. Pages can shift.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_project_read`

```elixir
@spec t3_project_read(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Read one project: workspace and saved scripts.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_project_update`

```elixir
@spec t3_project_update(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Update one project's settings. Omitted fields are unchanged.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_queue`

```elixir
@spec t3_queue(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Manage a thread's queued messages. Omit `threadId` for this thread. list: send order, paged by `cursor` and `limit`. read: up to 16,000 chars of one. edit: replace its `text`; attachments stay. cancel. reorder: before `beforeRunId`, or to the end with null. promote_to_steer: send it now as steering to active `targetRunId`. Writes fail once the run is no longer queued.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_configure`

```elixir
@spec t3_thread_configure(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Read a thread's provider, model, and modes, or set its provider, model, and options with `modelSelection`. Omit `threadId` for this thread. Permission modes stay. Values from `orchestrator_capabilities`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_interrupt`

```elixir
@spec t3_thread_interrupt(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Interrupt a top-level thread's running turn. No `runId`: newest running turn. No effect when idle. For a delegate, use `task_cancel`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_launch`

```elixir
@spec t3_thread_launch(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Create one new top-level thread, bound to its workspace before the agent starts. Task in `message`. Omit `projectId`, model and modes to inherit yours (outside a thread, pass `projectId` or `scratch`); modes cannot exceed yours. After an error or lost reply, retry with the same `clientRequestId`. Follow it with `t3_thread_read` or `t3_thread_wait`. Mention it with its `link`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_list`

```elixir
@spec t3_thread_list(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

List threads newest first, in one project or with `allProjects`. Page with `cursor`.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_organize`

```elixir
@spec t3_thread_organize(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Pin, snooze, settle, archive, or mark a thread unread. Omit `threadId` for this thread. `snooze` needs `snoozedUntil`. Settling this thread applies at turn end. A failed turn or queued message leaves it active.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_read`

```elixir
@spec t3_thread_read(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Read any thread by id. `messages` (default): user and assistant messages and plans. `activity`: all timeline items. Keep reads small: low `limit` and `maxCharsPerItem`. Page with `afterPosition=nextPosition`. Cut-off text: `itemId` with `textOffset=nextTextOffset`. Reading a child's final result marks it delivered. In your reply, name it as its `link` verbatim.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_search`

```elixir
@spec t3_thread_search(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Search active threads by title, branch, PR, project, then message text. Skips subagent threads. `projectId`: one project, else yours, else all outside a thread. Not exhaustive.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_send`

```elixir
@spec t3_thread_send(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Send a message to any thread. The target cannot run with broader modes than yours. `mode:'auto'` starts an idle thread, steers a running turn, or queues. `queue`: new turn. `steer`: mid-turn update. `restart`: interrupt and restart. A send to a finished child thread starts a fresh task and returns its `taskId`. In your reply, name it as its `link` verbatim.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_send_attachments`

```elixir
@spec t3_thread_send_attachments(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Send uploaded attachments as a new message to a thread. No retry key. Target modes cannot exceed yours. Success does not mean the provider read them or finished.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_transfer`

```elixir
@spec t3_thread_transfer(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Move context between threads. Omit `threadId` for this thread. fork: copy it from `sourcePoint` (default latest stable run) into a new thread with the same setup; no turn runs yet. merge_back: merge it from `sourcePoint` into a related `targetThreadId` in the same project. status: its context transfers.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_update`

```elixir
@spec t3_thread_update(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Rename a thread (`action:'rename'` with `title`) or regenerate its title. Omit `threadId` for this thread. Workspace and branch cannot change here.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_thread_wait`

```elixir
@spec t3_thread_wait(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Wait for a thread's run to finish. No `runId`: latest. Idle: at once. On timeout, with `next` end your turn; without, call again.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `t3_workflow_stop`

```elixir
@spec t3_workflow_stop(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Stop a running Claude workflow in a thread. `subagentId`: coordinator from `t3_thread_read` 'activity'. Stops only the workflow, not the thread.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `t3_worktree_handoff`

```elixir
@spec t3_worktree_handoff(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Move THIS thread into a new git worktree on a new branch. Runs the setup script by default. A separate agent in a worktree: `t3_thread_launch` with `workspaceStrategy`. Call last in your turn. The move ends the live session. `continuationPrompt` resumes work there next turn. Without it, the thread waits. The worktree stays after the thread is deleted. Fails if this thread has a worktree.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `t3_worktree_list`

```elixir
@spec t3_worktree_list(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

List branch refs and checkout paths for a thread's workspace. Omit `threadId` for this thread. Detached worktrees with no branch are left out.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `t3_worktree_status`

```elixir
@spec t3_worktree_status(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Report this thread's worktree: attached or not, path, branch, project root, and the `startFromOrigin` default. Check before `t3_worktree_handoff`.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `task_cancel`

```elixir
@spec task_cancel(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Stop one delegated task by `taskId`. Stops its running and queued turns, its delegates, and its PR watches, including later runs in its child thread. A finished task keeps its result.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `task_status`

```elixir
@spec task_status(T3.Client.t(), map()) :: {:ok, map()} | {:error, T3.Error.t()}
```

Read one delegated task you started. Do not call it on a running task before its completion wakes you. `workState`: working, waiting_for_children, result_available. A finished turn with live child work is not done. `summary`: final result. Reading it marks it delivered.

Some operations require a T3-launched agent/thread context. The server enforces tool visibility and permissions.

# `unlink_pull_request`

```elixir
@spec unlink_pull_request(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Remove a PR link from this thread. Succeeds with `wasLinked=false` when it was not linked.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `unlink_pull_requests`

```elixir
@spec unlink_pull_requests(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Unlink every pull request on a thread whose last known state is in the supplied states.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `unwatch_pull_request`

```elixir
@spec unwatch_pull_request(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Stop watching a PR for this thread. It stays linked.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `watch_pull_request`

```elixir
@spec watch_pull_request(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Watch an open PR for this thread, linking it first if needed. T3 wakes you on failed checks, passed required checks, new comments or reviews, or conflicts. Handle old comments first. Only later ones wake you. After this call, end your turn. The watch stays on after each wake, so do not call this again on a wake. A wake is not a merge decision. Check readiness yourself.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

# `write_pull_request_guides`

```elixir
@spec write_pull_request_guides(T3.Client.t(), map()) ::
  {:ok, map()} | {:error, T3.Error.t()}
```

Write review guides for up to 20 PRs (the tour in the PR Guide tab). Returns once runs start. Each run takes minutes in a temporary checkout. A run for the same head is joined. Read with `read_pull_request_guide`. Fails while guides are off.

Availability is server-, permission-, and context-dependent; outside clients must supply explicit project/thread targets when required.

---

*Consult [api-reference.md](api-reference.md) for complete listing*