dsh-composer-plus 1.18.0 → 1.19.0

package/README.md

@@ -12,7 +12,7 @@ Codex-style quality-of-life features for the [DeepSeek Harness](https://github.c
 
 <p align="center"><img src="docs/images/hero.webp" width="820" alt="DeepSeek Harness with Composer Plus: the running project shows a spinner in the sidebar and the Changes panel shows a git diff"></p>
 
-Unofficial community plugin. The only network calls are the update check (GitHub releases and the npm registry); switch off **Automatic updates** to stop them at startup. **Feature ideas** calls your chat's own model only when you click **Suggest features**. **Next message prediction** (on by default) calls the model chosen in Settings (dsh's default unless you pick another) once after each finished turn, without a click. Switch it off in **Settings → Composer Plus** to stop these calls. **Complete while typing** (off by default) calls its chosen model (by default the prediction's) at each pause while you type, after you switch it on. **Improve prompt** calls a model only when you click its magic wand. **Goal check** (on by default) calls a model once each time the agent marks a `/goal` complete in an automatic round. **Mobile connect** (off by default) accepts iPhone connections from your local network or tailnet only after you switch it on.
+Unofficial community plugin. The only network calls are the update check (GitHub releases and the npm registry); switch off **Automatic updates** to stop them at startup. **Feature ideas** calls your chat's own model only when you click **Suggest features**. **Next message prediction** (on by default) calls the model chosen in Settings (dsh's default unless you pick another) once after each finished turn, without a click. Switch it off in **Settings → Composer Plus** to stop these calls. **Complete while typing** (off by default) calls its chosen model (by default the prediction's) at each pause while you type, after you switch it on. **Improve prompt** calls a model only when you click its magic wand. **Task board** calls the new chat's model once for the tags of each task that you start on the board. **Goal check** (on by default) calls a model once each time the agent marks a `/goal` complete in an automatic round. **Mobile connect** (off by default) accepts iPhone connections from your local network or tailnet only after you switch it on.
 
 ## Install
 
@@ -27,7 +27,7 @@ dsh plugin --profile web add dsh-composer-plus
 
 Then restart dsh. (The CLI can't install into the desktop profile; the app manages it.)
 
-> dsh's pnpm skips versions younger than 24 hours. Right after a release, add the version: `dsh-composer-plus@1.18.0`.
+> dsh's pnpm skips versions younger than 24 hours. Right after a release, add the version: `dsh-composer-plus@1.19.0`.
 
 ## Features
 
@@ -69,11 +69,11 @@ Then restart dsh. (The CLI can't install into the desktop profile; the app manag
 | **Planned steps** | <a id="feature-plannedsteps"></a>Off by default: switch it on in **Settings → Composer Plus**. The agent gets the tool `plan_next_steps`: in the same message as a command, it can plan the next commands with their exact arguments and a condition, for example "run `npm test` when the build passes". When the result meets the condition, Composer Plus runs the next step itself, without a new model call, so a long chat uses fewer tokens. The step shows in the chat as a short line, "Composer Plus · Planned steps: ran `test` … without a model call", followed by its tool call and its result. Only `bash`, `read`, `grep` and `glob` steps; approvals, the sandbox and Protected files apply to each step as usual. The model answers again when a condition fails, when two steps are ready at the same time, after the last step, and when you send a message. The idea comes from HarnessMM (arXiv 2610.32813). | <a href="assets/features/plannedSteps.webp"><img src="assets/features/plannedSteps.webp" width="160" alt="Screenshot: Planned steps"></a> |
 | **Protected files** | <a id="feature-protectedfiles"></a>On by default. The agent's own file tools cannot read or change files that match your patterns: `read`, `read_image` and `grep` on a file are refused for **read and write** patterns, and `write`, `edit` and `str_replace_editor` for both kinds. The agent reads why and is told to ask you. The defaults are `.env*`, `*.pem` and `*.key`. Settings → Composer Plus → **Protected files**: add a pattern (for example `published/**` or `config/*.yml`), click its kind to switch between **read and write** and **write only**, remove it with ✕, or **Use the defaults**. A pattern without `/` matches a file name in any folder. This is a guard rail, not a sandbox: a shell command (`cat .env`), a script or an MCP tool can still reach the file (see Limits). | <a href="assets/features/protectedFiles.webp"><img src="assets/features/protectedFiles.webp" width="160" alt="Screenshot: Protected files"></a> |
 | **Blocked commands** | <a id="feature-blockedcommands"></a>On by default, with an empty list. The agent's shell commands (`bash`, `pwsh`) cannot run a command that matches your rules: a **block** rule refuses the call (the agent reads why and is told to ask you), an **ask first** rule shows dsh's approval card, and the command runs only when you allow it. Settings → Composer Plus → **Blocked commands**: type a rule (for example `npm publish`, `git push --force` or `ssh *192.168.2.19`), click the kind to switch between **block** and **ask first**, then **Add**; click a rule's kind to change it, remove it with ✕. A rule is a command name and words that must come after it in this order; `*` matches any text. It also finds the command after `&&`, `;`, `\|`, inside `$(…)`, `bash -c "…"` or `eval`, and after `sudo` or `env`. This is a guard rail, not a sandbox: a variable (`$CMD`), a script file or another program can still run the command (see Limits). | <a href="assets/features/blockedCommands.webp"><img src="assets/features/blockedCommands.webp" width="160" alt="Screenshot: Blocked commands"></a> |
-| **Task board** | <a id="feature-taskboard"></a>Left sidebar → **Task board**. A kanban board of your dsh projects for you and the agents: **Todo**, **Doing**, **Review** and **Done** (and **Backlog**, see below). Pick a project or **All projects** on the left. **New task** (or `n`) opens a new card: type its title and press `Enter`. Drag a card to another column or between two cards. Click a card to see and change its **Status**, **Tags**, **Human** (agents skip it), description (Markdown) and comments. `/` searches every project, `h` shows only human tasks, the export button saves the board as Markdown or JSON. Agents get board tools: ask a chat to "take the next task from the board" and it moves the top **Todo** card to **Doing**, comments on what it did and moves it to **Review**; you move it to **Done**. In a project with open tasks, each chat gets this rule by itself. Settings → Composer Plus → **Task board** has the **Backlog** column switch: agents leave its cards to you. | <a href="assets/features/taskBoard.webp"><img src="assets/features/taskBoard.webp" width="160" alt="Screenshot: Task board"></a> |
+| **Task board** | <a id="feature-taskboard"></a>Left sidebar → **Task board**. A kanban board of your dsh chats with the live state that the sidebar shows: a chat that waits for your approval, answer or plan review is in **Review** with an orange dot, a running chat is in **Doing**, a finished chat is in **Done** (green until you open it). Pick a project or **All projects** on the left; a Branch per chat folder counts as its project. **New task** (or `n`) takes only a prompt: `Enter` starts a new chat in the project, the card shows in **Todo**, dsh names the chat and the chat's model writes up to 3 tags. Click a card to open its chat. On an orange card, click **Answer** to answer it on the board: **Reject** or **Allow once**, **Approve** or **Request changes** for a plan, or the options and your own text for a question. **Hide finished** hides **Done** on this device. | <a href="assets/features/taskBoard.webp"><img src="assets/features/taskBoard.webp" width="160" alt="Screenshot: Task board"></a> |
 | **Project memory** | <a id="feature-projectmemory"></a>Off by default: switch it on in **Settings → Composer Plus**. Each project folder gets its own memory, which later chats of that project read, as DS Bot keeps one per Bot. After each finished turn, one call to the chat's model reads the new messages (not rolled-back ones) and keeps your lasting preferences, decisions and facts as short notes, and changes or removes old ones. The agent can also save, remove and search notes itself (`memory_remember`, `memory_forget`, `memory_recall`). A note can also be global: every project reads it. A new chat gets the notes in its system prompt; a note saved later shows from the next chat. The files are Markdown under the dsh home (`storages/dsh-composer-plus/memory/`), never in the project folder. **Open memory** in the same row shows every saved note, grouped by project (and the global memory), with a filter. Write what to change in your own words (for example "I switched from yarn to pnpm"), then **Preview changes**: dsh's default model proposes the changes, and only **Apply** saves them. In Tether: chat title menu → Project memory. | <a href="assets/features/projectMemory.webp"><img src="assets/features/projectMemory.webp" width="160" alt="Screenshot: Project memory"></a> |
 | **Allow for this chat** | <a id="feature-allowforchat"></a>When Auto Review asks you, the approval card gets **Allow for this chat**: the same tool in the same chat is allowed from then on, with any arguments, until the time limit ends (1 hour by default; choose it under **Settings → Composer Plus → Allow for this chat**). Then the agent asks again. A header chip lists the grants with their end time and revokes them. Grants survive a restart. | <a href="assets/features/allowForChat.webp"><img src="assets/features/allowForChat.webp" width="160" alt="Screenshot: Allow for this chat"></a> |
 | **Project status** | <a id="feature-projectstatus"></a>A project row in the sidebar shows the same spinner / waiting / done marker as its chats, so a collapsed project still tells you a chat inside is working or needs you. A chat waiting for you shows first, then a finished chat you have not opened yet (the green dot, also while another chat still runs), then the spinner. Hover it for details. In **Workspace Tree**, the row of a parent folder also shows the chats of each project inside it (for example each branch folder in `.worktrees/`), also while it is collapsed. | <a href="assets/features/projectStatus.webp"><img src="assets/features/projectStatus.webp" width="160" alt="Screenshot: Project status"></a> |
-| **Git branch on chat rows** | <a id="feature-sessionbranch"></a>Each chat row in the sidebar shows a small grey pill with the git branch that the chat's project folder was on at the chat's last turn (for example `main` or `feature/login`; a detached HEAD has no branch and shows no pill). Two chats of one project on different branches no longer look the same, and you see at once when you are about to continue a chat on the wrong branch. Hover the pill for the full name. The Host half reads the branch (`git branch --show-current`, read-only) when a turn starts and when it ends; a chat with no turn since you installed this, or a folder that is not a git repository, shows no pill. A chat under a project row with its branch's name (a “Branch per chat” folder) shows no pill, except in “In one list”. | <a href="assets/features/sessionBranch.webp"><img src="assets/features/sessionBranch.webp" width="160" alt="Screenshot: Git branch on chat rows"></a> |
+| **Git branch on chat rows** | <a id="feature-sessionbranch"></a>In the sidebar's “In one list” view, each chat row shows a small grey pill with the git branch that the chat's project folder was on at the chat's last turn (for example `main` or `feature/login`; a detached HEAD has no branch and shows no pill). Two chats of one project on different branches no longer look the same, and you see at once when you are about to continue a chat on the wrong branch. Hover the pill for the full name. The Host half reads the branch (`git branch --show-current`, read-only) when a turn starts and when it ends; a chat with no turn since you installed this, or a folder that is not a git repository, shows no pill. In “WorkSpace” and “Workspace Tree”, no chat row shows the pill, because the chat is already under its project row. | <a href="assets/features/sessionBranch.webp"><img src="assets/features/sessionBranch.webp" width="160" alt="Screenshot: Git branch on chat rows"></a> |
 | **Mark all as read** | <a id="feature-markprojectread"></a>In the sidebar, click a project's **…** button → **Mark all as read**. Every chat in that project loses its green unread dot at once; other projects keep theirs. The item is greyed out (**No unread chats**) when the project has none. | <a href="assets/features/markProjectRead.webp"><img src="assets/features/markProjectRead.webp" width="160" alt="Screenshot: Mark all as read"></a> |
 | **Active projects first** | <a id="feature-activeprojectsfirst"></a>When a chat starts running or needs you, its project moves to the top of the sidebar with dsh's own row animation (the same move as dragging it there). Finished projects stay where they are; drag them anywhere as usual. Moves are saved to dsh's project order, so turning this off keeps the current order. | <a href="assets/features/projectStatus.webp"><img src="assets/features/projectStatus.webp" width="160" alt="Screenshot: Active projects first"></a> |
 | **Recent projects filter** | <a id="feature-recentprojects"></a>Sidebar → view options (sliders icon) → **Active in the last 2 hours**. While it is selected, the sidebar shows only projects with a chat that was active in the last 2 hours: a chat updated in that time, a running or waiting chat, the open chat, or a finished chat that you did not open yet (dsh's green “done” dot), also after the 2 hours. Projects without such a chat are hidden, also new and empty ones. In **Workspace Tree**, a parent folder stays while a project inside it is active, and the chats that were not active in the last 2 hours hide too, so only the recent chats show. Select it again to show all projects. The choice is kept on this device. | <a href="assets/features/recentProjects.webp"><img src="assets/features/recentProjects.webp" width="160" alt="Screenshot: Recent projects filter"></a> |
@@ -83,7 +83,7 @@ Then restart dsh. (The CLI can't install into the desktop profile; the app manag
 | **Open waiting chat when idle** | <a id="feature-idleswitch"></a>When a chat asks a question, or waits for an approval or a plan review (the orange dot), or finishes a turn that you have not read yet (the green dot), and you do not use dsh for 30 seconds, dsh opens that chat. Orange chats open before green ones. In each group, the one that waits longest opens first; the next one opens after another 30 seconds without use. A key, a click, a mouse move, the scroll wheel or a touch starts the 30 seconds again. Text in the field that has the focus, selected text, or an open menu or dialog also stops the switch. While a waiting chat is on screen, nothing moves. When you leave a waiting chat without an answer, it can open again after the next 30 seconds without use. When a green chat opens, its dot goes; the next green chat opens only after you use dsh again and then do not use it for 30 seconds. This also works while dsh is in the background, but dsh does not come to the front. | <a href="assets/features/idleSwitch.webp"><img src="assets/features/idleSwitch.webp" width="160" alt="Screenshot: Open waiting chat when idle"></a> |
 | **Application language** | <a id="feature-language"></a>Settings → Composer Plus → **Application language** switches the whole dsh interface to Türkçe, Español, Português (Brasil), Français, Deutsch, Русский, 日本語, 한국어, Bahasa Indonesia, Tiếng Việt or हिन्दी (see below). | <a href="assets/features/language.webp"><img src="assets/features/language.webp" width="160" alt="Screenshot: Application language"></a> |
 | **Mobile connect (iPhone)** | <a id="feature-mobileconnect"></a>Use dsh from your iPhone with the [Tether](tether/) app, on the same Wi-Fi or over [Tailscale](https://tailscale.com). Switch it on in **Settings → Composer Plus** (it is off by default, because it opens a network port on this Mac). Then click **Mobile connect** at the bottom left of the sidebar: scan the QR code with the iPhone Camera (tap **Open in Tether**) or with **Scan code** in Tether, tap **Connect** and click **Approve**. Tether must be installed first: without it the Camera cannot open the code. The phone shows your chats, sends messages (with photos: the composer's **+** → Camera, Photos or Paste image), answers approvals and questions, and switches models and agents. Pair as many Macs as you like: the Mac name at the top left of the app switches between them. The **Mobile connect** panel lists the paired iPhones with their last connection: **Remove** cuts one off at once. **Tailscale only** refuses the local network (for a shared Wi-Fi), and the access log shows who tried to connect. In Tether, **Settings → Privacy** locks the app with Face ID. | <a href="assets/features/mobileConnect.webp"><img src="assets/features/mobileConnect.webp" width="160" alt="Screenshot: Mobile connect (iPhone)"></a> |
-| **Automatic updates** | <a id="feature-autoupdate"></a>When dsh starts, the plugin checks the [latest GitHub release](https://github.com/furkancak1r/dsh-composer-plus/releases/latest). If it is newer and already on npm, it installs that exact version through dsh's own plugin manager (the same path as Settings → Plugins) and notifies you. Restart dsh to load it. **Settings → Composer Plus → Composer Plus updates** shows the version and has **Check for updates** / **Update now**. The first time dsh starts with the new version, a **What’s new in Composer Plus N** window shows the release notes of that version once (taken from the same update check, no extra network call); **Close** or `Esc` closes it. | <a href="assets/features/autoUpdate.webp"><img src="assets/features/autoUpdate.webp" width="160" alt="Screenshot: Automatic updates"></a> |
+| **Automatic updates** | <a id="feature-autoupdate"></a>When dsh starts, the plugin checks the [latest GitHub release](https://github.com/furkancak1r/dsh-composer-plus/releases/latest). If it is newer and already on npm, it installs that exact version through dsh's own plugin manager (the same path as Settings → Plugins) and notifies you. Restart dsh to load it. **Settings → Composer Plus → Composer Plus updates** shows the version and has **Check for updates** / **Update now**. The first time dsh starts with the new version, a **What’s new in Composer Plus N** window shows the release notes of that version once, in the language of **Application language** (they come with the new version, no extra network call; a language without notes shows the English notes); **Close** or `Esc` closes it. | <a href="assets/features/autoUpdate.webp"><img src="assets/features/autoUpdate.webp" width="160" alt="Screenshot: Automatic updates"></a> |
 | **Backup** | <a id="feature-backup"></a>Settings → Composer Plus → **Backup** → **Back up now** writes your whole dsh home (chats, settings, plugins, MCP, skills) into one archive in `~/Desktop/dsh-backups`, with a checksum. Secrets are masked in the archive: credential files, key files (`.pem`, `.key`) and the token, secret and password values of the yml settings stay on this computer only, in the folder's `vault`. `cache/`, `dsh-runtimes/` and `node_modules` are not archived (dsh makes them again). Each backup in the list has **Check** (reads it fully), **For another computer** (a folder to copy to the new computer, with the rescue console) and **Delete**. dsh-backup's archives in the same folder show and work too. To restore, quit dsh and use the rescue console. | <a href="assets/features/backup.webp"><img src="assets/features/backup.webp" width="160" alt="Screenshot: Backup"></a> |
 | **Automatic backup** | <a id="feature-autobackup"></a>Switch on **Automatic backup** (off by default: each copy is about as large as your dsh home without its cache). Choose how often (**Every**: 6 hours to 7 days, 24 hours by default) and how many backups stay (**Keep**: 3 to 14, 7 by default). The next time shows under the switch; a failed backup shows there too and is tried again 30 minutes later. When dsh or Composer Plus starts with a new version, a snapshot comes soon after the start, before the new version has used your data for long (the two newest stay, marked **Before an upgrade**). | <a href="assets/features/autoBackup.webp"><img src="assets/features/autoBackup.webp" width="160" alt="Screenshot: Automatic backup"></a> |
 | **Session log check** | <a id="feature-sessiondoctor"></a>**Check session logs** reads every chat's log and lists the ones that dsh cannot open (a broken frame, a cut record, a wrong sequence number). A torn tail is not listed: dsh repairs it itself. **Repair from backups** puts back the copy from the newest backup that has a healthy one and keeps the damaged file next to it (`.corrupt-<time>`). Messages written after that backup are not in the copy. A chat that is open in this dsh is not repaired here: quit dsh and repair it in the rescue console. | <a href="assets/features/sessionDoctor.webp"><img src="assets/features/sessionDoctor.webp" width="160" alt="Screenshot: Session log check"></a> |
@@ -167,7 +167,7 @@ Tested on dsh `0.2.0-rc.2` (desktop and web) and `0.2.1-rc.2` (web). CI runs the
 - **Goal check:** it runs only when the agent marks a `/goal` complete in an automatic round (or when you click **Run now**). The Host half runs the test command in the chat's folder with the chat's sandbox mode (as dsh's own `bash` tool: the same file-access policy; when that sandbox cannot start, the test does not run and the check fails). It reads only `package.json`, `Makefile`, `Cargo.toml`, `go.mod`, `pyproject.toml` and `pytest.ini` to find the command, as regular files inside the folder (no symlink out of it, no FIFO). Then it sends the goal, the chat since the goal started (your messages, the agent's replies, tool calls cut to 1,000 characters and the last 2,000 characters of each tool result; no reasoning, no rolled-back steps; at most about 60,000 characters, the newest part), `git status --short` and the end of the test output to the model chosen under **Goal check** (by default the chat's own model), as one request with no tools. Tool output can contain what the agent read, so this request can hold parts of your files, as the chat itself does. Nothing is written to the chat or the project. Your test command, the limits, the last result (with the end of its output) and the model choice are in `$DSH_HOME/storages/dsh-composer-plus/goal-check.json` (owner-only file, newest 500 chats).
 - **Continue in a new chat:** nothing runs until you click it. Then the Host half sends the chat (as Goal check reads it: no reasoning, no rolled-back steps) to the chat's own model and shows the note; only **Start new chat** makes a new chat. Nothing is written to the project.
 - **Context breakdown:** reads only the chat log on the Host; no model call, no project file.
-- **Task board:** the board (titles, descriptions, tags and comments of your tasks, the project folder paths and their short ids) is in `$DSH_HOME/storages/dsh-composer-plus/board.json` (owner-only file); the switch is in `board-switch.json` next to it. Nothing leaves your machine and nothing is written to a project folder. The board tools give the agents what you wrote on the board, so the text of a task reaches the chat's model when an agent reads it. A broken board file is kept as `board.json.broken-<time>` and the board starts empty.
+- **Task board:** the board shows dsh's own chats from dsh's own lists in this window; it adds no chat data of its own. When you start a task, the Host half makes a new chat in the project you chose and sends your prompt to it as its first message, as if you typed it there, so approvals, the sandbox and the chat's model apply as usual. Then it sends the prompt (its first 4,000 characters, nothing else) to that chat's model in one more request, with no tools, for up to 3 tags. The prompt, the tags and the start time of each task are kept in `$DSH_HOME/storages/dsh-composer-plus/board-chats.json` (owner-only file, the newest 2,000); the switch is in `board-switch.json` next to it. Nothing is written to a project folder. **Answer** sends your answer to dsh's own pending request, the same way the chat's own card does. The old task list of earlier versions (`board.json`) stays on disk as it was and is not read.
 - **Protected files:** the list and the switch are in `$DSH_HOME/storages/dsh-composer-plus/protected-files.json` (owner-only file). The check reads only the path of each file tool call (and its real path), never the file.
 - **Blocked commands:** the rules and the switch are in `$DSH_HOME/storages/dsh-composer-plus/blocked-commands.json` (owner-only file). The check reads only the command text of each `bash` and `pwsh` call; it runs nothing and sends nothing.
 - **Project memory:** off until you switch it on. While it is on, after each finished turn of a top-level chat, the Host half sends the chat's own new messages since the last review (your messages and the agent's text replies; no tool output, no reasoning, no hidden context, no rolled-back messages; a fork's copy of its parent is left out; at most about 16,000 characters) and the saved notes to the chat's own model, as one request with no tools. The notes are Markdown files under `$DSH_HOME/storages/dsh-composer-plus/memory/` (owner-only files): `projects/<id>/` for each project folder (`<id>` is a hash of the folder's real path; `project.json` names the folder), `global/`, `journal.jsonl` (every change with the line before and after) and `reviewed.json` (how far each chat was read). Nothing is written to the project folder. Notes that look like a key, a token, a password or an ID number are refused. The notes of a project go into the system prompt of each new chat in that folder, so they reach the model with every request of that chat. The switch is in `memory.json` next to it. **Open memory** sends nothing until you click **Preview changes**; then it sends the notes it shows and your text to dsh's default model, as one request with no tools. Its changes are written only on **Apply**, with `editor` in the journal. Tether reads and changes the notes through the same route.
@@ -189,10 +189,10 @@ Tested on dsh `0.2.0-rc.2` (desktop and web) and `0.2.1-rc.2` (web). CI runs the
 - **A chat did not continue after a restart:** Resume after restart was off when dsh quit, you stopped that turn yourself, the turn had ended (done or failed), the chat was archived, or more than 20 chats were running (the newest 20 continue).
 - **The queue is empty after a restart:** dsh itself empties the queue when it quits. Resume after restart puts it back only in a chat that it continues; in other chats, send the messages again. A message that you removed just before the quit can come back: remove it again.
 - **Open GitHub issue says "gh could not open the issue":** the message is `gh`'s own first line. Run `gh auth status` in a terminal and log in with `gh auth login`; the chat's folder must have a GitHub remote (`git remote -v`). "not installed or not on the PATH of dsh" means dsh did not find `gh`: install it, or start dsh from a terminal where `gh` works.
-- **No branch pill on a chat row:** the chat had no turn since you installed this version, its folder is not a git repository, or **Git branch on chat rows** is off. After an update, restart dsh (the Host half records the branch).
+- **No branch pill on a chat row:** the sidebar is not in “In one list” (in “WorkSpace” and “Workspace Tree”, no chat row shows a pill), the chat had no turn since you installed this version, its folder is not a git repository, or **Git branch on chat rows** is off. After an update, restart dsh (the Host half records the branch).
 - **Goal check says the test exited with code 127 or "not found":** dsh started from the Finder or the Dock can have a shorter PATH than your terminal, so it does not find `npm`, `pnpm` or `cargo`. Start dsh from a terminal, or set your own test command with the full path under **Goal check** → **Edit**. **Run now** shows the result at once.
 - **The goal does not close and the agent keeps working:** **Goal check** found a failing test or missing work; the row under the goal shows why (hover the result for the details). Fix the cause or the test command, or complete the goal yourself with `/goal` or the goal bar (that is not checked).
-- **Install fails right after a release:** add the version (`dsh-composer-plus@1.18.0`), see the install note above.
+- **Install fails right after a release:** add the version (`dsh-composer-plus@1.19.0`), see the install note above.
 - **Back up now says "another backup action is running":** an action runs in another dsh window or in the rescue console (they share a lock file, `.composer-plus.lock`, in the backup folder). Wait for it. If no action runs, the lock of a closed process is taken over at the next click.
 - **The rescue console says "dsh is running":** quit dsh first. If dsh is really closed, the file named in the message is left from a crash: remove it and try again.
 - **After a restore, dsh does not start or a plugin is missing:** the plugin packages of a profile must be installed again. The rescue console offers it after a restore; or run `pnpm install` in each folder under `$DSH_HOME/profiles/` that it lists. Secrets that were not in the vault (another computer) must be entered again: the console lists them.
@@ -212,6 +212,7 @@ Tested on dsh `0.2.0-rc.2` (desktop and web) and `0.2.1-rc.2` (web). CI runs the
 - **Delete chat** needs dsh's archive (dsh 0.2.0 and later). A chat (or one of its subagent chats) that does not stop within 15 s, or that another dsh holds, stays archived and nothing moves. On other systems than macOS the trash folder must be on the same disk as the chat history. An open chat that you delete stays in dsh's memory, archived and hidden, until dsh restarts. Empty the Trash yourself; dsh does not.
 - dsh's queue has no `move` action, so the plugin's Host moves the queued message itself in dsh's queue (one change, the same message). Messages with images or files move too. Only your own messages move: a goal round or a question reply in the queue stays where it is. If a message starts to send while you drag, nothing moves and a notice says so.
 - dsh 0.2.1 loads an update at once when the new version changes no dsh settings; otherwise, and on dsh 0.2.0, restart dsh to load it. The plugin never restarts dsh for you. Web/CLI profiles without dsh's plugin manager only report a new version.
+- **What’s new in Composer Plus N** shows the notes in the language of **Application language**. A UI language with another region gets the notes of its base language (`en-GB` gets the English notes, `zh-TW` the Chinese notes of `zh`). A language without notes (one that another language pack adds, or `pt-PT`, which is not `pt-BR`) shows the English notes. The notes come with the new version. When the running copy has no readable notes file (`release-notes.json`), the window shows the English notes from GitHub.
 - **Allow for this chat** counts the time limit from the moment of the grant. A new time limit applies at once to the grants that run, so a shorter one can end them at once. Grants from version 1.12 and earlier have no time: after the update, the agent asks once again for those tools.
 - **Keep composer focus** gives the focus back only after a `/` command or skill. While dsh resolves the command, the composer stays read-only for a few milliseconds, so keys pressed in that time are lost. If dsh's `/` menu is still open, `Enter` picks the highlighted row and does not send.
 - **Fit question card to window** changes only dsh's question card, not the plan review card. It finds the card by dsh's markup (`data-question-key`, `data-question-scroll`); if a dsh update changes that markup, the card shows as dsh draws it. The card's height follows the window, not the chat: in a chat in a narrow side panel, a tall card can still reach above the chat.
@@ -225,7 +226,7 @@ Tested on dsh `0.2.0-rc.2` (desktop and web) and `0.2.1-rc.2` (web). CI runs the
 - **This chat** counts only files that dsh's file tools (`write`, `edit`, `str_replace_editor`) wrote. Files that a command (`bash`) changed are not in this view; they show under **Uncommitted**. Without a Turn rollback snapshot of the chat (Turn rollback off, dsh-rewind-plugin installed, or a chat older than the plugin), the view compares with the last commit and says so. Turn rollback keeps the 50 newest snapshots of a chat: in a longer chat, the view compares with the oldest kept one, says from which message, and does not count earlier changes. **Hide whitespace changes** is `git diff -w`: a line that changed only in spaces inside it is hidden too.
 - **Open GitHub issue** needs the GitHub CLI (`gh`) on the PATH of dsh and a GitHub remote in the chat's folder. It runs at most 60 s; if `gh` takes longer, the issue can exist on GitHub without its link in the list (click again: the list reads the link only from a finished run, so look on GitHub before you open a second one). A folder with more than one GitHub remote uses `gh`'s own default (`gh repo set-default`).
 - **Chats that changed this file** knows only dsh's file tools (`write`, `edit`, `str_replace_editor`), as **This chat**: a change made by a command (`bash`) is not listed. It reads the newest 300 chats of the repository (by when they were made) and says so when there are more; it shows at most 100 rows. A renamed file is listed under the name that the tool wrote. A chat whose folder is outside the repository (also through another path to the same files) is not counted. The first open after a dsh start reads every chat log of the repository (about 4 s for 275 chats); later opens read only the chats that changed since.
-- **Git branch on chat rows** shows the branch of the chat's folder when its last turn started or ended, not the branch now: a branch switch outside a turn shows after the next turn. Chats from before this version show no pill until their next turn. The pill sits in dsh's chat row markup (dsh has no slot there); if a dsh update changes that markup, no pill shows. A chat under a project row with its branch's name (a “Branch per chat” folder) shows no pill, except in “In one list”.
+- **Git branch on chat rows** shows the branch of the chat's folder when its last turn started or ended, not the branch now: a branch switch outside a turn shows after the next turn. Chats from before this version show no pill until their next turn. The pill sits in dsh's chat row markup (dsh has no slot there); if a dsh update changes that markup, no pill shows. The pill shows only in “In one list”.
 - **Branch per chat** in plan mode: dsh sends `/plan <message>` as a command, not as a message, so Composer Plus takes the command's submit in dsh's composer (not a public API). If a dsh update changes it, `/plan <message>` with **New branch** chosen runs in the open New chat as dsh's own command. When the Host cannot turn on plan mode in the new chat, the branch folder stays and the message is not sent, so the new chat does not change files in the default mode.
 - **Branch per chat**: when a chat's branch folder (`<project>/.worktrees/<name>`) is deleted, for example when the chat's own agent removes the worktree and deletes the branch, the chat's next step moves the chat out of it. Its branch folder project goes from the sidebar, and the chat shows under Ungrouped and stays open. On dsh 0.2.1 and later the chat continues in the main project folder, and the model gets a note about the new folder. On dsh 0.2.0 the chat keeps the deleted folder: a command there fails until you start a new chat. A project of a deleted branch that no chat uses also leaves the sidebar: Composer Plus checks the branch folders at start and every 30 seconds, also with no sidebar filter. While a chat moves, **New branch** in the same repository answers "try again". With the switch off, dsh's own error shows again ("working-directory: directory does not exist").
 - **Branches in the workspace tree** writes to git without a click: when it moves a chat, it switches the project folder back to its branch (`git switch`) and adds a worktree (`git worktree add`). It never deletes a branch, a worktree or a file. dsh cannot change the folder of a chat, so a moved chat is a copy (dsh's own fork, with a new id) and the old chat is archived. The copy continues the stopped task; a tool call that was running when the branch appeared ends with a refusal, and the agent runs it again in the new folder. A goal of the old chat does not move with it. Only a chat whose folder is the repository's main folder moves, and only for a branch that it created and switched to in that turn (`git switch -c`, `git checkout -b`): a branch made with `git branch` alone, a folder with uncommitted changes, a linked worktree or a subfolder moves nothing. Only worktrees directly in `<project>/.worktrees/` with a branch show in the tree; a detached worktree or one elsewhere does not. The copy opens by itself only when its chat was the open one (the plugin reads dsh's sidebar row for that); else it is in the branch project.
@@ -246,7 +247,7 @@ Tested on dsh `0.2.0-rc.2` (desktop and web) and `0.2.1-rc.2` (web). CI runs the
 - **Continue in a new chat** sends the chat (messages, tool calls and the end of each tool result, at most about 60,000 characters, the newest part) to the chat's own model. The note can miss a decision or a file: read it before you start. The new chat knows only the note and the linked chat (dsh attaches the old chat as read-only context); its model context starts small, the old chat stays as it is. One note or start per chat at a time.
 - **Context breakdown** shows estimates with dsh's own rule (about 4 characters per token), the same rule as dsh's context ring; the model's own count can differ. Tool definitions are the ones of the newest request. It shows the context as the chat log has it; a turn that runs now appears after its next step.
 - **Planned steps** saves tokens only when the model plans: while it is on, each request carries the `plan_next_steps` tool and a short instruction (about 500 tokens), also in chats where the model never plans. A condition proves only what it says (for example: the build exit code was 0), not that the work is right. `ok` reads dsh's own result marks (`[exit code: N]`, timeouts, sandbox denials); a command that fails without a non-zero exit code passes. Steps run one at a time; two steps that are ready at the same time go back to the model. The step's message is stored as an assistant message of the chat's model (dsh has no mark for a message that a plugin wrote), so its text says that Composer Plus ran it. Not in Tether.
-- **Task board** knows only dsh's projects: a chat outside a project shows **All projects**, and a Branch per chat folder (`<project>/.worktrees/<name>`) counts as its project. The project ids (`acme#12`) come from the folder name and stay when you rename the project in dsh. The rule "keep the board current" goes into a chat only when its project has open tasks; a chat that got it keeps it. Agents are told to leave **Done**, **Backlog** and human tasks to you, but the tools do not refuse it: an agent can still move such a card. The board tools are in every chat's tool list while the feature is on (about 1,000 tokens per request); switch it off if you do not use the board. The page reads the board every 2 seconds while it shows; a change by an agent shows within that time. A text that you edit while an agent changes the same field is not saved: the panel shows the new text and the reason. No images, no git sync between computers and no sharing over the network (Kanzo has them). The idea and the look come from [Kanzo](https://github.com/emanuele-em/kanzo) by emanuele-em (AGPL-3.0); Composer Plus uses no code from it.
+- **Task board** shows the chats that dsh lists in this window: a chat outside a project shows only in **All projects**, and a Branch per chat folder (`<project>/.worktrees/<name>`) counts as its project. A card's column is the chat's live state, so cards cannot be dragged: a chat goes to **Done** when its turn ends, also after an error or a stop, and back to **Doing** when it runs again. The green dot is dsh's own done dot, which dsh keeps only in this window: after a reload, finished chats show without it. **Done** shows the newest 50 chats (**Show N older** shows the rest). The tags come from one model call per started task: they can be wrong, and a chat that you did not start on the board has none. The title is dsh's own chat title (dsh's title service, with the chat's model); until it comes, the card shows the first line of the prompt. A prompt that starts with a `/` command that dsh knows (`/plan`, `/goal`) runs as that command. **Answer** answers only the newest request of the chat: when the chat answered it elsewhere (another window, Tether, Auto Review) or asks something new, the panel says so and sends nothing. Earlier versions had a task list with comments and agent tools; they are gone, and the old `board.json` is not shown. The idea and the look come from [Kanzo](https://github.com/emanuele-em/kanzo) by emanuele-em (AGPL-3.0); Composer Plus uses no code from it.
 - **Send after Stop goes first** works only after you stop the chat (or after a turn that failed, or when you open a chat that still has a queue): a message that you send while a turn runs still waits at the end of the queue. It moves only past your own queued messages: when a goal round or a question reply waits in the queue, dsh's own order stays. It reads a part of dsh that is not a public API (whether the stopped turn still ends); if a dsh update renames it, the message moves only after that turn has ended. Subagent chats keep dsh's own order.
 - **Project memory** belongs to the chat's first folder (dsh's project folder): a chat that changes its folder with `cd` keeps its first project's memory, and the same folder opened through another path to the same files shares it. A chat freezes its memory section when it starts, so a note saved later shows from the next chat (`memory_recall` finds it at once). The review keeps only what the model decides to keep: it can miss a fact or keep a wrong one; check them in **Open memory** and change them there, or edit the files by hand while dsh is closed. **Open memory** sends the notes of the selected project and the global notes (all projects when you select All notes; at most about 60,000 characters, the rest is counted and cannot change in that request) and your text to dsh's default model, not to the chat's model. A preview is kept on the Mac for 30 minutes and until dsh restarts; when a review or the agent changes the notes in between, **Apply** refuses and you preview again. **Apply** saves all the changes of a preview or none: when one change cannot be saved (for example, MEMORY.md is full), the notes stay as they were and the reason shows. Each finished turn with a message from you costs one model call; a failed call reads the same messages again after the next turn. Subagent chats are not reviewed. The idea and the file format come from [DS Bot](https://github.com/Fei2411/DS-Bot) (Apache-2.0); Composer Plus uses no code from it, and it never reads or writes DS Bot's own memory.
 - **Backup** keeps one fixed folder, `~/Desktop/dsh-backups` (dsh-backup's default, so its archives stay usable); there is no setting for another folder. An archive is about as large as the dsh home without `cache/` and `dsh-runtimes/` (measured: 1.6 GB of files gave an 830 MB archive in about 30 s on Apple Silicon; dsh stayed responsive). A file that changes while it is read is stored as it was when the backup opened it, so an open chat's log can end in a cut-off record, which dsh repairs at its next write. Masking finds a secret in a yml file by its key name on one line (`token:`, `apiKey:`, …); a secret in a flow map (`{token: x}`), in a list under such a key, in a JSON file (for example an MCP server's `apiKey` in a `.json` file) or under another name stays in the archive. dsh-backup's typed archives (`dsh-t-…`) are not listed. **For another computer** copies the archive (a clone on APFS: no extra space); the vault does not go with it. **Back up now** deletes no backup. An automatic backup keeps the newest backups that Composer Plus made (the **Keep** setting of **Automatic backup**) and deletes its older ones; snapshots before an upgrade are counted apart (the newest 2 stay). Archives of dsh-backup are never deleted: remove them with **Delete**. While dsh-backup is still installed, it counts the Composer Plus archives in its own keep count and can delete them.
@@ -283,7 +284,7 @@ Tested on dsh `0.2.0-rc.2` (desktop and web) and `0.2.1-rc.2` (web). CI runs the
 
 **Can the agent remember my preferences across chats, like DS Bot's memory?** Yes, with **Project memory** (off by default): switch it on in **Settings → Composer Plus**. After each turn, your lasting preferences and decisions are kept as short notes for the chat's project, and each new chat in that project reads them. Ask the agent to remember something and it saves it at once. To see or change the notes, click **Open memory** in the same row and write what to change.
 
-**Can my agents and I share one task board, like Kanzo?** Yes, with **Task board** (on by default): open it in the left sidebar and add tasks with **New task**. In a chat, ask the agent to "take the next task from the board": it moves the card to **Doing**, comments on what it did and moves it to **Review**. Mark a task **Human** to keep it for yourself.
+**Can I see all my chats as a kanban board and start new ones from it?** Yes, with **Task board** (on by default): open it in the left sidebar. Each chat is a card in **Doing**, **Review** (it waits for you) or **Done**. **New task** takes only a prompt and starts a new chat with it; click **Answer** on an orange card to answer it without opening the chat.
 
 **Can dsh back up my chats and settings, like dsh-backup?** Yes: **Settings → Composer Plus → Backup → Back up now**. It writes the same archive format into the same folder (`~/Desktop/dsh-backups`), so dsh-backup's archives show and restore too, and you can remove dsh-backup. Switch on **Automatic backup** for a schedule.
 
@@ -405,7 +406,7 @@ PLAYWRIGHT=/path/to/playwright node test/browser-continue-queue.mjs /path/to/dsh
 SHOT=1 PLAYWRIGHT=/path/to/playwright node test/browser-queue-stop-send.mjs /path/to/dsh/lib/bin.js
 # Edit queued message in place with images and files (slow fake model) + its thumbnail
 SHOT=1 PLAYWRIGHT=/path/to/playwright node test/browser-queue-edit.mjs /path/to/dsh/lib/bin.js
-# Task board: the page, the agent tools (fake model), drag and drop, search, the switch
+# Task board: a prompt starts a chat, AI tags, live columns, Answer on the board, Hide finished, the switch
 SHOT=1 PLAYWRIGHT=/path/to/playwright node test/browser-task-board.mjs /path/to/dsh/lib/bin.js
 ```
 

package/README.pt-BR.md

@@ -14,7 +14,7 @@ Recursos práticos no estilo do Codex para a interface desktop e web do [DeepSee
 
 <p align="center"><img src="docs/images/hero.webp" width="820" alt="DeepSeek Harness com o Composer Plus: o projeto em execução mostra um indicador de carregamento na barra lateral e o painel de alterações mostra um diff do git"></p>
 
-Plugin não oficial da comunidade. As únicas chamadas de rede são a verificação de atualizações (releases do GitHub e registro do npm); desative **Atualizações automáticas** para que elas não aconteçam ao iniciar. **Ideias de recursos** chama o próprio modelo do seu chat só quando você clica em **Sugerir recursos**. **Previsão da próxima mensagem** (ativada por padrão) chama o modelo escolhido nas Configurações (o padrão do dsh, a menos que você escolha outro) uma vez após cada turno concluído, sem nenhum clique. Desative-a em **Configurações → Composer Plus** para parar essas chamadas. **Completar ao digitar** (desativado por padrão) chama o modelo escolhido para ele (por padrão, o da previsão) a cada pausa enquanto você digita, depois que você o ativa. **Melhorar prompt** só chama um modelo quando você clica na varinha mágica dele. **Verificação da meta** (ativada por padrão) chama um modelo uma vez cada vez que o agente marca uma `/goal` como concluída em uma rodada automática. **Conexão móvel** (desativada por padrão) só aceita conexões do iPhone vindas da sua rede local ou da sua tailnet depois que você a ativa.
+Plugin não oficial da comunidade. As únicas chamadas de rede são a verificação de atualizações (releases do GitHub e registro do npm); desative **Atualizações automáticas** para que elas não aconteçam ao iniciar. **Ideias de recursos** chama o próprio modelo do seu chat só quando você clica em **Sugerir recursos**. **Previsão da próxima mensagem** (ativada por padrão) chama o modelo escolhido nas Configurações (o padrão do dsh, a menos que você escolha outro) uma vez após cada turno concluído, sem nenhum clique. Desative-a em **Configurações → Composer Plus** para parar essas chamadas. **Completar ao digitar** (desativado por padrão) chama o modelo escolhido para ele (por padrão, o da previsão) a cada pausa enquanto você digita, depois que você o ativa. **Melhorar prompt** só chama um modelo quando você clica na varinha mágica dele. **Quadro de tarefas** chama o modelo do novo chat uma vez para as etiquetas de cada tarefa que você inicia no quadro. **Verificação da meta** (ativada por padrão) chama um modelo uma vez cada vez que o agente marca uma `/goal` como concluída em uma rodada automática. **Conexão móvel** (desativada por padrão) só aceita conexões do iPhone vindas da sua rede local ou da sua tailnet depois que você a ativa.
 
 ## Instalação
 
@@ -29,7 +29,7 @@ dsh plugin --profile web add dsh-composer-plus
 
 Depois, reinicie o dsh. (A CLI não consegue instalar no perfil desktop; quem gerencia esse perfil é o app.)
 
-> O pnpm do dsh ignora versões publicadas há menos de 24 horas. Logo depois de uma nova versão, informe a versão: `dsh-composer-plus@1.18.0`.
+> O pnpm do dsh ignora versões publicadas há menos de 24 horas. Logo depois de uma nova versão, informe a versão: `dsh-composer-plus@1.19.0`.
 
 ## Recursos
 
@@ -71,11 +71,11 @@ Depois, reinicie o dsh. (A CLI não consegue instalar no perfil desktop; quem ge
 | **Etapas planejadas** | <a id="feature-plannedsteps"></a>Desativado por padrão: ative em **Configurações → Composer Plus**. O agente recebe a ferramenta `plan_next_steps`: na mesma mensagem de um comando, ele pode planejar os próximos comandos com os argumentos exatos e uma condição, por exemplo “rode `npm test` quando o build passar”. Quando o resultado atende à condição, o Composer Plus executa a próxima etapa sozinho, sem uma nova chamada ao modelo, e um chat longo usa menos tokens. A etapa aparece no chat como uma linha curta, “Composer Plus · Planned steps: ran `test` … without a model call”, seguida da chamada da ferramenta e do resultado. Somente etapas de `bash`, `read`, `grep` e `glob`; aprovações, sandbox e Arquivos protegidos valem para cada etapa como sempre. O modelo responde de novo quando uma condição falha, quando duas etapas ficam prontas ao mesmo tempo, depois da última etapa e quando você envia uma mensagem. A ideia vem do HarnessMM (arXiv 2610.32813). | <a href="assets/features/plannedSteps.webp"><img src="assets/features/plannedSteps.webp" width="160" alt="Captura de tela: Etapas planejadas"></a> |
 | **Arquivos protegidos** | <a id="feature-protectedfiles"></a>Ativado por padrão. As ferramentas de arquivo do próprio agente não podem ler nem alterar arquivos que correspondem aos seus padrões: `read`, `read_image` e `grep` em um arquivo são recusados para padrões de **leitura e gravação**, e `write`, `edit` e `str_replace_editor` para os dois tipos. O agente lê o motivo e é orientado a perguntar a você. Os padrões iniciais são `.env*`, `*.pem` e `*.key`. Configurações → Composer Plus → **Arquivos protegidos**: adicione um padrão (por exemplo `published/**` ou `config/*.yml`), clique no tipo dele para alternar entre **leitura e gravação** e **somente gravação**, remova-o com ✕ ou clique em **Usar os valores padrão**. Um padrão sem `/` corresponde a um nome de arquivo em qualquer pasta. Isto é uma barreira de proteção, não um sandbox: um comando de shell (`cat .env`), um script ou uma ferramenta MCP ainda podem acessar o arquivo (veja Limites). | <a href="assets/features/protectedFiles.webp"><img src="assets/features/protectedFiles.webp" width="160" alt="Captura de tela: Arquivos protegidos"></a> |
 | **Comandos bloqueados** | <a id="feature-blockedcommands"></a>Ativado por padrão, com a lista vazia. Os comandos de shell do agente (`bash`, `pwsh`) não podem executar um comando que corresponda às suas regras: uma regra **bloquear** recusa a chamada (o agente lê o motivo e é orientado a perguntar a você), uma regra **perguntar antes** mostra o cartão de aprovação do dsh, e o comando só é executado quando você permite. Configurações → Composer Plus → **Comandos bloqueados**: digite uma regra (por exemplo `npm publish`, `git push --force` ou `ssh *192.168.2.19`), clique no tipo para alternar entre **bloquear** e **perguntar antes** e depois clique em **Adicionar**; clique no tipo de uma regra para mudá-lo e remova-a com ✕. Uma regra é um nome de comando e palavras que precisam vir depois dele nesta ordem; `*` corresponde a qualquer texto. A verificação também encontra o comando depois de `&&`, `;`, `\|`, dentro de `$(…)`, `bash -c "…"` ou `eval`, e depois de `sudo` ou `env`. Isto é uma barreira de proteção, não um sandbox: uma variável (`$CMD`), um arquivo de script ou outro programa ainda podem executar o comando (veja Limites). | <a href="assets/features/blockedCommands.webp"><img src="assets/features/blockedCommands.webp" width="160" alt="Captura de tela: Comandos bloqueados"></a> |
-| **Quadro de tarefas** | <a id="feature-taskboard"></a>Barra lateral esquerda → **Quadro de tarefas**. Um quadro kanban dos seus projetos do dsh, para você e para os agentes: **A fazer**, **Fazendo**, **Em revisão** e **Concluído** (e **Em espera**, veja abaixo). Escolha um projeto ou **Todos os projetos** à esquerda. **Nova tarefa** (ou `n`) abre um cartão novo: digite o título e pressione `Enter`. Arraste um cartão para outra coluna ou entre dois cartões. Clique em um cartão para ver e mudar **Status**, **Etiquetas**, **Manual** (os agentes a ignoram), a descrição (Markdown) e os comentários. `/` busca em todos os projetos, `h` mostra só as tarefas manuais e o botão de exportar salva o quadro como Markdown ou JSON. Os agentes recebem ferramentas do quadro: peça a um chat para "pegar a próxima tarefa do quadro" e ele move o primeiro cartão de **A fazer** para **Fazendo**, comenta o que fez e o move para **Em revisão**; você o move para **Concluído**. Em um projeto com tarefas abertas, cada chat recebe essa regra sozinho. Configurações → Composer Plus → **Quadro de tarefas** tem a chave da coluna **Em espera**: os agentes deixam os cartões dela para você. | <a href="assets/features/taskBoard.webp"><img src="assets/features/taskBoard.webp" width="160" alt="Captura de tela: Quadro de tarefas"></a> |
+| **Quadro de tarefas** | <a id="feature-taskboard"></a>Barra lateral esquerda → **Quadro de tarefas**. Um quadro kanban dos seus chats do dsh com o estado ao vivo que a barra lateral mostra: um chat que espera sua aprovação, sua resposta ou a revisão de um plano fica em **Em revisão** com um ponto laranja, um chat em execução fica em **Fazendo** e um chat concluído fica em **Concluído** (verde até você abri-lo). Escolha um projeto ou **Todos os projetos** à esquerda; uma pasta de “Um branch por chat” conta como o projeto dela. **Nova tarefa** (ou `n`) pede só um prompt: `Enter` inicia um novo chat no projeto, o cartão aparece em **A fazer**, o dsh dá nome ao chat e o modelo do chat escreve até 3 etiquetas. Clique em um cartão para abrir o chat dele. Em um cartão laranja, clique em **Responder** para responder no quadro: **Rejeitar** ou **Permitir uma vez**, **Aprovar** ou **Solicitar alterações** para um plano, ou as opções e o seu próprio texto para uma pergunta. **Ocultar concluídos** oculta **Concluído** neste dispositivo. | <a href="assets/features/taskBoard.webp"><img src="assets/features/taskBoard.webp" width="160" alt="Captura de tela: Quadro de tarefas"></a> |
 | **Memória do projeto** | <a id="feature-projectmemory"></a>Desativado por padrão: ative em **Configurações → Composer Plus**. Cada pasta de projeto tem a própria memória, que os chats seguintes desse projeto leem, como o DS Bot guarda uma por Bot. Depois de cada turno concluído, uma chamada ao modelo do chat lê as mensagens novas (não as revertidas), guarda suas preferências, decisões e fatos duradouros como notas curtas, e muda ou remove as antigas. O agente também pode salvar, remover e buscar notas sozinho (`memory_remember`, `memory_forget`, `memory_recall`). Uma nota também pode ser global: todos os projetos a leem. Um chat novo recebe as notas no prompt de sistema; uma nota salva depois aparece a partir do chat seguinte. Os arquivos são Markdown na pasta inicial do dsh (`storages/dsh-composer-plus/memory/`), nunca na pasta do projeto. **Abrir memória**, na mesma linha, mostra todas as notas salvas agrupadas por projeto (e a memória global), com um filtro. Escreva com suas palavras o que mudar (por exemplo "troquei yarn por pnpm") e toque em **Ver prévia das mudanças**: o modelo padrão do dsh propõe as mudanças e só **Aplicar** as salva. No Tether: menu do título do chat → Project memory. | <a href="assets/features/projectMemory.webp"><img src="assets/features/projectMemory.webp" width="160" alt="Captura de tela: Memória do projeto"></a> |
 | **Permitir neste chat** | <a id="feature-allowforchat"></a>Quando a Revisão automática pergunta, o cartão de aprovação ganha **Permitir neste chat**: a mesma ferramenta no mesmo chat passa a ser permitida daí em diante, com quaisquer argumentos, até o fim do limite de tempo (1 hora por padrão; escolha em **Configurações → Composer Plus → Permitir neste chat**). Depois, o agente pergunta de novo. Um chip no cabeçalho lista as autorizações com o horário de término e as revoga. As autorizações continuam valendo depois de reiniciar. | <a href="assets/features/allowForChat.webp"><img src="assets/features/allowForChat.webp" width="160" alt="Captura de tela: Permitir neste chat"></a> |
 | **Status do projeto** | <a id="feature-projectstatus"></a>A linha de um projeto na barra lateral mostra o mesmo indicador de em execução / aguardando / concluído dos chats dele, então um projeto recolhido ainda avisa que um chat dentro dele está trabalhando ou precisa de você. Primeiro aparece um chat que está esperando você, depois um chat concluído que você ainda não abriu (o ponto verde, mesmo enquanto outro chat ainda está em execução) e depois o indicador de em execução. Passe o mouse sobre ele para ver os detalhes. Em **Árvore de workspaces**, a linha de uma pasta pai também mostra os chats de cada projeto dentro dela (por exemplo, cada pasta de branch em `.worktrees/`), mesmo quando ela está recolhida. | <a href="assets/features/projectStatus.webp"><img src="assets/features/projectStatus.webp" width="160" alt="Captura de tela: Status do projeto"></a> |
-| **Branch do Git nas linhas de chat** | <a id="feature-sessionbranch"></a>Cada linha de chat na barra lateral mostra uma pequena etiqueta cinza com o branch do git em que a pasta do projeto do chat estava no último turno do chat (por exemplo `main` ou `feature/login`; um HEAD destacado não tem branch e não mostra etiqueta). Dois chats de um mesmo projeto em branches diferentes não parecem mais iguais, e você vê na hora quando está prestes a continuar um chat no branch errado. Passe o mouse sobre a etiqueta para ver o nome completo. A parte Host lê o branch (`git branch --show-current`, somente leitura) quando um turno começa e quando termina; um chat sem turno desde que você instalou isto, ou uma pasta que não é um repositório git, não mostra etiqueta. Se a linha de projeto acima do chat tem o mesmo nome do branch (por exemplo, uma pasta de “Um branch por chat”), a linha do chat não mostra a etiqueta, mas “Em uma única lista” ainda a mostra. | <a href="assets/features/sessionBranch.webp"><img src="assets/features/sessionBranch.webp" width="160" alt="Captura de tela: Branch do Git nas linhas de chat"></a> |
+| **Branch do Git nas linhas de chat** | <a id="feature-sessionbranch"></a>Na visualização “Em uma única lista” da barra lateral, cada linha de chat mostra uma pequena etiqueta cinza com o branch do git em que a pasta do projeto do chat estava no último turno do chat (por exemplo `main` ou `feature/login`; um HEAD destacado não tem branch e não mostra etiqueta). Dois chats de um mesmo projeto em branches diferentes não parecem mais iguais, e você vê na hora quando está prestes a continuar um chat no branch errado. Passe o mouse sobre a etiqueta para ver o nome completo. A parte Host lê o branch (`git branch --show-current`, somente leitura) quando um turno começa e quando termina; um chat sem turno desde que você instalou isto, ou uma pasta que não é um repositório git, não mostra etiqueta. Em “Workspace” e “Árvore de workspaces”, nenhuma linha de chat mostra a etiqueta, porque o chat já fica abaixo da linha do projeto dele. | <a href="assets/features/sessionBranch.webp"><img src="assets/features/sessionBranch.webp" width="160" alt="Captura de tela: Branch do Git nas linhas de chat"></a> |
 | **Marcar tudo como lido** | <a id="feature-markprojectread"></a>Na barra lateral, clique no botão **…** de um projeto → **Marcar tudo como lido**. Todos os chats desse projeto perdem o ponto verde de não lido de uma vez; os outros projetos mantêm os deles. O item fica cinza (**Nenhum chat não lido**) quando o projeto não tem nenhum. | <a href="assets/features/markProjectRead.webp"><img src="assets/features/markProjectRead.webp" width="160" alt="Captura de tela: Marcar tudo como lido"></a> |
 | **Projetos ativos primeiro** | <a id="feature-activeprojectsfirst"></a>Quando um chat começa a ser executado ou precisa de você, o projeto dele vai para o topo da barra lateral com a própria animação de linha do dsh (o mesmo movimento de arrastá-lo até lá). Projetos concluídos ficam onde estão; arraste-os para qualquer lugar, como de costume. As movimentações são salvas na ordem de projetos do dsh, então desativar este recurso mantém a ordem atual. | <a href="assets/features/projectStatus.webp"><img src="assets/features/projectStatus.webp" width="160" alt="Captura de tela: Projetos ativos primeiro"></a> |
 | **Filtro de projetos recentes** | <a id="feature-recentprojects"></a>Barra lateral → opções de exibição (ícone de controles deslizantes) → **Ativos nas últimas 2 horas**. Enquanto essa opção está selecionada, a barra lateral mostra só os projetos com um chat ativo nas últimas 2 horas: um chat atualizado nesse período, um chat em execução ou aguardando, o chat aberto, ou um chat concluído que você ainda não abriu (o ponto verde de “concluído” do dsh), mesmo depois das 2 horas. Projetos sem um chat assim ficam ocultos, inclusive os novos e vazios. Em **Árvore de workspaces**, uma pasta pai continua visível enquanto um projeto dentro dela estiver ativo, e os chats que não ficaram ativos nas últimas 2 horas também ficam ocultos, então só aparecem os chats recentes. Selecione a opção de novo para mostrar todos os projetos. A escolha fica salva neste dispositivo. | <a href="assets/features/recentProjects.webp"><img src="assets/features/recentProjects.webp" width="160" alt="Captura de tela: Filtro de projetos recentes"></a> |
@@ -85,7 +85,7 @@ Depois, reinicie o dsh. (A CLI não consegue instalar no perfil desktop; quem ge
 | **Abrir o chat em espera quando ocioso** | <a id="feature-idleswitch"></a>Quando um chat faz uma pergunta, aguarda uma aprovação ou uma revisão do plano (o ponto laranja) ou termina um turno que você ainda não leu (o ponto verde), e você não usa o dsh por 30 segundos, o dsh abre esse chat. Os chats laranja abrem antes dos verdes. Em cada grupo, o que espera há mais tempo abre primeiro; o próximo abre depois de mais 30 segundos sem uso. Uma tecla, um clique, um movimento do mouse, a roda de rolagem ou um toque reiniciam os 30 segundos. Texto no campo com o foco, texto selecionado ou um menu ou caixa de diálogo aberta também impedem a troca. Enquanto um chat em espera está na tela, nada muda. Se você sair de um chat em espera sem responder, ele pode abrir de novo depois dos próximos 30 segundos sem uso. Quando um chat verde abre, o ponto dele some; o próximo chat verde só abre depois que você usar o dsh de novo e então ficar 30 segundos sem usá-lo. Também funciona com o dsh em segundo plano, mas o dsh não vem para a frente. | <a href="assets/features/idleSwitch.webp"><img src="assets/features/idleSwitch.webp" width="160" alt="Captura de tela: Abrir o chat em espera quando ocioso"></a> |
 | **Idioma do aplicativo** | <a id="feature-language"></a>Configurações → Composer Plus → **Idioma do aplicativo** muda toda a interface do dsh para Türkçe, Español, Português (Brasil), Français, Deutsch, Русский, 日本語, 한국어, Bahasa Indonesia, Tiếng Việt ou हिन्दी (veja abaixo). | <a href="assets/features/language.webp"><img src="assets/features/language.webp" width="160" alt="Captura de tela: Idioma do aplicativo"></a> |
 | **Conexão móvel (iPhone)** | <a id="feature-mobileconnect"></a>Use o dsh no seu iPhone com o app [Tether](tether/), na mesma rede Wi-Fi ou pelo [Tailscale](https://tailscale.com). Ative em **Configurações → Composer Plus** (o recurso vem desativado por padrão, porque abre uma porta de rede neste Mac). Depois, clique em **Conexão móvel** no canto inferior esquerdo da barra lateral: leia o código QR com a Câmera do iPhone (toque em **Open in Tether**) ou com **Scan code** no Tether, toque em **Connect** e clique em **Approve**. Instale o Tether antes: sem ele, a Câmera não consegue abrir o código. O celular mostra seus chats, envia mensagens (com fotos: o **+** do editor de mensagens → Camera, Photos ou Paste image), responde a aprovações e perguntas, e troca de modelo e de agente. Pareie quantos Macs quiser: o nome do Mac no canto superior esquerdo do app alterna entre eles. O painel **Conexão móvel** lista os iPhones pareados com a última conexão de cada um: **Remove** desconecta um deles na hora. “Tailscale only” recusa a rede local (para um Wi-Fi compartilhado), e o registro de acesso mostra quem tentou se conectar. No Tether, “Settings → Privacy” bloqueia o app com o Face ID. | <a href="assets/features/mobileConnect.webp"><img src="assets/features/mobileConnect.webp" width="160" alt="Captura de tela: Conexão móvel (iPhone)"></a> |
-| **Atualizações automáticas** | <a id="feature-autoupdate"></a>Quando o dsh inicia, o plugin verifica a [versão mais recente no GitHub](https://github.com/furkancak1r/dsh-composer-plus/releases/latest). Se ela for mais nova e já estiver no npm, o plugin instala exatamente essa versão pelo próprio gerenciador de plugins do dsh (o mesmo caminho de Configurações → Plugins) e avisa você. Reinicie o dsh para carregá-la. **Configurações → Composer Plus → Atualizações do Composer Plus** mostra a versão e tem **Verificar atualizações** / **Atualizar agora**. Na primeira vez que o dsh abre com a nova versão, uma janela **Novidades do Composer Plus N** mostra uma vez as notas dessa versão (da mesma verificação de atualizações, sem outra chamada de rede); **Fechar** ou `Esc` a fecha. | <a href="assets/features/autoUpdate.webp"><img src="assets/features/autoUpdate.webp" width="160" alt="Captura de tela: Atualizações automáticas"></a> |
+| **Atualizações automáticas** | <a id="feature-autoupdate"></a>Quando o dsh inicia, o plugin verifica a [versão mais recente no GitHub](https://github.com/furkancak1r/dsh-composer-plus/releases/latest). Se ela for mais nova e já estiver no npm, o plugin instala exatamente essa versão pelo próprio gerenciador de plugins do dsh (o mesmo caminho de Configurações → Plugins) e avisa você. Reinicie o dsh para carregá-la. **Configurações → Composer Plus → Atualizações do Composer Plus** mostra a versão e tem **Verificar atualizações** / **Atualizar agora**. Na primeira vez que o dsh abre com a nova versão, uma janela **Novidades do Composer Plus N** mostra uma vez as notas dessa versão no idioma de **Idioma do aplicativo** (elas vêm com a nova versão, sem outra chamada de rede; um idioma sem notas mostra as notas em inglês); **Fechar** ou `Esc` a fecha. | <a href="assets/features/autoUpdate.webp"><img src="assets/features/autoUpdate.webp" width="160" alt="Captura de tela: Atualizações automáticas"></a> |
 | **Backup** | <a id="feature-backup"></a>Configurações → Composer Plus → **Backup** → **Fazer backup agora** grava toda a sua pasta home do dsh (chats, configurações, plugins, MCP, skills) em um único arquivo compactado em `~/Desktop/dsh-backups`, com checksum. Os segredos ficam mascarados no arquivo compactado: arquivos de credenciais, arquivos de chave (`.pem`, `.key`) e os valores token, secret e password das configurações yml ficam só neste computador, no `vault` da pasta. `cache/`, `dsh-runtimes/` e `node_modules` não entram no arquivo compactado (o dsh os cria de novo). Cada backup da lista tem **Verificar** (lê o backup inteiro), **Para outro computador** (uma pasta para copiar para o novo computador, com o console de resgate) e **Excluir**. Os arquivos compactados do dsh-backup na mesma pasta também aparecem e funcionam. Para restaurar, saia do dsh e use o console de resgate. | <a href="assets/features/backup.webp"><img src="assets/features/backup.webp" width="160" alt="Captura de tela: Backup"></a> |
 | **Backup automático** | <a id="feature-autobackup"></a>Ative **Backup automático** (desativado por padrão: cada cópia tem mais ou menos o tamanho da sua pasta home do dsh sem o cache). Escolha a frequência (**A cada**: de 6 horas a 7 dias, 24 horas por padrão) e quantos backups ficam guardados (**Manter**: de 3 a 14, 7 por padrão). O horário do próximo backup aparece abaixo da chave; um backup que falhou também aparece ali e é tentado de novo 30 minutos depois. Quando o dsh ou o Composer Plus inicia com uma nova versão, um snapshot é feito logo após o início, antes que a nova versão use seus dados por muito tempo (os dois mais recentes ficam guardados, marcados como **Antes de uma atualização**). | <a href="assets/features/autoBackup.webp"><img src="assets/features/autoBackup.webp" width="160" alt="Captura de tela: Backup automático"></a> |
 | **Verificação de logs de sessão** | <a id="feature-sessiondoctor"></a>**Verificar logs de sessão** lê o log de cada chat e lista os que o dsh não consegue abrir (um frame quebrado, um registro cortado, um número de sequência errado). Um final incompleto não entra na lista: o próprio dsh o repara. **Reparar a partir dos backups** coloca de volta a cópia do backup mais recente que tenha uma cópia íntegra e mantém o arquivo danificado ao lado dela (`.corrupt-<hora>`). As mensagens escritas depois desse backup não estão na cópia. Um chat aberto neste dsh não é reparado aqui: saia do dsh e repare-o no console de resgate. | <a href="assets/features/sessionDoctor.webp"><img src="assets/features/sessionDoctor.webp" width="160" alt="Captura de tela: Verificação de logs de sessão"></a> |
@@ -169,7 +169,7 @@ Testado no dsh `0.2.0-rc.2` (desktop e web) e `0.2.1-rc.2` (web). A CI executa o
 - **Verificação da meta:** só é executada quando o agente marca uma `/goal` como concluída em uma rodada automática (ou quando você clica em **Executar agora**). A parte Host executa o comando de teste na pasta do chat, no modo sandbox do chat (como a própria ferramenta `bash` do dsh: a mesma política de acesso a arquivos; quando esse sandbox não consegue iniciar, o teste não é executado e a verificação falha). Para encontrar o comando, ela lê só `package.json`, `Makefile`, `Cargo.toml`, `go.mod`, `pyproject.toml` e `pytest.ini`, como arquivos comuns dentro da pasta (sem symlink para fora dela, sem FIFO). Depois envia a meta, o chat desde o início da meta (as suas mensagens, as respostas do agente, as chamadas de ferramentas cortadas em 1.000 caracteres e os últimos 2.000 caracteres de cada resultado de ferramenta; sem raciocínio e sem passos revertidos; no máximo cerca de 60.000 caracteres, a parte mais recente), o `git status --short` e o fim da saída do teste para o modelo escolhido em **Verificação da meta** (por padrão, o próprio modelo do chat), como uma única solicitação sem ferramentas. A saída das ferramentas pode conter o que o agente leu, então essa solicitação pode ter partes dos seus arquivos, como o próprio chat. Nada é gravado no chat nem no projeto. O seu comando de teste, os limites, o último resultado (com o fim da saída) e o modelo escolhido ficam em `$DSH_HOME/storages/dsh-composer-plus/goal-check.json` (arquivo só para o dono, os 500 chats mais recentes).
 - **Continuar em um novo chat:** nada é executado até você clicar. Então a parte Host envia o chat (como a Verificação da meta o lê: sem raciocínio e sem passos revertidos) para o próprio modelo do chat e mostra a nota de passagem; só **Iniciar novo chat** cria um novo chat. Nada é gravado no projeto.
 - **Detalhamento do contexto:** a parte Host lê só o log do chat; nenhuma chamada ao modelo, nenhum arquivo do projeto.
-- **Quadro de tarefas:** o quadro (títulos, descrições, etiquetas e comentários das suas tarefas, os caminhos das pastas dos projetos e os ids curtos delas) fica em `$DSH_HOME/storages/dsh-composer-plus/board.json` (arquivo só para o dono); a chave fica em `board-switch.json`, ao lado. Nada sai do seu computador e nada é gravado em uma pasta de projeto. As ferramentas do quadro dão aos agentes o que você escreveu no quadro, então o texto de uma tarefa chega ao modelo do chat quando um agente a lê. Um arquivo do quadro corrompido é guardado como `board.json.broken-<time>` e o quadro começa vazio.
+- **Quadro de tarefas:** o quadro mostra os próprios chats do dsh, a partir das próprias listas do dsh nesta janela; ele não adiciona dados de chat próprios. Quando você inicia uma tarefa, a parte Host cria um novo chat no projeto que você escolheu e envia o seu prompt a ele como a primeira mensagem, como se você o tivesse digitado ali, então as aprovações, o sandbox e o modelo do chat valem como de costume. Depois, ela envia o prompt (os primeiros 4.000 caracteres dele, nada mais) ao modelo desse chat em mais uma solicitação, sem ferramentas, para obter até 3 etiquetas. O prompt, as etiquetas e a hora de início de cada tarefa ficam em `$DSH_HOME/storages/dsh-composer-plus/board-chats.json` (arquivo só para o dono, as 2.000 mais recentes); a chave fica em `board-switch.json`, ao lado. Nada é gravado em uma pasta de projeto. **Responder** envia a sua resposta para a solicitação pendente do próprio dsh, do mesmo jeito que o cartão do próprio chat. A lista de tarefas antiga das versões anteriores (`board.json`) fica no disco como estava e não é lida.
 - **Arquivos protegidos:** a lista e a chave ficam em `$DSH_HOME/storages/dsh-composer-plus/protected-files.json` (arquivo só para o dono). A verificação lê só o caminho de cada chamada de ferramenta de arquivo (e o caminho real dele), nunca o arquivo.
 - **Comandos bloqueados:** as regras e a chave ficam em `$DSH_HOME/storages/dsh-composer-plus/blocked-commands.json` (arquivo só para o dono). A verificação lê só o texto do comando de cada chamada de `bash` e `pwsh`; não executa nada e não envia nada.
 - **Memória do projeto:** desativada até você ativar. Enquanto está ativada, depois de cada turno concluído de um chat de nível superior, a parte Host envia as mensagens novas do próprio chat desde a última revisão (suas mensagens e as respostas de texto do agente; sem saída de ferramentas, sem raciocínio, sem contexto oculto, sem mensagens revertidas; a cópia do chat pai num chat ramificado fica de fora; no máximo cerca de 16.000 caracteres) e as notas salvas para o modelo do próprio chat, como uma única solicitação sem ferramentas. As notas são arquivos Markdown em `$DSH_HOME/storages/dsh-composer-plus/memory/` (arquivos só do proprietário): `projects/<id>/` para cada pasta de projeto (`<id>` é um hash do caminho real da pasta; `project.json` nomeia a pasta), `global/`, `journal.jsonl` (cada mudança com a linha antes e depois) e `reviewed.json` (até onde cada chat foi lido). Nada é escrito na pasta do projeto. Notas que parecem uma chave, um token, uma senha ou um número de documento são recusadas. As notas de um projeto entram no prompt de sistema de cada chat novo nessa pasta, então chegam ao modelo com cada solicitação desse chat. A chave fica em `memory.json`, na mesma pasta. **Abrir memória** não envia nada até você tocar em **Ver prévia das mudanças**; então envia as notas que mostra e o seu texto ao modelo padrão do dsh, em uma única solicitação sem ferramentas. As mudanças só são gravadas em **Aplicar**, com `editor` no registro. O Tether lê e muda as notas pela mesma rota.
@@ -191,10 +191,10 @@ Testado no dsh `0.2.0-rc.2` (desktop e web) e `0.2.1-rc.2` (web). A CI executa o
 - **Um chat não continuou depois de reiniciar:** Retomar após reiniciar estava desativado quando o dsh fechou, você mesmo interrompeu aquele turno, o turno já tinha terminado (concluído ou com falha), o chat foi arquivado, ou mais de 20 chats estavam em execução (os 20 mais novos continuam).
 - **A fila está vazia depois de reiniciar:** o próprio dsh esvazia a fila quando fecha. Retomar após reiniciar só a devolve em um chat que continua; nos outros chats, envie as mensagens de novo. Uma mensagem que você removeu logo antes do fechamento pode voltar: remova-a de novo.
 - **Abrir issue no GitHub diz "gh could not open the issue":** a mensagem é a primeira linha do próprio `gh`. Execute `gh auth status` em um terminal e faça login com `gh auth login`; a pasta do chat precisa ter um remoto do GitHub (`git remote -v`). "not installed or not on the PATH of dsh" significa que o dsh não encontrou o `gh`: instale-o ou inicie o dsh a partir de um terminal em que o `gh` funcione.
-- **Nenhuma etiqueta de branch em uma linha de chat:** o chat não teve nenhum turno desde que você instalou esta versão, a pasta dele não é um repositório git, ou **Branch do Git nas linhas de chat** está desativado. Depois de uma atualização, reinicie o dsh (a parte Host registra o branch).
+- **Nenhuma etiqueta de branch em uma linha de chat:** a barra lateral não está em “Em uma única lista” (em “Workspace” e “Árvore de workspaces”, nenhuma linha de chat mostra uma etiqueta), o chat não teve nenhum turno desde que você instalou esta versão, a pasta dele não é um repositório git, ou **Branch do Git nas linhas de chat** está desativado. Depois de uma atualização, reinicie o dsh (a parte Host registra o branch).
 - **Verificação da meta diz que o teste saiu com o código 127 ou "not found":** o dsh iniciado pelo Finder ou pelo Dock pode ter um PATH mais curto que o do seu terminal, então ele não encontra `npm`, `pnpm` ou `cargo`. Inicie o dsh a partir de um terminal ou defina o seu próprio comando de teste com o caminho completo em **Verificação da meta** → **Editar**. **Executar agora** mostra o resultado na hora.
 - **A meta não fecha e o agente continua trabalhando:** **Verificação da meta** encontrou um teste com falha ou trabalho faltando; a linha abaixo da meta mostra o motivo (passe o mouse sobre o resultado para ver os detalhes). Corrija a causa ou o comando de teste, ou conclua a meta você mesmo com `/goal` ou com a barra da meta (isso não é verificado).
-- **A instalação falha logo depois de uma nova versão:** informe a versão (`dsh-composer-plus@1.18.0`); veja a nota de instalação acima.
+- **A instalação falha logo depois de uma nova versão:** informe a versão (`dsh-composer-plus@1.19.0`); veja a nota de instalação acima.
 - **Fazer backup agora diz "Outra ação de backup está em andamento":** uma ação está em execução em outra janela do dsh ou no console de resgate (eles compartilham um arquivo de bloqueio, `.composer-plus.lock`, na pasta de backups). Aguarde até ela terminar. Se nenhuma ação estiver em execução, o próximo clique assume o bloqueio de um processo encerrado.
 - **O console de resgate diz "dsh is running":** feche o dsh primeiro. Se o dsh estiver mesmo fechado, o arquivo citado na mensagem sobrou de uma falha: remova-o e tente de novo.
 - **Depois de uma restauração, o dsh não inicia ou falta um plugin:** os pacotes de plugin de um perfil precisam ser instalados de novo. O console de resgate oferece isso depois de uma restauração; ou execute `pnpm install` em cada pasta de `$DSH_HOME/profiles/` que ele listar. Os segredos que não estavam no vault (outro computador) precisam ser informados de novo: o console os lista.
@@ -214,6 +214,7 @@ Testado no dsh `0.2.0-rc.2` (desktop e web) e `0.2.1-rc.2` (web). A CI executa o
 - **Excluir chat** precisa do arquivamento do dsh (dsh 0.2.0 ou mais recente). Um chat (ou um dos chats de subagente dele) que não para em 15 s, ou que outro dsh está usando, continua arquivado, e nada é movido. Em sistemas que não são o macOS, a pasta de lixo precisa estar no mesmo disco que o histórico de chats. Um chat aberto que você exclui fica na memória do dsh, arquivado e oculto, até o dsh reiniciar. Esvazie o Lixo você mesmo; o dsh não faz isso.
 - A fila do dsh não tem uma ação `move`, então a parte Host do plugin move a própria mensagem na fila do dsh (uma única alteração, a mesma mensagem). Mensagens com imagens ou arquivos também são movidas. Só as suas próprias mensagens são movidas: uma rodada de meta ou uma resposta a uma pergunta na fila fica onde está. Se uma mensagem começar a ser enviada enquanto você arrasta, nada é movido e um aviso informa isso.
 - O dsh 0.2.1 carrega uma atualização imediatamente quando a nova versão não muda nenhuma configuração do dsh; caso contrário, e no dsh 0.2.0, reinicie o dsh para carregá-la. O plugin nunca reinicia o dsh por você. Perfis web/CLI sem o gerenciador de plugins do dsh só avisam que há uma nova versão.
+- **Novidades do Composer Plus N** mostra as notas no idioma de **Idioma do aplicativo**. Um idioma da interface com outra região recebe as notas do seu idioma base (`en-GB` recebe as notas em inglês, e `zh-TW`, as notas em chinês de `zh`). Um idioma sem notas (um que outro pacote de idioma adiciona, ou `pt-PT`, que não é `pt-BR`) mostra as notas em inglês. As notas vêm com a nova versão. Se a cópia em execução não tiver um arquivo de notas legível (`release-notes.json`), a janela mostra as notas em inglês do GitHub.
 - **Permitir neste chat** conta o limite de tempo a partir do momento da autorização. Um novo limite de tempo vale na hora para as autorizações em vigor, então um limite menor pode encerrá-las na hora. As autorizações da versão 1.12 e anteriores não têm horário: depois da atualização, o agente pergunta mais uma vez sobre essas ferramentas.
 - **Manter o foco no editor** só devolve o foco depois de um comando `/` ou de uma skill. Enquanto o dsh resolve o comando, o editor de mensagens fica somente leitura por alguns milissegundos, então as teclas pressionadas nesse tempo se perdem. Se o menu `/` do dsh ainda estiver aberto, `Enter` escolhe a linha destacada e não envia.
 - **Ajustar o cartão de pergunta à janela** muda só o cartão de pergunta do dsh, não o cartão de revisão do plano. Ele encontra o cartão pela marcação do dsh (`data-question-key`, `data-question-scroll`); se uma atualização do dsh mudar essa marcação, o cartão aparece como o dsh o desenha. A altura do cartão segue a janela, não o chat: em um chat dentro de um painel lateral estreito, um cartão alto ainda pode passar do topo do chat.
@@ -227,7 +228,7 @@ Testado no dsh `0.2.0-rc.2` (desktop e web) e `0.2.1-rc.2` (web). A CI executa o
 - **Este chat** conta só os arquivos que as ferramentas de arquivo do dsh (`write`, `edit`, `str_replace_editor`) gravaram. Arquivos que um comando (`bash`) alterou não estão nesta visão; eles aparecem em **Não confirmadas**. Sem um snapshot de Reverter turno do chat (Reverter turno desativado, dsh-rewind-plugin instalado ou um chat mais antigo que o plugin), a visão compara com o último commit e avisa isso. Reverter turno guarda os 50 snapshots mais recentes de um chat: num chat mais longo, a visão compara com o mais antigo guardado, informa a partir de qual mensagem e não conta as alterações anteriores. **Ocultar alterações de espaço em branco** é `git diff -w`: uma linha que mudou só nos espaços dentro dela também fica oculta.
 - **Abrir issue no GitHub** precisa do GitHub CLI (`gh`) no PATH do dsh e de um remoto do GitHub na pasta do chat. Ele roda no máximo 60 s; se o `gh` demorar mais, a issue pode existir no GitHub sem o link dela na lista (antes de clicar de novo, olhe no GitHub: a lista só lê o link de uma execução concluída, então um novo clique pode abrir uma segunda issue). Uma pasta com mais de um remoto do GitHub usa o padrão do próprio `gh` (`gh repo set-default`).
 - **Chats que alteraram este arquivo** só conhece as ferramentas de arquivo do dsh (`write`, `edit`, `str_replace_editor`), como **Este chat**: uma alteração feita por um comando (`bash`) não aparece na lista. Ele lê os 300 chats mais recentes do repositório (pela data de criação) e avisa quando há mais; mostra no máximo 100 linhas. Um arquivo renomeado aparece com o nome que a ferramenta escreveu. Um chat cuja pasta fica fora do repositório (também por outro caminho para os mesmos arquivos) não é contado. A primeira abertura depois de iniciar o dsh lê todos os registros de chat do repositório (cerca de 4 s para 275 chats); as aberturas seguintes leem só os chats que mudaram desde então.
-- **Branch do Git nas linhas de chat** mostra o branch da pasta do chat quando o último turno dele começou ou terminou, não o branch atual: uma troca de branch fora de um turno aparece depois do próximo turno. Chats de antes desta versão não mostram etiqueta até o próximo turno. A etiqueta fica na marcação das linhas de chat do dsh (o dsh não tem um espaço ali); se uma atualização do dsh mudar essa marcação, nenhuma etiqueta aparece. Se a linha de projeto acima do chat tem o mesmo nome do branch (por exemplo, uma pasta de “Um branch por chat”), a linha do chat não mostra a etiqueta, mas “Em uma única lista” ainda a mostra.
+- **Branch do Git nas linhas de chat** mostra o branch da pasta do chat quando o último turno dele começou ou terminou, não o branch atual: uma troca de branch fora de um turno aparece depois do próximo turno. Chats de antes desta versão não mostram etiqueta até o próximo turno. A etiqueta fica na marcação das linhas de chat do dsh (o dsh não tem um espaço ali); se uma atualização do dsh mudar essa marcação, nenhuma etiqueta aparece. A etiqueta só aparece em “Em uma única lista”.
 - **Um branch por chat** no modo de plano: o dsh envia `/plan <mensagem>` como comando, não como mensagem, então o Composer Plus intercepta o envio do comando no editor de mensagens do dsh (não é uma API pública). Se uma atualização do dsh mudar isso, `/plan <mensagem>` com **Novo branch** escolhido roda no Novo chat aberto como comando do próprio dsh. Quando o Host não consegue ativar o modo de plano no novo chat, a pasta do branch fica e a mensagem não é enviada, então o novo chat não altera arquivos no modo padrão.
 - **Um branch por chat**: quando a pasta do branch de um chat (`<project>/.worktrees/<name>`) é excluída, por exemplo quando o próprio agente do chat remove o worktree e exclui o branch, o próximo passo do chat tira o chat dessa pasta. O projeto da pasta do branch sai da barra lateral, e o chat aparece em Sem grupo e continua aberto. No dsh 0.2.1 e posteriores, o chat continua na pasta principal do projeto, e o modelo recebe uma nota sobre a nova pasta. No dsh 0.2.0, o chat mantém a pasta excluída: um comando nela falha até você começar um novo chat. O projeto de um branch excluído que nenhum chat usa também sai da barra lateral: o Composer Plus verifica as pastas de branch ao iniciar e a cada 30 segundos, também sem filtro da barra lateral. Enquanto um chat é movido, **Novo branch** no mesmo repositório responde "tente de novo". Com a chave desligada, o erro do próprio dsh volta a aparecer ("working-directory: directory does not exist").
 - **Branches na árvore de workspaces** escreve no git sem um clique: quando move um chat, volta a pasta do projeto para o branch anterior (`git switch`) e adiciona um worktree (`git worktree add`). Nunca apaga um branch, um worktree ou um arquivo. O dsh não pode mudar a pasta de um chat, então um chat movido é uma cópia (o fork do próprio dsh, com um id novo) e o chat antigo é arquivado. A cópia continua a tarefa parada; uma chamada de ferramenta que rodava quando o branch apareceu termina com uma recusa, e o agente a roda de novo na pasta nova. Um objetivo do chat antigo não vai junto. Só se move um chat cuja pasta é a pasta principal do repositório, e só por um branch que ele criou e para o qual mudou naquele turno (`git switch -c`, `git checkout -b`): um branch feito só com `git branch`, uma pasta com alterações não commitadas, um worktree vinculado ou uma subpasta não movem nada. Na árvore só aparecem worktrees diretamente em `<project>/.worktrees/` com um branch; um worktree desanexado (detached) ou em outro lugar não aparece. A cópia abre sozinha só quando o chat dela era o aberto (o plugin lê isso da linha da barra lateral do dsh); senão, ela está no projeto do branch.
@@ -248,7 +249,7 @@ Testado no dsh `0.2.0-rc.2` (desktop e web) e `0.2.1-rc.2` (web). A CI executa o
 - **Continuar em um novo chat** envia o chat (mensagens, chamadas de ferramentas e o fim de cada resultado de ferramenta, no máximo cerca de 60.000 caracteres, a parte mais recente) para o próprio modelo do chat. A nota de passagem pode deixar de fora uma decisão ou um arquivo: leia-a antes de iniciar. O novo chat conhece só a nota e o chat vinculado (o dsh anexa o chat antigo como contexto somente leitura); o contexto do modelo dele começa pequeno, e o chat antigo fica como está. Só uma nota ou um início por chat de cada vez.
 - **Detalhamento do contexto** mostra estimativas com a regra do próprio dsh (cerca de 4 caracteres por token), a mesma regra do anel de contexto do dsh; a contagem do próprio modelo pode ser diferente. As definições de ferramentas são as da solicitação mais recente. Ele mostra o contexto como o log do chat o tem; um turno em execução aparece depois do próximo passo dele.
 - **Etapas planejadas** economiza tokens só quando o modelo planeja: enquanto está ativado, cada requisição leva a ferramenta `plan_next_steps` e uma instrução curta (cerca de 500 tokens), também em chats em que o modelo nunca planeja. Uma condição prova só o que diz (por exemplo: o código de saída do build foi 0), não que o trabalho está certo. `ok` lê as marcas de resultado do próprio dsh (`[exit code: N]`, tempo esgotado, recusas do sandbox); um comando que falha sem um código de saída diferente de zero passa. As etapas rodam uma de cada vez; duas etapas prontas ao mesmo tempo voltam para o modelo. A mensagem da etapa fica salva como mensagem de assistente do modelo do chat (o dsh não tem uma marca para mensagem escrita por plugin), por isso o texto diz que o Composer Plus a executou. Não está no Tether.
-- **Quadro de tarefas** conhece só os projetos do dsh: um chat fora de um projeto mostra **Todos os projetos**, e a pasta de um branch por chat (`<project>/.worktrees/<name>`) conta como o projeto dela. Os ids de projeto (`acme#12`) vêm do nome da pasta e não mudam quando você renomeia o projeto no dsh. A regra "mantenha o quadro em dia" entra em um chat só quando o projeto dele tem tarefas abertas; um chat que já a recebeu a mantém. Os agentes são orientados a deixar **Concluído**, **Em espera** e as tarefas manuais para você, mas as ferramentas não recusam: um agente ainda pode mover um desses cartões. As ferramentas do quadro ficam na lista de ferramentas de todo chat enquanto o recurso está ativado (cerca de 1.000 tokens por solicitação); desative-o se você não usa o quadro. A página lê o quadro a cada 2 segundos enquanto aparece; uma mudança de um agente aparece nesse tempo. Um texto que você edita enquanto um agente muda o mesmo campo não é salvo: o painel mostra o texto novo e o motivo. Não há imagens, nem sincronização por git entre computadores, nem compartilhamento pela rede (o Kanzo tem isso). A ideia e a aparência vêm do [Kanzo](https://github.com/emanuele-em/kanzo), de emanuele-em (AGPL-3.0); o Composer Plus não usa código dele.
+- **Quadro de tarefas** mostra os chats que o dsh lista nesta janela: um chat fora de um projeto aparece só em **Todos os projetos**, e uma pasta de “Um branch por chat” (`<project>/.worktrees/<name>`) conta como o projeto dela. A coluna de um cartão é o estado ao vivo do chat, então os cartões não podem ser arrastados: um chat vai para **Concluído** quando o turno dele termina, também depois de um erro ou de uma parada, e volta para **Fazendo** quando é executado de novo. O ponto verde é o próprio ponto de concluído do dsh, que o dsh mantém só nesta janela: depois de recarregar, os chats concluídos aparecem sem ele. **Concluído** mostra os 50 chats mais recentes (**Mostrar N mais antigas** mostra o resto). As etiquetas vêm de uma chamada ao modelo por tarefa iniciada: elas podem estar erradas, e um chat que você não iniciou no quadro não tem nenhuma. O título é o próprio título do chat no dsh (o serviço de títulos do dsh, com o modelo do chat); até ele chegar, o cartão mostra a primeira linha do prompt. Um prompt que começa com um comando `/` que o dsh conhece (`/plan`, `/goal`) é executado como esse comando. **Responder** responde só à solicitação mais recente do chat: quando o chat a respondeu em outro lugar (outra janela, Tether, Revisão automática) ou pergunta algo novo, o painel avisa e não envia nada. As versões anteriores tinham uma lista de tarefas com comentários e ferramentas para agentes; elas não existem mais, e o `board.json` antigo não é mostrado. A ideia e a aparência vêm do [Kanzo](https://github.com/emanuele-em/kanzo), de emanuele-em (AGPL-3.0); o Composer Plus não usa código dele.
 - **Prioridade à mensagem enviada após Parar** só age depois que você interrompe o chat (ou depois de um turno que falhou, ou ao abrir um chat que ainda tem fila): uma mensagem enviada enquanto um turno é executado continua esperando no fim da fila. Ela só passa à frente das suas próprias mensagens na fila: se uma rodada de meta ou uma resposta a uma pergunta espera na fila, a ordem do dsh fica. Ela lê uma parte do dsh que não é uma API pública (se o turno interrompido ainda está terminando); se uma atualização do dsh mudar esse nome, a mensagem só passa à frente depois que esse turno terminar. Chats de subagentes mantêm a ordem do dsh.
 - **Memória do projeto** pertence à primeira pasta do chat (a pasta de projeto do dsh): um chat que muda de pasta com `cd` continua com a memória do primeiro projeto, e a mesma pasta aberta por outro caminho para os mesmos arquivos a compartilha. Um chat congela sua seção de memória quando começa, então uma nota salva depois aparece a partir do chat seguinte (`memory_recall` a encontra na hora). A revisão guarda só o que o modelo decide guardar: pode deixar passar um fato ou guardar um errado; confira em **Abrir memória** e mude lá, ou edite os arquivos à mão com o dsh fechado. **Abrir memória** envia as notas do projeto selecionado e as notas globais (todos os projetos quando você seleciona Todas as notas; no máximo cerca de 60.000 caracteres, o resto só é contado e não pode mudar nesse pedido) e o seu texto ao modelo padrão do dsh, não ao modelo do chat. Uma prévia fica no Mac por 30 minutos e até o dsh reiniciar; se uma revisão ou o agente mudar as notas nesse meio-tempo, **Aplicar** recusa e você pede a prévia de novo. **Aplicar** grava todas as mudanças de uma prévia ou nenhuma: se uma mudança não puder ser gravada (por exemplo, MEMORY.md está cheio), as notas ficam como estavam e o motivo aparece. Cada turno concluído com uma mensagem sua custa uma chamada ao modelo; uma chamada com falha lê as mesmas mensagens de novo depois do turno seguinte. Chats de subagentes não são revisados. A ideia e o formato de arquivo vêm do [DS Bot](https://github.com/Fei2411/DS-Bot) (Apache-2.0); o Composer Plus não usa o código dele e nunca lê nem escreve a memória do próprio DS Bot.
 - **Backup** usa uma única pasta fixa, `~/Desktop/dsh-backups` (o padrão do dsh-backup, para que os arquivos compactados dele continuem utilizáveis); não há opção para outra pasta. Um arquivo compactado tem mais ou menos o tamanho do dsh home sem `cache/` e `dsh-runtimes/` (medido: 1,6 GB de arquivos geraram um arquivo compactado de 830 MB em cerca de 30 s no Apple Silicon; o dsh continuou respondendo). Um arquivo que muda enquanto é lido é guardado como estava quando o backup o abriu, então o log de um chat aberto pode terminar em um registro cortado, que o dsh repara na próxima gravação. O mascaramento encontra um segredo em um arquivo yml pelo nome da chave em uma linha (`token:`, `apiKey:`, …); um segredo em um mapa de fluxo (`{token: x}`), em uma lista sob uma dessas chaves, em um arquivo JSON (por exemplo, a `apiKey` de um servidor MCP em um arquivo `.json`) ou com outro nome fica no arquivo compactado. Os arquivos compactados por tipo do dsh-backup (`dsh-t-…`) não aparecem na lista. **Para outro computador** copia o arquivo compactado (um clone no APFS: sem espaço extra); o vault não vai junto. **Fazer backup agora** não exclui nenhum backup. Um backup automático mantém os backups mais recentes feitos pelo Composer Plus (a opção **Manter** do **Backup automático**) e exclui os backups mais antigos que ele fez; os snapshots de antes de uma atualização são contados à parte (os 2 mais recentes ficam). Os arquivos compactados do dsh-backup nunca são excluídos: remova-os com **Excluir**. Enquanto o dsh-backup ainda estiver instalado, ele conta os arquivos compactados do Composer Plus no próprio limite de cópias mantidas e pode excluí-los.
@@ -285,7 +286,7 @@ Testado no dsh `0.2.0-rc.2` (desktop e web) e `0.2.1-rc.2` (web). A CI executa o
 
 **O agente pode lembrar minhas preferências entre chats, como a memória do DS Bot?** Sim, com **Memória do projeto** (desativada por padrão): ative em **Configurações → Composer Plus**. Depois de cada turno, suas preferências e decisões duradouras são guardadas como notas curtas para o projeto do chat, e cada chat novo desse projeto as lê. Peça ao agente para lembrar algo e ele salva na hora. Para ver ou mudar as notas, clique em **Abrir memória** na mesma linha e escreva o que mudar.
 
-**Meus agentes e eu podemos usar um só quadro de tarefas, como no Kanzo?** Sim, com **Quadro de tarefas** (ativado por padrão): abra-o na barra lateral esquerda e adicione tarefas com **Nova tarefa**. Em um chat, peça ao agente para "pegar a próxima tarefa do quadro": ele move o cartão para **Fazendo**, comenta o que fez e o move para **Em revisão**. Marque uma tarefa como **Manual** para ficar com ela.
+**Posso ver todos os meus chats como um quadro kanban e iniciar novos chats a partir dele?** Sim, com **Quadro de tarefas** (ativado por padrão): abra-o na barra lateral esquerda. Cada chat é um cartão em **Fazendo**, **Em revisão** (ele espera por você) ou **Concluído**. **Nova tarefa** pede só um prompt e inicia um novo chat com ele; clique em **Responder** em um cartão laranja para responder sem abrir o chat.
 
 **O dsh consegue fazer backup dos meus chats e configurações, como o dsh-backup?** Sim: **Configurações → Composer Plus → Backup → Fazer backup agora**. Ele grava o mesmo formato de arquivo compactado na mesma pasta (`~/Desktop/dsh-backups`), então os arquivos compactados do dsh-backup também aparecem e podem ser restaurados, e você pode remover o dsh-backup. Ative **Backup automático** para ter backups agendados.
 
@@ -407,7 +408,7 @@ PLAYWRIGHT=/path/to/playwright node test/browser-continue-queue.mjs /path/to/dsh
 SHOT=1 PLAYWRIGHT=/path/to/playwright node test/browser-queue-stop-send.mjs /path/to/dsh/lib/bin.js
 # Edit queued message in place with images and files (slow fake model) + its thumbnail
 SHOT=1 PLAYWRIGHT=/path/to/playwright node test/browser-queue-edit.mjs /path/to/dsh/lib/bin.js
-# Task board: the page, the agent tools (fake model), drag and drop, search, the switch
+# Task board: a prompt starts a chat, AI tags, live columns, Answer on the board, Hide finished, the switch
 SHOT=1 PLAYWRIGHT=/path/to/playwright node test/browser-task-board.mjs /path/to/dsh/lib/bin.js
 ```