# Suggested tasks This file says how the lead offers, records and cleans up suggested tasks. A session a card started works from its brief instead, because `chips brief` prints every rule its own task's rows need. It reads this file only to offer or drop another task. The pstack block in `AGENTS.md` points here. The `sync-pstack` skill renders this file from its shared source in `udecode/dotai`, so change it there. - **Suggested tasks.** Every runtime follows this rule. A suggested task is side work outside the run's target, or a measurement the block's Time budget rule sends there, that the owner can start in a new session, and the ledger is where the project tracks it, in place of an issue tracker. A finding that pivots the run never becomes one, as the Autopilot rule says. Two of them may write the same project files at once, because each works in its own worktree and lands through land.mjs, as Landing says. Every session, the lead's included, works in its own worktree, so the main checkout holds the only live ledger, in the plans directory's `artifacts/`, which git ignores. `decisions-check.mjs` switches to it for `chips` and for an `append` to the ledger's own path, and reads it for each `base-red:` token, so a session runs every ledger command as written from its own worktree. Agents write in the main checkout only under the plans directory's `artifacts/`, which holds the ledger and the run directories, as `.agents/pstack/rules/land.md` says. No commit on `next` holds the ledger, so starting a session never commits there. Each run of `setup.mjs`, which every session's SessionStart hook and every sweep start, keeps the ledger in step with `refs/pstack/ledger` on origin, or on the companion repository's origin when the project has a companion, so its rows stay durable and shared between clones. The file gains the rows only the ref holds, and the ref gains the rows only the file holds, pushed as a fast-forward. Then it fast-forwards the main checkout. The ledger's former path, `/suggested-tasks.decisions.tsv`, is a tracked link to it, so helpers that predate the move write the same file. When a plain file is there instead, `setup.mjs` moves its rows into the ledger. A `run:` wait reads its plan from `origin/next` as last fetched, in the companion repository when the project has one, and a plan that only a worktree holds has not landed. The sweep starts with `node .agents/pstack/setup.mjs` run in the main checkout, which fast-forwards it when no local edit is in the way, because the board reads paths there. No path keeps two tasks apart, another repository's file included, because the owner dropped that wait for trunk delivery (owner's word, 2026-10-18). A session that finds such a file changed under it redoes its change on the newer copy. - **Ledger.** A task lives as rows in the project's ledger `/artifacts/suggested-tasks.decisions.tsv`, under one id it keeps for good, because a task outlives the run that offered it and every card that showed it. A card in a suggest tool, such as Claude Code desktop's `spawn_task` or `start_session`, is only a view of a task. The lead queues and appends ledger rows like any other decision-log row, with phase `chip`, and never in a run's own log. - The decision is ` `, repeated unchanged on every later row. A new task takes its id from `node .agents/pstack/decisions-check.mjs chips id`. The card's own id goes in a `card:` token, never in the decision. - `node .agents/pstack/decisions-check.mjs chips` prints every open task as Ready, Started, Waiting or Unmigrated, with what each waits on and the checks it owns, Ready and Waiting tasks in priority order, as Cards says, with P2, P3 and untagged tasks shown only as counts unless `chips all`, then the stale plans that offered tasks wait on, the tasks a dropped card closed as `gone`, the topics with more than one task or a design question, and a Do list. The Do list shows one pass at a time, withdrawals, then ledger rows, then cards, with check items beside it, and `chips` exits 1 when any pass, shown or not, holds a problem: a card on a task that cannot start, a wait that can never clear, or two open design questions in one topic. `chips` leaves a malformed wait on a task with no topic to that task's migration. `chips --fetch` first runs `git fetch --all`, which refreshes the remote branches that PR waits read. `chips sync` prints the same board without its card pass, and its withdrawal pass takes only the cards of tasks that cannot start. `chips --session <id>` names this session, so the Do list asks to check each card another session holds; without it, every card counts as this session's. `chips brief <id>` prints the prompt a card for that task carries, with a `State:` line that says whether the board has it Ready, Started, Waiting and on what, or Unmigrated, whatever its priority; for a task merged into an offered task that has no card, or one an older helper replaced with such a task, it prints that task's brief, and otherwise, as for a closed task, it says there is nothing to start. The board also tells a session a card started to work from `chips brief`, which reaches a card whose prompt predates that instruction. - `chips stale` lists, for each open task, what may have made it stale: its age, a ship item that closed, each path it writes that was deleted since its offer or is missing, the commits on its paths since its offer, its closed PR waits and its card. It reads each repository's history once, along first parents, so it counts the commits that reached the branch. A project path, written relative or absolute, reads the project and its companion repository, and an absolute path outside the project reads the repository that holds it. It counts no commit that only renames a path, and neither half of a move between the project and its companion, which is a delete in one and an add of the same path and content in the other within a day. A path renamed away is missing, not deleted. `chips groups` lists the open tasks that may answer one question, as Sweep's Groups bullet says. - **Title.** The title is an imperative phrase. It ends in ` (xhigh)` only for a design question, which is a `kind: decide` task, or for a bug or slowness whose cause nobody has located yet. Every other task has a plain title and runs at `high`. That includes a hard fix whose finding names the cause and the function or file where it lives, because the session that found the cause already did that judgment. A design question stays at `xhigh` through its build. The title keeps `(xhigh)` whatever `maxEffort` allows, so the owner sees the recommendation. No title says when the task can start, because `chips` works that out on every read; `append` refuses a new offer whose title says `Now:` or `After:`, starts with a priority such as `[P1]`, or ends in `(high)` or `(fast)`, because `chips brief` prints the priority that Priority gives the task. - **Fast.** An offer or `updated` row takes `fast: yes` for a fix at `high` effort that names its exact change and a check that fails today, and changes no public call. The lead judges those conditions. `append` refuses `fast: yes` only on a design question, a review task or a task whose title shows ` (xhigh)`. `fast: no` drops the mark. A task is fast while it carries `fast: yes`, is a `kind: fix` task and its title shows no ` (xhigh)`, so a fold or dup that raises it drops the mark. The brief's title and the board line add ` (fast)`, and the brief says the owner's start of its card, or their "start <id>", is the word fast for its session, as the Fast rule says. - When the suggest tool has an effort setting, such as `start_session`'s `effort` for a task that starts fresh, the card sets it, and so does the lead when it starts a task on "start <id>", because a session started without one runs at the lead's own effort. It passes the `Effort:` level that `chips brief` prints. That level is `xhigh` for a design question. Otherwise it is the task's last `effort:` token, or, when it has none, `xhigh` for a title that ends in ` (xhigh)` or a task that covers one, and `high` for the rest. The project's `maxEffort` in `.agents/pstack.json` caps it when it sets one. The brief's title, and the task's line on the `chips` board, end in ` (xhigh)` exactly when that level is `xhigh` before the `maxEffort` cap, as the Title rule says, so an `updated` row with `effort: high` drops a stored tag from both, while later rows still repeat the stored decision. A `dismissed dup` that brings in an `xhigh` task raises the task it keeps. When the suggest tool has no effort setting, the card session starts at the lead's own effort. An `updated` row that changes a carded task's effort leaves its card at the old level, so `chips` lists that card in the withdrawal pass of the session that holds it, and once that session logs `uncarded`, its card pass offers the task again at the new level. A card session the owner already started keeps its effort, which is the owner's to change. No session can lower its own effort, so a card session that the session tool shows above its brief's level tells the owner in its first reply. A board line names the effort only where `maxEffort` lowers it. When the tool refuses that level, such as one above the lead's own, the card passes the nearest level the tool takes. The owner can raise the setting on the card. - **Priority.** Each open task has a priority, so the board puts the work a release needs first instead of listing every task in the order it was filed (owner's word, 2026-10-19). The agent that offers a task judges it, and `append` checks its evidence: - `P0` is broken now: a task that owns a check failing on the base branch, which `chips` counts as P0 whatever its token says, unless `chips.tiers` places it after its catch-all, which caps it at P1, as Tiers says; a regression, with `regressed: <commit>` naming the commit that broke it; or a major bug, such as data loss, peers that diverge, or a throw or stuck state in a public call, with `repro: <failing test, or exact steps someone ran and saw fail, such as a reporter or a tester>`. - `P1` is work a release needs: the open items of the project's ship list, the design questions they wait on and the builds of the designs they settle, each with `ship: <item id>`, and user-visible bugs with `repro:`. - `P2` is product work that blocks nothing: refactors, performance that breaks no budget, design questions no ship item waits on, docs fixes such as a dead link, and bugs with no repro yet. - `P3` is workflow, repository and agent tooling, such as lint output, and measurements. - A task shows the more urgent of its own priority and the priority of each offered task that waits on it through `task:`, directly or through other offered tasks' waits, because the waiting task cannot start until it lands (owner's word, 2026-10-20). A started task's waits no longer count, so it raises nothing. `chips` uses that priority on the board, where the task's line adds `blocks <id>`, in the stale report and in the brief, so the card's title carries it too. The task's `priority:` token keeps its own priority, which a sweep judges, and the task shows it again once no waiting task is more urgent. - `append` refuses a new offer with no priority and no owned check, a new P2 or P3 offer with no `via:`, a `via:` other than `verdict`, `babysit`, `time`, `hook`, `panel` or `stale`, a `via: panel` or `via: stale` on an offer whose kind is not `decide`, a P0 claim with no `owns:`, `regressed:` or `repro:`, a P1 claim with no `owns:`, `repro:` or `ship:`, a `regressed:` that names no commit and a `ship:` that names no open item. A task with no `priority:` token and no owned check gets no card until a sweep tags it, even when a waiting task raises it, and each full sweep judges every task's priority again from the stale report, which prints it. - A project names its ship list command in `.agents/pstack.json` as `"chips": { "ship": [<argv>] }`. The command prints a JSON array of the open items a release needs, each `{ "id", "title", "finding", "writes", "topic", "kind", "waits" }`, where `waits` lists the waits a task that serves the item starts with, such as `run:<plan>` for a plan already working on it. `chips` orders P1 tasks like every other priority, and its ledger pass offers a P1 task with those waits for each item no open task serves. A project with no such command has no ship list, and its P1 tasks are bugs with a repro. - **Milestone.** Where `.agents/pstack.json` sets `triage.experimental`, `chips` sorts the tasks of each priority by the milestone class that triage would give a bug with the same facts, so the work a release waits on comes first (owner's word, 2026-11-05). Each task names the review scope that owns its code as `review-scope: <id>`, or `review-scope: none` when no review scope file names its code, such as workflow tooling. A bug that used to work also names the pages where it works, as `regression: <url>, <url>`. A page counts when the bug's report names it and says the behavior works there, or when the session tries the steps there and they work. Triage takes the same evidence, and where the project's triage names the sites a regression page must be on, only a page on one of those sites counts. A task for a triaged issue takes `review-scope:` from the record's `scope:` and `regression:` from the record's `regression:`. When the record's `priority:` is above the task's, the task takes that priority with the evidence Priority asks, and the highest priority among the current records of the issues it covers stays its floor whenever its priority is judged again. Those facts are the whole task's, and no `dismissed dup`, `folded` or `reopened` row moves them. So a session whose dup, fold or reopen changes the work a task covers logs `updated` on it with the facts of all that work. When a later record of an issue changes either fact, the session that writes the record logs `updated` on each open task that covers the issue, through its own `repro:` or a duplicate it absorbed. That row gives each of the review scope and the regression pages that changes, from the current records of every issue the task covers, with an empty `regression:` when none has one any more, because a row names only the tokens that change. When those records name several scopes, the task takes the one of them that owns most of its writes, after leaving out each scope that `triage.experimental` lists, unless it lists them all, so the task ranks with the work a release needs most. A task that covers no triaged issue, or whose issues' current records name no scope, such as a `dup` or `needs-repro` record, or only scopes whose files `chips.scopes` no longer holds, takes the review scope that owns most of its writes. A task with `ship:` leaves out the experimental scopes the same way, unless they own all of its writes, because a release waits on it. A scope owns a path when its file's `owners` list names that path, a folder that holds it or a file inside it. When the `owners` lists leave a tie, such as between record scopes that own none of its writes, the session picks the tied scope the task's brief is about, with each file's `members` list as evidence, because a broad `members` folder, such as one that holds every browser test, says little about the code a task changes. A task with no record scope whose paths no scope file names takes `none`. A task whose review scope is not `none` is a regression when it names `regression:`, experimental when `triage.experimental` lists its scope, and new otherwise. A regression in an experimental scope is still a regression. A task with no review scope, or with `none`, has no class. Within a priority, `chips` lists and cards the regressions first, then the new tasks and the tasks with no class, then the experimental ones, because a release waits on its regressions and the experimental scopes hold up no release. The class orders tasks inside a priority and never changes one, so a bug in an experimental scope keeps the priority that Priority gives it. The board line and the brief name the class. The stale report says `no review scope` for an offered task that names none, so a sweep judges it, whatever session owns the task, because the row moves no card. The sweep takes `regression:` only from a record or from a page the task's own evidence names as working, and tries no steps for it. A sweep gives no review scope to a started task, because the board lists started tasks apart and ranks only the others. A started task still takes the facts when a record of its issue changes. Where `chips.scopes` in `.agents/pstack.json` names the folder that holds one file per review scope, `append` refuses a `review-scope:` other than `none` that names no file there. In trunk delivery it reads that folder in the main checkout and in the worktree the command runs from, because a worktree can hold a scope that the main checkout has not pulled yet or that its own run adds. A project with no `triage.experimental` keeps the order that Priority and Cards give. - **Deferred.** Where `.agents/pstack.json` sets `chips.deferred` to a list of review scope ids, `chips` ranks each open task whose `review-scope:` is on that list after every other task, whatever its priority or milestone class, a regression included, so the owner can set a domain aside without changing a priority (owner's word, 2026-11-06). The board lists deferred Ready and Waiting tasks in their own sections, each after the other Ready or Waiting tasks, the card pass cards them last, and the brief says the task is deferred. Each task keeps its `priority:` token, so taking a scope off the list brings the old order back. Its card's title still starts with that priority, because a deferral changes when the task runs, not how urgent it is. When an offered task that is not deferred waits on a deferred task through `task:`, directly or through other offered tasks' waits, the deferred task counts as not deferred everywhere this rule names, because it holds that work back. So does a task that owns a check failing on the base branch, because that check fails every change, as Priority says. A deferred task raises the priority only of the deferred tasks it waits on, so deferred work moves no other task up the board. Priority and Milestone order the deferred tasks among themselves. `chips` asks to fix a `chips.deferred` that is not a list of ids, or that names an id with no file in `chips.scopes`, before its card pass runs. A deferral changes no triage record, milestone or `review-scope:` pick, so a task takes its scope as Milestone says whether or not that scope is deferred. A deferred regression still holds its milestone open, so a release that waits on that milestone also waits on the deferred task. For a task that no triage record covers, that pick rests on the code its `writes:` names, which is the code of the feature whose behavior the repro shows broken while no session has traced the cause. When a session traces the cause to code that another scope owns, it logs the new paths the way Later rows lets a task in that state take them, such as a `started` row that adds them, and `updated` with the new `review-scope:`, which moves the task into or out of the deferred sections. `chips` reads the list from the `.agents/pstack.json` of the checkout it reads the ledger from, so every session's board ranks alike, and a deferral takes effect once that checkout holds it. Close cards no deferred task. When the Ready tasks outside the list that this session may card outnumber the cards it has room for under the limit Cards gives, `chips` asks it to withdraw its own cards on deferred tasks, one for each task left without room, the lowest-ranked first, and to log each withdrawal as Limits says. Every other card on a deferred task stays. - **Tiers.** Where `.agents/pstack.json` sets `chips.tiers`, the tier replaces the milestone class inside each priority, so the owner sets the order layer by layer, such as core before features and experimental work last (owner's word, 2026-11-12). `chips.tiers` is a list in rank order, and each entry has a `name` and may list `paths`, `except`, `scopes` and `checks`. A task takes the first entry whose `checks` prefixes hold every check it owns. Otherwise it takes the first entry that lists a folder holding one of its `writes:` paths, outside every folder that entry's `except` lists, or that lists its `review-scope:`. So a task that writes core code ranks as core whatever its scope, and an `except` folder keeps a feature that lives inside a core package out of the core tier. A task that no entry matches takes the one entry that lists neither paths, scopes nor checks, the catch-all, or ranks after every entry when there is none. A task that owns a check failing on the base branch or names `regression:` ranks first, as tier `regression`, and the owned check makes it P0, as Priority says, but only when its own tier is the catch-all or comes before it. A task in a tier after the catch-all keeps that tier and ranks at P1 at most, whatever its token, its owned check or a waiting task says, because such work holds up no release, so experimental work never outranks core work (owner's word, 2026-11-12). Its `priority:` token stays as logged, so dropping `chips.tiers` brings the old order back. Deferred still ranks last. The board line and the brief name the tier. `chips` asks to fix a `chips.tiers` that is not such a list, or that has more than one catch-all, before its card pass runs. A project without `chips.tiers` keeps the order Milestone gives. - **Offer.** A run cards a task only for a finding in its domain (owner's word, 2026-11-11). The domain is the subject the run's plan or target names, such as its topic, its review scope or the input a verdict or babysit run judges, or the feature its target changes when it names none. A finding is in the domain when it is the run's own target, when its fix changes code, docs or a plan that subject owns, a file the run's plan added included, or when it exists only because of the run's own result, such as a rerun of the run's own measurement or a question of how another feature adopts what the run built. The run's change is everything its plan has built, its earlier steps and sessions included. Any other finding is outside the domain at any priority. A bug in another subject's code that also shows without the run's change, such as on the commit before its plan's first step, is outside even when one of its cases shows only with that change, the run found it, its panel raised it, a step or gate of its plan waits on it, its plan edits the same shared code, its fix also changes a file the run's plan added or its symptom shows inside the run's feature. Until a trace finds where its cause lies, a finding other than the run's own target that also shows without the run's change counts as such a bug. The domain decides only who owns the task and which session shows it. Whether the run fixes the finding, leaves it open or pivots stays with the block's Suggested tasks and Autopilot rules and `.agents/pstack/rules/panel.md`. When the run fixes or pivots onto a finding that an open task holds, it logs `started` on that task with `session:` naming itself before it writes, and `landed` once the fix lands. For a finding outside the domain that the run leaves open, the run names the subject that owns the fix in the text of its plan's Open work line, or in its reply when it keeps no plan. It also offers a task for it when it ranks P0 or P1, or when a gate needs one: the design question that two open critical panel findings require, as `.agents/pstack/rules/panel.md` says, or the task that owns a check a `base-red:` row blames, as Base branch says. That offer names `session: none`, so the task has no owner. Neither the run's Close nor a plain `/chips` cards it, in any runtime; only `/chips all` does, as Owner says. A `folded` row joins a finding to a task that answers the same question, so the two lie on the same side of the domain. Inside its domain, a run offers a task only for a new P0 or P1 finding, as Priority defines them, and lists a P2 or P3 finding in its plan's Open work, or in its reply when it keeps no plan (owner's word, 2026-10-23). A verdict run may offer any priority for an item its verdict judges, and offers any other finding only at P0 or P1 (owner's word, 2026-11-04). `append` cannot tell such an item from another finding, so the run keeps that limit itself. A babysit run may offer any priority, and so may a measurement the block's Time budget rule sends to a task. So may a project hook that finds recurring work due, such as an intake once enough fixes have landed. Its task lies outside the domain of the run its hook stops, so its offer names `session: none`, and that session tells the owner in one line that `/chips all` cards it (owner's word, 2026-11-11, which replaces the 2026-11-02 rule that the stopped session cards it). That line is no hand-back and starts no new stage, so the session keeps its title, and the run's Close does not count the hook's task as one the run offered. So may the design question that two open critical panel findings require, as `.agents/pstack/rules/panel.md` says, and the fresh verdict the ledger pass offers on a stale plan, as the waits bullet says. Such an offer names its route as `via: verdict`, `via: babysit`, `via: time`, `via: hook`, `via: panel` or `via: stale`, and `via: panel` and `via: stale` go only on a `kind: decide` offer. A `folded` row adds to a task that already exists, so it needs no route. Run `chips` before offering. When the finding belongs to the question an offered task's topic names and that task holds no card, log it as a `folded` row on that task instead of offering a new task. The row lists what the finding adds in `writes:`, `waits:` and `owns:`. It carries `kind: decide` when the finding is a design question, or only `effort: xhigh` when the finding shows a bug or slowness whose cause nobody has located. When it belongs to the question of a started task or of a task that holds a card, with two kinds of evidence and one fix that removes both, as the Sweep's dup bullet asks, offer a new task in that topic that waits on it with `task:`, because a started session keeps its own plan and a card cannot show new work; `chips` merges it into the carded task once that card is withdrawn. Otherwise the offer's evidence holds these tokens, each `key: value`, named once and separated by semicolons, and its result is `offered`: - `writes: <path>, <path>`, required, each a repository path or directory, a path the companion repository tracks included, or an absolute path in another checkout, with no whitespace, glob, quote, comma or semicolon; - `topic: <name>`, required, one lowercase kebab-case name for the owner question, such as `plite-landing`, never an area such as `core` or `pstack`; reuse a topic `chips` lists when the finding belongs to its question; - `kind: decide` when the task settles a design question before any fix, `kind: review` for a review task, as Review says, and nothing or `kind: fix` otherwise; a topic holds at most one offered `decide` task that waits on no task of its topic, and while its design question is started or holds a card, a new one on that topic waits on it with `task:`; - `waits: <wait>, <wait>`, one for each thing the task needs first, never the task itself. `pr:<number>` clears when a commit subject starts `Merge pull request #<number> from` or ends in `(#<number>)`. `chips` reads those subjects on `refs/remotes/<remote>/<branch>` as last fetched, for each remote `git remote` lists, where `<branch>` is the `branch` in `.agents/pstack.json`. With no `branch` there, any remote branch counts. A PR that was closed or rebase-merged never clears it, so the lead logs `updated` with the waits the task has now. Before any row adds a `task:` wait between two open tasks, other than a wait the dup bullet gives a duplicate, the lead checks the two against the Sweep's dup bullet, because `chips groups` skips two tasks a `task:` wait joins. `task:<id>` clears when that task lands or is dismissed `done`, following each `dup` to the task it merged into; when its `landed` row names a `patch:`, it clears only once each path that patch touches is committed, because a new card session starts from the branch's last commit. A path counts as committed when it matches `HEAD` in the project's checkout, untracked files counting as uncommitted, or when a commit made after the `landed` row touched it, since that commit holds the landed work and any difference left is a later edit. `run:<plan path>` clears when that plan's `Status:` says it landed, such as `done` or `executed`. A plan that has not landed is stale once it has had no commit on it or its decision log, and no row in any checkout's copy of that log, for seven days, because a plan idle for a week does not resume (owner's word, 2026-11-13). The commits count in the project and its companion repository, on origin's copy of the branch in trunk delivery and on `HEAD` otherwise, and a plan that only a worktree holds counts its log rows alone. `chips` lists each stale plan an offered task waits on under Stale plans, the ones that wait on the owner first. A stale plan waits on the owner when its `Status:` starts with `paused`, or when a wait word, such as waiting, blocked, needs, hold or until, comes before you, your or owner in one clause. A period or semicolon ends a clause. Such a plan keeps its waits, and the sweep's report names it for the owner. A stale plan's review scope is the first entry of its frontmatter list that `pageTopic.field` names, or else its `Topic:` line. Its verdict topic is `review-<scope>`, or the plan's name when it has no review scope. Its fresh verdict is an open `kind: decide` task that writes it, or else the open design question in its verdict topic when that question is offered with no card. A task that started before the plan's last activity, counted from its first `started` row, is the run that wrote the plan, never its verdict. When the design question does not write the plan yet, the ledger pass folds the plan into its writes. When a plan has no verdict, the ledger pass offers one fresh verdict for each verdict topic. A sweep logs a stale plan's rows only after it has judged each task that waits on the plan, because a task it closes needs no verdict. When the run that wrote the plan still holds that topic, the pass instead asks to settle that run as `landed` with its commit or as `dismissed stopped`. When the topic's design question holds a card or has started, the fresh verdict waits on it with `task:`, as Offer says, and the question takes none of the plan's waits. That verdict is a `kind: decide` task at P2 with `via: stale` and `session: none`, so only `/chips all` cards it, and it writes those plans and the scope's file in `chips.scopes`. When the scope has no file there, the verdict takes the plans themselves as its input and records its outcome in each plan's Close. Once a plan has its verdict, the pass moves each `run:` wait on it to `task:<that id>`, one `updated` row per waiting task with every other wait kept, and the verdict drops its own wait on that plan. The move keeps the dependency the task declared on the plan: a task that needs the plan's result, or that writes the plan's files, which are the plan, its decision log and its subject file as Cards names them, waits on the verdict, because the verdict closes the plan and its log and a Pursue continues the plan's subject. When the task needs neither, the lead logs `updated` without the wait instead, because only a real dependency makes a task wait, as Cards says. A task with a card keeps its wait until the withdrawal pass takes the card. When the verdict waits back on a waiting task, counting the moves the same pass prints before it, the pass asks for an `updated` row on that task instead, because the move would close a loop and `append` would refuse the batch. The fresh verdict closes each old plan as superseded, then Pursues into a fresh plan or Stops. When it Pursues, each task that waits on the verdict and needs the fresh plan's result, or writes the fresh plan's files, gets a `run:` wait on that plan, as Cards says. A task or plan that closes any other way, such as superseded or cancelled, and a task wait that loops back to the task through the waits of offered tasks, leave the wait stuck, and `chips` asks for an `updated` row. A started task's waits no longer count. A task that needs the current run's result waits on `run:` with the run's plan, and a wait never goes in the title or the why; - `owns: <check>, <check>` when the task fixes a check that fails on the base branch, such as `ci:check`; - `priority: P0`, `P1`, `P2` or `P3`, required unless the task owns a check, with the evidence Priority asks of a P0 or P1 claim: `repro: <failing test, or exact steps someone ran and saw fail, such as a reporter or a tester>`, `regressed: <commit>` or `ship: <item id>`; - `via: verdict`, `via: babysit`, `via: time`, `via: hook` or `via: panel`, required on a P2 or P3 offer, naming the route that lets the run offer it, as above; - `review-scope: <id>` and `regression: <url>, <url>`, where Milestone asks for them; - `session: <id>`, the id of the session that offers the task, where the runtime's session tool gives one, as Owner says, and `session: none` on an offer for a finding outside the run's domain, as Offer says; beside `card:`, that session also holds the card. `append` adds `transcript: <id>`, the id of the writing session's transcript file, when it can read it. - **Owner.** Each task except a ship-list task belongs to one session, its owner: the session its offer names in `session:`, or, for an offer that names no session or names `session: none`, the first session that carded it. A card session's offer names its own session, like any other offer, and its Close cards it, as Landing says. `/chips` in a session cards only the tasks that session owns, because the owner wants each session's chips to stay in that session (owner's word, 2026-10-17). A task that serves a ship-list item, one with `ship:`, belongs to no session, and neither its card nor an `updated` row's `session:` gives it an owner (owner's word, 2026-10-20). Only `/chips all` cards it once it is Ready, because a session's plain `/chips` cards only its own tasks (owner's word, 2026-10-24). The Close of a run that offered it for its own finding in its domain cards it too, and one offered for a finding outside the domain names `session: none`, so only `/chips all` cards it. A sweep runs no Close, so a ship-list task that a plain sweep's ledger pass offers waits for `/chips all`. Its offer names no `session:`. `chips --session <id>` lists the other open tasks under Other owners, and `append` refuses a `carded` row from a session that does not own the task. A session matches its tasks by its session id or by its transcript id, because switching the owner's Claude account can change the session id. `/chips all` covers the tasks no live session owns, such as those of a parent session the owner archived with work still open, and the ship-list tasks. It runs `chips all --session <id> --sessions <file>` with the session tool's list saved as in Cleanup. That board cards each Ready task no session owns, and the card makes this session the owner of each one that serves no ship-list item. Its ledger pass lists each task whose owner session the list shows archived or does not list, and the lead logs `updated` with `session: <its id>` on each to take it. A session that owns a task its own run offered for a finding outside that run's domain, such as one offered before Offer named `session: none`, or a task a project hook offered when it stopped that session, logs `updated` with `session: none` on it, after it withdraws the task's card as Limits says when it holds one, because `append` takes an `updated` row only on an offered or started task, and on a started one only `owns:`, `review-scope:` and `regression:`. That leaves the task with no owner, and `chips` then lists it for no session but `/chips all`. A later session that continues the same plan logs that row too once no other session holds the task's card, even while the owner session lives, because neither that session's Close nor its plain `/chips` may card such a task, so the row takes nothing from it. A task whose card another session holds stays with that session until a sweep logs `uncarded`. - **Cards.** Only a task that `chips` lists as Ready before its card gets one. A task is Ready when it has a topic and each of its waits has cleared. A shared project path holds no task back, because a card session works in its own worktree and redoes its change on the newer file when it clashes, as Landing says; only a real dependency makes it wait. A task that writes an active plan's files, the plan, its decision log or its subject file, has one, because that plan's session is rewriting them and `chips` sees only ledger tasks, so the lead logs `updated` with its waits plus `run:<that plan>` instead of the card. The board's Ready line names each open task that shares one, and before each card the lead judges whether the task needs the result of another open task, those first, or of an open design question its work builds on, such as a title-slot answer a table-of-contents task reads. When it does, the lead logs `updated` with its waits plus `task:<that id>` instead of the card. Before that row, the lead checks the two against the Sweep's dup bullet, here, at a start and in Close, because `chips groups` skips two tasks a `task:` wait joins. It settles a duplicate as that bullet says. Otherwise, when the two share a topic, it logs `apart` with `from:` naming the task waited on before the wait, because `chips` merges a task into one it waits on in its own topic. A full sweep judges the same way each task that already holds a card and shares paths, because someone may have carded it before anyone judged its dependencies. A carded task takes the wait that judgment adds. Before each card, and in a full sweep for each task that already holds one, the lead checks the effort `chips brief` prints against the Title rule and logs `updated` with the right `effort:` when they differ, which a carded task takes. The card's prompt is what `chips brief <id>` prints, verbatim, which leads with the task and ends by telling its session to print the current brief, so the session works from the task as it stands when it starts. The card's title is the brief's first line, which starts with the task's priority in brackets, such as `[P0]`, so the owner's queue shows how urgent each card is (owner's word, 2026-10-19). A card keeps its title when the task's priority changes later, because its session prints the current brief first. When the suggest tool limits a title's length, such as `start_session`'s 60 characters, the lead shortens only the words between the priority and any ` (xhigh)` or ` (fast)` tag. A session the lead starts on "start <id>" takes the same title. The card pass lists at most 10 cards minus the ones this session already holds, highest priority first, so the owner's queue shows the most urgent work (owner's word, 2026-10-19). Within one priority and one milestone class, as Milestone says, a task whose `repro:` names a public issue, as `#<number>`, `<repo>#<number>` or an issues URL, comes first, because its reporter waits on it (owner's word, 2026-10-24). The lead offers every card the pass lists in one turn and lists each Ready task that limit left uncarded by id and title, with `start <id>`. The owner's "start <id>" starts that task as a new session whose prompt is its brief, with no card, once the lead has judged its dependencies and effort as it does before a card; when the task needs another task's result, the lead logs `updated` with its waits plus `task:<that id>` instead and tells the owner what it waits on. The next sweep cards the rest. After each card it logs `carded` with `card: <tool id>` and `session: <id>`. The session id is the one the runtime's session tool gives this session, such as Claude Code desktop's `get_session` with `self`, because a card goes away with the session that offered it. - **Quiet sessions.** The card, and the session the owner's "start <id>" opens, starts in its own worktree, which the lead asks for explicitly, such as `start_session`'s `use_worktree: true`, because the tool's default shares the lead's folder when the lead itself did not start in a worktree. A session that shares the lead's folder edits the lead's branch and cannot be detached. A session still linked to the lead wakes it each time that session ends a turn, and each wake re-reads the lead's whole context, so the task's brief has its session detach itself from the lead's as its first step, as the block's Calls rule says. When a note from such a session still reaches the lead, the lead detaches that session itself, such as with Claude Code desktop's `detach_session`, in the same message as its reply. The task's session sends the lead no message, because a suggested task is side work the lead's run never waits on (owner's word, 2026-10-21). Its ledger rows, its session title and its last report carry its outcome, and the next sweep's Cleanup reads that report and settles its question, as the `chips` skill's Sweep step 6 settles one. A question only the lead could answer does not stop it; it takes the most reversible answer, as the Autopilot rule says, and its report names that pick. When the runtime refuses or lacks the detach, the session stays linked and still wakes the lead at each turn end, which no rule here can stop. The lead then answers such a note only when it reports a landing, a PR or a stop only the owner can settle, in one line, starts no sweep for it and goes on with any work in progress. That line is not a hand-back, even when the note says every linked session has gone idle. - When a card leaves the queue without the owner starting or dismissing it, such as when a newer card pushes it out or its session ends, the lead logs `uncarded` with its `card:`, and the task stays open; `chips` lists it as Ready or Waiting again by the test above. Limits says how the lead tells those cases apart. For a card whose session ended, a later session's sweep logs it, as Sweep says. A task that holds a card takes no `folded` row, no `dismissed dup` into it and no `updated` row, except one that only narrows its `writes:` to paths inside the ones it lists, only adds waits and keeps every wait it has, or only sets its effort, its priority with that priority's evidence, or the `review-scope:` and `regression:` facts that Milestone ranks by, which changes no work, so its card always shows the whole task. A wait added that way makes the task wait, so the withdrawal pass pulls a card this session holds. A card another session holds keeps its prompt, whose board check tells its session to stop and say what the task waits on; a session the owner already started keeps running, and the lead tells the owner which dependency it started without. When the dismiss tool or the owner says the owner dismissed the card, the lead logs `dismissed declined` with its `card:`, which closes the task as its card showed it. A task that waited on it then has a stuck wait. Once the lead drops that wait, the task gets its own card, because the owner never saw its work. Before any other dismissal of an offered task whose card this session holds, the lead first withdraws the card as Limits says. When the owner says to drop such a task, the lead withdraws the card and logs `dismissed declined` with its `card:` in place of `uncarded`, so no merge lands between the two rows. When the tool reports the owner started it, the lead logs `started` instead. A started task closes with `landed` or `dismissed stopped` and needs no withdrawal. - **Later rows.** A later row's result is one of these, and it takes only the tokens named here: - `started`, with `writes:` for any path it adds and `session:` naming the session that runs the task, where the runtime's session tool gives that id. The session a card started logs it before it writes, and the lead logs it when the dismiss tool reports that the owner already started the task, or when the owner says so; - `landed` when a commit holds the change, the started session applied its patch to the checkout as Landing says or reports it delivered the change as the Delivery rule says, or the owner says so, with `patch:` naming the patch the session applied when it applied one and `commit:` naming each commit that delivered it, which `append` refuses unless each resolves to a commit in the checkout or in its companion repository. For a task that writes only in another checkout, such as the shared source, the row names that checkout's commit in its evidence, and `commit:` names only the project commit that brought the change in, such as its sync; a half-written change in the tree, or a patch nobody applied, does not count; - `reviewed` on a landed task, logged by the review task's session for each task it reviewed, as Review says; - `updated`, on an offered task with no card, or on one that has a card only to narrow its `writes:`, add to its `waits:` or set its `effort:`, `priority:` and their evidence, `review-scope:` or `regression:`, when its paths, topic, kind, effort, priority, evidence, review scope, regression pages, waits, owned checks, fast mark or owner change, and on a started task only for its owned checks, `review-scope:` and `regression:`; `effort:` takes `high` or `xhigh`, while a `folded` row takes only `effort: xhigh`; the row names only the tokens that change, and each replaces that token's whole list; - `folded` on an offered task with no card, with `writes:`, `waits:` and `owns:` that join the task's own, `kind: decide`, which makes it a design question, `effort: xhigh`, and `priority:` with its evidence, which raises the task's priority and never lowers it; `carded` with `card:` and `session:`; or `uncarded` with `card:`, as Offer and Cards say; - `reopened` for a task that an older ledger closed as `gone` when its card left the queue, while its work is still owed or before a sweep dismisses it, as Sweep's Lost bullet says, or for a task dismissed as a `dup` that the owner says is separate work. That row takes the task, with the tasks merged into it, off the kept task's Also covers list. The lead then logs `apart` on it with `from:` the kept task. Unless the kept task has started, the lead also logs `updated` on the kept task without each path that only the reopened task writes; - `apart`, on an offered or started task, with `from: <task id>, <task id>` naming each other task the ledger holds that a sweep judged no duplicate of it, because they share fewer than two kinds of evidence or one fix does not remove both, even when both answer one topic's question, so `chips groups` stops pairing them and `chips` never merges them. It changes no work, so a task that holds a card takes it too, and a `dismissed dup` passes the duplicate's list to the kept task. No row removes a name from that list. When the owner says two tasks it keeps apart are one fix, the lead folds the later one's findings into the earlier one and dismisses the later one as `declined`, as Drop does, because `append` refuses a `dup` between them. When the earlier one holds a card or has started, so it takes no `folded` row, the later one instead takes `updated` with its waits plus `task:<earlier one>`, and a sweep dismisses it as done once the earlier one lands; - `dismissed` with one reason: `done` when the tree already holds the fix of a task nobody started; `dup <task id>` when another offered task covers a task nobody started; `superseded` when the target of a task nobody started is gone, such as one the run removed; `declined`, with the task's `card:` when it holds one, when the owner dismissed its card or said to drop it; or `stopped` when a started task's session ended before its change landed. That holds when the session tool reports the session archived, no commit holds the change, its last report neither says it delivered the change nor hands back a patch, and neither this checkout nor the session's own worktree holds an uncommitted edit on the task's paths. It also holds when the owner says they stopped the task or says to drop it. After a `dup`, the kept task keeps its own title, lists the duplicate's title and findings under Also covers in `chips brief`, and takes its paths and owned checks. It keeps its own `review-scope:` and `regression:`, as Milestone says. It also takes the duplicate's waits, except each wait that leads back to it through dup rows, the higher of the two priorities and each of `repro:`, `regressed:` and `ship:` it lacks, and becomes `decide` when the duplicate was one. A kept task that gains `ship:` belongs to no session, as Owner says. A dup that an older helper logged into a started task listed only the duplicate's title and findings under Also covers and took its owned checks. - **Checks.** `decisions-check.mjs` judges each chip row against the rows before it, in `append` and in the whole-log check, which skips rows committed at `HEAD`. It refuses each row the rules above forbid, except a verdict run's P2 or P3 offer for a finding its verdict does not judge, which Offer leaves to the run, and each refusal names its route; follow it. A chip row is bookkeeping, so it gets no writing pass of its own, and the lead drafts its reason clean in writing.md's voice. Only `append` judges a rule older ledgers predate or a state that can change after the row is written, such as the paths on disk, a plan's status or which task holds a card. - **Sweep.** The lead runs `chips` before it offers a task. It runs the sweep below only on `/chips` (owner's word, 2026-10-20). Plain words that name the whole board or every task, such as "clean up all the chips", run `/chips all`, and other plain words about the chips run `/chips`. `/chips sync`, or plain words that ask to bring the chips up to date without new cards, runs the same sweep through `chips sync`, which prints no card pass and withdraws no card that pass would offer again, so it offers no card (owner's word, 2026-11-13). Words that ask for no new cards win over words that name the whole board, because `/chips all` cards tasks. Every other run cards only its own offers, at its last hand-back, as Close says. A ledger pass holds at most one merge. `chips` prints it for a task that waits on a task of its own topic once neither holds a card and no `apart` row keeps them apart, and only when `append` would take the row. Before it logs that merge, the lead checks the pair against the dup bullet below, because a wait in one topic can still record a dependency, such as one logged before `apart` rows existed. When the two are no duplicate, it logs `apart` with `from:` instead. When the task that waits is the one that bullet keeps, it settles the pair as that bullet says instead of logging the printed merge. A fold item, which `chips` prints for two design questions in one topic that wait on nothing there, gets the same check. When the two are no duplicate, the lead logs `apart`, then adds a `task:` wait and keeps the topic when one needs the other's result, and otherwise gives the later one a topic of its own, as Groups says. The pass leaves every other item on those two tasks to the next pass, which sees what the merge moved. The lead applies the Do list's pass and the steps below in one `append --from` batch, runs the same `chips` read again, `chips all` under `/chips all`, and repeats until the Do list holds no item it can apply: - **Cleanup.** Before the passes below, the lead cleans up after each landed task's card session, because the owner said archiving it is fine (owner's word, 2026-10-16). It saves the session tool's list of every session, archived ones included, as a JSON array in the run directory and runs `node .agents/pstack/decisions-check.mjs chips cleanup --sessions <file> --session <id>`. For each session listed under Archive or Keep, it first reads that session's last report with the session tool and fixes each piece of workflow friction the report leaves unsettled, as Landing says. It then archives each session listed under Archive, saves the list again, runs `chips cleanup` once more and runs the `scan.mjs --remove` command it prints under Remove. That command stops each process working in a worktree, saves the worktree's uncommitted changes as a patch under the git folder's `cleanup/` and removes it without judging it, because its task landed. `chips cleanup` lists only a session whose worktree sits under `.claude/worktrees`, never one that is running or pinned, and never this session. It lists under Keep, instead of Archive, a card session that holds a card nobody has started while that card is under seven days old, because a card goes away with the session that offered it, and the app drops an unstarted card after seven days. The sweep's report opens with the first run's Report lines, one per task with its commit links, so the owner reads what landed without opening its session. A runtime without a session tool skips this step. - When the tree already holds an offered task's fix, the lead logs `dismissed done`. When a started task's change has landed, it logs `landed`. When a task's target is gone, such as one the run removed, it logs `dismissed superseded`. - When open tasks nobody started answer one question, the lead keeps the earliest design question among them, or the earliest task when none is one, and logs each other one `dismissed dup <kept id>`, first logging `updated` with the kept task's topic on one whose topic differs, unless both are design questions. Two tasks answer one question only when they share two kinds of evidence, as the Groups bullet names them, and one fix removes both; similar wording alone never makes a dup, and neither does a pair an `apart` row keeps apart. A dup never goes into a started task, because its session keeps its own plan, or into a task that holds a card. The duplicate waits on it with `task:` instead, and `chips` merges it into a carded one once the card is withdrawn. When the topics differ, the `updated` row that adds the wait on a carded task also gives the duplicate the kept task's topic, because that merge happens only within one topic. The lead logs no wait for two design questions in different topics, and a later sweep settles them once the card leaves the queue. A duplicate that holds a card itself takes none of these rows until that card is withdrawn: the lead withdraws it first when this session holds it, and otherwise logs nothing on it until it leaves the queue. Meanwhile the task it duplicates, when it holds no card and has not started, takes `updated` with its waits plus `task:<that duplicate>` and, when the topics differ, that duplicate's topic, so it gets no second card for the same fix, and `chips` prints a merge item for the pair once that card leaves the queue. Two design questions in different topics take no such row, as above. A task whose work a started task covers waits on it with `task:`, and the lead logs it `dismissed done` once that task lands with the fix. - **Groups.** Under `/chips all`, once it has appended the rows above, the lead runs `node .agents/pstack/decisions-check.mjs chips groups`. It pairs two open tasks that share at least two kinds of evidence, the bar issue triage sets for calling an issue a duplicate. Two tasks share the problem when their titles share at least 30 percent of the content words the two titles hold together, or their topics share half of the words the two topics hold together. They share the failure when they own the same check, or their repros name the same test or log file. They share the fix area when they write the same file, other than a changeset or a file in the plans directory, or when their findings name the same camelCase identifier or code file name and at most three open tasks name it, leaving out each file whose name their repros name. It skips a pair when one task waits on the other through `task:`, following dup rows, or when an `apart` row on either task names the other. It prints each connected group with its pairs and each member's card. Similar wording alone never makes a dup. The lead judges every pair, whatever session owns each task, because none of these rows moves a card, and only a task's owner session cards it, as Owner says. It reads both briefs and the code each pair names. In a group of three or more, it judges each task against the one it keeps, so a task that shares evidence only with a dismissed one stays open unless one fix removes it and the kept task. When one fix removes both, it settles them as the bullet above says. When another session holds the card of the task it would dismiss, it logs nothing on that task, and the task it keeps takes the wait the dup bullet gives it. When both are started, it logs nothing and the report names the pair, because each session keeps its own plan. Otherwise it logs `apart` with `from:` on either task. When both are design questions in one topic and neither needs the other's result, it also logs `updated` with a topic of its own on the later one, because `chips` keeps one open design question per topic among those that wait on nothing there. A task that holds a card takes that row only once its card is withdrawn, by this session first when it holds it, so when another session holds the later one's card, the lead moves the earlier one instead, and while other sessions hold both cards it logs nothing more. Then, when an offered task needs the other's result, it logs `updated` with that task's waits plus `task:<id>`. When one fix removes both but they share only one kind of evidence, the later one, when it is offered, waits on the earlier one the same way, and a sweep logs it `dismissed done` once the tree holds that fix. A started task's session settles its own waits. It moves no task into another task's topic, because `chips` merges a task into one it waits on in its own topic. It also checks once each pair that a `task:` wait joins across two topics with no `apart` row between them, because a wait logged before the Ledger bullet's check got none, and logs `apart` with `from:` on a pair that is no duplicate. `chips` never merges two tasks that an `apart` row keeps apart, and `append` refuses a `dismissed dup` between them. The sweep's report names each group it judged and its outcome. - Where the runtime's session tool gives this session's id, the lead runs `chips --session <id>` with it. For each card the Do list says another session holds, it looks that session up with the session tool and logs `uncarded` with its `card:` when the tool reports it archived or gone. For each started task, it looks up the session its `started` rows name. When they name none, it finds that session with the tool, archived sessions included: its transcript opens with the task's card prompt, and a session that only printed the board does not count. The lead then logs `started` with its `session:`. When the tool reports that session archived, the lead logs `landed` with `commit:` once a commit on `origin/next` holds the change, because a session whose land.mjs opened a PR has not landed it yet. It logs `dismissed stopped` when no such commit holds it and the session's own worktree is gone or holds no edit on the task's paths. Otherwise, and while the session is not archived or the tool cannot find it, the task stays started. The sweep's report says why, and that the owner's "drop <task id>" closes it. The lead never asks the owner whether a session still runs. A runtime without a session tool logs `uncarded` with its `card:` for a card on the owner's word that its session ended, and `dismissed stopped` for a started task on the owner's word that they stopped it. - For each task `chips` lists as Lost, which a dropped card closed as `gone`, the lead logs `reopened`, then `updated` with its topic and waits, or, when its work is already done or its target gone, `dismissed done` or `dismissed superseded` after the reopen. - Before the run writes a path an offered task writes, the lead judges whether that task needs the run's result first. When it does, the lead logs `updated` on that task with its waits plus `run:<the run's plan>`, which a carded task takes too; when the withdrawal tool then reports the owner started it, the next bullet applies. - A path a started task writes needs nothing before the run writes it, because that session lands on top, as Landing says. The lead runs the check above whenever the run is about to widen what it writes, not only at a sweep. - A session started from a task finds its own row by the id in its brief and skips it in these checks. It runs `chips brief <id>` and works from what it prints rather than from its card's prompt, which can be older. When the brief's `State:` line says the task is neither Ready nor Started, it tells the owner what that line says before it writes; a started task means the lead logged the owner's start from its card or "start <id>". Then it logs its `started` row, which names this session in `session:`, and runs `chips brief <id>` again, because the task can gain work until then. Before it writes a path its task does not list, it logs another `started` row whose `writes:` lists the added paths. - **Landing.** A session a card started works in its own worktree and lands its task itself through `node .agents/pstack/land.mjs`, as `.agents/pstack/rules/land.md` says, instead of handing work back for the lead to land. It writes its run directory under the main checkout's `<plans>/artifacts/` by absolute path, as the Plans and trails rule says, so removing its worktree deletes nothing its rows cite. Once land.mjs has pushed, it logs `landed` with `commit:` naming the commit land.mjs pushed, which the sweep's cleanup report links. When land.mjs opens a PR instead, it names the PR in its last report, and the task stays started until a sweep logs `landed` once a commit on `origin/next` holds the change. Its ledger commands run as written from its worktree, where its edits and checks stay, and the helper writes the main checkout's ledger, as its brief says. A measurement task the block's Time budget rule sends here lands its verdict rows through land.mjs like any other change. Once its task has landed or its PR is open, a card session fixes each piece of workflow friction it hit and has not fixed yet, such as a helper that hid a result or a file it could not reach, as the block's Improve the workflow mid-task rule says, because the owner wants each fix made in the session that hit it (owner's word, 2026-10-20). Each fix is a commit of its own: project tooling lands the way the task did, and a shared rule or helper goes through the `sync-pstack` skill's Lesson mode. Its last report names each item with the commit that settled it, or with what it could not fix and why. It offers no task for friction, which Priority ranks P3 as workflow tooling, as Offer says. A new P0 or P1 finding still goes through Offer, with `session:` naming its own session when the finding is in its task's domain and `session: none` otherwise, as Offer says. Once its friction fixes and any reflect are done, it runs Close on the tasks it offered, because the owner wants such a task carded by the session that found it (owner's word, 2026-10-26). Then it stops each server it started and merges each run directory that it or a tool, such as a page render, wrote under its worktree's `<plans>/artifacts/` into the same path in the checkout without overwriting, because the cleanup scan that later removes the worktree deletes ignored files. Then it runs the `cleanup` skill's `scan.mjs --landed <its worktree>`, which exits 0 only when every change there is committed where a branch, tag or remote reaches it or in the checkout, and every file under `<plans>/artifacts/` is in the checkout. Other ignored files are build output or copies of the checkout's, and commits that only HEAD's reflog reaches are what land.mjs's squash left, so neither keeps the worktree. It leaves its worktree in place, so the owner can still open its files, and the cleanup scan removes it once nothing has written it or the session's transcript for a day (owner's word, 2026-11-15). When that check fails, or the project lacks the `cleanup` skill, it locks the worktree with `git -C <checkout> worktree lock --reason "<what the check printed>" <its worktree>`, so the scan keeps it, and tells the owner. Whether land.mjs pushed or opened a PR, it titles its session `👀 <name>` in the same message as its last other call, such as the `scan.mjs --landed` check, and after that call, as `.agents/pstack/rules/title.md` says, so the owner's sidebar shows which sessions hold work to review. The lead fixes each item a report leaves unsettled, when the sweep's cleanup reads that report before it archives the session. - **Review.** A landed fast task stays owed a review until a `reviewed` row on it. The board lists it under Owed review, and the ledger pass prints one item for the fast tasks that hold a card, are started or are owed and that no open review task waits on: add them to the waits of an open review task with no card, or offer a review task, `kind: review` in topic `fast-review`, that waits on each. A review task's brief lists each task it waits on with the `patch:` or commits its landed row names. Its session runs a panel on their combined change, fixes what the Panel review rule accepts, logs `reviewed` on each task it reviewed, then lands its own fixes. A review task that closes any other way leaves its tasks owed, so the next sweep offers another. - **Base branch.** A decision row that blames a failing check on the base branch, rather than on the run, names that check in its evidence as `base-red: <check>`, such as `base-red: ci:check`. Before that row, an open ledger task must list the check in `owns:`. The lead reuses a check name `chips` already shows when it names the same failure, and otherwise offers a task that owns it, such as `Make the base branch green (xhigh)`, or logs `updated` with the whole `owns:` list on the task that already covers it, started or not. A row once appended stays valid after its owning task lands. - **Limits.** The tool cannot rename a card or change its prompt, so a card's session prints the current brief first. To withdraw a card, the lead calls the dismiss tool on it, then logs `started` when the tool reports the owner started it, `dismissed declined` with the card's `card:` when it reports the owner dismissed it or the owner said to drop the task, as Cards says, and `uncarded` with that `card:` otherwise. The dismiss tool works only in the session that offered the card. It withdraws a card the owner has not acted on, and for one the owner started or dismissed, it reports which. A suggest tool result that lists the cards still pending in this session, such as an offer's, shows which left, and a card the owner clicked or dismissed leaves that list too. So after each such result, for each task this session carded that is missing from that list and that `chips` still lists as Ready or Waiting, the lead withdraws its card. It leaves a card another session offered alone while that session lives, as Sweep says; that card's prompt has the session check the task before it writes. A runtime without a suggest tool offers no cards, though it still judges each task's dependencies as Cards says. It lists each Ready task it would card in the plan's `## Open work` as `<id> <title>`, with `owner:` the owner, `stop:` started or dismissed and the ledger as where it is tracked, or in its reply when the run has no plan or its plan has closed. A session tool here is one that gives this session's id and lists every session, archived ones included. A runtime without one reads the board with `chips` and no `--session`, which counts every open task as this session's except one whose `session: none` puts it outside its run's domain, because `chips all` takes the tasks it covers for a session and needs one. It cannot tell which tasks and cards a live session owns, so it skips Cleanup, applies no withdrawal item, logs no row on a duplicate that holds a card, gives no task back with `session: none` and cards no task. Under `/chips all` it still runs `chips stale` and `chips groups`, which cover every open task. Its board skips the withdrawal pass, because a board read with no session counts every card as this session's. It lists each Ready task as above, and each duplicate that holds a card beside the task it duplicates. Once the owner says that card's session has ended, the lead logs `uncarded` with its `card:`, then `dismissed dup` with the task it duplicates. `chips` shows P2 and P3 tasks only as counts there, so the lead reads the `State:` line of `chips brief <id>` for each P2 or P3 task the stale report lists. A duplicate of a carded task still takes its wait, as the dup bullet says. - **Close.** At a run's last hand-back, once the run has delivered its work, closed its plan and made its last offer, reflect's included, the lead cards the tasks the run offered, without the sweep (owner's word, 2026-10-21), except a task offered outside its domain, whose `session: none` leaves it to `/chips all`, as Offer says (owner's word, 2026-11-11). It runs `chips brief <id>` for each task the run offered, whose `State:` line says at any priority whether the task is Ready and what it waits on, and reads no board, because a board's card pass lists tasks the run did not offer (owner's word, 2026-10-24). For each task the run offered that is Ready and not deferred, it judges dependencies and effort as Cards says. A deferred task the run offered waits for `/chips`, whose card pass cards it after every task that ranks above it, as Deferred says. For a task that needs another open task's result, it logs `updated` with that `task:` wait in place of a card, after an `apart` row naming that task when the two share a topic and are no duplicate, as Cards says. The lead offers the other cards in one turn, within the card limit Cards gives, and logs `carded` for each. Every other task waits for `/chips`. The reply adds one line just above its links: how many tasks the run offered, how many it carded and what each of the rest inside its domain waits on, or that it is deferred, which `/chips` cards once the wait clears, or `/chips all` for a ship-list task or once this session is gone, and how many lie outside its domain, which only `/chips all` cards. A session a card started runs Close too, for the tasks it offered, at the point Landing gives. A task it leaves waiting or uncarded because it is deferred stays its own until the lead's cleanup archives that session, and `/chips all` takes it then. A runtime without a suggest tool lists each Ready task it would card in the reply instead, as Limits says for a plan that has closed, and its line leaves out the `/chips` and `/chips all` hints, which card nothing there.