Tasks and worktree
In the local test version, the browser element context is passed to the built-in session or ready local CLI in the active copy of this task. The choice does not change the composition of the problem; Attachment files are saved in the selected copy. For CLI, insert without Enter, start manually. Details - transfer contract.
Unit of Work in Pulse − task: prompt, repository, your own git-worktree and one or more agent sessions over it.
Issues for this board are stored locally. Swarm queue 24/7 from packages/pulse-core maintains a separate state in Postgres; see task state boundaries.
How a task is created
Composer at the bottom of the board:
| element | What does |
|---|---|
| Repository | git folder Pulse creates a worktree on a branch pulse/<id> from the current HEAD. Without repository - draft folder scratch/<id> with your git |
| Agent | who performs: base agent, your variant agent or swarm |
| Team | several agent options for one prompt: the task will have a session for each |
| Swarm | named composition of roles, see Agent swarm |
| Resources (paperclip) | files attached to the task: the agent sees their paths as the first turn |
/ |
skills and teams from .claude/skills, .claude/commands repository and ~/.claude |
| Launch | create a task and immediately start the first turn |
| Prepare | create a task without launching; launched later by a button in the task |
Pulse comes up with the name of the task itself based on the meaning of the prompt (a short call to a fast model), so meaningful lines are visible on the board, and not the first 40 characters of text.
Board
Three types, switchable in the top panel:
- List — table: ID, name, branch, agent, turns, calls, tokens, cost, status, age. Clicking opens a preview on the right.
- Columns — kanban by status: Todo · In progress · Awaiting · Accepted · Error. Columns scroll individually.
- Agent Graph — graph of the entire fleet: all tasks, their sessions and turns on one canvas.
Search by title, ID and branch - field above the board; ⌘ K opens the palette immediately on the task section (tasks:), ↵ opens the highlighted one. Filter - by status, agent, repository.
Statuses are the stages of the task, not the raw status of the agent process: Todo (prepared, agent did not start), Launch, In progress, Stops, Waiting (the agent has finished his turn, the result has not yet been checked), Waiting for an answer (open request for permission),
Needs improvement, At the reception, Accepted, Vlita, Canceled, Error. The signature considers the general stage selector (src/shared/taskWorkflow.ts) is the same as for the graph and the result of the task.
Inside a task
Six tabs: Session · Diff · Graph · Terminal · Files · Git.
Session
Chat with an agent: turns, text, tool call cards, permissions, cost. On the left is the sessions column: each author of a regular team receives a separate worktree and branch. Additional sessions are also isolated; For inspectors, the working folder is determined by the subject of the inspection. For old sessions with a shared folder, simultaneous turns are blocked. You can add a session (+), switch (⌘ ⇧ ] / ⌘ ⇧ [), transfer the session to another agent or another model (agent chip or limit chip) - the new one will start with a transfer report, see.
Limits and session transfer.
Column width reaches for the right edge and is remembered; Double clicking on the separator returns the default width. Long role names and task lines are wrapped rather than cut off.
For a swarm task, the column is called “Swarm”: under each participant you can see his task and report, and the arrow button gives the participant the task directly. The task goes to him on your behalf - just as the architect distributes it; the report will be returned to the architect, and not through this window.
At the bottom of the column - task notes: They go into the context of the first turn of each session of that task. This is a full-fledged Markdown editor: insertion panel (bold, italic, code, title, lists, checklist, quote, table, code block, link), markup highlighting directly in the field, “Edit” / “View” modes and a “full screen” button. Hotkeys: ⌘ B, ⌘ I,
⌘ E, Tab - indentation There is also a “Repository Memory” button - what Pulse already knows about the project (see. Memory and context); it is edited by the same editor.
Diff
Tree of changed files and patch. Multiple choice (⌘-click, ⌘ A), stage / unstage, viewing images, commit from the interface. This is the main way to test the agent's work before merging it into the main branch.
Graph
Task tree: sessions → turns → tool calls, subagents and files. Nodes glow according to their state, identical calls collapse into groups (“Read · 26”), the depth is adjusted with a slider. The timeline below rewinds the graph and chat to any moment in the past.
Terminal
Shell in worktree tasks (⌘ T - new tab, up to six). Tests, build, git - everything is in the same working copy where the agent runs.
Panel ⌘ J opens the terminal from below from any section - not only from the task. The tabs in it go through working copies of tasks, switching ⌘ ⇧ [ and ⌘ ⇧ ], the height is dragged by the mouse and remembered. “+” to the right of the tabs opens another terminal in the same folder (the tab with a number is closed with a cross). Point to the tab - a hint will tell you what shell it is and what version it is (the shell reports this itself at startup; if it didn’t tell you, that’s what it says), what folder it is in now, what branch the task is in, and what sandbox the terminal is under; The branch in the “Repository” tab is not tracked. A dot on a tab indicates its state while you are looking at another: blinking - there is a command in progress, red - the last command failed (removed as soon as you open the tab), gray - the shell has ended. In the header of the panel next to the active tab there is a summary “per session”: how many commands, how many failures and how long they took - for the blocks of this session since its launch. Section "Terminal" in the left panel (⌘ 6) shows the same panel in full screen - the same tabs, sessions and view; On the screen, the tab can be cut into a panel: ⌘ ⇧ D - new panel on the right, ⌘ ⇧ E - below (each - its own terminal of the same folder, tab · N, no more than four), ⌘ ⇧ ↵ unfolds the panel and returns it, ⌘ ⌥ ←/→ and ⌘ ⌥ ⇧ ↑/↓ transfer focus to the neighboring one, the cross next to the tab closes the panel; ⌘ ⌥ S enables synchronous input - a command launched in the focus panel (from Blocks, Flow or Palette), by ↵ goes entirely into all other panels of the group; the bar at the bottom names the recipients, the checkboxes uncheck the panel, the panel occupied by an agent or team is skipped with a mark; a block card can be dragged to an adjacent panel - its command will be included in the input of that panel (you launch it), and with ⌥ — a copy of the block without secrets will go to the buffer; at the long output - "Filter" (or / for the selected block): strings with substring or by regex, inversion ¬, context ±0/1/3, counter “N of M lines”, gaps between groups are named by number; this is only a view - copy, "To task" and "Explain" get the full output; the title of a long block sticks to the top when scrolling, clicking on it leads to the beginning; list density and separators - in Settings → General; terminal colors - in Settings → Appearance → "Terminal": JSON file with xterm keys or Warp YAML theme (the theme is stored in the settings, the file is not needed after import), "Reset" - Pulse tokens; The default font size is there, and on one tab - ⌘ ⌥ = / ⌘ ⌥ - / ⌘ ⌥ 0; press again or ⌘ J collapse it back to the bottom panel of the section from which you came. The panel has two views for the same session:
- Flow — a regular terminal, as in the tasks tab;
- Blocks - command history: title with command, return code, duration, reduction, (full screen programs -
less,vim,htop— they don’t get into the block: instead of the screen, one line “[full-screen program: screen not saved]”, the return code is real), copying (command, output, all or all as Markdown), “Repeat”, pinning to the top of the list; SSH — the button next to the tabs opens the “Connect via SSH” form (address, folder on the other side, agreement to put markup hooks in~/.pulse/remote), the tab is markedssh, blocks with codes come from that device; agent commands do not go there, there is no sandbox there; "To the project" at the block and the session button in the panel, a masked copy is posted in the team project (section “Terminal” in “Team Projects”: open, revoke), pinned blocks can be attached to the task submission (pinned task blocks - command, code and the first lines without secrets - are seen by the agent in the first turn of the new session and the swarm architect, section “What the terminal showed”), "On task" — the command and output go to the task session composer of this tab as Markdown (without secrets), the window goes to the task; the block is selected by clicking or using the keys (⌘ ↑,↑/↓,↵- repeat;⌘ ⌥ ↑/⌘ ⌥ ↓- to the previous and next failure, in the flow they scroll to the failure command). In the flow, each command has a label on the left: green - code 0, red - failure, gray - code unknown or the command is in progress; the same marks are on the strip on the right. ⌘↑ / ⌘↓ lead through the commands of the thread (the current line is highlighted), ⌘⇧↑ highlights the output of this command; any input returns to the prompt. The failed test team (vitest, jest, pytest, go test, cargo test) has - "Only the Fallen": the repeat command with a filter for fallen ones is placed in the input line, you run it; and "Find in code" — the file of the failed test opens in the “Files” tab. The runner is not recognized - there are no buttons. The failed team gets "Explain the conclusion": the command, return code and tail of the output go to the application’s AI service (see. AI assistance in working with code), and the answer lies directly under the block. The input line below sends the command to the same shell,↑and↓scroll through the history of this session.
Search - ⌘ ⇧ F or a magnifying glass in the header: in “Stream” it searches for the terminal itself with backlighting and a counter, in “Blocks” matches are highlighted in cards, ↵ leads to the next one, the “in block” switch limits the search to the selected block; case and regular expressions - buttons
Aa and .*.
The blocks are not obtained by guessing: Pulse asks the shell itself to mark the stream with OSC 133 markers - for zsh it slips in its own .zshrc through ZDOTDIR, for bash --rcfile, for fish the script is connected with the key -C after your config, for PowerShell - after the profile. Your settings are connected first and do not lose anything. The same hooks report the current folder (OSC 7): after cd panel tab shows where the shell is now, -
./src/main inside a working copy or ~/Downloads outside of it. Other shells work as before - blocks are parsed approximately, without return codes. Turns off in Settings → Terminal → “Block layout”; valid for new terminals. There is also a shell for new tabs and its arguments, a shell for agent commands and “Without your rc files” (agent commands do not see your aliases and functions), notifications, paths, clearing command history.
A command can be written to the terminal by someone other than a human agent or workflow, but only through
term-run: the team receives a class (only reads · changes · network · secrets · irreversibly), passes the policy, and if the policy or class requires it, the “Agent wants to perform …” card appears in the panel with the class, reason, triggered rule and the buttons “Allow once”, “Dry-run first” (if the team has a rehearsal) and “Reject”; the same card - in a floating window and on the phone. A block of such a command carries the badge “agent · name” or “workflow”. The output of the "secrets" class command is not returned to the agent.
This is how the agents themselves work: the team bash built-in agent and commands of ACP agents that can use the client terminal are executed in the task terminal, and not in the agent’s own shell - each is visible as a block with a badge, the badge leads to the session from which the command came. While the agent’s command is in progress, there is a bar above the terminal “Agent · name is executing...”: your input into this terminal awaits its end (only ^C), button "Abort" sends
^C, "Reply manually" gives the keyboard to the command if it is waiting for input. An agent with sandbox enabled (Settings → Policies) gets its terminal under it - the “· agent” tab next to the task tab; It does not write to your terminal without a sandbox. If block marking is turned off, agent teams follow the same path, without blocks and without stripes.
The agent does not print where you print. If you write in the agent's tab (the line has been typed, your command is in progress, or you typed less than 10 seconds ago), his command does not go to the terminal. The field “Agent... offers a command” appears above the terminal with its text and class. ↵ or "Send ↵" sends a string on your behalf, you can correct it first. Esc, "Reject" or ↵ on an empty field - refusal, the agent receives it in words. While the field is waiting, the agent is also waiting and sees “waiting for human dispatch.” In a tab without block markings, the agent also only offers a line: Pulse does not recognize its code and output and will tell the agent so.
You can also set up your terminal under the sandbox: button "Under the Sandbox" in the panel header, restarts the terminal tab under sandbox-exec (macOS) or bwrap (Linux) - writing only to the working folder, tmp and package manager caches, the network is open; chip sandbox on the tab shows what the session lives under. Then the agent writes to the same terminal, and not to his own. Disabled by default: without prepared caches, the sandbox breaks package installation. On Windows and Linux without bubblewrap the button is locked and explains why.
Team history - common to all terminals of this machine and all tasks, undergoes a restart. “Blocks” input line – editor: ⇧ ↵ (and ⌥ ↵) starts a new line, ↵
sends the entire command - the multi-line shell receives it in one insert and executes it as one, and the block is also one; inserted multi-line text remains in the editor until you ↵;
Esc cleanses; a team that reads secrets or irreversibly loses data will have a class badge next to it even before launch, with the same words and colors as the permission card (other classes do not receive a badge). A command that is not among the aliases and shell functions of the tab, nor in its
PATH, is emphasized by a wavy red line (zsh, bash, fish; the word you are still typing is not underlined, the word after sudo/npx, the path and everything that Pulse doesn't know for sure; there is no underscore in PowerShell or on Windows). When typed, a gray prompt appears - a fresh command with the same beginning, first from the same folder (→ at the end of the line or Tab accepts it; only for now the text is on one line); ↑/↓ scroll through the commands according to the typed beginning - first this session, then from history (↑ from the first line ↓ from the last one; inside multi-line text, arrows move the cursor).
Ctrl R (in “Blocks” and “Stream”) opens a search: fuzzy match on the command text with highlighting, filters "failures", "hour / day / week", "this task", "this folder"; the line has a return code, who wrote it (agent, workflow), when and where. ↵ puts the command in the input line (in “Stream” - at the shell prompt, without ↵), ⌘ ↵ performs immediately; the history itself doesn't trigger anything. Stored in SQLite in the application data folder without secrets (masked before recording) and under keychain encryption; where there is no link, the window says so. “Clear history” at the bottom of the window erases it entirely. In the tooltip, the block duration is the time until the first byte of output.
Palette ⌘ K — one window for the entire application, opens from any section and from the terminal itself. Four sections, prefixed on line or chip on top: tasks: — tasks (by name, ID, branch, repository; ↵ opens), actions: (or >) - application commands with their combinations and commands without combinations (“Search by tasks on the board”, board types, settings pages), scripts: — project scripts from a working copy of the tab task: scripts from
package.json (command - npm run …, pnpm/yarn/bun by packageManager or lock file), target Makefile, tasks Taskfile.yml; history: - the same team history as Ctrl R, with the same filters. Without a prefix - three lines from each section; from the terminal the history comes first, from the board the palette opens immediately on tasks:. Scripts and history lines show the class of the command before they are launched - based on what will actually be executed (script body, target recipe), and not on an opaque one npm run x. The signature at the bottom always says what it will do ↵: for the script - execute in the terminal tab (⌘ ↵ - just insert into the input), at the history line - insert (⌘ ↵ - execute), for a command of the “irreversible” class - just insert, and so and so. If the terminal panel is closed, it will open in the task tab and wait for the shell; the team leaves as yours, without a permission card. Fifth section - ai: (chip "AI"): describe what to do - "delete .log older than 7 days" - and ↵ will ask the application model (consent to send the code is general, like “Explain”). The model offers one command with an explanation, and the palette shows it before launch: the command class with the reason, the policy verdict (“will ask with a card” / “policy prohibits: ..."), rehearsal - dry-run, if the team has one (the palette accepts a rehearsal invented by the model only if it only reads). “Dry-run first” performs the rehearsal without closing the palette, and shows its output right there; "Run as agent" sends the command like an agent's command: class, policy, permission card and “agent · ai: …” badge on the block are the same as for agent teams; "Paste into input" puts text on a line without running it. While the request has not changed, ↵ - “Run” ⌘ ↵ - insert; changed the text - ↵ will ask again. If the task limit is reached, the section says so, but nothing goes into the model; The model's response without a command is called words rather than a blank card. Prefixes
files: the palette knows and says that these sections do not yet exist, and not “nothing was found.”
Workflows - repository commands with arguments in files .pulse/workflows/*.yaml (format compatible with YAML Warp: name, command with {{arguments}}, arguments with description and default,
tags, shells, source_url, author; the file from the Warp directory works without edits). In the palette - section w:; ↵ opens the form: argument fields (default, list enum, "Get options" button if the argument has enum_command - the command is executed in the terminal through the policy, its output lines become options), under them - the command after substitution exactly in the form in which it is left, its class and what the policy will say (“a permission card will appear” / “the policy prohibits”). “Run” sends the command as a workflow command - with a class, policy, card and badge “workflow · name” on the block; “Copy”, “Paste into input” (without running) and “Open YAML” in “Files”. Workflows that Warp already has on this machine (~/.warp/workflows on macOS, %APPDATA%\warp\Warp\data\workflows on Windows ~/.local/share/warp-terminal/workflows on Linux), the palette is read as is by the second source - read only, lines are marked “warp · file” and come after their own; “Open YAML” is locked and calls the path. The file can be appended class: destructive (or secret) and
permission: always-ask - then the card will always be there; the file cannot weaken the policy. What’s not clear is that the section signature names the file and the reason, rather than showing an empty list.
Files
A working copy of the task next to the chat: a list of files, a simple editor with version control and a preview of the running application with the selection of an element in the context of the agent. Details - Your code and app in one window.
Git
Branches, history and deferred changes (stash) of the working copy of the task: switching branches, viewing the log, deferring/reverting edits - without leaving the terminal. Actions that change the working copy or are irreversible are asked for confirmation and the git failure reason is shown in place.
Budget and audit
In the task header there is a cost chip and a button "Audit":
- the task budget limits the total cost of its sessions; a warning appears at the threshold; when the session is exhausted, they stop (see. Control);
- audit uploads to
exports/report: who ran what, what permissions were granted and denied, what files were affected. The button has two options: “Report without command output” and “With terminal command output” - in the second, the output of agents’ commands in the terminal is printed masked. The “Terminal” section in both: a table of agent commands (class, who authorized, code, duration, how many places are masked) and the number of human commands - their text does not appear in the report in any version.
Unloading the activity feed
Section Activity — general log for all tasks: progress, errors, resolutions, call failures, swarm, maintenance. Filters: period (hour, today, week, all the time), type, task, search and order of records.
Buttons CSV, JSON and Markdown on the right in the filter panel they give the log as a file - for example, to attach a month of work to the report. Exactly what is now on the screen is unloaded: the same filters, the same order, the same number of lines as the counter next to it shows. Nothing that the filters hide gets into the file.
| Format | What's inside |
|---|---|
| CSV | table for Excel: date, time, type, task, session, agent, event. BOM and CRLF, Cyrillic opens without the “Import Wizard” |
| JSON | the same field entries, plus applied filters and the number of entries in the log |
| Markdown | readable document: header with the moment of upload, Pulse version and filters, then a table |
CSV remains a pure table (extra lines at the top break the parsing), so the upload time and filters are written in JSON and Markdown. The unloading itself is included in the log as a separate entry: what went outside can be seen there.
The log stores the last 400 entries, so "all time" is all that is left in it, and not the entire history of the application.
Archive and deletion
- To the archive — the task disappears from the board, the data remains. You can enable display of the archive using a filter.
- Delete — Pulse removes the worktree, task branch and swarm member branches, transcripts remain in the data folder until cleared.
What you should know about worktree
- Each task runs in its own working copy, so tasks don't interfere with each other or switch branches in your master clone.
- The worktree root changes to Settings → General.
- Section Worktree (
⌘ 3) shows all working copies, their branches and status; From there you can open the folder or delete the orphaned copy. - The issue branch is a regular git branch: merge it as always (
git merge, PR, MR). GitHub and GitLab integrations provide a link to PR/MR in the issue branch.
Checking and acceptance
The task stages—Queued, In Progress, Under Review, Accepted, Canceled—are separated from the agent process state. The answer-question and the usual completion of the turn do not accept the task.
In the tab Diff → Problem Result select the general thread or the author. The full diff takes into account commits, index, working and new files relative to the saved database. You can launch the inspector, merge the author's branch with the issue, accept the reviewed version and merge it into the local database. The changed version requires re-review.
Acceptance is not available with running agents, non-integrated authors, or a dirty base branch. The local merge conflict is rolled back; The task branch remains for correction. The quality check is also version-related: the old report does not confirm the new files.
You can open a working copy from the result in VS Code, Cursor, or Windsurf. A prepared task is created from GitHub issue; the related issue falls into the PR description. Merge PR uses the expected SHA and only accepts a task if it matches a clean local result.