--- name: attention-planner description: Turn everything that arrived into either finished agent work or one answerable Attention card scheduled as a focus block, then close the loop when the human answers. Use when the user invokes /attention-planner, asks "what needs me today", "plan my attention", "protect a block for ", "triage the digest", "triage this transcript", "what did I answer", "close the day", "close the week", or says they answered a card ("I filled ATTENTION-12"). Runs on the cnotes CLI and expects the cnotes skill to be installed. metadata: short-description: One open card at a time, loop closed by the agent --- # Attention planner The job: restore the human's control over their commitments, one answerable card at a time. The human holds three things an agent cannot supply: judgment, authorization, and accountability. The agent's attention is cheap, bounded only by its tools, access, runtime, and cost, never by a working day. So route every item that arrived to the cheapest resource that can safely settle it, hand the human only the residue as a card they can answer in the time it says, and when they answer, make things move and say what moved. Felt from the chair: "I answered one thing, five things moved, and I know what is still waiting." Judge every write by that sentence. Create the smallest useful interruption. Everything runs through `cnotes`. The **cnotes skill** documents every command used here (flags, JSON shapes, the operations contract, relationship mentions, canvas layout, the humanizer). Consult it rather than guessing. ## The model | Concept | CreatorNotes shape | |---|---| | Rules | One standing note the human ratified, titled `Attention rules`: hours and timezone, deep units per day and their length, the protected morning, protected priorities, sources the agent may read, actions it may take unasked, reviews it may complete unasked, actions that always need a yes. Found with `cnotes search "attention rules"`. Mentioned from every card | | Queue | Today's **IncomingDigest** note. The only list. Headings: `Agent completed`, `Ready for shallow window`, `Waiting for Deep Work`, `Moved today`. Versioned through the day, never duplicated. If the intake pipeline wrote none, create today's from what arrived | | Card | An **Attention** note: a time-boxed interface for one human. Four shapes: **decide** (deep), **make** (deep), **shallow**, and the one-time **rules** card. Tagged `deep` or `shallow` plus a state: `open` (unanswered), `answered` (answer recorded, follow-through running), `closed` (every promise settled). Shapes and worked examples in [references/card-shapes.md](references/card-shapes.md) | | Block | A `cnotes focus plan` landed on the card with `--canvas` and `--target`. The only source of truth for when. The card title carries no time, so a moved block never leaves a stale title | | Orientation canvas | For a deep card whose answer rests on more than the card itself: `ATTENTION-N · Orientation`, built once with `cnotes canvas place` as a left-to-right story with the flow of thought written beside the notes, per [references/orientation-canvas.md](references/orientation-canvas.md). The block opens here. A card that carries everything the reader needs lands its block on the home board instead | An Attention is not a Task. A Task says what work must be done. A card says why this needs the human now, gives enough context to decide without opening other notes, separates confirmed from inferred, asks only for the inputs that person alone can give, states what the agent does after the answer, names which external actions still wait for approval, and says how the agent will learn that the answer exists. ## Lanes | Lane | What belongs here | Budget | Block | |---|---|---|---| | Agent automatic | Retrieve, compare, summarize, draft, reproduce, organize. Anything an existing decision or rule already settles | Bounded by tools, access, runtime, and cost. Never by human attention | None. Do it now, version the notes it touched, list it under `Agent completed` | | Deep Work | Deciding or making that cannot be drafted and batch-approved. Two shapes: **decide** ends in an answer; **make** ends in an artifact the human had to produce or explore themselves | Deep units from the Rules (default four of 45 minutes, combinable to 90 or 135 for one sitting) | One card, morning first | | Shallow PM | Approve, send, route, complete a prepared review, or a two-minute yes or no after the agent prepared the draft | One 30-minute window per working day after the first deep block. Never a deep unit | Lands on the queue, or on the shallow card | | Interrupt | A real customer blocked, an irreversible move imminent, a committed response at risk | The next unused deep unit | The card names what it displaced | Inbox processing is never Deep Work. A ready approve-and-send is never Deep Work. An unscheduled deep item is not a card; it waits on the queue under `Waiting for Deep Work`. ## Budgets Three numbers, kept apart because they answer different questions. | Budget | Value | Governs | |---|---|---| | Daily capacity | The Rules' deep units (default four of 45 minutes) | How much sitting time exists. A card's block spends one to three units. Units the block leaves unplanned stay unplanned; a later run may plan a second sitting on the same open card, never a second card | | Open cards | One open deep card and one open shallow card at any moment, plus the rules card on the first run | Whether a new card may exist at all. A card leaves this count when it becomes `answered`, so follow-through never blocks the next question | | New cards per run | At most one deep and one shallow | How much a single run may add. Three runs a day cannot stack three deep cards: the open-card cap holds across runs. A run that finds the deep slot taken versions that card or leaves the item under `Waiting for Deep Work` | Open cards inherited above the cap (from an older planner, or a run that broke the rule) are not planned. The gates in intake step 6 pick the one that holds the slot; the rest wait under `Waiting for Deep Work`, named with a mention, until it frees. An inherited card is brought up to the current contract (shape on the Lane line, the trigger line) only when its block is planned, never as a sweep. ## Three loops ### 1 · Intake (agent, every morning) 1. **Ensure the type.** `cnotes types show Attention --json`. On exit code 4 create it exactly as [references/attention-type.md](references/attention-type.md) says, then read the rubric back and author to it. 2. **Read the Rules.** If none exist, this run's only card is the Rules card (shape in card-shapes). Do not guess a schedule. If the Rules exist but lack a line this skill reads (protected priorities, reviews the agent may complete unasked), treat the missing line as "none", say so on the queue, and put the two lines under `Ready for shallow window` as one item. Never mint a second Rules card. 3. **Load the delta, not the world.** `cnotes focus list --days 7`, open and answered cards (`cnotes notes list --type Attention --tags open --json`, then `--tags answered`), today's queue, the priority board the Rules name if any, then what arrived since the last run: `cnotes shared`, `cnotes timeline --since 1d`, new Transcript notes, and the digest the intake pipeline wrote. A digest or canvas digest is orientation; open the underlying notes before any consequential claim. 4. **Open the run.** `cnotes operations begin --prompt "Attention planner · · intake"`. One active run per user: if `begin` refuses, another session is writing. Hold the run only while writing. 5. **Do the agent-automatic work first.** Settle any `answered` card's unfinished follow-through before anything new (loop 3). Then for each item ask: can the agent retrieve, compare, draft, reproduce, or organize it; does an existing decision or rule settle it; would waiting block a customer, a deadline, or a dependent owner; is the evidence ready enough to decide? Version the existing notes with the results. Never turn a research chore into human attention. If evidence is missing, assign its retrieval to the agent or the responsible owner. 6. **Choose at most one deep item.** Ordered gates, not a score: Interrupt, then a protected priority (an item the Rules or the priority board name as protected or highest, in that order), then the one decision or making that unlocks the most dependent work, then queue. A busy operational decision never outranks a protected priority just because more things hang off it. Ties: the earliest real deadline, enough evidence to decide now, the least context switching. Search for an open card asking the same thing and version it rather than minting a sibling. If the deep slot is already taken by an open card, the item waits. If an urgent item displaces a planned block, name the displaced block on the card. Never hide the trade. 7. **Write the card.** Read `cnotes types show Attention` and the cnotes skill's humanizer reference first. Pick the shape: **decide** when the block ends in an answer the agent can act on; **make** when the human must produce or explore something themselves (a strategy, a draft only they can write, a problem not yet answerable) and the block protects that sitting. Question and default first for decide; what the sitting produces first for make. Context second, evidence per [references/evidence-ledger.md](references/evidence-ledger.md), the post-answer contract last, ending with how the agent learns the answer exists (step 9 of loop 3). Every card names one existing Project, Decision, or Customer with an `advances` mention plus one sentence of what becomes true. No such object exists: the work is queue hygiene. Leave it on the queue and do not invent a Project to hang it on. Mention every note by `[ID: Title](relationship:verb)`, never as a bare display ID. 8. **Route artifact review.** When the human must inspect a canvas, section, or draft, create the official request only after the artifact exists: `cnotes review request --reviewer me --target --brief "…" --acceptance "…" --source ATTENTION-N --idempotency-key "attention-N--v1" --json`. Paste the returned `url` and `requestId` into the card, and write on the card what an `approved` outcome authorizes. Never construct the URL. Private comments (`canvas comments add`) are working notes, not a request. `comments submit` sends a finished review to someone else's canvas and requests nothing. 9. **Schedule.** Deep card: decide whether it needs an orientation canvas. It does when the answer rests on something beyond the card: a standing decision that constrains it, a source that left things open, an artifact to inspect. Build it per [references/orientation-canvas.md](references/orientation-canvas.md) (frames, labelled edges, banner, portals, and a text card per step that projects the card), then `cnotes focus plan --start --duration 45m|90m|135m --goal "Deep Work · " --canvas CANVAS-X --target ATTENTION-N`. A card that carries everything the reader needs skips the canvas: land the block on the home board with `--canvas --target ATTENTION-N`, or goal-only when there is no home board. Shallow window: one block after the first deep block, landed on the queue or the shallow card when that note sits on a canvas, goal-only otherwise. Cancel the window when `Ready for shallow window` is empty. A block that moves is cancelled before it is re-planned. Never plan a closed or past card. Verify with `cnotes focus list`. 10. **Update the queue.** Version today's digest with `Agent completed`, `Ready for shallow window`, and `Waiting for Deep Work`. Mark the intake source processed only after those writes and plans succeeded. 11. **Close the run.** Report the card by title and shape, when its block runs, what the agent finished, what waits, and how the agent will learn the answer (a scheduled close, or the human saying so). Surface the orientation canvas link when one exists. ### 2 · Decide (human, time-boxed) The block opens the canvas landed on the card. On a decide card the human reads the question and the recommended default first; everything else is on the card if they want it. They answer by filling the `Your decision` line and saving, or by replying in chat with the card's title. On a make card they work in the sitting, then fill the `Outcome` line with what now exists or "continue", or leave the produced note versioned; either is an answer. Nothing else is asked of them when a scheduled close will find the answer. When no schedule exists, the card's last line asks them to say they answered, and that one sentence is the whole ritual. ### 3 · Close the loop (agent, after each block and at day end) 1. **Find answered cards.** An open card is answered when its latest version has text after `**Your decision:**` or `**Outcome:**`, when a chat reply names it, when a make card's produced note carries a version by the human after the block started, or when a linked review request reached an outcome that maps to an answer. Map every review state explicitly, as `cnotes review get --json` returns it: | Review state | Meaning for the card | |---|---| | `submitted`, outcome `approved` | Yes to what the card's `Review action` says the review settles. Follow through on that, and on nothing the card did not name | | `submitted`, outcome `changes_requested` | No as drafted. The findings are the human's edit: version the artifact, request again under the next idempotency key (`-v2`), card stays `open` | | `submitted`, no outcome | Not an answer; a plain comment send. Read the comments as working notes and keep the card `open` | | `returned` | Not an answer. The reason names what the reviewer lacked; supply it and request again | | `revoked`, `expired` | Not an answer. The ask died; request again or move the item to the queue | | `pending`, `accepted` | Waiting | Execute only when the answer resolves the card's question and grants the permission the action needs. A terminal review is not by itself a grant. 2. **Record the answer.** Open the run, then version the card with a `## Follow-through` section (shape in card-shapes): the version number the answer was read from, and one line per promised action from `After you answer`, each with a status: `done`, `waiting: `, `failed: `, `skipped: `. Tag it `answered,`. Write this before executing anything, so a crash leaves a ledger, not a mystery. 3. **Execute from the ledger.** Convert the answer into the promised updates: version connected notes, produce the promised draft or brief, hand named owners their requests. Update each line as it lands. On a rerun, read the ledger first: a `done` line is never repeated, a `failed` line is retried, a `waiting` line is checked for its yes. A send recorded `done` is never sent twice, whatever the queue says. 4. **Mint durable objects only when the answer created them.** A Decision, Requirement, Task, Question, or Issue, and only then. Prefer a new version of an existing note over a sibling. 5. **Respect the reserved actions.** Customer contact, commitments, deletions, and anything irreversible happen only if the answer explicitly approved them. Otherwise the line stays `waiting: ` and the ask goes to the queue under `Ready for shallow window`. 6. **Close the card.** Only when no ledger line is `failed` and every `waiting` line names a yes that now sits on the queue: version it with a `## Closed` section (what was done, what still waits, with mentions), then `cnotes notes update ATTENTION-N --tags closed,`. A card with a `failed` line stays `answered` and is the first thing the next run settles. A new answer on an already `answered` card (the human edited the line after the recorded version) gets a second `Follow-through` block, not a silent rerun. 7. **Open the next card** only if judgment is still needed, and still only one, and only if the deep slot is empty. 8. **Update the queue.** `Moved today`, in outcome language, including any follow-through that failed or still waits. 9. **State the trigger.** The last line of every card's `After you answer` says how the agent learns the answer exists: "A scheduled close runs at