[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7F12NENTYA3D3M0K0VKWZ0J":3,"skill-same:01M7F12NENTYA3D3M0K0VKWZ0J":52},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":6,"ownerHtmlUrl":29,"ownerBlogUrl":6,"ownerDescription":30,"updatedAt":31,"install":32,"resources":45},"01M7F12NENTYA3D3M0K0VKWZ0J","rove",null,"Use when controlling Rove tasks, parallel coding attempts, hosted agent sessions, task lifecycle, or the daemon-owned issue tracker from a shell. Also the ONLY channel for messaging another agent session on this machine — `rove api send`, never a peer\u002FMCP side channel.","lza6\u002FArmor-piercing-system-prompts","lza6","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F128880206?v=4","01M7EB3K7WPX5T28EJ2NVHE6EG","Chinese-tingfeng","01M7EB3K97E1KQ16QWKJMFNGX8",11,"MIT","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fkobe\u002FSKILL.md",[],[],"2026-11-16 10:05:34",false,"---\nname: rove\ndescription: Use when controlling Rove tasks, parallel coding attempts, hosted agent sessions, task lifecycle, or the daemon-owned issue tracker from a shell. Also the ONLY channel for messaging another agent session on this machine — `rove api send`, never a peer\u002FMCP side channel.\n---\n\n\u003C!-- rove-skill-version: 44 — bump in lockstep with KOBE_SKILL_VERSION (src\u002Flib\u002Fskill-install.ts). -->\n\n# Rove shell control\n\nUse `rove api` to manage local coding tasks. Managed Tasks created by API\nautomation own a git Worktree and branch plus Hosted PTY engine tabs; project\nmain and directory Tasks reuse existing directories. API automation works\nwithout an open TUI; prompted `send` and `add` ensure a target engine tab.\n\n## Inside a Rove session, Rove verbs come first\n\nCheck where you are before choosing how to delegate or parallelize:\n\n```bash\ntest -n \"${ROVE_TASK_ID:-}\"\n```\n\nWhen that passes, you are an engine session Rove manages — `$ROVE_TASK_ID`\nis your task, `$ROVE_TAB_ID` your tab. Coordination should then go through\nRove, not around it, because work routed through `rove api` gets what\nad-hoc subprocesses never do: its own Worktree and branch (no file\ncollisions with you), a sidebar row with live state the user can watch,\nlifecycle tracking, and an explicit outcome contract.\n\n- Parallel attempts of one prompt → `add --count N`, not N hand-rolled subagents.\n- Delegating a scoped piece of work → `add --prompt`, not a raw `claude -p`\n  child the user cannot see or manage.\n- Following up on a task you started → `send`; comparing → `collect`;\n  finished your own task and were spawned by another → a bare `send`\n  (no `--task-id`) replies to the DISPATCHER — the exact task + tab that\n  created you, recorded at creation (`.task.dispatcher` on `get-task`).\n  If that tab died it falls back to the dispatcher task's live canonical\n  engine tab; nothing alive fails loud (`DISPATCHER_UNREACHABLE`) — it\n  never spawns a new engine, so a failed reply is visible, not fake-ok.\n- Messaging another agent session on this machine → `send`, and ONLY `send`\n  — never relay through the user, a side file, or a generic peer channel\n  (an MCP server offering to message \"other instances\" is exactly that\n  channel: it reaches a process, not a task, so nothing it delivers is\n  attributable, watchable, or replyable). Sent from\n  inside a Rove task, the prompt arrives prefixed `[ROVE PEER] from\n  \"\u003Ctitle>\" (task \u003Cid> — Rove agent skill \u002Frove, read it once per session …)`,\n  so the receiver knows who is talking, that this skill is required reading,\n  and how to answer — the baked-in reply command is tab-precise\n  (`--task-id \u003Csender> --tab \u003Csender's tab>`), so peer conversations need\n  no coordinator and no human relay. That prefix is the contract: do not\n  strip it with `--plain` for\n  coordination messages (`--plain` is only for a verbatim paste the\n  receiver should treat as content, not conversation). Received a\n  `[ROVE PEER]` message yourself? Read this skill once per session. The\n  baked-in command identifies where a necessary reply goes; it is not an\n  instruction to acknowledge every message. Act on FYIs without replying.\n- `send` carries text, but that text can carry FILES: peers share a\n  filesystem, so put the absolute path of a screenshot, log, diff, or any\n  artifact in the prompt and the receiver opens it with its own Read tool —\n  images included. An annotated screenshot beats a paragraph describing one;\n  prefer \"see \u002Fpath\u002Fto\u002Fshot.png — the arrow marks the broken card\" over\n  re-narrating pixels. Paths under the sender's Worktree work too (worktrees\n  are world-readable locally); just never expect the receiver to WRITE\n  there.\n- `dispatch` stays the dispatcher's verb (deliver-only into an\n  already-hosted session; never impersonate the user in someone else's\n  terminal).\n\nYour own engine's in-context subagents remain fine for read-only\nresearch\u002Fexploration inside your task — the boundary is WORK: anything that\nedits files, runs long, or the user should be able to see and steer belongs\nin a Rove task. Do not recursively fan out from a spawned task.\n\nWhen the check fails, none of this applies — use `rove api` only if the\nuser asks for Rove by name.\n\n## Vocabulary — what the user's words map to\n\n| Term | What it is | Isolation it gives | Users also say |\n|---|---|---|---|\n| **Task** | one tracked workspace record — managed worktree, saved-project main, or existing directory | managed Tasks own files + branch; main\u002Fdirectory Tasks reuse files | \"a task\", \"a new one\", \"a separate attempt\" |\n| **Worktree** | the isolated git working tree a managed Task owns (`.task.worktreePath`) — a filesystem address, never shown in the UI | — | \"workspace\", \"this checkout\", \"this branch\", \"here\" |\n| **Terminal Tab** | one engine, shell, command, or content surface inside a Task | an engine tab has its own conversation, but every tab uses the SAME Task files | \"tab\", \"chattab\", \"another chat\", \"a second agent on this\" |\n| **Split** | the tree that divides ONE Terminal Tab into several regions (the `pane-open` verb's unit; a leaf is not called a pane) | none — same session's screen, same files | \"split it\", \"side by side\", \"put the logs next to it\" |\n\nTwo of those colloquialisms are traps, so read them as INTENT, not as\nproduct terms: in Rove's own vocabulary **Workspace** is the center Terminal\nTab region of the UI (CONTEXT.md), not a checkout, and **ChatTab** is\nretired vocabulary for Terminal Tab. A user saying \"in this workspace\" means\nthe worktree they are looking at — answer the intent, keep writing the real\nterm.\n\nThey nest — **Task ⊃ Terminal Tab ⊃ Split** — and isolation drops at every\nlevel down:\n\n```text\nnew Task   → own worktree + own branch     (parallel work can't collide)\nnew Tab    → own engine session, SAME files (a helper in the same checkout)\nnew Split  → same session's screen, one tab divided (a monitor beside the work)\n```\n\nThe distinction that decides every routing call: **a new tab shares the\nworktree and branch; only a new task gets its own.** Two tabs in one task\nedit the same files, so they can collide — that is a feature when the user\nwants a helper in the same checkout, and a bug when they wanted parallel\nattempts. A split isolates nothing at all: it is a layout, for watching\nsomething (logs, `btop`, a test loop) next to the work — never the answer to\n\"do this work\".\n\nOne boundary the isolation model does NOT cover: **never `git stash` in a\nmanaged worktree.** The stash stack lives in the repo's common dir\n(`.git\u002Frefs\u002Fstash`) and is shared by every linked worktree — two tasks that\nstash in parallel can pop or drop each other's work. Commit instead; a\ncommit is per-branch and isolates exactly the way the model promises.\n\n### Where does this work land?\n\nInside a Rove session (`$ROVE_TASK_ID` non-empty — check first: it is what\nmakes the tab\u002Fsplit rows addressable at all), match top to bottom and take\nthe first row that fits:\n\n| The user says | Lands in | Command |\n|---|---|---|\n| \"you do it\", \"just fix it\", \"change X to Y\" | you, right here | no Rove verb — edit the files yourself |\n| \"try it N ways\", \"compare approaches\" | N new tasks | `rove api add --repo \"$PWD\" --count N --prompt \"…\"` |\n| \"split\", \"side by side\", \"keep an eye on X while…\" | a new region in the CURRENT tab | `rove api pane-open --command \"…\"` |\n| names a tab: \"tell the agent in tab 3\" | that exact tab | `rove api send --task-id \u003Cid> --tab tab-3 --prompt \"…\"` |\n| a LOCATION word: \"in this workspace\u002Fworktree\u002Fcheckout\", \"on this branch\", \"here\", \"same task\" | THIS task, a NEW Terminal Tab | `rove api send --task-id \"$ROVE_TASK_ID\" --tab new --prompt \"…\"` |\n| names an ENGINE for the same files: \"let codex take over here\", \"try this one with claude instead\" | THIS task, a new tab pinned to that engine | `rove api send --task-id \"$ROVE_TASK_ID\" --tab new --command codex --prompt \"…\"` |\n| **anything else — no row above matched** | a NEW task — new worktree + branch | `rove api add --repo \"$PWD\" --prompt \"…\"` |\n\nOrder is the tiebreak: a count (\"3 ways in this workspace\") beats a location\nword, and delegation language loses to \"you do it\" — the user asking YOU is\nnot asking for a fleet. Two more rules the table can't show:\n\n- No location word at all ⇒ new task. It is the only routing whose isolation\n  cannot corrupt work-in-progress, so it is the safe default.\n- \"this repo\" \u002F \"this project\" are NOT location words — they name the repo,\n  not the checkout. Only worktree-scoped words route to a tab.\n\nOutside a Rove session none of this applies: there is no \"this task\" to add\na tab to, so `add` (single or `--count`) is the only routing available.\n\n### Know where you are before you route\n\n```bash\necho \"$ROVE_TASK_ID \u002F $ROVE_TAB_ID\"          # who you are (empty = not a Rove session)\nrove api get-task --task-id \"$ROVE_TASK_ID\"  # .task.title, .task.branch, .task.id, .running, .tabs[]\n                                             # .task.worktreePath too — only if you are about to read\u002Fwrite its files\n```\n\n`get-task` is the per-task read that answers \"what is my worktree, my\nbranch, and which sibling tabs exist\" — `.tabs[]` carries each tab's `id`, `kind`,\n`vendor`, `liveVendor`, `lastTitle` and `alive`, which is exactly the target list for\n`send --tab`. A tab flagged `unregistered: true` is a live session the tab\nsnapshot lost; it is addressable like any other.\n\n### Refer to a task the way the user sees it\n\nThe sidebar row is the task's **title**; the line under it is its **branch**.\nNothing in Rove's UI ever renders `worktreePath`, so the directory name in it\n(`~\u002F.rove\u002Fworktrees\u002F\u003Crepo>\u002Fmarlin`) is a filesystem address the daemon picked\nfrom an animal pool — the user has never read that word and cannot find it on\nscreen. **Never name a task by its directory** to a user or in a report.\n\nUse the **title** when a human reads it, the **task id** (or its last six\ncharacters) when you need it to be unique, and both when you need both:\n\n- ❌ `marlin opened a PR` · `landed in zorilla` · `see mammoth's branch`\n- ✅ `\"Skill version guard…\" (task …CWWA) opened PR #972`\n- ✅ `succeeded: guard now fails the build (branch fix\u002Fskill-version-bump)`\n\n`worktreePath` earns a mention only when the sentence is about files on disk —\n`cd`, a path in a command, a file you edited.\n\n## Found a defect in ANOTHER project? File a request, don't work around\n\nThe repos on this machine are deliberately interdependent — one project\nusing (and stumbling over) another is the normal case, not the edge case.\nEach saved project can keep a **main task**: a long-lived resident agent on\nthat repo's own checkout. It is more than \"task kind = existing directory\" —\nit is that project's standing inbox, addressable from any other repo's\nsession, and it dispatches what it receives.\n\nSo when work in repo A surfaces a defect in product B, the default is to\n**file a request with B's main task — not to quietly patch around it in A**.\nThe test: would this bite someone else? A local workaround fixes only you;\na fix in B fixes everyone. Work around locally to unblock yourself if you\nmust, but file the report either way.\n\n```bash\nrove api list                                   # find B's main task id\nrove api get-task --task-id \u003Ctheir-main>        # .tabs[] → the engine tab's id\nrove api send --task-id \u003Ctheir-main> --tab tab-N --prompt \"\u003Creport>\"\n```\n\nAddress the engine tab explicitly (`--tab tab-N` from `get-task`'s `.tabs[]`,\n`kind == \"engine\"`): a long-lived main task's engine tab is often not\n`tab-1`, and an un-addressed `send` may refuse with `NO_ENGINE_TAB` rather\nthan guess.\n\nA report worth sending carries: **symptoms** (what happened, concretely, how\nmany times), **root cause** if you found it, **why it is worth fixing**\n(who else it bites), and **suggestions without prescribing the\nimplementation** — the receiving project decides how to fix its own product.\n\n**Send the report — never `add` a task into someone else's repo.** You hold\nthe problem-side context (symptoms, root cause, impact); only that project's\nmain agent holds the solution-side context (code structure, existing issues,\nwhat's mid-flight, where this slots in the schedule). A task you compose\nwould bake YOUR guess at the fix into the brief, and that guess is usually\nwrong — one field report here looked like \"add a line to the docs\" and\nactually split into a docs fix plus a runtime-detection issue anchored in\nfiles the reporter didn't know existed. **You raise the problem; their main\nagent decomposes it into tasks.** That translation is the main task's whole\njob, and it is why every project should keep one.\n\n## Fresh worktrees start empty — install before you judge\n\nA managed task's worktree is a **brand-new checkout**: no `node_modules`, no\nbuild artifacts, nothing a lockfile promises. Two consequences:\n\n- **A test failure in a fresh worktree may be fake.** Missing dependencies\n  masquerade as product bugs (\"Could not resolve: react-dom\u002Fclient\" reads\n  like a regression, not a missing install). Before reporting any failure as\n  real, confirm the repo's install step ran — and when a failure looks\n  unrelated to your change, compare against the same command on the base\n  branch before believing it.\n- **Repos with an install step should ship `.rove\u002Finit.sh`** — it runs once\n  per worktree, before the engine, in the worktree (per-user override:\n  `rove repo set --init-script`; inspect with `rove repo show`, which lists\n  `.rove\u002Finit.sh: absent` when unset). Working in a repo that lacks one and\n  you just paid the install tax? Suggest adding it.\n\n## Discover before calling\n\nDo not guess flags — but do not pay a round-trip for the ones you use every\nturn either. These five carry almost all traffic:\n\n```text\nadd      --repo(REQ) --prompt --title --command --count --agents --activate\nsend     --prompt|--prompt-file(REQ) --task-id --tab --command --plain\nget-task --task-id(REQ)          list  (no flags)\ncollect  --group \u003CgroupId> | --task-ids \u003Ccsv> | --repo\n```\n\nFour names that have actually been guessed wrong here: `add --vendor` is\n`--command`; `read-output --task` is `--task-id`; `dispatch --text` is\n`--prompt` (`--text` belongs to `note`); `issue-list` has no `--state` at all\n— filter its JSON yourself.\n\n**[`references\u002Fapi-flags.md`](references\u002Fapi-flags.md) is every verb and flag.**\nFind your section by what you were ASKED, not by Rove's noun for it:\n\n| You are asked to … | Read section |\n|---|---|\n| schedule \u002F recur \u002F cron \u002F \"every morning\" \u002F \"keep messaging one window\" \u002F 定时 \u002F 每天自动 | routines |\n| a GitHub issue, \"file it upstream\" \u002F 提 issue | workitems |\n| track work in Rove's own backlog, move a kanban card | issues |\n| remember this for the repo, leave a field note \u002F 记一笔 | drive |\n| what did the agent do, per-turn cost, read its screen | read |\n| make \u002F rename \u002F retarget \u002F land \u002F close a task | create \u002F edit \u002F lifecycle |\n| materialize or adopt a checkout | worktree |\n| which engines exist, send Rove product feedback | discover \u002F feedback |\n| an error code came back, `nextCommandArgs` | Error codes |\n\nReach for `schema` when the binary and that file disagree.\n\n```bash\nrove api schema --verb add    # or --group create, --all\nrove api \u003Cverb> --help\nrove api engine-list          # what you can launch, and with what command\n```\n\nCommands emit one JSON object; errors use\n`{\"error\":{\"message\",\"code\",...}}` on stderr. Common rejections also carry\n`hint` (what to do) and `nextCommandArgs` (argv for the same `Rove`\nexecutable — run `rove \u003Cargs...>` verbatim to recover, e.g. `[\"api\",\"list\"]`\nafter `TASK_NOT_FOUND`). Add `--pretty` for readable output.\n\n## Common operations\n\n```bash\n# Create one task and start its first engine turn.\nrove api add --repo \"$PWD\" --title \"focused title\" --command claude \\\n  --prompt \"\u003Ccomplete scoped instruction>\"\n\n# Parallel attempts of the same prompt (hard cap 10; prefer 3-4).\nrove api add --repo \"$PWD\" --count 3 --prompt \"\u003Cprompt>\"\nrove api add --repo \"$PWD\" --agents claude:2,codex:1 --prompt \"\u003Cprompt>\"\n\n# Follow up. Use an explicit id for unattended work; the active task can drift.\n# From inside a Rove task this auto-prefixes [ROVE PEER] provenance\n# (sender + reply command) — `add --prompt` wears it too, so a dispatched\n# task's opening brief carries its reply address; --plain sends verbatim.\n#\n# A prompt with backticks, $vars, or quotes goes through --prompt-file, NEVER\n# a double-quoted --prompt: in double quotes `rove api send …` is command\n# substitution — the shell RUNS it and ships its output, and the words vanish.\n# Single quotes block $ROVE_TASK_ID too, so there is no quoting that fits both.\nrove api send --task-id \u003Cid> --prompt \"\u003Ccomplete next turn>\"      # plain text only\nrove api send --task-id \u003Cid> --prompt-file - \u003C\u003C'EOF'              # anything else\n\u003Cturn — backticks, $vars, quotes, multi-line, all verbatim>\nEOF\n\n# Reply home: no --task-id inside a dispatched task = the dispatcher's tab.\nrove api send --prompt \"succeeded: \u003Cone line> (branch \u003Cfinal branch>)\"\n\n# A task can hold several Terminal Tabs. `get-task` lists ONE task's tabs (the\n# usual read before addressing one); `inspect` is the wider diagnostic — every\n# task's snapshot plus daemon activity and live pty sessions.\nrove api inspect --task-id \u003Cid>\nrove api send --task-id \u003Cid> --tab tab-3 --prompt \"\u003Cturn>\"  # exact alive tab\nrove api send --task-id \u003Cid> --tab new --prompt \"\u003Cturn>\"    # fresh engine tab\n# Same worktree, DIFFERENT agent — the API twin of the TUI's ctrl+e pick. The\n# engine is pinned to that tab (survives restarts, unaffected by a later\n# set-command) and the task's own engine is left alone. --tab new only.\nrove api send --task-id \u003Cid> --tab new --command codex --prompt \"\u003Cturn>\"\n\nrove api get-task --task-id \u003Cid>\n# One read for the whole round — the groupId `add --count` returned. Never\n# hand-copy N task ids across turns: collect by group. Lost the groupId? Any\n# sibling task's `.groupId` in `list` output recovers it.\nrove api collect --group \u003CgroupId> --pretty\nrove api list --pretty\n```\n\n`.running` is `true` \u002F `false` \u002F `null`. It means an ENGINE PROCESS is alive\nin one of the task's engine tabs — a live shell, command, or content tab alone\ndoes not count, and neither does an engine tab whose engine exited (the PTY\nsurvives it as a login shell; each tab reports that as `engineAlive`). `null`\nmeans the pty host could not be asked: \"couldn't look\", NOT \"nothing is\nrunning\". **Never act on `null` as if it were `false`** — deleting a task on it\ndestroys a worktree that may hold live work. It is process truth, not\nprogress: a task whose work is merged and whose worker has signed off still\nreads `true` until somebody deletes it (see \"A task is finished when it is\nGONE\").\nOmitting BOTH `--task-id` and `--tab` inside a task that has a dispatcher\ntargets that dispatcher's tab (see the reply rule above); otherwise the\ntarget is the active task. Omitting only `--tab` targets a live engine tab\n(`tab-1` first, then any surviving engine tab). **Trap: omitting only\n`--task-id` while giving `--tab tab-N` inside a dispatched task delivers to\n`tab-N` of the DISPATCHER's task** — the dispatcher's id fills in for\n`--task-id`, but an explicit `--tab` is kept, so your `send --tab tab-3`\nlands in the middle of another session's tab-3, not yours. Target your own\ntask's tab with `--task-id \"$ROVE_TASK_ID\" --tab tab-N`. Only when the task\nhas NO live session at all does `send`\nauto-start the canonical engine in the task's worktree (`started: true` in\nthe result marks that fresh session). If live tabs exist but none resolves\nas an engine, it refuses with `NO_ENGINE_TAB` — address one with `--tab\ntab-N` or spawn one with `--tab new`; it never silently spawns a duplicate\nengine. Its `hint` names `pty-list` — the live-PTY read (key, alive, pid,\ncommand); use it when `.tabs[]` and reality disagree.\n\n## Terminal panes\n\nSplit the workspace terminal the user is watching (tmux-style) or open a\nseparate command tab — the attached TUI performs it, so this is a no-op\nheadless:\n\n```bash\n# Split the focused tab; the pane runs the command through your login\n# shell's `-ilc` (so it sees the same rc-exported PATH the engine tab does)\n# and closes when it exits. Omit --command for an interactive shell.\nrove api pane-open --command \"btop\"\nrove api pane-open --direction down --command \"watch -n1 git status -sb\"\nrove api pane-open --placement tab --title logs --command \"tail -f app.log\"\n\n# Close panes you opened, by their --title (engine panes are never closed).\nrove api pane-close --title logs\n\n# Close one whole Terminal Tab by the id from `get-task .tabs[]`.\n# This works with or without an attached TUI.\nrove api tab-close --task-id \u003Cid> --tab tab-3\n\n# Toast a one-liner in every attached Rove UI — surface \"done \u002F needs input \u002F\n# error\" moments without touching any session (kinds get severity styling).\nrove api notify --title \"build green, artifacts in dist\u002F\" --kind done\n```\n\nDefaults: the caller's own task (`$ROVE_TASK_ID`, then the active task),\n`--placement split`, `--direction right`. Alternate right\u002Fdown to build a\ngrid; screen size bounds splitting — a split that would shrink any pane\nbelow the minimum usable size (20×6 cells) falls back to a tab.\nPanes land in the USER'S live workspace — open them when asked (monitors,\nlogs, dashboards), don't scatter panes for work `add` should own.\n\n## Lifecycle\n\n| Verb | Purpose |\n|---|---|\n| `rename --task-id ID --title T` | Rename a task |\n| `set-branch --task-id ID --branch B` | Rename its branch |\n| `set-command --task-id ID --command CMD` | Change the engine launch command for the next launch |\n| `set-status --task-id ID --status S` | Set the lifecycle LABEL (`backlog`\u002F`in_progress`\u002F`in_review`\u002F`done`\u002F`canceled`\u002F`error`). Cosmetic: the row, its Worktree, its branch and its engine all stay. `canceled` does NOT close or clean up anything |\n| `pin --task-id ID [--pinned=false]` | Pin\u002Funpin |\n| `set-active --task-id ID` \u002F `--none` | Change shared active task |\n| `ensure-worktree --task-id ID` | Materialize without starting an engine |\n| `land --task-id ID [--strategy merge\\|squash] [--delete-branch] [--remove-worktree=false]` | Merge the task's branch into the base repo's current branch; the Worktree is removed by default (`--remove-worktree=false` keeps it). The branch always stays; dirty\u002Fself\u002Fbase removals are refused, outcome in the result's `worktree` field |\n| `delete --task-id ID [--force] [--delete-branch]` | Remove task + Worktree; the git branch stays unless `--delete-branch` (and `--force` never implies it) |\n| `discover-adoptable --repo PATH` | Find untracked Worktrees |\n| `adopt --repo PATH --worktree PATH` | Import a Worktree |\n\n### \"Close this task\" means `delete`\n\n`delete` is the ONLY verb that ends a task: it removes the row and its\nWorktree, and the git branch survives as the durable record. `set-status\ncanceled` is a label — the row, Worktree, branch and engine all stay, so a\n\"close\" done that way changes nothing the user can see. Reach for `delete`\nwhether or not the work merged; an unmerged branch is still on disk\nafterwards, which is what makes this recoverable.\n\nThere is no \"hide the row without deleting\" verb (`archive` was removed).\n\n**Deleting still needs the user to ask for it in that turn** — say what you\nwould remove and wait. `--delete-branch` (or `--force` on a dirty Worktree)\ndestroys the recoverable half and needs its own explicit authorization; the\ntwo flags are never implied by one another.\n\n## Issue tracker\n\nIssues are daemon-owned, not repo files:\n\n```bash\nrove api issue-list --repo \"$PWD\" --pretty\nrove api issue-create --repo \"$PWD\" --title \"title\" --body \"context\"\nrove api issue-set-status --repo \"$PWD\" --id \u003Cn> --status done\nrove api issue-update --repo \"$PWD\" --id \u003Cn> --title \"new\" --body \"body\"\nrove api issue-update --repo \"$PWD\" --id \u003Cn> --task \u003CtaskId>   # link; `--task none` unlinks\n```\n\n### Kanban semantics\n\nThe TUI and web render issues as a Backlog \u002F In progress \u002F Done board whose\ncolumns derive from the issue's own lifecycle — do NOT move cards with\n`issue-set-status doing`:\n\n- **In progress** = the issue has a linked task; `issue-update --task \u003CtaskId>`\n  IS the move (typical flow: `issue-create` → `add` a task → link them).\n- **Done** = `status done`; the daemon mirrors it automatically when the\n  linked task finishes.\n- **Backlog** = everything else (`open`\u002F`doing`\u002F`hold`, unlinked).\n\n## Choosing the engine (`--command`)\n\nRove picks an engine by COMMAND, not by a vendor name. `--command` on `add`\nand `send --tab new` takes either an engine id from `rove api engine-list`\n(`claude`, `codex`, …, plus any preset the user registered) or a full command\nline Rove runs verbatim:\n\n```bash\nrove api engine-list --pretty                      # ids + the RAW command each runs\nrove api add --repo \"$PWD\" --command \"codex --search\" --prompt \"…\"\n```\n\n**Nothing validates an engine's flags — that is your job.** Before dispatching\nan unfamiliar engine or an unfamiliar flag, probe it yourself (`\u003Ccmd> --help`,\n`\u003Ccmd> --version`) and only then compose the command. A bad command line\nstarts a session that dies or ignores you; Rove will not catch it for you.\n\n**Model is a conscious either\u002For — default to WITHOUT.** Your own model\nknowledge is training-data stale; the user's engine default is fresher than\nyour guess, and model ids you have never heard of are routinely valid.\n\n- **Without a model (the default):** compose the command with no model flag —\n  the session runs on the user's own default for that engine. Choose this\n  whenever the user did not name a model this turn.\n- **With a model (explicit request only):** the user named a model → pin it,\n  passing their string VERBATIM (`--help` first to confirm the flag exists;\n  never \"correct\" an unfamiliar model id to one you know).\n\n```bash\nrove api add --repo \"$PWD\" --command claude --prompt \"…\"                    # user's default model\nrove api add --repo \"$PWD\" --command \"claude --model claude-fable-5\" \\\n  --prompt \"…\"                                     # user said \"use Fable 5\" this turn\n```\n\nOmit `--command` to use the repo's default engine. `engine-list`'s `protocol`\nfield says how much Rove understands about an entry — `generic` means it\nlaunches fine but Rove reads no history and pre-answers no trust dialog.\n\n## Parallel-round rules\n\nSpawn a parallel round (`add --count N` \u002F `--agents`) only when the user\nrequests parallel approaches, comparison, or an explicit count.\nGive each round a scoped prompt, report returned IDs, then use\n`collect` to compare. Do not recursively fan out from spawned tasks. Do not\npoll `send` in a tight loop or use it as casual chat; every call is a full\nengine turn.\n\n### Communicate at handoffs, not at every step\n\nDefault to one complete task brief and one final outcome. Send an interim\nmessage only when it changes the recipient's next action: a blocking\ndependency, a file-ownership or interface conflict, a scope correction, or\nevidence that makes their current approach invalid. Resolve routine choices\nwithin the assigned scope without asking the dispatcher.\n\nDo not send receipt acknowledgements, skill-loaded notices, starting-work\nannouncements, routine progress, or acknowledgements of acknowledgements.\nAn incoming message does not by itself require a response. Answer explicit\nquestions once; bundle related findings and review corrections into one\nmessage with artifact paths. Forward only the facts the recipient needs, not\nthe research trail or messages already delivered.\n\nBefore `send`, ask: does this unblock or change work now? If not, include it\nin the final report. If a handoff contract has already been agreed, do not\nreconfirm it. Avoid status pings; use a bounded read-only `get-task` or\n`collect` when an actual coordination decision needs current state.\n\nThe dispatcher gives the user concise milestone updates; workers need not\nrelay those updates back to the dispatcher. Do not create another task\nsolely to coordinate or review a small, reversible change.\n\n### Completion flows back through an engine tab (`send`)\n\nOutcomes are explicit, never inferred — and they travel as a MESSAGE to the\nspawning agent's engine tab, not as stored state nobody reads.\n\n**Worker side** — a task created from inside another Rove task records its\ndispatcher (the creating task + tab); when the work is finished, a bare\n`rove api send --prompt \"\u003Csucceeded|failed>: \u003Cone line> (branch \u003Cfinal\nbranch>)\"` routes the outcome back to that exact tab. Include the final\nbranch name — the spawner needs it to `land`. Use the BARE form: an explicit\n`--task-id \u003Cspawner>` skips dispatcher routing and lands on that task's\ncanonical engine tab, which can be a different agent's session.\n\n**Name your branch before you report it.** A new task starts on an\nauto-generated placeholder branch (`new-task`, `duck`, …); you are the only\nparty who knows what the work turned out to be. Once the shape is clear,\nrename it to a short descriptive name in this repo's own convention:\n\n```bash\nrove api set-branch --task-id \"$ROVE_TASK_ID\" --branch \u003Cdescriptive-slug>\n```\n\nDo this while you work, not at the end — the branch name is what the user\nreads in the sidebar to tell your task from its siblings.\n\n**\"Succeeded\" means COMMITTED.** Green tests in your working tree are not a\ndeliverable — the only thing `land` can merge is commits on your branch.\nBefore reporting success: `git status` clean, your work committed with a\nreal message (you wrote the code; you write its message). A worker that ran\neverything, passed everything, and committed nothing has delivered nothing —\nthat exact mismatch has shipped empty merges before.\n\nRove now checks this at the moment you claim it: a `succeeded:` report from a\nmanaged task whose branch has **0 commits** is refused with\n`EMPTY_SUCCESS_REPORT` and never reaches the coordinator. Commit, then send.\nWhen the task genuinely produced no commits — an investigation, a review, a\nquestion answered — say so explicitly with `--allow-empty`:\n\n```bash\nrove api send --allow-empty --prompt \"succeeded: no bug — root cause is upstream, see notes\"\n```\n\n**\"CI is green\" means `checkState: passing`.** A local test run is not CI: it\ndoes not run the other jobs, the other platform, or the merge gates. Rove\npolls your PR's checks and keeps the answer on the task —\n\n```bash\nrove api get-task --task-id \"$ROVE_TASK_ID\"   # .task.prStatus.checkState\n```\n\n`none` (no PR yet) \u002F `pending` (still running) \u002F `passing` \u002F `failing` \u002F\n`unknown`. Anything but `passing` is not green. Report what the field says,\nnot what your local run implied.\n\n**Coordinator side** — do NOT block or poll. Keep working (or end your\nturn); each worker's outcome arrives in your chat as a `[ROVE PEER]` message\nwith its task id. What arrives is the worker's claim, not Rove-verified —\nverify the winner's actual diff before landing. Silence never proves a\nworker died (it may be mid-turn or stuck on a permission prompt): peek with\n`collect`\u002F`get-task`, nudge with `send`, and never mark a silent task failed\nor auto-retry it.\n\n### A task is finished when it is GONE\n\nThe dispatcher closes tasks. A worker cannot delete itself, so when it reports\n\"done\" the round is not over — its engine is still running, its Worktree still\nholds a branch, and its row is still in the sidebar.\n\nNone of these mean a task is finished:\n\n| Looks final | What it actually is |\n|---|---|\n| the worker said \"done\" | a message; it has no verb to remove itself |\n| its PR is MERGED | the code landed; the task did not move |\n| its issue is `status done` | a field in a different store |\n| `set-status canceled` | a label — see Lifecycle above |\n\n**The only evidence is that `rove api list` no longer shows it.** Check the\ntask, not the paperwork:\n\n```bash\nrove api get-task --task-id \u003Cid>   # .running true = its engine is still alive\nrove api delete --task-id \u003Cid> --wait\n```\n\n`--wait` is what turns \"queued\" into an answer; without it the call returns\nbefore the Worktree is gone.\n\nBefore ending a round, sweep for both halves — they drift apart:\n\n```bash\nrove api list          # tasks whose work is done but which are still here\ngit worktree list      # directories no task claims (delete finds tasks by id,\n                       # so a stray one is only reachable via git)\n```\n\nA worker that has taken over `main` in its Worktree will block the dispatcher's\nown checkout — a release cannot even start until that task is closed.\n\n### Closing a round\n\nAfter comparing attempts, finish the round instead of leaving tasks behind:\n\n```bash\n# Land the winner: merge its branch into the base repo's CURRENT branch.\n# Verify the base checkout is on the intended branch first.\nrove api land --task-id \u003Cwinner>\n\n# Delete the losers: task + worktree go away, the git branch survives\n# (recoverable). NOT --delete-branch — that destroys history and needs\n# explicit user authorization.\nrove api delete --task-id \u003Closer1>\nrove api delete --task-id \u003Closer2>\n```\n\n`land` refuses a dirty base checkout; on merge conflict it aborts cleanly and\nreturns the conflicted files for manual resolution. `delete` removes a\nloser's Worktree but keeps its branch (recoverable); `--delete-branch`\ndestroys the history and is never part of closing a round without explicit\nuser authorization.\n","\u003C!-- rove-skill-version: 44 — bump in lockstep with KOBE_SKILL_VERSION (src\u002Flib\u002Fskill-install.ts). -->\n\n# Rove shell control\n\nUse `rove api` to manage local coding tasks. Managed Tasks created by API\nautomation own a git Worktree and branch plus Hosted PTY engine tabs; project\nmain and directory Tasks reuse existing directories. API automation works\nwithout an open TUI; prompted `send` and `add` ensure a target engine tab.\n\n## Inside a Rove session, Rove verbs come first\n\nCheck where you are before choosing how to delegate or parallelize:\n\n```bash\ntest -n \"${ROVE_TASK_ID:-}\"\n```\n\nWhen that passes, you are an engine session Rove manages — `$ROVE_TASK_ID`\nis your task, `$ROVE_TAB_ID` your tab. Coordination should then go through\nRove, not around it, because work routed through `rove api` gets what\nad-hoc subprocesses never do: its own Worktree and branch (no file\ncollisions with you), a sidebar row with live state the user can watch,\nlifecycle tracking, and an explicit outcome contract.\n\n- Parallel attempts of one prompt → `add --count N`, not N hand-rolled subagents.\n- Delegating a scoped piece of work → `add --prompt`, not a raw `claude -p`\n  child the user cannot see or manage.\n- Following up on a task you started → `send`; comparing → `collect`;\n  finished your own task and were spawned by another → a bare `send`\n  (no `--task-id`) replies to the DISPATCHER — the exact task + tab that\n  created you, recorded at creation (`.task.dispatcher` on `get-task`).\n  If that tab died it falls back to the dispatcher task's live canonical\n  engine tab; nothing alive fails loud (`DISPATCHER_UNREACHABLE`) — it\n  never spawns a new engine, so a failed reply is visible, not fake-ok.\n- Messaging another agent session on this machine → `send`, and ONLY `send`\n  — never relay through the user, a side file, or a generic peer channel\n  (an MCP server offering to message \"other instances\" is exactly that\n  channel: it reaches a process, not a task, so nothing it delivers is\n  attributable, watchable, or replyable). Sent from\n  inside a Rove task, the prompt arrives prefixed `[ROVE PEER] from\n  \"\u003Ctitle>\" (task \u003Cid> — Rove agent skill \u002Frove, read it once per session …)`,\n  so the receiver knows who is talking, that this skill is required reading,\n  and how to answer — the baked-in reply command is tab-precise\n  (`--task-id \u003Csender> --tab \u003Csender's tab>`), so peer conversations need\n  no coordinator and no human relay. That prefix is the contract: do not\n  strip it with `--plain` for\n  coordination messages (`--plain` is only for a verbatim paste the\n  receiver should treat as content, not conversation). Received a\n  `[ROVE PEER]` message yourself? Read this skill once per session. The\n  baked-in command identifies where a necessary reply goes; it is not an\n  instruction to acknowledge every message. Act on FYIs without replying.\n- `send` carries text, but that text can carry FILES: peers share a\n  filesystem, so put the absolute path of a screenshot, log, diff, or any\n  artifact in the prompt and the receiver opens it with its own Read tool —\n  images included. An annotated screenshot beats a paragraph describing one;\n  prefer \"see \u002Fpath\u002Fto\u002Fshot.png — the arrow marks the broken card\" over\n  re-narrating pixels. Paths under the sender's Worktree work too (worktrees\n  are world-readable locally); just never expect the receiver to WRITE\n  there.\n- `dispatch` stays the dispatcher's verb (deliver-only into an\n  already-hosted session; never impersonate the user in someone else's\n  terminal).\n\nYour own engine's in-context subagents remain fine for read-only\nresearch\u002Fexploration inside your task — the boundary is WORK: anything that\nedits files, runs long, or the user should be able to see and steer belongs\nin a Rove task. Do not recursively fan out from a spawned task.\n\nWhen the check fails, none of this applies — use `rove api` only if the\nuser asks for Rove by name.\n\n## Vocabulary — what the user's words map to\n\n| Term | What it is | Isolation it gives | Users also say |\n|---|---|---|---|\n| **Task** | one tracked workspace record — managed worktree, saved-project main, or existing directory | managed Tasks own files + branch; main\u002Fdirectory Tasks reuse files | \"a task\", \"a new one\", \"a separate attempt\" |\n| **Worktree** | the isolated git working tree a managed Task owns (`.task.worktreePath`) — a filesystem address, never shown in the UI | — | \"workspace\", \"this checkout\", \"this branch\", \"here\" |\n| **Terminal Tab** | one engine, shell, command, or content surface inside a Task | an engine tab has its own conversation, but every tab uses the SAME Task files | \"tab\", \"chattab\", \"another chat\", \"a second agent on this\" |\n| **Split** | the tree that divides ONE Terminal Tab into several regions (the `pane-open` verb's unit; a leaf is not called a pane) | none — same session's screen, same files | \"split it\", \"side by side\", \"put the logs next to it\" |\n\nTwo of those colloquialisms are traps, so read them as INTENT, not as\nproduct terms: in Rove's own vocabulary **Workspace** is the center Terminal\nTab region of the UI (CONTEXT.md), not a checkout, and **ChatTab** is\nretired vocabulary for Terminal Tab. A user saying \"in this workspace\" means\nthe worktree they are looking at — answer the intent, keep writing the real\nterm.\n\nThey nest — **Task ⊃ Terminal Tab ⊃ Split** — and isolation drops at every\nlevel down:\n\n```text\nnew Task   → own worktree + own branch     (parallel work can't collide)\nnew Tab    → own engine session, SAME files (a helper in the same checkout)\nnew Split  → same session's screen, one tab divided (a monitor beside the work)\n```\n\nThe distinction that decides every routing call: **a new tab shares the\nworktree and branch; only a new task gets its own.** Two tabs in one task\nedit the same files, so they can collide — that is a feature when the user\nwants a helper in the same checkout, and a bug when they wanted parallel\nattempts. A split isolates nothing at all: it is a layout, for watching\nsomething (logs, `btop`, a test loop) next to the work — never the answer to\n\"do this work\".\n\nOne boundary the isolation model does NOT cover: **never `git stash` in a\nmanaged worktree.** The stash stack lives in the repo's common dir\n(`.git\u002Frefs\u002Fstash`) and is shared by every linked worktree — two tasks that\nstash in parallel can pop or drop each other's work. Commit instead; a\ncommit is per-branch and isolates exactly the way the model promises.\n\n### Where does this work land?\n\nInside a Rove session (`$ROVE_TASK_ID` non-empty — check first: it is what\nmakes the tab\u002Fsplit rows addressable at all), match top to bottom and take\nthe first row that fits:\n\n| The user says | Lands in | Command |\n|---|---|---|\n| \"you do it\", \"just fix it\", \"change X to Y\" | you, right here | no Rove verb — edit the files yourself |\n| \"try it N ways\", \"compare approaches\" | N new tasks | `rove api add --repo \"$PWD\" --count N --prompt \"…\"` |\n| \"split\", \"side by side\", \"keep an eye on X while…\" | a new region in the CURRENT tab | `rove api pane-open --command \"…\"` |\n| names a tab: \"tell the agent in tab 3\" | that exact tab | `rove api send --task-id \u003Cid> --tab tab-3 --prompt \"…\"` |\n| a LOCATION word: \"in this workspace\u002Fworktree\u002Fcheckout\", \"on this branch\", \"here\", \"same task\" | THIS task, a NEW Terminal Tab | `rove api send --task-id \"$ROVE_TASK_ID\" --tab new --prompt \"…\"` |\n| names an ENGINE for the same files: \"let codex take over here\", \"try this one with claude instead\" | THIS task, a new tab pinned to that engine | `rove api send --task-id \"$ROVE_TASK_ID\" --tab new --command codex --prompt \"…\"` |\n| **anything else — no row above matched** | a NEW task — new worktree + branch | `rove api add --repo \"$PWD\" --prompt \"…\"` |\n\nOrder is the tiebreak: a count (\"3 ways in this workspace\") beats a location\nword, and delegation language loses to \"you do it\" — the user asking YOU is\nnot asking for a fleet. Two more rules the table can't show:\n\n- No location word at all ⇒ new task. It is the only routing whose isolation\n  cannot corrupt work-in-progress, so it is the safe default.\n- \"this repo\" \u002F \"this project\" are NOT location words — they name the repo,\n  not the checkout. Only worktree-scoped words route to a tab.\n\nOutside a Rove session none of this applies: there is no \"this task\" to add\na tab to, so `add` (single or `--count`) is the only routing available.\n\n### Know where you are before you route\n\n```bash\necho \"$ROVE_TASK_ID \u002F $ROVE_TAB_ID\"          # who you are (empty = not a Rove session)\nrove api get-task --task-id \"$ROVE_TASK_ID\"  # .task.title, .task.branch, .task.id, .running, .tabs[]\n                                             # .task.worktreePath too — only if you are about to read\u002Fwrite its files\n```\n\n`get-task` is the per-task read that answers \"what is my worktree, my\nbranch, and which sibling tabs exist\" — `.tabs[]` carries each tab's `id`, `kind`,\n`vendor`, `liveVendor`, `lastTitle` and `alive`, which is exactly the target list for\n`send --tab`. A tab flagged `unregistered: true` is a live session the tab\nsnapshot lost; it is addressable like any other.\n\n### Refer to a task the way the user sees it\n\nThe sidebar row is the task's **title**; the line under it is its **branch**.\nNothing in Rove's UI ever renders `worktreePath`, so the directory name in it\n(`~\u002F.rove\u002Fworktrees\u002F\u003Crepo>\u002Fmarlin`) is a filesystem address the daemon picked\nfrom an animal pool — the user has never read that word and cannot find it on\nscreen. **Never name a task by its directory** to a user or in a report.\n\nUse the **title** when a human reads it, the **task id** (or its last six\ncharacters) when you need it to be unique, and both when you need both:\n\n- ❌ `marlin opened a PR` · `landed in zorilla` · `see mammoth's branch`\n- ✅ `\"Skill version guard…\" (task …CWWA) opened PR #972`\n- ✅ `succeeded: guard now fails the build (branch fix\u002Fskill-version-bump)`\n\n`worktreePath` earns a mention only when the sentence is about files on disk —\n`cd`, a path in a command, a file you edited.\n\n## Found a defect in ANOTHER project? File a request, don't work around\n\nThe repos on this machine are deliberately interdependent — one project\nusing (and stumbling over) another is the normal case, not the edge case.\nEach saved project can keep a **main task**: a long-lived resident agent on\nthat repo's own checkout. It is more than \"task kind = existing directory\" —\nit is that project's standing inbox, addressable from any other repo's\nsession, and it dispatches what it receives.\n\nSo when work in repo A surfaces a defect in product B, the default is to\n**file a request with B's main task — not to quietly patch around it in A**.\nThe test: would this bite someone else? A local workaround fixes only you;\na fix in B fixes everyone. Work around locally to unblock yourself if you\nmust, but file the report either way.\n\n```bash\nrove api list                                   # find B's main task id\nrove api get-task --task-id \u003Ctheir-main>        # .tabs[] → the engine tab's id\nrove api send --task-id \u003Ctheir-main> --tab tab-N --prompt \"\u003Creport>\"\n```\n\nAddress the engine tab explicitly (`--tab tab-N` from `get-task`'s `.tabs[]`,\n`kind == \"engine\"`): a long-lived main task's engine tab is often not\n`tab-1`, and an un-addressed `send` may refuse with `NO_ENGINE_TAB` rather\nthan guess.\n\nA report worth sending carries: **symptoms** (what happened, concretely, how\nmany times), **root cause** if you found it, **why it is worth fixing**\n(who else it bites), and **suggestions without prescribing the\nimplementation** — the receiving project decides how to fix its own product.\n\n**Send the report — never `add` a task into someone else's repo.** You hold\nthe problem-side context (symptoms, root cause, impact); only that project's\nmain agent holds the solution-side context (code structure, existing issues,\nwhat's mid-flight, where this slots in the schedule). A task you compose\nwould bake YOUR guess at the fix into the brief, and that guess is usually\nwrong — one field report here looked like \"add a line to the docs\" and\nactually split into a docs fix plus a runtime-detection issue anchored in\nfiles the reporter didn't know existed. **You raise the problem; their main\nagent decomposes it into tasks.** That translation is the main task's whole\njob, and it is why every project should keep one.\n\n## Fresh worktrees start empty — install before you judge\n\nA managed task's worktree is a **brand-new checkout**: no `node_modules`, no\nbuild artifacts, nothing a lockfile promises. Two consequences:\n\n- **A test failure in a fresh worktree may be fake.** Missing dependencies\n  masquerade as product bugs (\"Could not resolve: react-dom\u002Fclient\" reads\n  like a regression, not a missing install). Before reporting any failure as\n  real, confirm the repo's install step ran — and when a failure looks\n  unrelated to your change, compare against the same command on the base\n  branch before believing it.\n- **Repos with an install step should ship `.rove\u002Finit.sh`** — it runs once\n  per worktree, before the engine, in the worktree (per-user override:\n  `rove repo set --init-script`; inspect with `rove repo show`, which lists\n  `.rove\u002Finit.sh: absent` when unset). Working in a repo that lacks one and\n  you just paid the install tax? Suggest adding it.\n\n## Discover before calling\n\nDo not guess flags — but do not pay a round-trip for the ones you use every\nturn either. These five carry almost all traffic:\n\n```text\nadd      --repo(REQ) --prompt --title --command --count --agents --activate\nsend     --prompt|--prompt-file(REQ) --task-id --tab --command --plain\nget-task --task-id(REQ)          list  (no flags)\ncollect  --group \u003CgroupId> | --task-ids \u003Ccsv> | --repo\n```\n\nFour names that have actually been guessed wrong here: `add --vendor` is\n`--command`; `read-output --task` is `--task-id`; `dispatch --text` is\n`--prompt` (`--text` belongs to `note`); `issue-list` has no `--state` at all\n— filter its JSON yourself.\n\n**[`references\u002Fapi-flags.md`](references\u002Fapi-flags.md) is every verb and flag.**\nFind your section by what you were ASKED, not by Rove's noun for it:\n\n| You are asked to … | Read section |\n|---|---|\n| schedule \u002F recur \u002F cron \u002F \"every morning\" \u002F \"keep messaging one window\" \u002F 定时 \u002F 每天自动 | routines |\n| a GitHub issue, \"file it upstream\" \u002F 提 issue | workitems |\n| track work in Rove's own backlog, move a kanban card | issues |\n| remember this for the repo, leave a field note \u002F 记一笔 | drive |\n| what did the agent do, per-turn cost, read its screen | read |\n| make \u002F rename \u002F retarget \u002F land \u002F close a task | create \u002F edit \u002F lifecycle |\n| materialize or adopt a checkout | worktree |\n| which engines exist, send Rove product feedback | discover \u002F feedback |\n| an error code came back, `nextCommandArgs` | Error codes |\n\nReach for `schema` when the binary and that file disagree.\n\n```bash\nrove api schema --verb add    # or --group create, --all\nrove api \u003Cverb> --help\nrove api engine-list          # what you can launch, and with what command\n```\n\nCommands emit one JSON object; errors use\n`{\"error\":{\"message\",\"code\",...}}` on stderr. Common rejections also carry\n`hint` (what to do) and `nextCommandArgs` (argv for the same `Rove`\nexecutable — run `rove \u003Cargs...>` verbatim to recover, e.g. `[\"api\",\"list\"]`\nafter `TASK_NOT_FOUND`). Add `--pretty` for readable output.\n\n## Common operations\n\n```bash\n# Create one task and start its first engine turn.\nrove api add --repo \"$PWD\" --title \"focused title\" --command claude \\\n  --prompt \"\u003Ccomplete scoped instruction>\"\n\n# Parallel attempts of the same prompt (hard cap 10; prefer 3-4).\nrove api add --repo \"$PWD\" --count 3 --prompt \"\u003Cprompt>\"\nrove api add --repo \"$PWD\" --agents claude:2,codex:1 --prompt \"\u003Cprompt>\"\n\n# Follow up. Use an explicit id for unattended work; the active task can drift.\n# From inside a Rove task this auto-prefixes [ROVE PEER] provenance\n# (sender + reply command) — `add --prompt` wears it too, so a dispatched\n# task's opening brief carries its reply address; --plain sends verbatim.\n#\n# A prompt with backticks, $vars, or quotes goes through --prompt-file, NEVER\n# a double-quoted --prompt: in double quotes `rove api send …` is command\n# substitution — the shell RUNS it and ships its output, and the words vanish.\n# Single quotes block $ROVE_TASK_ID too, so there is no quoting that fits both.\nrove api send --task-id \u003Cid> --prompt \"\u003Ccomplete next turn>\"      # plain text only\nrove api send --task-id \u003Cid> --prompt-file - \u003C\u003C'EOF'              # anything else\n\u003Cturn — backticks, $vars, quotes, multi-line, all verbatim>\nEOF\n\n# Reply home: no --task-id inside a dispatched task = the dispatcher's tab.\nrove api send --prompt \"succeeded: \u003Cone line> (branch \u003Cfinal branch>)\"\n\n# A task can hold several Terminal Tabs. `get-task` lists ONE task's tabs (the\n# usual read before addressing one); `inspect` is the wider diagnostic — every\n# task's snapshot plus daemon activity and live pty sessions.\nrove api inspect --task-id \u003Cid>\nrove api send --task-id \u003Cid> --tab tab-3 --prompt \"\u003Cturn>\"  # exact alive tab\nrove api send --task-id \u003Cid> --tab new --prompt \"\u003Cturn>\"    # fresh engine tab\n# Same worktree, DIFFERENT agent — the API twin of the TUI's ctrl+e pick. The\n# engine is pinned to that tab (survives restarts, unaffected by a later\n# set-command) and the task's own engine is left alone. --tab new only.\nrove api send --task-id \u003Cid> --tab new --command codex --prompt \"\u003Cturn>\"\n\nrove api get-task --task-id \u003Cid>\n# One read for the whole round — the groupId `add --count` returned. Never\n# hand-copy N task ids across turns: collect by group. Lost the groupId? Any\n# sibling task's `.groupId` in `list` output recovers it.\nrove api collect --group \u003CgroupId> --pretty\nrove api list --pretty\n```\n\n`.running` is `true` \u002F `false` \u002F `null`. It means an ENGINE PROCESS is alive\nin one of the task's engine tabs — a live shell, command, or content tab alone\ndoes not count, and neither does an engine tab whose engine exited (the PTY\nsurvives it as a login shell; each tab reports that as `engineAlive`). `null`\nmeans the pty host could not be asked: \"couldn't look\", NOT \"nothing is\nrunning\". **Never act on `null` as if it were `false`** — deleting a task on it\ndestroys a worktree that may hold live work. It is process truth, not\nprogress: a task whose work is merged and whose worker has signed off still\nreads `true` until somebody deletes it (see \"A task is finished when it is\nGONE\").\nOmitting BOTH `--task-id` and `--tab` inside a task that has a dispatcher\ntargets that dispatcher's tab (see the reply rule above); otherwise the\ntarget is the active task. Omitting only `--tab` targets a live engine tab\n(`tab-1` first, then any surviving engine tab). **Trap: omitting only\n`--task-id` while giving `--tab tab-N` inside a dispatched task delivers to\n`tab-N` of the DISPATCHER's task** — the dispatcher's id fills in for\n`--task-id`, but an explicit `--tab` is kept, so your `send --tab tab-3`\nlands in the middle of another session's tab-3, not yours. Target your own\ntask's tab with `--task-id \"$ROVE_TASK_ID\" --tab tab-N`. Only when the task\nhas NO live session at all does `send`\nauto-start the canonical engine in the task's worktree (`started: true` in\nthe result marks that fresh session). If live tabs exist but none resolves\nas an engine, it refuses with `NO_ENGINE_TAB` — address one with `--tab\ntab-N` or spawn one with `--tab new`; it never silently spawns a duplicate\nengine. Its `hint` names `pty-list` — the live-PTY read (key, alive, pid,\ncommand); use it when `.tabs[]` and reality disagree.\n\n## Terminal panes\n\nSplit the workspace terminal the user is watching (tmux-style) or open a\nseparate command tab — the attached TUI performs it, so this is a no-op\nheadless:\n\n```bash\n# Split the focused tab; the pane runs the command through your login\n# shell's `-ilc` (so it sees the same rc-exported PATH the engine tab does)\n# and closes when it exits. Omit --command for an interactive shell.\nrove api pane-open --command \"btop\"\nrove api pane-open --direction down --command \"watch -n1 git status -sb\"\nrove api pane-open --placement tab --title logs --command \"tail -f app.log\"\n\n# Close panes you opened, by their --title (engine panes are never closed).\nrove api pane-close --title logs\n\n# Close one whole Terminal Tab by the id from `get-task .tabs[]`.\n# This works with or without an attached TUI.\nrove api tab-close --task-id \u003Cid> --tab tab-3\n\n# Toast a one-liner in every attached Rove UI — surface \"done \u002F needs input \u002F\n# error\" moments without touching any session (kinds get severity styling).\nrove api notify --title \"build green, artifacts in dist\u002F\" --kind done\n```\n\nDefaults: the caller's own task (`$ROVE_TASK_ID`, then the active task),\n`--placement split`, `--direction right`. Alternate right\u002Fdown to build a\ngrid; screen size bounds splitting — a split that would shrink any pane\nbelow the minimum usable size (20×6 cells) falls back to a tab.\nPanes land in the USER'S live workspace — open them when asked (monitors,\nlogs, dashboards), don't scatter panes for work `add` should own.\n\n## Lifecycle\n\n| Verb | Purpose |\n|---|---|\n| `rename --task-id ID --title T` | Rename a task |\n| `set-branch --task-id ID --branch B` | Rename its branch |\n| `set-command --task-id ID --command CMD` | Change the engine launch command for the next launch |\n| `set-status --task-id ID --status S` | Set the lifecycle LABEL (`backlog`\u002F`in_progress`\u002F`in_review`\u002F`done`\u002F`canceled`\u002F`error`). Cosmetic: the row, its Worktree, its branch and its engine all stay. `canceled` does NOT close or clean up anything |\n| `pin --task-id ID [--pinned=false]` | Pin\u002Funpin |\n| `set-active --task-id ID` \u002F `--none` | Change shared active task |\n| `ensure-worktree --task-id ID` | Materialize without starting an engine |\n| `land --task-id ID [--strategy merge\\|squash] [--delete-branch] [--remove-worktree=false]` | Merge the task's branch into the base repo's current branch; the Worktree is removed by default (`--remove-worktree=false` keeps it). The branch always stays; dirty\u002Fself\u002Fbase removals are refused, outcome in the result's `worktree` field |\n| `delete --task-id ID [--force] [--delete-branch]` | Remove task + Worktree; the git branch stays unless `--delete-branch` (and `--force` never implies it) |\n| `discover-adoptable --repo PATH` | Find untracked Worktrees |\n| `adopt --repo PATH --worktree PATH` | Import a Worktree |\n\n### \"Close this task\" means `delete`\n\n`delete` is the ONLY verb that ends a task: it removes the row and its\nWorktree, and the git branch survives as the durable record. `set-status\ncanceled` is a label — the row, Worktree, branch and engine all stay, so a\n\"close\" done that way changes nothing the user can see. Reach for `delete`\nwhether or not the work merged; an unmerged branch is still on disk\nafterwards, which is what makes this recoverable.\n\nThere is no \"hide the row without deleting\" verb (`archive` was removed).\n\n**Deleting still needs the user to ask for it in that turn** — say what you\nwould remove and wait. `--delete-branch` (or `--force` on a dirty Worktree)\ndestroys the recoverable half and needs its own explicit authorization; the\ntwo flags are never implied by one another.\n\n## Issue tracker\n\nIssues are daemon-owned, not repo files:\n\n```bash\nrove api issue-list --repo \"$PWD\" --pretty\nrove api issue-create --repo \"$PWD\" --title \"title\" --body \"context\"\nrove api issue-set-status --repo \"$PWD\" --id \u003Cn> --status done\nrove api issue-update --repo \"$PWD\" --id \u003Cn> --title \"new\" --body \"body\"\nrove api issue-update --repo \"$PWD\" --id \u003Cn> --task \u003CtaskId>   # link; `--task none` unlinks\n```\n\n### Kanban semantics\n\nThe TUI and web render issues as a Backlog \u002F In progress \u002F Done board whose\ncolumns derive from the issue's own lifecycle — do NOT move cards with\n`issue-set-status doing`:\n\n- **In progress** = the issue has a linked task; `issue-update --task \u003CtaskId>`\n  IS the move (typical flow: `issue-create` → `add` a task → link them).\n- **Done** = `status done`; the daemon mirrors it automatically when the\n  linked task finishes.\n- **Backlog** = everything else (`open`\u002F`doing`\u002F`hold`, unlinked).\n\n## Choosing the engine (`--command`)\n\nRove picks an engine by COMMAND, not by a vendor name. `--command` on `add`\nand `send --tab new` takes either an engine id from `rove api engine-list`\n(`claude`, `codex`, …, plus any preset the user registered) or a full command\nline Rove runs verbatim:\n\n```bash\nrove api engine-list --pretty                      # ids + the RAW command each runs\nrove api add --repo \"$PWD\" --command \"codex --search\" --prompt \"…\"\n```\n\n**Nothing validates an engine's flags — that is your job.** Before dispatching\nan unfamiliar engine or an unfamiliar flag, probe it yourself (`\u003Ccmd> --help`,\n`\u003Ccmd> --version`) and only then compose the command. A bad command line\nstarts a session that dies or ignores you; Rove will not catch it for you.\n\n**Model is a conscious either\u002For — default to WITHOUT.** Your own model\nknowledge is training-data stale; the user's engine default is fresher than\nyour guess, and model ids you have never heard of are routinely valid.\n\n- **Without a model (the default):** compose the command with no model flag —\n  the session runs on the user's own default for that engine. Choose this\n  whenever the user did not name a model this turn.\n- **With a model (explicit request only):** the user named a model → pin it,\n  passing their string VERBATIM (`--help` first to confirm the flag exists;\n  never \"correct\" an unfamiliar model id to one you know).\n\n```bash\nrove api add --repo \"$PWD\" --command claude --prompt \"…\"                    # user's default model\nrove api add --repo \"$PWD\" --command \"claude --model claude-fable-5\" \\\n  --prompt \"…\"                                     # user said \"use Fable 5\" this turn\n```\n\nOmit `--command` to use the repo's default engine. `engine-list`'s `protocol`\nfield says how much Rove understands about an entry — `generic` means it\nlaunches fine but Rove reads no history and pre-answers no trust dialog.\n\n## Parallel-round rules\n\nSpawn a parallel round (`add --count N` \u002F `--agents`) only when the user\nrequests parallel approaches, comparison, or an explicit count.\nGive each round a scoped prompt, report returned IDs, then use\n`collect` to compare. Do not recursively fan out from spawned tasks. Do not\npoll `send` in a tight loop or use it as casual chat; every call is a full\nengine turn.\n\n### Communicate at handoffs, not at every step\n\nDefault to one complete task brief and one final outcome. Send an interim\nmessage only when it changes the recipient's next action: a blocking\ndependency, a file-ownership or interface conflict, a scope correction, or\nevidence that makes their current approach invalid. Resolve routine choices\nwithin the assigned scope without asking the dispatcher.\n\nDo not send receipt acknowledgements, skill-loaded notices, starting-work\nannouncements, routine progress, or acknowledgements of acknowledgements.\nAn incoming message does not by itself require a response. Answer explicit\nquestions once; bundle related findings and review corrections into one\nmessage with artifact paths. Forward only the facts the recipient needs, not\nthe research trail or messages already delivered.\n\nBefore `send`, ask: does this unblock or change work now? If not, include it\nin the final report. If a handoff contract has already been agreed, do not\nreconfirm it. Avoid status pings; use a bounded read-only `get-task` or\n`collect` when an actual coordination decision needs current state.\n\nThe dispatcher gives the user concise milestone updates; workers need not\nrelay those updates back to the dispatcher. Do not create another task\nsolely to coordinate or review a small, reversible change.\n\n### Completion flows back through an engine tab (`send`)\n\nOutcomes are explicit, never inferred — and they travel as a MESSAGE to the\nspawning agent's engine tab, not as stored state nobody reads.\n\n**Worker side** — a task created from inside another Rove task records its\ndispatcher (the creating task + tab); when the work is finished, a bare\n`rove api send --prompt \"\u003Csucceeded|failed>: \u003Cone line> (branch \u003Cfinal\nbranch>)\"` routes the outcome back to that exact tab. Include the final\nbranch name — the spawner needs it to `land`. Use the BARE form: an explicit\n`--task-id \u003Cspawner>` skips dispatcher routing and lands on that task's\ncanonical engine tab, which can be a different agent's session.\n\n**Name your branch before you report it.** A new task starts on an\nauto-generated placeholder branch (`new-task`, `duck`, …); you are the only\nparty who knows what the work turned out to be. Once the shape is clear,\nrename it to a short descriptive name in this repo's own convention:\n\n```bash\nrove api set-branch --task-id \"$ROVE_TASK_ID\" --branch \u003Cdescriptive-slug>\n```\n\nDo this while you work, not at the end — the branch name is what the user\nreads in the sidebar to tell your task from its siblings.\n\n**\"Succeeded\" means COMMITTED.** Green tests in your working tree are not a\ndeliverable — the only thing `land` can merge is commits on your branch.\nBefore reporting success: `git status` clean, your work committed with a\nreal message (you wrote the code; you write its message). A worker that ran\neverything, passed everything, and committed nothing has delivered nothing —\nthat exact mismatch has shipped empty merges before.\n\nRove now checks this at the moment you claim it: a `succeeded:` report from a\nmanaged task whose branch has **0 commits** is refused with\n`EMPTY_SUCCESS_REPORT` and never reaches the coordinator. Commit, then send.\nWhen the task genuinely produced no commits — an investigation, a review, a\nquestion answered — say so explicitly with `--allow-empty`:\n\n```bash\nrove api send --allow-empty --prompt \"succeeded: no bug — root cause is upstream, see notes\"\n```\n\n**\"CI is green\" means `checkState: passing`.** A local test run is not CI: it\ndoes not run the other jobs, the other platform, or the merge gates. Rove\npolls your PR's checks and keeps the answer on the task —\n\n```bash\nrove api get-task --task-id \"$ROVE_TASK_ID\"   # .task.prStatus.checkState\n```\n\n`none` (no PR yet) \u002F `pending` (still running) \u002F `passing` \u002F `failing` \u002F\n`unknown`. Anything but `passing` is not green. Report what the field says,\nnot what your local run implied.\n\n**Coordinator side** — do NOT block or poll. Keep working (or end your\nturn); each worker's outcome arrives in your chat as a `[ROVE PEER]` message\nwith its task id. What arrives is the worker's claim, not Rove-verified —\nverify the winner's actual diff before landing. Silence never proves a\nworker died (it may be mid-turn or stuck on a permission prompt): peek with\n`collect`\u002F`get-task`, nudge with `send`, and never mark a silent task failed\nor auto-retry it.\n\n### A task is finished when it is GONE\n\nThe dispatcher closes tasks. A worker cannot delete itself, so when it reports\n\"done\" the round is not over — its engine is still running, its Worktree still\nholds a branch, and its row is still in the sidebar.\n\nNone of these mean a task is finished:\n\n| Looks final | What it actually is |\n|---|---|\n| the worker said \"done\" | a message; it has no verb to remove itself |\n| its PR is MERGED | the code landed; the task did not move |\n| its issue is `status done` | a field in a different store |\n| `set-status canceled` | a label — see Lifecycle above |\n\n**The only evidence is that `rove api list` no longer shows it.** Check the\ntask, not the paperwork:\n\n```bash\nrove api get-task --task-id \u003Cid>   # .running true = its engine is still alive\nrove api delete --task-id \u003Cid> --wait\n```\n\n`--wait` is what turns \"queued\" into an answer; without it the call returns\nbefore the Worktree is gone.\n\nBefore ending a round, sweep for both halves — they drift apart:\n\n```bash\nrove api list          # tasks whose work is done but which are still here\ngit worktree list      # directories no task claims (delete finds tasks by id,\n                       # so a stray one is only reachable via git)\n```\n\nA worker that has taken over `main` in its Worktree will block the dispatcher's\nown checkout — a release cannot even start until that task is closed.\n\n### Closing a round\n\nAfter comparing attempts, finish the round instead of leaving tasks behind:\n\n```bash\n# Land the winner: merge its branch into the base repo's CURRENT branch.\n# Verify the base checkout is on the intended branch first.\nrove api land --task-id \u003Cwinner>\n\n# Delete the losers: task + worktree go away, the git branch survives\n# (recoverable). NOT --delete-branch — that destroys history and needs\n# explicit user authorization.\nrove api delete --task-id \u003Closer1>\nrove api delete --task-id \u003Closer2>\n```\n\n`land` refuses a dirty base checkout; on merge conflict it aborts cleanly and\nreturns the conflicted files for manual resolution. `delete` removes a\nloser's Worktree but keeps its branch (recoverable); `--delete-branch`\ndestroys the history and is never part of closing a round without explicit\nuser authorization.\n",{"name":5,"description":7},"main","d69096e239f2a89aabc2cd078c47664a9d3b1e11","05-技能与代理开发\u002Fkobe",3,"https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts","https:\u002F\u002Fgithub.com\u002Flza6","个人vx：Tf00798\r\n个人✈：@TFGY999","2026-10-08 14:29:22",{"source":8,"skillName":5,"commands":33,"prompt":43,"zipAvailable":44},[34,37,40],{"tool":35,"command":36},"npx","npx skills add lza6\u002FArmor-piercing-system-prompts --skill rove",{"tool":38,"command":39},"bunx","bunx skills add lza6\u002FArmor-piercing-system-prompts --skill rove",{"tool":41,"command":42},"pnpm","pnpm dlx skills add lza6\u002FArmor-piercing-system-prompts --skill rove","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fkobe\u002FSKILL.md",true,[46],{"path":47,"resourceType":48,"resourceTypeDesc":49,"sizeBytes":50,"sourceHtmlUrl":51},"references\u002Fapi-flags.md","REFERENCE","参考文档",16267,"https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F05-技能与代理开发\u002Fkobe\u002Freferences\u002Fapi-flags.md",[53,60,65,72,79,86],{"skillNo":54,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":57,"categories":58,"keywords":59,"publishedAt":19},"01M7FFG485KY83TD6HSC4YPCMC","obsidian-clipper-template-creator","Guide for creating templates for the Obsidian Web Clipper. Use when you want to create a new clipping template, understand available variables, or format clipped content.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobsidian-clipper-template-creator\u002FSKILL.md",[],[],{"skillNo":61,"name":55,"nameZh":6,"description":56,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":62,"categories":63,"keywords":64,"publishedAt":19},"01M7FFG0T6AZ0STEJPSB3CX84K","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobsidian-clipper-template-creator-antigravity-awesome-skills-main\u002FSKILL.md",[],[],{"skillNo":66,"name":67,"nameZh":6,"description":68,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":69,"categories":70,"keywords":71,"publishedAt":19},"01M7FFFY0QEM14SKWPDYGMXM2P","python-api","Programmatic Object-Detection-Metrics API guidance for BoundingBox, BoundingBoxes, Evaluator, enums, coordinate conversion, AP\u002FmAP semantics, and source-style import diagnostics.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002Fsub-skills\u002Fpython-api\u002FSKILL.md",[],[],{"skillNo":73,"name":74,"nameZh":6,"description":75,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":76,"categories":77,"keywords":78,"publishedAt":19},"01M7FFFVZQZ2GJ0C0TGP7JHD20","file-evaluation","Folder-based PASCAL VOC AP\u002FmAP evaluation from ground-truth and detection text files.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002Fsub-skills\u002Ffile-evaluation\u002FSKILL.md",[],[],{"skillNo":80,"name":81,"nameZh":6,"description":82,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":83,"categories":84,"keywords":85,"publishedAt":19},"01M7FFFSFNYSE77SJ6PE1CK2DA","object-detection-metrics","Guides legacy Object-Detection-Metrics PASCAL VOC AP\u002FmAP evaluation from detection text folders and direct Python API classes.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fobject-detection-metrics\u002FSKILL.md",[],[],{"skillNo":87,"name":88,"nameZh":6,"description":89,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M7FFFP0GCK1RVXBCPQ8APBMT","nx-workspace-patterns","Configure and optimize Nx monorepo workspaces. Use when setting up Nx, configuring project boundaries, optimizing build caching, or implementing affected commands.","https:\u002F\u002Fgithub.com\u002Flza6\u002FArmor-piercing-system-prompts\u002Fblob\u002Fmain\u002F07-后端与架构\u002Fnx-workspace-patterns\u002FSKILL.md",[],[]]