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 asks, 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. The first write's change description uses the seed-note template in references/card-shapes.md with the verb Opened and Canvas pending when the canvas does not exist yet (or none when the card has no orientation canvas). The focus block lives on the card (cnotes focus list), not in the timeline line. Pass that one line as changeDescription on the notes create item, with {displayId} in the {ID} slot. The create stamps the real display id into that token, so version 1 is the pending seed note. One line, verb first. Never Created. No title/summary pair, and no empty description for the platform to fill.
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. If that paste is its own version before the block exists, its change description stays the pending seed line, still verb Opened. It is not a title and a summary. 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. After that check, version the card with the full seed line as --description and never write a free-form description. The verb stays Opened: this block was placed, not moved. A moved block is cancelled, re-planned, verified the same way, then versioned with Rescheduled and the new times.
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>. The change description is the seed note with the verb 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: <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>. The change description on that version is the seed note with the verb 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 <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.
• Asks. cnotes asks is the inbox of asks and shares. cnotes shared is the same command. 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.
10. A write that creates an Attention card, moves its focus block, or records that it was answered or closed, uses the seed note as its change description: verb first (Opened, Rescheduled, Answered, Closed), one line, the template in card-shapes. Never Created, never a title/summary pair, never a free-form description.

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.

The Attention type

Run this once per workspace, before the first card. cnotes types show Attention --json exits 0 with the rubric when the type exists. Exit code 4 means it is missing.

Create it (only on exit code 4)

Inside the run, once. Never retry types create after an ambiguous network failure: run types show again first, or you duplicate workspace vocabulary.

cnotes types create Attention \
  --display-name "Attention" \
  --description "A time-boxed, source-grounded decision interface for one human's judgment or approval" \
  -w <workspaceId> --json

That --description is the type's blurb. It is not a card's change description. Every write that creates, reschedules, answers, or closes an Attention card uses the one-line seed note in card-shapes.md. The verb comes first (Opened, Rescheduled, Answered, Closed), then the display id, the plain-language ask, and the orientation canvas or none. The focus block lives on the card (cnotes focus list), not in this line. Never Created. No title/summary pair. No date or time. Canvas pending until the canvas exists, then one version with the full line, still Opened unless the block moved.

Apply the rubric

types create has no rubric flag, so apply it with types update. Keep save-time validation off: the rubric is the authoring spec agents read, and it must never block a quick human capture.

RUBRIC=$(cat <<'TXT'
An Attention note is a time-boxed interface for one human. It asks only for judgment, permission, preference, or accountability that an agent cannot supply safely, or protects a sitting in which the human must make or explore something themselves. A good one leads with the question and a recommended default, or with what the sitting produces, says why it needs attention now, gives enough source-grounded context to decide without opening other notes, and states what happens after the answer, which external actions still need approval, and how the agent will learn the answer exists. Keep the time box honest: about two minutes for a shallow approve-or-send, 45 to 135 minutes for deep judgment or making.

If you are an agent: do every safe step first and list it under "What the agent already did". Name the Project, Decision, or Customer this card advances with an advances mention and one sentence of what becomes true. Classify each consequential claim as Confirmed, Reported, Inference, Recommendation, or Unknown, and link its source with a readable relationship mention such as [NOTE-12: Title](relationship:references); never a bare display ID. Treat untested product behaviour as Unknown. Lean less the harder the choice is to undo; on a pure value fork, do not pick, give the default with its dissent. When the human must inspect a canvas or draft, link an official review request with its server-returned URL and request ID; private comments are not a request. Write "Complete when" as an observable state, never "discussed" or "reviewed".
TXT
)
cnotes types update Attention \
  --validation-prompt "$RUBRIC" \
  --disable-validation \
  -w <workspaceId> --json

cnotes types show Attention -w <workspaceId> --json   # validationPrompt must be present

If an existing Attention type comes back with an empty validationPrompt, or one that predates the make shape (no mention of a sitting), apply the rubric above the same way and read it back again.

Related types the planner may touch

Read each type's rubric with cnotes types show <Type> before authoring a note of that type.

Card shapes

Four shapes, one rule: the reader arrives cold and should be able to answer before scrolling. Question first, recommended default second, context third, evidence fourth, the post-answer contract last. Depth follows the stakes: a shallow card is a screen at most, a deep card a few, and neither carries a section that adds no decision value. Provenance and the post-answer contract are never omitted, and the contract always ends by saying how the agent will learn the answer exists.

The human answers after the colon on a **Your decision:** line (decide and shallow cards) or an **Outcome:** line (make cards). A card is answered when any such line has text after the colon, when the human names the card in chat, or, on a make card, when the produced note carries a version by the human after the block started. Titles carry no time: the focus block is the source of truth for when, and a moved block must not leave a stale title behind.

States travel as tags: open until answered, answered while the ledger runs, closed once every promise is settled. The lane tag (deep, shallow) stays throughout.

Read cnotes types show Attention and the cnotes skill's humanizer reference before writing. Mention every note as [ID: Title](relationship:verb); reuse the workspace's relationship vocabulary (cnotes rel types).

Seed note (timeline line)

Every write that creates an Attention card, places or moves its focus block, or records that the card was answered or closed, has one change description. That description is the seed note: the line a person reads on cnotes timeline. It is one line, and it is navigation, not a summary of the card. The shape follows Timeline labels are navigation, not summaries and the GUIDE-41 verb discipline: a movement verb, then the specific object, then the twist. Leave the description empty and the platform writes a title and a summary ("Decide on Team price range and feature scope" over "The author is seeking a decision..."), which is the line this template replaces.

{Verb} {ID}: {plain-language ask}. Canvas {canvas ID}.

{Verb} comes first. It is a movement verb: Opened for a new card, Rescheduled when the block moves, Answered or Closed for lifecycle changes. Never Created. Never "The author...". {ID} is the card's display id. {plain-language ask} is what the human is asked, in plain words. {canvas ID} is the orientation canvas, or none. The focus block lives on the card (cnotes focus list), not in this line. No date, weekday, or time. One line, no title/summary pair.

If the canvas does not exist at the first write, the verb is still Opened, and the line uses Canvas pending. Version the card once the canvas exists. That version stays Opened: the block was placed, not moved. A card with no orientation canvas uses none from the first write, not Canvas pending. A later move uses Rescheduled and the same shape. Recording the answer uses Answered. Closing the card uses Closed. Never a free-form description.

On the first write, pass the line as changeDescription on the notes create item. Write {displayId} in the {ID} slot. The create replaces that token with the new display id before it stores version 1. When both the canvas and the block exist, and on any later reschedule, answer, or close, pass the full line as --description on cnotes versions create, with the real display id already filled in. Nothing else goes in that flag.

Opened ATTENTION-6K2: approve the $20 to $30 Team price as standing. Canvas CANVAS-371.

Opened ATTENTION-6K2: approve the $20 to $30 Team price as standing. Canvas pending.

Rescheduled ATTENTION-6K2: approve the $20 to $30 Team price as standing. Canvas CANVAS-371.

This seed note is the timeline change description. It is not the outline a make sitting starts from, not the --description on cnotes types create, and not the text on an orientation banner.

Deep card · decide

# <The decision the human will produce>

**Lane:** Deep Work · 45 min · decide
**Advances:** [PROJECT-N: Title](relationship:advances) by <what becomes true if this block succeeds>
**Rules:** [NOTE-N: Attention rules](relationship:references)

## Your decision

### 1 · <The question, as a question>

**Recommendation:** <default>, because it optimizes <criterion>. Flips if <condition>.

**Your decision:**

<A second numbered question only when the block genuinely needs two answers.>

## Why now

<Stakes, what changed, and the consequence of delay. Three sentences. If this
block displaced a planned one, name it here.>

## What you need to know

<The minimum context to decide: current state, what changed, what the
options cost. Under one screen. Orientation mentions belong here:>

- [CANVAS-N: Orientation canvas](relationship:related-to)
- [DECISION-N: The standing decision this touches](relationship:related-to)

## Evidence

| Classification | Claim | Source | Confidence or gap |
| --- | --- | --- | --- |
| Confirmed | <claim> | [NOTE-N: Title](relationship:references) | Directly supported |
| Reported | <who, channel, date, claim> | [HUDDLE-N: Title](relationship:derived-from) | Not independently verified |
| Inference | <reasoning> | [INSIGHT-N: Title](relationship:based-on) | <where confidence ends> |
| Unknown | <missing evidence> | Unverified: source not found | <who can resolve it> |

## What the agent already did

- <research, comparison, draft, reproduction, or coordination completed>
- <what is ready for review>
- <what is assigned to another owner, by name>

## After you answer

1. The agent will <named update or artifact>.
2. The agent will <scheduling, delegation, or preparation step>.
3. The agent will not <customer contact, commitment, destructive change, or
   other external side effect> without your explicit yes.
4. <"A scheduled close runs at HH:MM and picks this up." or "Tell the agent
   you answered; nothing runs until you do.">

## Complete when

<An observable handoff or decision state.>

Add this section only when the human must inspect an artifact, and only after the artifact exists and cnotes review request returned:

## Review action

**Decision:** <what this review settles>
**An approved outcome authorizes:** <exactly what the agent may then do, and
what still needs a separate yes>
**Acceptance:** <short, testable criteria>
**Open the review:** [Review the proposal](<url returned by the server>)
**Request:** `<requestId>`

[CANVAS-N: Artifact canvas](relationship:related-to)
[SECTION-N: The exact review surface](relationship:related-to)

Deep card · make

For a sitting the human must spend themselves: a strategy to develop, a problem to explore before it has an answerable question, a draft only they can write. The block protects the making; the agent scaffolds it and takes over afterwards. The card leads with what the sitting produces, not with a question.

# <The artifact or state the sitting produces>

**Lane:** Deep Work · 90 min · make
**Advances:** [PROJECT-N: Title](relationship:advances) by <what becomes true when this exists>
**Rules:** [NOTE-N: Attention rules](relationship:references)

## What this sitting produces

<One sentence: the note, section, or canvas that exists at the end, and the
state it must reach. Name the target note with a mention:>

- [STRATEGY-N: Title](relationship:produces)

**Outcome:**

## Why now

<Stakes and what waits on this. Three sentences.>

## Start here

<The agent's scaffold: the notes to open first, the draft or outline it
prepared, the questions to hold in mind, the constraints that already bind
the answer. Under one screen. Orientation mentions belong here.>

## Evidence

<Only the claims the making rests on. The full table when a claim would
change what gets made; otherwise one line per claim with its class and
source.>

## What the agent already did

- <the outline, comparison, or research the sitting starts from>
- <what is assigned to another owner, by name>

## After the block

1. The agent will read the produced note and <version the linked notes, or
   extract the decisions it contains into Decision notes>.
2. The agent will <schedule the next sitting if the outcome says "continue",
   or route what now exists>.
3. The agent will not <share, send, or commit the artifact> without your
   explicit yes.
4. <"A scheduled close runs at HH:MM and picks this up." or "Tell the agent
   you finished; nothing runs until you do.">

## Complete when

<An observable state of the artifact: "a version of STRATEGY-N names the
wedge and the two alternatives it rejects", never "time was spent".>

The Outcome line takes what now exists, or continue with what is still missing. A make card whose outcome is continue stays open and the next run plans another sitting on the same card; it never mints a sibling. That later sitting is a reschedule: version the card with the seed note, verb Rescheduled, and the new block. Never a free-form description.

Shallow card

Only for a consequential external send that already has a draft. Anything smaller is a line under Ready for shallow window on the queue.

# Send <what> to <whom>?

**Lane:** Shallow PM · 2 min
**Advances:** [CUSTOMER-N: Title](relationship:advances) by <what becomes true>
**Draft:** [COMMS-N: Title](relationship:references)

**Recommendation:** send as drafted, because <criterion>.

**Your decision:**

Reply `yes`, `edit` and say what, or `hold`.

## Why now

<Two sentences: the commitment or deadline, and the cost of waiting.>

## Evidence

<One line per claim the draft makes, each with its class and source. If the
draft makes no product-behaviour claims, say so in one line.>

## After you answer

1. `yes`: the agent sends it and records the send on <note>.
2. `edit`: the agent applies your edit, then sends.
3. `hold`: it returns to the queue under `Ready for shallow window`.

Rules card (first run only)

The one shallow card allowed without a draft. Its answer becomes the standing Attention rules note that every later card mentions.

# Set your attention rules

**Lane:** Shallow PM · 5 min

**Recommendation:** ratify these defaults. Edit any line.

- Working hours and timezone: <09:00 to 17:30, Region/City (+HH:MM)>
- Deep units: four of 45 minutes per day, combinable to 90 or 135; morning protected until <12:00>
- Shallow window: one 30-minute block after the first deep block
- Sources the agent may read: <the intake workspace, shared items, transcripts, the priority board>
- Actions the agent may take unasked: research, compare, draft, version notes, plan and cancel focus blocks
- Actions that always need a yes: customer contact, commitments, deletions, anything irreversible
- Protected priorities: <the one or two objects that outrank throughput, such as a strategy canvas, or "none">
- Reviews the agent may complete unasked: <a class, such as reviews it requested itself or drafts under 500 words, or "none: prepare every review, I complete it">
- Interrupt rule: a blocked customer takes the next unused deep unit

**Your decision:**

## After you answer

The agent saves the ratified lines as the standing `Attention rules` note,
mentions it from every future card, and runs intake.

Follow-through section

Appended as a new version the moment an answer is found, before anything is executed, and updated as each line lands. The tags change to answered,<lane> in the same write. A rerun reads this first: done is never repeated, failed is retried, waiting is checked for its yes. The change description is the seed note with the verb Answered. It is not a title with a summary under it, and it does not narrate the ledger in free form.

## Follow-through

Answer read from version <N>, <date>: <the answer in one line>.

1. <promised action> · done · [NOTE-N: Title](relationship:references)
2. <promised action> · waiting: <whose yes, and where it sits on the queue>
3. <promised action> · failed: <reason, and what the next run will try>
4. <promised action> · skipped: <why the answer made it unnecessary>

A second answer on the same card (the human changed the line after version N) gets a second Follow-through block under it, never an edit of the first.

Closed section

Appended as a new version only when no line above is failed and every waiting line names a yes that now sits on the queue. The tags change to closed,<lane> in the same write. The change description is the seed note with the verb Closed. It is not a title with a summary under it.

## Closed

Done: <what the agent did, with mentions>.
Still waiting: <the external action that needs a yes and where it sits, or "nothing">.

Worked example · decide

A fictional customer, written the way a real card should read.

# Choose the recovery offer for Northwind's export failures

**Lane:** Deep Work · 45 min · decide
**Advances:** [CUSTOMER-7: Northwind Logistics](relationship:advances) by a recovery offer they can accept this week instead of escalating to procurement
**Rules:** [NOTE-31: Attention rules](relationship:references)

## Your decision

### 1 · Which recovery offer do we make?

**Recommendation:** offer the fix date (Thursday) plus one month's credit, because it keeps the renewal conversation on product rather than on compensation. Flips if the reproduction shows the failure also drops rows silently; then the offer must include a data audit.

**Your decision:**

## Why now

Northwind's ops lead said on Tuesday's call that they will raise the export failures with procurement on Friday. A fix date exists, but nobody has told them, and the renewal is in six weeks. Waiting past Thursday turns a product conversation into a compensation one.

## What you need to know

Exports over 50,000 rows time out; the agent reproduced it today. The fix is scheduled and does not need a decision. What needs you is the offer: fix date alone, fix date plus credit, or fix date plus credit plus a data audit.

- [CANVAS-88: Northwind recovery · Orientation](relationship:related-to)
- [DECISION-58: Ship the streaming export fix Thursday](relationship:related-to)

## Evidence

| Classification | Claim | Source | Confidence or gap |
| --- | --- | --- | --- |
| Confirmed | Exports over 50,000 rows time out after 30 seconds | [VALIDATION-3: Export timeout reproduction](relationship:references) | Reproduced today, screenshots on the orientation canvas |
| Confirmed | The streaming fix ships Thursday | [DECISION-58: Ship the streaming export fix Thursday](relationship:references) | Directly supported |
| Reported | Their ops lead, Tuesday call, said procurement gets involved Friday | [HUDDLE-19: Northwind check-in](relationship:derived-from) | Not independently verified |
| Inference | A credit now costs less than a procurement-led renewal | [INSIGHT-44: Escalated renewals close smaller](relationship:based-on) | Based on three prior accounts; sample is small |
| Unknown | Whether rows are dropped silently below the timeout | Unverified: source not found | Engineering owner can confirm from export logs |

## What the agent already did

- Reproduced the failure and wrote the Validation with screenshots.
- Drafted the customer note as [COMMS-12: Northwind recovery note](relationship:references), pending your offer choice.
- Asked the engineering owner for the dropped-rows log check; answer expected before Thursday.

## After you answer

1. The agent will fill the offer into the draft and version it.
2. The agent will queue the send for the shallow window.
3. The agent will not send anything to Northwind without your explicit yes on the draft.
4. A scheduled close runs at 12:15 and picks this up.

## Complete when

The draft carries the chosen offer and sits under `Ready for shallow window`.

Worked example · shallow

# Send the recovery note to Northwind?

**Lane:** Shallow PM · 2 min
**Advances:** [CUSTOMER-7: Northwind Logistics](relationship:advances) by getting the fix date and the offer in front of them before Friday
**Draft:** [COMMS-12: Northwind recovery note](relationship:references)

**Recommendation:** send as drafted, because every claim in it is confirmed and the offer matches your answer on the deep card.

**Your decision:**

Reply `yes`, `edit` and say what, or `hold`.

## Why now

Their procurement conversation is Friday. Sending today gives them two working days with the offer in hand.

## Evidence

- Confirmed: the fix ships Thursday, [DECISION-58: Ship the streaming export fix Thursday](relationship:references).
- Confirmed: the offer is fix date plus one month's credit, [ATTENTION-42: Choose the recovery offer for Northwind's export failures](relationship:derived-from).
- The draft makes no other product-behaviour claims.

## After you answer

1. `yes`: the agent sends it and records the send on the customer note.
2. `edit`: the agent applies your edit, then sends.
3. `hold`: it returns to the queue under `Ready for shallow window`.
4. A scheduled close runs at 12:15 and picks this up.

Worked example · follow-through

The decide card above, after the human wrote "fix date plus one month's credit" on version 3 and the close loop ran:

## Follow-through

Answer read from version 3, Tuesday: fix date plus one month's credit.

1. Fill the offer into [COMMS-12: Northwind recovery note](relationship:references) · done
2. Queue the send for the shallow window · done · listed under `Ready for shallow window` on [INCOMINGDIGEST-9: Tuesday](relationship:references)
3. Send to Northwind · waiting: your yes on [ATTENTION-43: Send the recovery note to Northwind?](relationship:references)

Every line is done or waiting on a yes that sits on the queue, so the card closes in the same run. Had line 1 failed (the draft locked by another session, say), the card would stay answered and the next run would retry line 1 before minting anything new.

Evidence ledger

Classify every consequential claim before it goes on a card or into a draft. A consequential claim is one that would change the decision, the priority, or what the customer is told if it turned out to be wrong.

The five classes

Rules

• The seed note is the card's timeline line (card-shapes.md), not a ledger row. It leads with a movement verb (Opened, Rescheduled, Answered, Closed), never Created and never "The author is seeking...". Do not turn a claim or a class into that line.
• Columns on a deep card: Classification, Claim, Source, Confidence or gap.
• Put the mention beside the claim. Note sources carry facts; a canvas mention is for orientation only, never the source of a fact.
• Never write a bare display ID in a note body. [NOTE-12: Title](relationship:references), not NOTE-12. Reuse the workspace's relationship vocabulary before coining one.
• No source can be linked: write Unverified: source not found and narrow the claim until it is true.
• A reported claim or an inference does not become a fact because several summaries repeat it. Summaries derived from one source count once.
• Preserve speaker, date, and channel for every customer or stakeholder statement.
• A live product behaviour is Confirmed only when a Validation or Observation records a reproduction. Untested means Unknown. An untested behaviour never appears as fact in a customer draft; if the card or the send depends on it, run the test, write the Validation, and put the screenshots on the evidence or orientation canvas first.
• Lean less the harder the choice is to undo. On a two-way door, recommend plainly. On a one-way door, give the default with its dissent and say what would change your mind. On a pure value fork, do not pick: state the fork and the default the human has used before, if any.

Proportionality

The ledger's depth follows the stakes, not the template.

A decide card with no Reported, Inference, or Unknown rows is a signal to look again: either the decision is agent-automatic and should not be a card, or a claim has been promoted without a source.

Orientation canvas

A deep card whose answer rests on more than itself gets a canvas the block opens on: a standing decision that constrains it, a source that left things open, an artifact to inspect. A card that carries everything the reader needs skips the canvas and lands its block on the home board; a canvas that would hold only the card and its source is presentation overhead, not orientation. When the canvas is warranted, it is not done when the right notes are on it. A flat pile of five correct notes makes the human reconstruct the chain the agent already knows, which is the failure the canvas exists to prevent. Lay it as a story the reader follows left to right in ten seconds, and write the flow of thought on the board beside the notes.

Title: ATTENTION-N · Orientation, using the card's immutable display id, never its heading. Goal: one sentence saying what the block decides and that the card is first. One cnotes canvas place call builds the whole thing from a spec; the sections size themselves around their content, so no coordinates.

The frames, left to right

The hero at the top: richtext large, untinted, # <card title> shortened to under 50 characters, the one line legible at zoom-to-fit. The banner directly under it: richtext medium, untinted, no heading, at most five sentences, in the cnotes skill's banner order (hard rule 7 in its references/canvas-elements.md): what happened, what this board is for, who answers and where, how to read it. Then the lines only this canvas needs: the block day and time, "answer on the card", where the portals go. A banner that opens with the block time and the reading order and never says what the card is about fails the cnotes cold-reader test. Reminder material (rules, operating plan) does not go on an orientation canvas; the home board carries it.

The text cards

Each text card is a projection of a note that already holds the full record. The rules are the cnotes skill's rules for text elements (references/canvas-elements.md), applied hard:

• At most three sentences. One bold lead phrase is fine (**Why now.**, **1 · The date you owe.**).
• Every number, date, name, and recommendation is lifted from the card or its source verbatim. Never restate a figure, never add one. Run the preservation gate before placing.
• Name every note and canvas with a relationship mention carrying its real title ([DECISION-6J2: Title](relationship:constrains)); it renders as a chip. A bare display id is a defect. The chip is for the reader, not the graph: the note body still carries the mention that travels.
• Untinted by default. Tint only by role: #F59E0B for the constraining rule, #3B82F6 for source evidence. Nothing else.
• size: "small" (560px) beside a 340px note card. Put text cards in the same frame as the note they project, in a vertical stack under or beside it.

A text card that says something no note says is a bug: put it in the note first, then project it.

Spec template

{ "placement": "exact", "origin": { "x": 100, "y": 100 },
  "root": { "kind": "stack", "axis": "vertical", "gap": "spacious", "items": [
    { "kind": "item", "type": "richtext", "size": "large", "content": "# <card title, under 50 characters>" },
    { "kind": "item", "type": "richtext", "size": "medium", "content": "<what happened>\n<what this board decides>\n<who answers, on the card>\n<Day HH:MM> · Read left to right; portals below." },
    { "kind": "stack", "axis": "horizontal", "gap": "spacious", "align": "start", "items": [
      { "kind": "section", "name": "1 · Came from", "child": { "kind": "stack", "axis": "vertical", "gap": "medium", "items": [
        { "kind": "item", "type": "note", "noteId": "<DIGEST>", "key": "src" },
        { "kind": "item", "type": "richtext", "size": "small", "content": "<which item, why only this sitting>" } ] } },
      { "kind": "stack", "axis": "vertical", "gap": "medium", "items": [
        { "kind": "section", "name": "2 · Decide here", "child": { "kind": "stack", "axis": "horizontal", "gap": "medium", "align": "start", "items": [
          { "kind": "item", "type": "note", "noteId": "ATTENTION-N", "key": "card" },
          { "kind": "stack", "axis": "vertical", "gap": "tight", "items": [
            { "kind": "item", "type": "richtext", "size": "small", "content": "**Why now.** <from the card>" },
            { "kind": "item", "type": "richtext", "size": "small", "content": "**1 · <decision>.** <recommendation>. Flips if <condition>." } ] } ] } },
        { "kind": "section", "name": "What it rests on", "child": { "kind": "stack", "axis": "horizontal", "gap": "medium", "align": "start", "items": [
          { "kind": "stack", "axis": "vertical", "gap": "tight", "items": [
            { "kind": "item", "type": "note", "noteId": "<DECISION>", "key": "rule" },
            { "kind": "item", "type": "richtext", "size": "small", "colorHex": "#F59E0B", "content": "<the standing rule and what it forces here>" } ] },
          { "kind": "stack", "axis": "vertical", "gap": "tight", "items": [
            { "kind": "item", "type": "note", "noteId": "<HUDDLE or VALIDATION>", "key": "open" },
            { "kind": "item", "type": "richtext", "size": "small", "colorHex": "#3B82F6", "content": "<what it left open, what is reported, what is unknown>" } ] } ] } } ] },
      { "kind": "section", "name": "3 · Advances", "child": { "kind": "stack", "axis": "vertical", "gap": "medium", "items": [
        { "kind": "item", "type": "note", "noteId": "<PROJECT>", "key": "obj" },
        { "kind": "item", "type": "richtext", "size": "small", "content": "<what becomes true; which send stays with the human>" } ] } } ] },
    { "kind": "section", "name": "Where things live", "child": { "kind": "stack", "axis": "horizontal", "gap": "medium", "items": [
      { "kind": "item", "type": "canvas", "linkedCanvasId": "<work board convex id>" },
      { "kind": "item", "type": "canvas", "linkedCanvasId": "<home board convex id>" } ] } } ] },
  "edges": [
    { "from": "@src",  "to": "@card", "label": "produced" },
    { "from": "@card", "to": "@obj",  "label": "advances" },
    { "from": "@rule", "to": "@card", "label": "constrains" },
    { "from": "@open", "to": "@card", "label": "left open" } ] }

Drop a frame that has nothing to hold; never leave an empty one. Add a frame only when the card rests on something the reader must see (a Contradiction or a Fork gets its own layout from the workspace's layout catalog instead).

Rebuilding

An orientation canvas is rebuilt, not patched: bulk-remove every node (notes, sections, portals, the banner) inside one operations run, then place the new spec. Section ids change; nothing should reference them by id. The focus block targets the card, not a section, so it survives the rebuild. Verify with cnotes focus list that the block still lands on the canvas and the card. A rebuild does not rewrite the card's change description. Placing or moving the block does: after that check, version the card with the seed note in card-shapes.md. Verb Opened when the block is first placed, Rescheduled when it moves. One line, never a free-form description, never Created, never a title/summary pair, never the block's date or time. The focus block lives on the card (cnotes focus list). The banner's day and time is for the person reading this canvas. It is not that timeline line.

Read-back test

cnotes canvas read: every note sits in a named frame, every edge carries a verb, every text card is at most three sentences and traceable to a note, the banner names the block, and both portals resolve. Then the glance test: a person zoomed to fit should see came from, decide here, advances, and start reading at the card.