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

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

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.

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 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 · <date> · 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, 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 <canvas> --reviewer me --target <ref> --brief "…" --acceptance "…" --source ATTENTION-N --idempotency-key "attention-N-<slug>-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 (frames, labelled edges, banner, portals, and a text card per step that projects the card), then cnotes focus plan --start <ISO with the Rules' offset> --duration 45m|90m|135m --goal "Deep Work · <decision or artifact>" --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 <home board> --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 <requestId> --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: <whose yes>, failed: <reason>, skipped: <why>. Tag it answered,<lane>. 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: <whose yes> 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,<lane>. 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 <time>" when a routine exists, or "Tell the agent you answered" when none does. Never promise follow-through the host cannot wake up for.

Closing the day and the week

Day. When the user says so, or after the last block, version today's digest with Moved today: what is now true that was not true this morning; deep units used of the budget; whether the shallow window ran or was cancelled; what is still open, including answered cards whose follow-through failed or waits. A move is a change in what is true: a commitment made, a blocker released, a decision recorded, an artifact that now exists. A sent email or a drafted brief counts by the change it enabled, named in outcome language; the artifact alone is not the move. If nothing moved, write that. Do not mint a journal or an Achievement note.

Week. Friday after the last block, version the standing Update titled Attention spend · weekly close (create it once if it does not exist, never a sibling): deep units by the object they advanced, consequential sends and whether they landed, hygiene that had no higher object, and one honest line on whether the week was busy but empty. Mint a deep card from it only when it shows a trade the human must choose.

Intake sources

• IncomingDigest. Already synthesized, PII-free evidence. Read only the latest version of today's. PII here means what the pipeline stripped: end users' names, emails, phone numbers, ticket IDs, and source-system identifiers. Never write those into CreatorNotes. Workspace members, named owners, Customer notes (an account, not a person), and speaker attribution by role or member name are workspace vocabulary and belong on cards. Join Q-IDs only through the owner's private action key if they gave one. Older IntakeDigest or DailyAttentionDigest notes are superseded: read them, never create them.
• Transcript. Raw evidence, never a reading assignment for the human. Preserve it. Write one short Huddle outcome note derived-from it, separating what participants settled from what they proposed, questioned, or reported. Version the notes it changes. Route factual verification and artifact production to the named owners. Tag the transcript digested only after the linked updates and plans succeed. The card carries the decision-ready context and links the transcript as provenance only.
• Shared with you. cnotes shared is the inbox of asks and shares. The agent prepares every review assigned to the human: cnotes review get, judge the pinned target against every criterion, draft the findings and the outcome. It runs complete or return itself only when the Rules delegate that class of review (the Rules card names which). Every other prepared review goes under Ready for shallow window with the drafted outcome as the recommended default, the criterion that fails and the edit that would satisfy it, and the human completes it in the window. Dates and promises inside a draft go stale while a review waits; check them against today before calling a criterion met. Never fabricate an outcome you could not judge.

Board hygiene

The Focus calendar is the orientation surface; canvas placement alone never schedules anything. If the workspace keeps a home board, add the day's cards with one cnotes canvas place (a vertical stack into that day's section when one exists, cnotes canvas arrange --layout stack --stack-axis vertical to reflow) and never hand-compute coordinates. Supporting Comms or Validation sit under the card they support. Copy them onto the orientation canvas only when the send rests on them.

Invariants

1. Work the agent can do safely never becomes a card.
2. One open deep card and one open shallow card at a time, at most one of each minted per run. A shallow card only for a drafted, consequential external send. The Rules card is the single exception.
3. Every card names what it advances with an advances mention, or the work stays on the queue.
4. Untested product behaviour is Unknown. It never appears as fact in a customer draft. If the send depends on it, run the test, write a Validation, then draft.
5. A review request carries the server-returned URL and request ID, or it does not exist on the card.
6. End-user PII and source identifiers never enter CreatorNotes from the queue.
7. Intake is marked processed only after the writes and plans succeed.
8. The agent executes only on an answer that resolves the question and grants the permission the action needs. A terminal review, a cancelled ask, or a returned review is not an answer.
9. A card closes only from its follow-through ledger, and a ledger line is never repeated once done.

Triage mints nothing but Attention, plus Comms or Validation when a card will approve or rest on that object, plus one Huddle on the transcript path. Every other type waits for the answer.

How the agent wakes

Three moments: morning intake, the close after the last block, the Friday close. The text of this skill cannot wake anyone; only one of these can:

• Scheduled routines, when the host agent supports them. Schedule all three so the card is waiting when the human sits down and the close finds the answer without being told. This is the intended mode.
• The human's invocation: "I filled ATTENTION-12", "close the day", "what did I answer". Always a trigger, and the only one when no routine exists.

There is no event trigger: saving an answer or finishing a block does not notify the agent. So at the end of intake, say which mode is in force, and write it on the card (loop 3, step 9). Automatic follow-through that was never scheduled is a broken promise, not a feature.