team-toon-tack 3.12.0 → 3.13.0

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
 			"name": "team-toon-tack",
 			"source": "./",
 			"description": "Linear/Trello task sync & management CLI with commands and skills",
-			"version": "3.12.0"
+			"version": "3.13.0"
 		}
 	]
 }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
 	"name": "team-toon-tack",
 	"description": "Linear/Trello task sync & management CLI for Claude Code - saves tokens vs MCP",
-	"version": "3.12.0",
+	"version": "3.13.0",
 	"author": {
 		"name": "wayne930242",
 		"email": "wayne930242@gmail.com"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.12.0",
+	"version": "3.13.0",
 	"description": "透過 ttt CLI 同步與管理 Linear、Trello 任務。",
 	"author": {
 		"name": "wayne930242"

package/README.md

@@ -9,6 +9,7 @@ Optimized task workflow for Claude Code — supports Linear and Trello, saves si
 - **Token Efficient** — Local cycle cache eliminates repeated API calls, saving significant tokens vs MCP
 - **Multi-source Support** — Works with both Linear and Trello
 - **Batch Ticket Claiming** — Claim one or many tickets at once with `ttt claim`, or auto-pick your highest priority pending tasks with `ttt claim next <n>`
+- **Work Orders** — One file per train batch carries its tickets from claim to Done: `ttt claim --order`, then `ttt order close` completes the whole batch after the merge
 - **Multi-team Support** — Sync and filter issues across multiple teams/boards
 - **Flexible Sync Modes** — Choose between remote (immediate sync) or local (offline-first, sync later with `--update`)
 - **Completion Modes** — Four modes for task completion (Linear): simple, strict review, upstream strict, upstream not strict
@@ -156,6 +157,7 @@ ttt claim MP-123 MP-124    # Batch claim
 ttt claim next             # Claim highest priority pending task
 ttt claim next 3           # Claim top 3 pending tasks
 ttt claim --dry-run        # Preview without changes
+ttt claim MP-123 --order auto --project app   # Also record it in the project's open work order
 ```
 
 Completed, in-review, and blocked tickets are reported and skipped without
@@ -168,6 +170,11 @@ that a full `ttt sync` rewrites local data from the current cycle, so a stored
 ticket outside it drops out on the next sync (`ttt done <id> --from-remote`
 still completes it).
 
+`--order <id|auto>` also records the claimed tickets in a [work order](#ttt-order).
+`auto` means the project's open order; when the last one was sealed, a new order `<project>/<YYYY-MM-DD>-<next letter>` is opened.
+`--project <name>` names the project for `auto` (default: the directory that holds `.ttt`).
+An order that cannot take the ticket (sealed, handed off, closed) refuses before anything is claimed.
+
 ### `ttt estimate`
 
 Save a local human-effort estimate that persists in `.ttt/cycle.toon`.
@@ -186,6 +193,7 @@ Mark task as completed.
 ```bash
 ttt done                         # Auto-select if only one in-progress
 ttt done MP-123                  # Specific issue
+ttt done MP-123 MP-124 -m "Merged in v1.2.0"   # Several issues, one message
 ttt done -m "Fixed the bug"      # With completion message
 ttt done MP-123 --from-remote    # Fetch from remote (bypasses local data check)
 ttt done MP-123 --commit 1a2b3c4 # Record this commit instead of HEAD
@@ -196,6 +204,61 @@ Use `--from-remote` (or `-r`) when the issue exists in remote but not in local s
 
 Use `--commit <sha>` (and `--repo <path>` when the commit lives in another checkout) to close a ticket whose commit was merged earlier. Without it, the current HEAD is recorded.
 
+With several IDs, `-m`, `--commit`, `--repo`, and `--from-remote` apply to every ticket.
+Every ID must resolve first: one that is unknown or not in progress stops the run before any ticket moves.
+Each ticket gets a result line, and one failing ticket does not stop the rest.
+A ticket that is already done (or, under `strict_review`, already at the testing status) is reported and skipped, so a run can be repeated after a partial failure.
+IDs repeated in another case count once.
+The exit code is non-zero when any ticket failed.
+To close a whole train batch after its merge, use a [work order](#ttt-order) instead.
+
+### `ttt order`
+
+A work order is one TOON file per train batch.
+It carries the batch's tickets from claim to Done, with each ticket's branch, MR, head, review verdict, and passed test runs in one place.
+Use it when several tickets ride one integration branch and are closed together after its merge.
+
+```bash
+# Coordinator (the one writer while tickets are being worked on)
+ttt claim MP-1 MP-2 --order auto --project app      # Claim into the project's open order
+ttt order set app/2026-11-11-a MP-1 --branch feat/mp-1 --mr '!812' --head 1a2b3c4 \
+    --review "P0/P1=0" --tests "bun test scripts/x = pass"
+ttt order review app/2026-11-11-a MP-1 MP-2         # Move to the testing status, keep the assignee
+ttt order train app/2026-11-11-a --branch agent-train/2026-11-11-a --mr '!900'
+ttt order seal app/2026-11-11-a --gated-head 5d6e7f8   # No more tickets
+ttt order export app/2026-11-11-a --handoff         # Paste the block into the train MR
+
+# Integrator (the writer after the handoff)
+glab mr view 900 | ttt order import -               # Reads the block out of any text
+ttt order close app/2026-11-11-a --merged 9a8b7c6 --version v1.2.0 --dry-run
+ttt order close app/2026-11-11-a --merged 9a8b7c6 --version v1.2.0
+```
+
+| Command | What it does |
+|---------|--------------|
+| `open [<project>/<code>] [--project p] [--reviewer r]` | Open an order. Without an id the code is `<YYYY-MM-DD>-<next letter>`. |
+| `list [--project p] [--all]` | List orders; closed ones only with `--all`. |
+| `show <id> [--toon]` | Show an order, or its stored TOON. |
+| `set <id> <ticket> [--branch --mr --head --review --tests]` | Record what a worker reported. Each `--tests "<cmd> [@ <sha>] [= <result>]"` appends one run; the SHA defaults to the ticket's head and the result to `pass`. |
+| `review <id> <ticket>... [--status name]` | Move tickets to the testing status (`status_transitions.testing`, else `dev_testing_status`) and mark them in-review. |
+| `train <id> [--branch b] [--mr mr]` | Record the train branch and its merge request. |
+| `seal <id> --gated-head <sha>` | Fix the batch on the head the gate passed on. Every ticket must be in review or dropped. |
+| `drop <id> <ticket> --reason <text>` | Leave a ticket out of the batch. Its remote status is not touched. |
+| `export <id> [--handoff]` | Print the order as a fenced block. `--handoff` makes the local copy read-only. |
+| `import <file\|-> [--id id] [--force]` | Take the block from a file or stdin; the importer becomes the writer. |
+| `reclaim <id>` | Take a handed-off order back when it was returned without an export. |
+| `close <id> --merged <sha> [--version v] [--dry-run]` | Complete every in-review ticket and comment on each. |
+
+How an order behaves:
+
+- **Storage.** Orders live in `.ttt/orders/<project>/<code>.toon` on the writer's machine and are never committed. Writes are atomic (temp file, then rename) and serialized by a lock per project. The default project is the directory that holds `.ttt`.
+- **Stages.** `open` → `sealed` → `merged` → `closed`. A project holds one open order at a time. After the seal, `ttt claim --order auto` opens the next one, and a returned ticket is reworked inside its own order: record the new head with `set`, then `seal` again.
+- **One writer.** Workers report; the coordinator records. `export --handoff` passes the pen to the integrator, and write commands on the handed-off copy refuse with the way back: import the returned copy, or `reclaim`. An import never overwrites a writable local copy without `--force`, and never takes an older revision.
+- **Close.** Each in-review ticket goes through the same completion handler as `ttt done`, so `completion_mode` and parent issues apply. Each gets one comment with its MR, the merge commit, the version, and the order id. Dropped tickets are untouched. A ticket canceled at the source, or moved out of review since the seal, stops the close until it is dropped or sent back to review. Close requires the done status: a completion mode that leaves a ticket at testing (`strict_review`, or `upstream_strict` without a parent to take it) fails that ticket and keeps the order merged. A rerun skips what is already done and does not comment twice.
+- **Identity.** The writer's name in `owner` and the log is `TTT_ACTOR`, else `<current_user>@<hostname>`.
+
+A ticket rides one order per project at a time: claiming it into a second order of the same project, or having `review` adopt it there, is refused until it is dropped from the first. `review` leaves a Done or Canceled ticket where it is.
+
 ### `ttt status`
 
 Show or modify task status.
@@ -257,6 +320,7 @@ your-project/
     ├── config.toon     # Team config (gitignore recommended)
     ├── local.toon      # Personal settings (gitignore)
     ├── cycle.toon      # Current cycle data + local estimates (auto-generated)
+    ├── orders/         # Work orders: <project>/<code>.toon (never commit)
     └── output/         # Downloaded attachments (images, files)
 ```
 
@@ -268,6 +332,7 @@ your-project/
 | `TRELLO_API_KEY` | **Required for Trello.** Your Trello API key |
 | `TRELLO_TOKEN` | **Required for Trello.** Your Trello authorization token |
 | `TOON_DIR` | Config directory (default: `.ttt`) |
+| `TTT_ACTOR` | Writer's name in work orders (default: `<current_user>@<hostname>`) |
 
 ### Trello Setup
 
@@ -302,7 +367,8 @@ Install the plugin for Claude Code integration:
 | `/ttt:sync` | Sync issues to local cycle data |
 | `/ttt:work-on` | Claim ticket(s) and work on them |
 | `/ttt:estimate` | Save a local human-effort estimate |
-| `/ttt:done` | Mark current task as completed |
+| `/ttt:done` | Mark one or more tasks as completed |
+| `/ttt:order` | Work orders: carry a train batch from claim to Done |
 | `/ttt:status` | Show or modify task status |
 | `/ttt:show` | Show issue details or search issues |
 

package/README.zh-TW.md

@@ -9,6 +9,7 @@
 - **節省 Token** — 本地 cycle 快取避免重複 API 呼叫，比 MCP 省下大量 token
 - **多來源支援** — 支援 Linear 和 Trello
 - **批次領票** — `ttt claim` 可一次領一張或多張票，`ttt claim next <n>` 自動領取最高優先級的待辦任務
+- **工單** — 一個列車批次一份檔案，把這批票從領票帶到 Done：`ttt claim --order` 領票入單，合併後 `ttt order close` 一次完成整批
 - **多團隊支援** — 跨多個團隊/看板同步與過濾 issue
 - **彈性同步模式** — 選擇 remote（即時同步）或 local（離線優先，稍後用 `--update` 同步）
 - **完成模式** — 四種任務完成模式（Linear）：簡單、嚴格審查、上下游嚴格、上下游非嚴格
@@ -156,6 +157,7 @@ ttt claim MP-123 MP-124    # 批次領票
 ttt claim next             # 領最高優先級的待辦任務
 ttt claim next 3           # 領最高優先級的前 3 張票
 ttt claim --dry-run        # 預覽，不改狀態
+ttt claim MP-123 --order auto --project app   # 同時記進該專案目前開著的工單
 ```
 
 已完成、審核中、blocked 的票會逐張回報並跳過，不中斷整批。
@@ -164,6 +166,11 @@ ttt claim --dry-run        # 預覽，不改狀態
 已關閉（完成或取消）的票會回報並跳過。
 注意：完整的 `ttt sync` 會依目前 cycle 重寫本地資料，不在 cycle 內的票下次同步後會消失（仍可用 `ttt done <id> --from-remote` 完成）。
 
+加 `--order <id|auto>` 會把領到的票同時記進[工單](#ttt-order)。
+`auto` 指該專案目前開著的工單；上一張已封單時，會開一張新的 `<project>/<YYYY-MM-DD>-<下一個字母>`。
+`--project <name>` 指定 `auto` 用的專案（預設：`.ttt` 所在的目錄名稱）。
+工單無法收票時（已封單、已交接、已關閉），會在領任何票之前拒絕。
+
 ### `ttt estimate`
 
 把人類工程工時估算寫進 `.ttt/cycle.toon`，並在之後的同步中保留下來。
@@ -182,6 +189,7 @@ ttt estimate MP-123 --clear                   # 移除既有估時
 ```bash
 ttt done                         # 若只有一個進行中，自動選擇
 ttt done MP-123                  # 指定 issue
+ttt done MP-123 MP-124 -m "已隨 v1.2.0 合併"   # 一次完成多張票，共用說明
 ttt done -m "修復了錯誤"           # 附上完成說明
 ttt done MP-123 --from-remote    # 從遠端取得（略過本地資料檢查）
 ttt done MP-123 --commit 1a2b3c4 # 記錄指定 commit，而非目前 HEAD
@@ -192,6 +200,59 @@ ttt done MP-123 --commit 1a2b3c4 --repo ~/projects/app   # ...從另一個 repos
 
 要關閉 commit 早已合併的 ticket，用 `--commit <sha>`（commit 在另一個 checkout 時再加 `--repo <path>`）。未指定時記錄目前的 HEAD。
 
+一次給多個 ID 時，`-m`、`--commit`、`--repo`、`--from-remote` 套用到每一張票。
+每張票各有一行結果，其中一張失敗不會中斷其他票。
+已經完成的票只回報、不重做，所以部分失敗後可以原指令重跑。
+只要有一張失敗，結束碼就不是 0。
+整批列車合併後要一次關票，改用[工單](#ttt-order)。
+
+### `ttt order`
+
+工單（work order）是一個列車批次一份的 TOON 檔。
+它把這一批票從領票帶到 Done，每張票的分支、MR、head、審查結論與通過的測試紀錄都記在同一處。
+多張票搭同一條整合分支、合併後一起關票時使用。
+
+```bash
+# 協調者（票還在做的期間，唯一的寫入者）
+ttt claim MP-1 MP-2 --order auto --project app      # 領票並寫進該專案目前開著的工單
+ttt order set app/2026-11-11-a MP-1 --branch feat/mp-1 --mr '!812' --head 1a2b3c4 \
+    --review "P0/P1=0" --tests "bun test scripts/x = pass"
+ttt order review app/2026-11-11-a MP-1 MP-2         # 改到測試狀態，指派人不變
+ttt order train app/2026-11-11-a --branch agent-train/2026-11-11-a --mr '!900'
+ttt order seal app/2026-11-11-a --gated-head 5d6e7f8   # 封單，不再收票
+ttt order export app/2026-11-11-a --handoff         # 把輸出的區塊貼進列車 MR
+
+# 整合者（交接後的寫入者）
+glab mr view 900 | ttt order import -               # 從任何文字中取出工單區塊
+ttt order close app/2026-11-11-a --merged 9a8b7c6 --version v1.2.0 --dry-run
+ttt order close app/2026-11-11-a --merged 9a8b7c6 --version v1.2.0
+```
+
+| 指令 | 作用 |
+|------|------|
+| `open [<project>/<code>] [--project p] [--reviewer r]` | 開工單。不給 id 時，代碼為 `<YYYY-MM-DD>-<下一個字母>`。 |
+| `list [--project p] [--all]` | 列出工單；加 `--all` 才列已關閉的。 |
+| `show <id> [--toon]` | 顯示工單，或印出儲存的 TOON。 |
+| `set <id> <ticket> [--branch --mr --head --review --tests]` | 記錄 worker 回報的內容。每個 `--tests "<指令> [@ <sha>] [= <結果>]"` 追加一筆測試紀錄；SHA 預設為該票的 head，結果預設為 `pass`。 |
+| `review <id> <ticket>... [--status name]` | 把票改到測試狀態（`status_transitions.testing`，沒有則用 `dev_testing_status`），並在工單標為 in-review。 |
+| `train <id> [--branch b] [--mr mr]` | 記錄列車分支與它的 MR。 |
+| `seal <id> --gated-head <sha>` | 以通過 gate 的 head 封單。每張票都必須已送審或已剔除。 |
+| `drop <id> <ticket> --reason <text>` | 把票從這一批剔除，遠端狀態不動。 |
+| `export <id> [--handoff]` | 把工單印成一個 fenced 區塊。加 `--handoff` 後本機這份改為唯讀。 |
+| `import <file\|-> [--id id] [--force]` | 從檔案或 stdin 取出區塊；匯入者成為寫入者。 |
+| `reclaim <id>` | 對方退回但沒有匯出時，把已交接的工單收回。 |
+| `close <id> --merged <sha> [--version v] [--dry-run]` | 完成每張送審中的票，並各留一則留言。 |
+
+工單的規則：
+
+- **儲存。** 工單存在寫入者機器上的 `.ttt/orders/<project>/<code>.toon`，不進版控。寫入先寫暫存檔再改名，並以每個專案一把鎖排隊。預設專案是 `.ttt` 所在的目錄名稱。
+- **階段。** `open` → `sealed` → `merged` → `closed`。一個專案同時只有一張開著的工單。封單之後，`ttt claim --order auto` 會開下一張；被退回的票留在原工單重做：用 `set` 記下新的 head，再 `seal` 一次。
+- **單一寫入者。** Worker 回報，協調者記錄。`export --handoff` 把寫入權交給整合者；之後在已交接的那份上執行寫入指令會被拒絕，訊息會說明怎麼拿回來：匯入對方退回的版本，或執行 `reclaim`。匯入時，本機那份若仍可寫，沒有 `--force` 不會被覆蓋；版本比本機舊的也不會被接受。
+- **關單。** 每張送審中的票走與 `ttt done` 相同的完成流程，所以 `completion_mode` 與上層 issue 的規則照常套用。每張票各有一則留言，寫明它的 MR、合併 commit、版本與工單 id。已剔除的票不動。遠端已取消的票會讓關單停下，剔除後才能繼續。重跑時，已完成的票會跳過，留言不會重複。
+- **身分。** `owner` 與紀錄中的寫入者名稱取自 `TTT_ACTOR`，未設定時為 `<current_user>@<hostname>`。
+
+一張票同一時間只搭一張工單：要領進第二張工單，必須先從第一張剔除。
+
 ### `ttt status`
 
 顯示或修改任務狀態。
@@ -249,6 +310,7 @@ your-project/
     ├── config.toon     # 團隊配置（建議 gitignore）
     ├── local.toon      # 個人設定（gitignore）
     ├── cycle.toon      # 當前 cycle 資料與本地估時（自動產生）
+    ├── orders/         # 工單：<project>/<code>.toon（不要 commit）
     └── output/         # 下載的附件（圖片、檔案）
 ```
 
@@ -260,6 +322,7 @@ your-project/
 | `TRELLO_API_KEY` | **Trello 必填**。你的 Trello API 金鑰 |
 | `TRELLO_TOKEN` | **Trello 必填**。你的 Trello 授權 token |
 | `TOON_DIR` | 配置目錄（預設：`.ttt`） |
+| `TTT_ACTOR` | 工單中的寫入者名稱（預設：`<current_user>@<hostname>`） |
 
 ### Trello 設定
 
@@ -294,7 +357,8 @@ your-project/
 | `/ttt:sync` | 同步 issue 到本地 |
 | `/ttt:work-on` | 領票並開始處理 |
 | `/ttt:estimate` | 寫入本地人力估時 |
-| `/ttt:done` | 標記當前任務完成 |
+| `/ttt:done` | 標記一張或多張任務完成 |
+| `/ttt:order` | 工單：把一批列車的票從領票帶到 Done |
 | `/ttt:status` | 顯示或修改任務狀態 |
 | `/ttt:show` | 顯示 issue 詳情或搜尋 issue |
 

package/commands/ttt-done.md

@@ -1,9 +1,9 @@
 ---
 name: ttt:done
-description: Mark current task as completed
+description: Mark one or more tasks as completed
 arguments:
   - name: issue-id
-    description: Issue ID if multiple tasks in progress (e.g., MP-624)
+    description: Issue ID if multiple tasks in progress (e.g., MP-624); several IDs complete them in one run
     required: false
   - name: message
     description: Completion message summarizing what was done
@@ -40,6 +40,7 @@ ttt done                                # Complete current in-progress task
 ttt done MP-624                         # Complete specific task
 ttt done -m "Fixed null check"          # With completion message
 ttt done MP-624 -m "Refactored auth"    # Specific task with message
+ttt done MP-624 MP-625 -m "Merged"      # Several tasks, options shared by all
 ttt done MP-624 --from-remote           # Issue not in local data, or still Todo (no claim needed)
 ttt done MP-624 --commit 1a2b3c4        # Record an earlier commit, not HEAD
 ```
@@ -47,10 +48,11 @@ ttt done MP-624 --commit 1a2b3c4        # Record an earlier commit, not HEAD
 ## Full CLI Reference
 
 ```
-Usage: ttt done [issue-id] [-m message] [--from-remote] [--commit <sha>] [--repo <path>]
+Usage: ttt done [issue-id...] [-m message] [--from-remote] [--commit <sha>] [--repo <path>]
 
 Arguments:
-  issue-id              Optional. Issue ID if multiple tasks in-progress
+  issue-id              Optional. Issue ID if multiple tasks in-progress.
+                        Several IDs complete each ticket with the same options
 
 Options:
   -m, --message         Completion message describing what was done
@@ -60,6 +62,14 @@ Options:
   --repo <path>         Git repository to read the commit from (default: cwd)
 ```
 
+## Several Tickets
+
+With several IDs each ticket gets a result line (`✅ done`, `⏭️ already done`, `❌ failed`).
+An ID that is unknown or not in progress stops the run before any ticket moves.
+One failing ticket does not stop the rest, and the exit code is non-zero when any failed.
+A ticket that is already done (under `strict_review`: already at the testing status) is skipped, so the same command can be rerun after a partial failure.
+For a train batch tracked in a work order, close it with `/ttt:order` (`ttt order close`) instead.
+
 ## Before Running
 
 Ensure:
@@ -89,5 +99,6 @@ Additionally:
 | `No in-progress task` | Specify issue-id explicitly |
 | `Multiple in-progress` | Specify issue-id to disambiguate |
 | `Issue not found` | Use `--from-remote` flag |
+| `❌ MP-x failed` in a batch | Fix the cause and rerun the same command; done tickets are skipped |
 | `不在進行中狀態` (task is Todo) | `ttt claim <id>` first, or `ttt done <id> --from-remote` |
 | `No commits found` | Commit your changes first |

package/commands/ttt-order.md

@@ -0,0 +1,134 @@
+---
+name: ttt:order
+description: Work orders - carry a train batch of tickets from claim to Done
+arguments:
+  - name: command
+    description: "open, list, show, set, review, train, seal, drop, export, import, reclaim, or close"
+    required: true
+  - name: args
+    description: "Order id (<project>/<code>), ticket ids, and options for the command"
+    required: false
+---
+
+<law>
+YOU MUST execute `ttt order` (and `ttt claim --order`) using the Bash tool.
+DO NOT edit files under `.ttt/orders/` by hand, and DO NOT commit them.
+ONE side writes an order at a time: the coordinator records for its workers; after `export --handoff` only the receiver writes.
+</law>
+
+# /ttt:order — Work Orders
+
+A work order is one TOON file per train batch (`.ttt/orders/<project>/<code>.toon`).
+It holds the batch's tickets with each one's branch, MR, head, review verdict, and test runs, and it closes every ticket with one command after the train merged.
+
+## Execution
+
+```bash
+ttt order {{ command }} {{ args }}
+```
+
+## Flow
+
+### Coordinator: claim, record, review, seal, hand off
+
+```bash
+ttt claim MP-624 MP-625 --order auto --project app   # Claim into the project's open order
+ttt order list                                       # Find the order id, e.g. app/2026-11-11-a
+
+# A worker reports its MR: the coordinator records it (workers never write the order)
+ttt order set app/2026-11-11-a MP-624 --branch feat/mp-624 --mr '!812' --head 1a2b3c4
+ttt order set app/2026-11-11-a MP-624 --review "P0/P1=0 @1a2b3c4" \
+    --tests "bun test scripts/order = pass"
+
+ttt order review app/2026-11-11-a MP-624 MP-625      # Move to the testing status
+ttt order drop app/2026-11-11-a MP-626 --reason "not ready for this train"
+
+ttt order train app/2026-11-11-a --branch agent-train/2026-11-11-a --mr '!900'
+ttt order seal app/2026-11-11-a --gated-head 5d6e7f8 # No more tickets
+ttt order export app/2026-11-11-a --handoff          # Paste the block into the train MR or slip
+```
+
+After the seal, `ttt claim <id> --order auto` opens the next order.
+After `--handoff` the local copy is read-only.
+
+### Integrator: import, merge, close
+
+```bash
+glab mr view 900 | ttt order import -                # Or: ttt order import slip.md
+ttt order show app/2026-11-11-a
+# ... merge the train ...
+ttt order close app/2026-11-11-a --merged 9a8b7c6 --version v1.2.0 --dry-run
+ttt order close app/2026-11-11-a --merged 9a8b7c6 --version v1.2.0
+```
+
+`close` completes every in-review ticket through the configured completion mode (parent issues included) and comments MR, merge commit, version, and order id on each.
+Dropped tickets are untouched.
+A ticket must reach the done status: under `strict_review` (or `upstream_strict` without a parent) it stops at testing, so close fails it and the order stays merged.
+When a ticket fails, fix the cause and rerun the same command: done tickets are skipped and no comment is posted twice.
+
+### A returned train
+
+The integrator returns the order with `ttt order export <id> --handoff`, and the coordinator runs `ttt order import <file>`.
+When nothing came back, the coordinator runs `ttt order reclaim <id>`.
+A reworked ticket stays in its order: record the new head and test runs with `set`, then `seal` again with the new gated head and hand off again.
+
+## Full CLI Reference
+
+```
+Usage: ttt order <command> [options]
+
+Commands:
+  open [<project>/<code>] [--project <p>] [--reviewer <name>]
+        Open an order. Without an id: <project>/<YYYY-MM-DD>-<next letter>.
+        A project holds one open order at a time.
+  list [--project <p>] [--all]
+        List orders (closed ones only with --all).
+  show <id> [--toon]
+        Show an order; --toon prints the stored TOON.
+  set <id> <ticket> [--branch <b>] [--mr <mr>] [--head <sha>]
+        [--review <verdict>] [--tests "<cmd> [@ <sha>] [= <result>]"]...
+        Record a ticket's branch, MR, head, review verdict, and test runs.
+        Each --tests appends one run; the sha defaults to the ticket's
+        head, the result to "pass".
+  review <id> <ticket>... [--status <name>]
+        Move tickets to the testing status (assignee unchanged) and mark
+        them in-review. An open order adopts a ticket it does not hold yet,
+        unless another order of the project holds it. Done or Canceled
+        tickets are left where they are.
+  train <id> [--branch <b>] [--mr <mr>]
+        Record the train branch and its merge request.
+  seal <id> --gated-head <sha>
+        Fix the batch: no more tickets. Every ticket must be in review or
+        dropped. Sealing again records a new gated head.
+  drop <id> <ticket> --reason <text>
+        Leave a ticket out of the batch; its remote status is not touched.
+  export <id> [--handoff]
+        Print the order as a fenced block for an MR description or a slip.
+        --handoff makes this copy read-only: the receiver writes from now on.
+  import <file|-> [--id <id>] [--force]
+        Read the block out of any text and become the order's writer.
+  reclaim <id>
+        Take a handed-off order back when it was returned without an export.
+  close <id> --merged <sha> [--version <v>] [--dry-run]
+        After the train merged: complete every in-review ticket through the
+        configured completion mode, and comment MR, merge commit, version,
+        and order id on each. Dropped tickets are untouched. Safe to rerun.
+```
+
+The default project is the directory that holds `.ttt`.
+The writer's name is `TTT_ACTOR`, else `<current_user>@<hostname>`.
+
+## Error Handling
+
+| Error | Solution |
+|-------|----------|
+| `was handed off ... read-only` | Import the returned copy, or `ttt order reclaim <id>` |
+| `takes no more tickets` | The order is sealed: claim with `--order auto` to use the next one |
+| `Cannot seal ...: MP-x still in progress` | `ttt order review <id> MP-x` or `ttt order drop <id> MP-x --reason ...` |
+| `is not sealed` on close | `ttt order seal <id> --gated-head <sha>` first |
+| `is Canceled at the source` on close | `ttt order drop <id> MP-x --reason canceled`, then rerun close |
+| `no longer in review` on close | The ticket moved since the seal: `ttt order drop` it, or put it back in review |
+| `is In Review, not Done` on close | The completion mode stops at testing; move it to Done or change `completion_mode`, then rerun |
+| `already in order ...` on review | A ticket rides one order per project; drop it there first |
+| `already exists here as a writable copy` on import | Check which copy is current; replace the local one with `--force` |
+| `No work order block found` | Pass text that contains the block printed by `ttt order export` |

package/commands/ttt-work-on.md

@@ -8,6 +8,12 @@ arguments:
   - name: dry-run
     description: Preview selection without changing status
     required: false
+  - name: order
+    description: "Work order to record the claimed tickets in: an order id, or 'auto' for the project's open order"
+    required: false
+  - name: project
+    description: Project for order 'auto' (default - the directory that holds .ttt)
+    required: false
 ---
 
 <law>
@@ -24,7 +30,7 @@ to in-progress locally and on the remote source.
 ## Execution
 
 ```bash
-ttt claim {{ issue-ids | default: "next" }} {{ "--dry-run" if dry-run }}
+ttt claim {{ issue-ids | default: "next" }} {{ "--dry-run" if dry-run }} {{ "--order " + order if order }} {{ "--project " + project if project }}
 ```
 
 ### Argument Resolution
@@ -38,6 +44,7 @@ ttt claim {{ issue-ids | default: "next" }} {{ "--dry-run" if dry-run }}
 | `MP-624 MP-625` | `ttt claim MP-624 MP-625` |
 | `--dry-run` | `ttt claim next --dry-run` |
 | `MP-624 --dry-run` | `ttt claim MP-624 --dry-run` |
+| `MP-624 MP-625` in a train batch | `ttt claim MP-624 MP-625 --order auto --project <name>` |
 
 ## Full CLI Reference
 
@@ -57,7 +64,13 @@ Arguments:
               claimed like any other
 
 Options:
-  --dry-run   Pick tickets without changing status (preview only)
+  --dry-run            Pick tickets without changing status (preview only)
+  --order <id|auto>    Also record the claimed tickets in a work order
+                       (see 'ttt order --help'). 'auto' is the project's open
+                       order; when the last one was sealed, a new order
+                       <project>/<YYYY-MM-DD>-<next letter> is opened
+  --project <name>     Project for '--order auto'
+                       (default: the directory that holds .ttt)
 ```
 
 Tickets that are already completed, in review, or blocked are reported and
@@ -82,6 +95,12 @@ This command claims the tickets. The implementation workflow belongs to the user
 When several tickets were claimed at once, carry them one at a time and close
 each with `/ttt:done -m "summary"` before starting the next.
 
+## Batch Work on a Train
+
+When the tickets ride one integration branch and are closed together after its
+merge, claim them with `--order` and do not run `/ttt:done` per ticket. The work
+order then carries them to Done: see `/ttt:order`.
+
 ## Error Handling
 
 | Error | Solution |
@@ -89,3 +108,5 @@ each with `/ttt:done -m "summary"` before starting the next.
 | `No cycle data found` | Run `ttt sync` first |
 | `No eligible tasks` | All tasks assigned or in-review; run `ttt sync` to refresh |
 | `Issue not found` | Run `ttt sync <id>` to fetch it |
+| `Order ... takes no more tickets` | The order is sealed; use `--order auto` to claim into the next one |
+| `already in order ...` | The ticket rides another order; drop it there first (`ttt order drop`) |

package/dist/bin/cli.js

@@ -22,6 +22,7 @@ const COMMANDS = [
     "assign",
     "edit",
     "cancel",
+    "order",
     "config",
     "help",
     "version",
@@ -47,6 +48,7 @@ COMMANDS:
   assign     Reassign an issue to a user
   edit       Edit issue fields (title, description, priority, labels)
   cancel     Cancel an issue
+  order      Work orders: carry a train batch of tickets from claim to Done
   config     Configure settings (status mappings, filters)
   help       Show this help message
   version    Show version
@@ -68,6 +70,9 @@ EXAMPLES:
   ttt estimate MP-123 6         # Save a 6-hour estimate locally
   ttt done                      # Complete current task
   ttt done -m "Fixed the bug"   # With completion message
+  ttt done MP-123 MP-124        # Complete several tickets in one run
+  ttt claim MP-123 --order auto # Claim into the project's open work order
+  ttt order close app/2026-11-11-a --merged 1a2b3c4   # Batch → Done after merge
   ttt show MP-123               # Show issue from local data
   ttt show --label frontend     # Search local issues by label
   ttt show --status "In Progress"  # Filter by status
@@ -217,6 +222,10 @@ async function main() {
                 process.argv = ["node", "cancel.js", ...commandArgs];
                 await importScript("cancel.js");
                 break;
+            case "order":
+                process.argv = ["node", "order.js", ...commandArgs];
+                await importScript("order.js");
+                break;
             case "config":
                 process.argv = ["node", "config.js", ...commandArgs];
                 await importScript("config.js");