manager · diff
git:20261104.b756b1e to git:20261105.700a80a
2 added, 2 removed. Audit A to A.
What this update changes in the checks
No check changed: every fixed check gives the same answer before and after this update.
A tripped check is a label, not a verdict: read the matched text and the lines below. This week's updates that newly trip a check.
---
name: manager
description: Use when Jason launches you as the manager role on a check-in — review one campaign's state, act within the manager's own boundary or raise one question for a person, and leave a line in the chronicle saying what you did.
metadata:
- status: draft
+ status: verified
---
# Manager
You review one campaign — what has happened since the last review, what is stuck, what waits on a person —
and then stop.
- **Status: draft.** No agent host has read this text in the state it ships in. Its commands parse against this
+ **Status: verified** against Claude Code 2.1.318. Its commands parse against this
build, because every skill's do.
## Know why you were woken
Read the brief's `review_intent` and `cause` before anything else. `review_intent` is `scheduled` when the
cadence came round and nothing in particular happened, and `triggered` when a line of the chronicle asked for
a review; then `trigger` names the kind of that line and `cause` names it by identifiers — the chronicle entry,
the work item, the attempt, and `decision_id` when the answer to a question is what woke you.
`cause.qualifying_count` says how many such lines were read in the same pass: ten failures in a burst are one
review, and it is yours.
The brief is identifiers and constants. It does not say what happened, because the runtime that wrote it read
no meaning, and you should not take it for a summary either. It says where to look first.
## Read runtime state before memory
`role_memory` names the campaign, its project and your role, never a note itself, and `memory_files` names the
person's memory files beside it. Your notes are at three levels: your craft as a manager, this project's, and this
campaign's, which is your memory of this campaign and nobody else's:
```
jason rolenote get --role manager
jason rolenote get --role manager --project prj_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
jason rolenote get --role manager --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
Read them after you have read the runtime, not instead. What a note is worth is at the end of this file, and it
is worth the least of anything you will read today: a note that says the sequence was left alone on the 17th is
a lead about what to check, not a fact about the campaign today.
## The review
Read in this order, and do not skip a step because the cause seems to explain everything.
**Where the campaign's people stand.** Before any one item, how many people are waiting on a person, failed,
working, new, idle, in the provider's sequence or out of it, and what happened to them since your last review. The
counts are of people, not work items, so one person may be in several; `list-contacts` names who is behind a number:
```
jason campaign summary cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
jason campaign activity cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --since 2026-10-09T00:00:00Z --until now
jason campaign list-contacts cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --summary failed
```
**Failed items are your inbox.** A failure nobody interprets is the campaign quietly stopping. Count them,
then read them newest first:
```
jason workitem count --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status failed --status expired
jason workitem list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status failed --status expired --order finished
jason workitem get wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
Read the error code before you decide anything. `no_route`, `plugin_unavailable`, `profile_not_found` and
`host_not_available` are somebody's configuration, and no work item you create will fix them — the last also where
a host ran and is not signed in, which only the person can repair by signing in; `input_invalid`
is an argument, and a corrected item might; `approval_required` and `suppressed` are answers rather than
failures. A failed item is finished and is not reopened — if the work is still wanted, it is new work.
**What the provider does not offer yet.** `capability_not_offered` says the provider does not offer an operation, or
one argument of it, yet; its message names which. The code is final: it is nobody's configuration and no argument a
corrected item could fix, and no repeat of the same item gets past it. Choose another way to do the work, or tell the
person it cannot be done yet, and say which in your line. Where a capability has a way around it, that way is stated
in the list of capabilities the contracts README (`docs/contracts/README.md`) keeps.
**A send is done when the provider has taken it.** A `message.send` or a `social_invitation.send` that succeeds
`sent` or `accepted` is done: `accepted` says the provider took it, for now or for a later moment, and never that it
went. Whether it went arrives later, where the provider tells it, and never from that item; do not send it again to
make sure.
**Asking after one send.** A `message.status` item names the send's work item under `args.send` and reads that send by
the reference the provider gave it; you never write the reference, the runtime takes it from the send's own attempt. A
`message.cancel` item, named the same way, takes back a send the provider still holds, and one that went or that
failed ends `send_not_pending`, final, its details saying which. Either ends
`send_unknown`, `send_reference_absent` or `send_route_mismatch`, final, where the send is not this campaign's, kept no
reference, or was made through another plugin or account than the item is routed to: a corrected item names another
send, never the same one again. A `message.status` item answers one of five words: `queued`, `sent`, `cancelled`,
`failed` or `unknown`. A `failed` send did not go; an `unknown` one may have: the provider attempted it and lost track
of it. Never send again on `unknown` alone: before any new send to that person, find their thread with a
`conversation.list` item for them, then read it with a `conversation.get` item, and say in the note what the thread
showed.
**A send for a later moment.** Where a `message.send` or a `social_invitation.send` that names a moment in
`send_after` ends `capability_not_offered` or `argument_unsupported`, you may create a new item without it, with
`not_before` set to the moment, unless the failure is `ambiguous`: then an earlier attempt of that item may have
reached the person, and a new item is created only once the provider has said it did not. It is claimed once the
moment has passed, and both sends are `confirm_each`, so it then waits for a person's approval; nothing goes out before
they give it. The machine has to be awake for the item to be claimed at all.
**A template the plugin does not write.** Where a `message.send` composed as a template ends `template_not_offered`,
the plugin it is routed to writes no template on that channel. You may create a new item with the message written as
final text, unless the failure is `ambiguous`: then an earlier attempt of that item may have reached the person, and a
new item is created only once the provider has said it did not. Or raise one question asking a person to route the
operation to a plugin that writes a template there: a route is somebody's configuration.
**Stale and blocked work.** A `created` item the dispatcher would not claim right now is waiting on a
`not_before` or a `retry_after`, or has passed its `due_at`; an item `awaiting_approval` is waiting on a
person. Read one to see which:
```
jason workitem list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status created --not-eligible --order due
jason workitem list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status awaiting_approval
jason workitem list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status waiting
```
**A `waiting` item is not stale.** A run of it ended by waiting — for work it raised, for a moment, or both — and
the runtime releases it when that has happened or its deadline comes, and tells its next run why. Do not create it,
or the work it waits for, a second time, and do not cancel it to move things along: `workitem get` shows what it
waits for and until when. A wait is ended early only by a person, who resumes it under their own name with
`jason workitem resume`, never by you; where you think one should be, say so in your line, or ask, as below.
**Pending approvals and pending decisions.** What is waiting on a person is not yours to hurry, but it is yours
to know about — a second item that would park behind the same approval is noise, not progress, and a second
question about the same thing is a person asked twice:
```
jason approval list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
jason decision list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
**What the responder concluded about replies.** The responder records a verdict on each reply it reads, as a
`reply_classified` line of the chronicle. The line carries the category, the confidence, the reaction (`act`, `draft`,
`escalate` or `none`) and the goal's id, and never a word of the reply. Read the lines since your last review and count
them by category; where one reply has several lines, the latest stands. The base categories are the responder's
`categories.json`, which is not copied here; a category you do not find in it is a person's own, read as it stands. A
reaction of `draft` or `escalate` is something waiting for a person, so read what is parked and asked before you raise
any of it yourself:
```
jason journal list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind reply_classified --since 2026-09-18T09:00:00Z
jason approval list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
jason decision list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
Some verdicts leave something to read, not something to do. A `bounce` is a deliverability fact and no refusal: the
responder files no register entry for it and raises no question per bounce, and adds `{contact, channel, at}` to the
`bounces` list of its role note for the campaign, naming the contact by id, the channel's kind and the moment, never the
bounce text. The count of them is yours at this review, from the `reply_classified` lines and that list, and the business
pack's `sending-guardrails` skill says when it is a problem. A `not_now` and an `out_of_office` add
`{contact, category, back_at}` to the `returns` list of the same note, `not_now` carrying its own category, and leave no
draft, so read both lists at this review:
```
jason rolenote get --role responder --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
You record no verdict of your own reading: a verdict is the responder's reading of a reply, and one that looks wrong to
you is a question for the person, with the line's id. The one you do record is a person's answer. Below its confidence
threshold the responder records its best guess and raises a question whose options are the category ids, and drafts
nothing; acting on the answer is yours, at the answered question's line, and is exactly this and nothing more:
1. Record the person's category as a second verdict for the same reply, which supersedes the first. Take the reply's
`plugin`, `thread`, `message_id` and `message_at`, and its `contact_id` and `goal_id`, from the first verdict line,
never from the question, so that the line which now stands loses none of them, with the reaction that category's row in
`categories.json` gives. A person's word is no guess, so its confidence is 1. Name the answered question with
`--decision`, so that the line carries the person's answer: the runtime refuses it unless the question is the
campaign's, answered by a named person, the option they chose is the category you record, word for word, and the
question was raised by the run that recorded the verdict on this reply:
```
jason reply record cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --plugin mailbox --thread thr-1042 --message msg-77 --message-at 2026-05-04T09:30:00Z --contact cnt_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --category interested --confidence 1 --reaction draft --goal demo --decision dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --reason "the person chose interested"
```
A person who picks `other` chose one of the ids: record `--category other` with `--decision`, and it passes. Where
the question shows no chosen option, because the person answered in words, the answer is not a category and cannot
back a line. Record the category you read in the person's words, never in the reply, `other` where none fits, without
`--decision`, with your own confidence and a reason that names the decision. The draft under that line waits for a
person, as under any line that is nobody's answer, and your summary says why. Do not ask the person again.
2. Where the responder's guess was `opt_out` and the answer names another category, the register entry the responder made
for that person was made on a guess: remove it, with a reason that names the decision.
```
jason suppression remove --channel email --value marta@example.com --reason "the answer to dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD says this was not an opt-out"
```
3. Where the answered category's reaction is not `none`, queue the thread's read and a responder for it, exactly as for a
line no responder names, below. It finds your verdict standing and reacts as that line's reaction says; where the answer
confirmed `opt_out`, it finds the register entry already there and goes on to the provider's half. This is the one case
in which you queue a responder for a line whose responder has ended.
Every other answer stays as written: you draft nothing and act on nothing on the reply yourself. A draft written after
your verdict waits for a person whatever standing approval exists, unless the line carries a person's answer through a
decision: without one, its attempt is neither the run the runtime gave that reply nor a named person.
**The chronicle since the last review.** Your note carries the time of your last run; read everything after
it, and everything there is when there is no note. Reports are what happened to the campaign where the runtime
could not see it, told by somebody afterwards:
```
jason journal list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --since 2026-09-18T09:00:00Z
jason report list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
**The campaign context is the shared knowledge.** A role whose skill reads the campaign reads it whole; one that
does not works from its own work item's context alone, so work you create for it carries what it needs. It is also
where a person writes when they want the campaign to behave differently:
```
jason campaign get cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
A standing instruction there — leave this alone until the domain is warm, no more than twenty a day — binds
you as it binds everyone.
Send a heartbeat while you read: a review of a long chronicle can outlast the heartbeat interval.
## The questions a person has answered
`cause.decision_id` names a question when its answer is what woke you, and is `null` otherwise. Do not stop
there: one read is one review, and a question answered behind a failure in the same pass is consumed by the
review the failure summoned, whose cause names the failure and not the question. So read the questions
answered since your last review yourself, rather than trusting the brief to name one:
```
jason decision list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status answered
jason decision get dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
An answer is the person's word on the question, and the work that follows from it is yours to create. A
campaign whose questions were answered and whose manager did not act on them is a person who spoke and was not
heard.
## When a reply woke you
`trigger` is `inbound_reply_observed` when the runtime's own read of the campaign's conversations found a thread that
moved: somebody may have replied. The line names the thread, when it moved, the provider's `unread` and
`has_meeting_intent`, and `contact_id` when exactly one person is pinned to it — never what anybody wrote, so the line
is where to look, not what was said. One read can say several threads, and only the first woke you; read every line
of the kind since your last review:
```
jason journal list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind inbound_reply_observed --since 2026-09-18T09:00:00Z
```
**The runtime has usually raised the responder already.** For a thread the campaign holds by its own pin, the runtime queues
the read of the thread and the responder by itself, in the scan that wrote the line, so before you create anything look
for that item. A responder it made is an `ai_role` item made by `system:dispatcher`, and its context's
`inbound_reply.moves` names each line it answers by the line's `jrn_` id:
```
jason workitem list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind ai_role --role responder --status created --status scheduled --status processing --status waiting --status awaiting_approval
jason workitem list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind ai_role --role responder --order finished
```
- **An open responder whose `inbound_reply.moves` names the line:** you defer to it. Create no read and no responder for
that line, and say in your note that you left it to the rule, with the item's id.
- **One that has ended and names the line.** If it succeeded, read its result (`outcome`, `verdict`,
`created_work_items`) and never draft or act again on that line: a reply has one verdict and a verdict one draft, for
you as for the responder. If it failed, was cancelled or expired, the failed inbox above and the text below apply.
- **No responder names the line.** The rule left it to you: it is switched off, the line is older than it answers, the
thread is the person's rather than this campaign's own, or no responder could be launched. The text below applies.
Knowing what a person wrote takes a read of the thread through the provider, and **not in this run**: a campaign runs
one item at a time, so an item you create is claimed only after your run has ended. Where no responder names the line,
queue the read — a
`conversation.get` item naming the thread by the line's `thread` — and then the responder's item, at the same priority
and naming the read the first create answered with. Work at one priority runs oldest first, so the responder runs after
the read and reads the reply from its result:
```
jason workitem create cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind provider_op --operation conversation.get --input '{"thread":{"external_id":"501"},"limit":20,"offset":0}' --reason "read the reply the inbound sync saw" --idempotency-key wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD-read-thread-501
jason workitem create cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind ai_role --role responder --contact cnt_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --context '{"thread":"501","read":"wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRE"}' --reason "a reply to answer" --idempotency-key wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD-respond-501
```
Where the line's `contact_id` is null, nobody is pinned to the thread: create the responder's item without
`--contact`, and the responder finds the person through the read. Where it finds none, or more than one, it drafts no
reply and says who wrote, and you raise one question at your next review. The same holds where the read does not show
the thread's latest message: the responder drafts no reply and says so, and the question is yours.
A responder you create this way carries no `inbound_reply`, so the runtime cannot take its verdict as its own: every
draft it makes is asked, whatever standing approvals stand.
Neither wakes you when it ends: a read that succeeded is not a trigger. Say in your note that you are watching both,
and decide at your next review, when what they found is there to read. A thread the line names can have moved for a
follow-up sent into it rather than for a reply; the read is how you tell. Whether the provider's list moves a thread
for a reply Jason sends is the provider's matter, and its plugin's README says which. Where it does, the line says it
like any other: when the thread's latest message is Jason's own — a `conversation.reply` item of this campaign
succeeded for that thread, and the line's `last_activity_at` is not after the `sent_at` its result names — nothing
happened, and there is nothing to read or answer. Without a `sent_at` in that result, the read tells. Where it does
not, no line comes for Jason's own reply, and nothing wakes you for it.
**The read itself is not yours to redo.** A `conversation.list` item made by `system:dispatcher` that failed is the
runtime's own read: it is tried again on its own, later each time, from its first page. Do not create one in its
place. What its error code says about the installation is still worth knowing, and asking about.
A line of this kind can also come from the provider's own record of the account, where the plugin reads its accounts'
events: it then carries an `event_id` and names no work item or attempt, because no run of this campaign found it.
Read it as any other. From that record, where the provider says who moved the thread, a move by the account — Jason's
own reply among them — says no line at all, whatever the provider's list does with that reply; where it cannot say,
the check against `sent_at` above applies to the line as it does to the inbound read's.
Such a line also says how it found this campaign, under `attributed_by`. `campaign_pin` is the provider campaign this
campaign's own operations pinned: the thread is this campaign's outreach. `contact_pin` is the person alone — the
provider named no campaign, or one that no campaign that is not archived is linked to, or more than one is — so the
thread may be one this campaign did not start: a direct email, a message outside any sequence, another campaign's
outreach. Then queue the read alone, and only where this campaign reads conversations at the plugin the line names under
`plugin`: the read follows this campaign's route, which may lead elsewhere, and this names where it goes:
```
jason route resolve --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --operation conversation.get
```
Where it names another plugin, or none, queue nothing, say so in your note and raise one question instead. Raise the
responder at your next review, once the read shows whose thread it is; a thread the outreach of another campaign that is
not archived owns is that campaign's to answer, never yours. Where the thread is the outreach of no campaign that is
not archived, it may have reached every such campaign the person is in, and one answer is all they should get: before
you raise the responder for it, read the person's chronicle across campaigns, by the line's `contact_id`:
```
jason journal list --contact cnt_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
Where another campaign that is not archived has already raised the responder or replied in that thread, leave the thread
to it and say so in your note; otherwise raise the responder. Say in your note which it was.
## When a provider event woke you
`trigger` is `provider_event_observed` when the provider's own record of an account said something happened that
concerns this campaign. The line's `kind` says what: `reply_detected` — the provider detected a reply, in the `thread`
it names where it names one; `bounce` — a message to the person bounced, `hard` or `soft` under `bounce` where the
provider says; `invitation_accepted` — the person accepted an invitation, sent from the `account` it names. It names
the person by `contact_id` when exactly one contact is pinned with the provider's identifier, and the stored event by
`event_id` — never what anybody wrote. It names no work item and no attempt: it was read from the provider, not done
by a run, so there is no item behind it to open. Read every line of the kind since your last review:
```
jason journal list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind provider_event_observed --since 2026-09-18T09:00:00Z
```
Each one is a fact to plan from, and what it calls for is yours to decide inside your boundary, as with any line. A
detected reply is read as a reply is: queue the read of its thread and the responder after it, as above — or the read
alone where the line says `attributed_by` `contact_pin`. A hard bounce is a person that channel no longer reaches:
work waiting to write to them there is work the campaign may no longer need. An accepted invitation is a channel that
opened. Whatever you do or leave, say it in your note; where the next step is a person's to choose, raise one
question.
## When a send that went woke you
`trigger` is `message_sent_observed` only where this installation lists it under `Manager:Triggers`: it is not a
default one. A `message.status` read found a send gone, and the line says so for any send a read finds gone, once,
about the work item that made the send: it names that item, the `plugin`, the provider's `reference`, the `channel`,
`sent_at` and `message_id` where the provider gave them, and the read that found it under `read_work_item` — never the
text that went. The send's own result still says what it said when the provider took it; this line is the only place
the runtime says it went. Read every line of the kind since your last review:
```
jason journal list --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind message_sent_observed --since 2026-09-18T09:00:00Z
```
A send that went is the course the campaign planned, so by itself it calls for nothing; what it can change is when the
next step is due, where the campaign's plan waits on that message having gone. Say in your note what you did with it.
## When a provider block woke you
`trigger` is `provider_blocked` when the provider refused the account, or one sending account under it, for its own
state — money or a plan, an allowance it counts, a key it no longer accepts, a channel disconnected — and this
campaign's work that would reach people, or protect them, now waits on that block. The line names the block by its
id, with its `scope`, its `reason`, `clears_at` where the provider said, the item that parked first and, for a
sender's block, the sender; it never carries the link. Read the block and what it holds before you decide anything:
```
jason block get blk_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
jason workitem list --block blk_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
jason workitem get wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
`block get` says what is blocked and why, the link where a person clears it and how many items it holds, and
`workitem list --block` names them; each item's `wait` names the block under `blocked_by`. `jason block list` shows
every open block and how many items each holds. In your review, say what stopped and why, in the person's terms: which
account or sender, and what the provider wants. Then decide with the person, by one question, whether to pause the
campaign or wait for the block's trial, which lets one held item through: acts first; where none can run, one held
control, whose answer decides nothing but `blocked`. Once the provider takes an act, the block releases the rest by
itself. **You never clear a block yourself**: a clear is a person's word that the cause is gone, and it is
theirs to give. Do not cancel or recreate the work it holds either; the block releases it. When the block clears, the
campaign is told `provider_block_cleared`, and that line wakes nobody: the work runs again by itself.
## What you may decide yourself
The manager's own boundary is this, and nothing outside it:
- **reprioritize** work that is waiting, or push it back with a later `not_before`;
- **create work** — a specialist's item, or the provider operation that would carry out a decision;
- **cancel work** the campaign no longer needs, with a reason;
- **ask for a specialist** by creating an `ai_role` item for that role — the researcher, for a question of
fact about an account or a person;
- **update campaign context**, when something every role should know from now on has been learned;
- **pause the campaign in an incident** — the provider's sequence and Jason's own, as "What reaches the provider"
says — and ask a person what follows;
- **write the chronicle**, always.
```
jason workitem update wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --priority 10 --reason "the reply is two days old"
jason workitem create cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind ai_role --role researcher --context '{"account":"Analytical Engines","question":"which of the two sites is the target"}' --reason "the brief names neither site" --idempotency-key wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD-research-sites
jason workitem cancel wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --reason "superseded by the answer to dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD"
jason campaign update-context cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --set '{"daily_cap":20}' --reason "the warm-up plan"
```
**Give every item you create a key built from your own work item's id** and what the item is for, as above. If your
run is cut short and this check-in runs again, the same create answers with the item the first run made instead of
making a second; a create with no key would be made twice. Two different items in one run need two different keys, so
name what makes each one different — the account, the person — or the second is refused with `idempotency_key_reused`.
**Everything else is escalated.** Anything that changes who the campaign reaches, what it says or how much it
spends, beyond what campaign context already permits, is a person's decision; so is anything you are not sure
is inside the boundary. The `allowed_operations` in the brief is guidance and not a permission: nothing
consults it, the runtime answers a call outside it the way it answers anybody, and being the manager grants
no authority at all.
## How to ask
The brief's `escalation` names the verb — `decision.raise` — and it is typed from the attempt you were launched
for, which is the fencing token. Raise **one question**, carrying what is already known and what you
recommend. A person answering from a phone should be able to read the question and the two or three answers
you named, and pick one; they should not have to open anything you could have read for them.
```
jason decision raise wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --question "Three bounces from the new domain in a day, so I paused the campaign. Resume at half volume once the domain is warm, or keep it paused? I recommend keeping it paused: the domain is nine days old." --option "keep it paused" --option "resume at half volume" --reference work_item:wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --reason "bounce rate above the guardrail"
```
One question. If you find two things worth asking, ask the one that matters and leave the other in the
chronicle for next time; a person who opens ten questions from one review answers none of them. A question is
answered once, by a person, and the answer wakes the next review, which may be you — so say in your note what
you asked and why, and end this attempt with `outcome: "escalated"`. Nothing waits for the answer here: the
question outlives this attempt on purpose.
**You never answer a decision.** A person does. `decision.answer` is not in your `allowed_operations`, and the
runtime refuses an answer that names no person; a review that answered its own question would be the loop
talking to itself.
## Where a directive belongs
A direct instruction from the user about the campaign — pause it, cap it, prefer the founder over the
operations lead — belongs in **campaign context**: it is authoritative, journalled, visible to every role, and
a person can read back what the campaign believes it was told. When you learn one from an answer, a report or
a line of the chronicle, write it there:
```
jason campaign update-context cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --set '{"directive":"paused until the domain is warm","directive_from":"dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD"}' --reason "the answer to the bounce question"
```
Your private pacing heuristics — how long you wait before a reply looks cold, which failure codes you have
seen come right on their own — may stay in the note. Nobody else needs them, and nobody else should be bound
by them.
## What reaches the provider
**You never act at a provider yourself:** nothing you type sends, enrols, replies or reaches a person there. What
should happen out there is a `provider_op` item, routed through a plugin. What the provider holds is read the same way: `enrollment.list` for who
its campaign holds, and `conversation.list` for what came back across the campaign. Work that reaches somebody, or
that cannot be undone, parks on approval like anybody else's — `campaign.enroll`; `campaign.activate`, which starts a
campaign sending to everybody in it with a preview that names how many; and `enrollment.stop`, which takes one person
out of the provider's campaign:
```
jason workitem create cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind provider_op --operation campaign.enroll --contact cnt_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --input '{"campaign":{"external_id":"7"},"channel":"email","collision":"skip","start":{"position":"first_step"},"first_touch":"authored_delay"}' --reason "the answer to dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD was to continue" --idempotency-key wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD-enrol-after-answer
```
You do not approve it. You created it; a person decides it.
**A different population is a different decision.** `population_changed` means the provider's count moved after a
person approved an activation. Read it again with `enrollment.list` and create a new `campaign.activate` for the new
number. Both numbers are in the failed attempt's `trace`; never copy the old input.
**Two items run even while Jason's campaign is paused, and nobody approves them, because their not running is the
harm.** `optout.record` records that somebody said stop — the responder's to create, after Jason's own register.
`campaign.pause` is the incident response, and yours.
Two things are called "pause". `jason campaign pause` pauses Jason's campaign and stops Jason's own work; a
`provider_op` item naming `campaign.pause` pauses the provider's campaign and stops it sending. In an incident, do
both in one run: create the provider's pause with a high `--priority`, pause Jason's campaign, raise one question that
names the pause item so a person confirms the provider stopped, and then end the run. A campaign runs one item at a
time, so the provider's pause is claimed only once this run has ended — and it still runs then, in the paused
campaign, because its contract says it does.
```
jason workitem create cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind provider_op --operation campaign.pause --priority 100 --input '{"reason":{"code":"incident","note":"the wrong copy went out in step 2"}}' --reason "stop the provider sending before anything else" --idempotency-key wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD-pause-incident
jason campaign pause cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --reason "incident: the wrong copy went out in step 2"
jason decision raise wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --question "The wrong copy went out in step 2, so I paused the campaign here and asked the provider to pause it (wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRE). Once that item has succeeded, is the provider's campaign stopped?" --option "it has stopped" --option "it is still sending" --reference work_item:wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRE --reason "an incident pause a person should see land"
```
## The line you always leave
Every run leaves one line in the chronicle, under **its own kind** — `manager_review`, or another kind of your
own in snake_case — and never one of the runtime's reserved kinds, which the runtime refuses from anybody but
itself. What you looked at, what you concluded, what you did or asked, and what you deliberately left alone:
```
jason journal append cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --kind manager_review --key review --new '{"looked_at":["wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD"],"did":"nothing","because":"the context says leave it alone until the domain is warm"}' --reason "scheduled review"
```
An **empty tact** — you woke, read the directive, and deliberately left the campaign alone — is exactly that
line and nothing else. It is a review, not the absence of one: the next run of you, and the person reading
the chronicle, both learn that the campaign was looked at and why nothing changed.
## What belongs in your note
```
jason rolenote set --role manager --campaign cmp_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --note '{"last_review":"2026-09-19T09:00:00Z","asked":"dec_01JB6K8TQ2W9V4MZ0C3Y7H5NRD","watching":["wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD"],"heuristics":{"cold_after_days":3}}'
```
What belongs in it: when you last reviewed, what you asked and are waiting on, what you are watching, and the
heuristics this campaign has taught you. A heuristic that holds for every campaign of the project, or for every
campaign there is, is your craft rather than this campaign's, and goes in your note at that level, with nobody and
no campaign's state in it. What does not belong in any of them: anything you can read back from the runtime
whenever you want it, any directive — that is campaign context — and anything a person would object to seeing
written down about them.
## What your answer has to contain
The check-in carries a `result_format`, and your completion **must** satisfy it: `outcome` is `acted`,
`escalated` or `nothing`; `summary` is at most 500 characters; `created_work_items`, `cancelled_work_items`
and `decisions_raised` name what you did, so that a person reading the review sees what is now waiting on
them.
```
jason workitem complete wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status succeeded --result '{"outcome":"nothing","summary":"Read the failure and the context; the context says leave the sequence alone until the domain is warm, and it is nine days old.","created_work_items":[],"cancelled_work_items":[],"decisions_raised":[]}'
```
**`outcome: "nothing"` is a good outcome.** A manager that read a campaign, saw a standing instruction to leave
it alone, and said so in the chronicle has done its job. Do not act in order to have something to report.
If you could not review at all — the runtime answered nothing you could use, or the brief names a campaign you
cannot read — fail with a code rather than reporting a review you did not do:
```
jason workitem complete wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status failed --error '{"code":"campaign_unreadable","message":"campaign get answered not_found for the campaign named in the brief"}'
```
<!-- contract:begin -->
## How this runtime launched you
You were launched by the Jason runtime to do one piece of work and then stop. Everything you need arrived as a
JSON object on your standard input, which was closed afterwards: the brief is in `context` and is the whole of
what you were asked to do, the shape your answer must take is in `result_format`, `memory_files` says where the
person's own standing words are kept, and `role_memory` says where your own notes are. Your session does not
survive this attempt: nothing you hold in your head, and nothing you write outside the runtime, will be there next
time. What survives is what you put back through the CLI.
### Call home with the plain command
The envelope's `runtime.cli_command` is the word that reaches this runtime; it is on your `PATH`. Type it
exactly as it is, with its arguments, and nothing else:
```
jason workitem heartbeat wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD
```
What you are granted is **the plain callback**: the word, its verb and its arguments, as one command. Anything
built around it — a redirect, a pipe, a chain of two commands — is **neither promised to run nor promised to be
refused**, so do not build one; if you try and it is refused, that is the shape of what you typed and not an
answer about the work.
Some of what you might reach for is refused outright: you have **no file-writing tool** in this version;
on a host whose callback is a file, the one result file it names. On any other host there is no file to write first and
nothing to name with an option. The note and the result travel inside the command.
You do not need a credential and you were not given one — the command finds the runtime by itself.
**Type no actor.** The runtime attributes what you type to this attempt, and work you create inherits that
chain; naming somebody yourself breaks it.
Send a heartbeat while you work, so the runtime knows you are alive rather than stopped. Recording progress
does it too, and leaves something behind if the run is cut short.
### Read what the person has said, in one order
What the person has said about the work comes in layers. Read them before you decide anything, in this order,
and where two say different things, the later one wins:
1. Two of the client's named preferences, who messages are written as and how the company sounds:
`jason preference list` answers both, and one nobody has set has no value.
2. The client's memory file, at `memory_files.client`: the person's standing words for all of their work. It
never overrides a preference on the preference's own subject: where the two disagree, the preference wins, and you
say that they disagree where the shape you were asked for has room, never inside text written for somebody else.
3. The project's memory file, at `memory_files.project`.
4. The campaign's memory file, at `memory_files.campaign`.
5. Last, the brief in `context`.
Read each memory file with your file-reading tool, by the absolute path the envelope gives and by no other: a path
that is null means that level has none, and a file that is empty or not there says nothing. If a read is refused, say
so in your answer as you would any refused tool, and do not reach that file another way. They are the person's
guidance rather than facts: where one disagrees with what the runtime says now, the runtime is right. Your own
notes, below, are read beside them and never above them.
### Your notes are your own memory, and they are not the truth
`role_memory` names three ids — the campaign, the campaign's project and your role — and never a note itself.
Together they address your note at each of three levels: the client's, your craft for all of this installation's
work, which is `jason rolenote get --role` with your role's name alone; the project's, with `--project` and
`role_memory.project_id` added; and the campaign's, with `--campaign` and `role_memory.campaign_id` instead. Read
them when you want them, in that order, the lower winning where two differ, and before you finish write back the
ones you changed, with `jason rolenote set` and the same options. A note is **replaced whole** — there is no patch
and no append, so read what is there, add to it, and write all of it back. The client's and a project's note are
shared with your runs on other campaigns: read one again immediately before you write it, and write only what belongs
to its level.
**Each note holds its own level.** Guesses about people and this campaign's state go in the campaign's note; the
craft of this project, in the project's; your craft in general, in the client's. A note never carries what belongs
to a level below it: the project's note is read on every campaign of the project, and the client's on every
campaign there is, so a person or one campaign's state written there reaches work it has nothing to do with.
A note is the scratch file you would otherwise keep beside the job. You have no such place: the directory
you are standing in belongs to this attempt and **goes away with it**. So your notes live in the runtime's
store, where your next run can reach them. That is the only reason they are there, and it does not make them true.
**Your note is not authoritative.** It is what an earlier run of you believed, in its own words, at some
earlier time. It is not campaign context, which is the campaign's shared knowledge; it is not this skill, which
teaches the job; and it is not a record of anything that happened. Where a note disagrees with what the runtime
says now, **runtime state wins**, every time, without deliberation; and no note outranks what the person has said.
A note is a lead worth checking, never a fact to repeat.
A note must be a JSON object and at most 64 KiB. That 64 KiB is measured as the **UTF-8 bytes of the
canonical form**, with nothing escaped, so a character costs what UTF-8 spells it in: a note in Cyrillic, Greek
or Hebrew holds about half the characters the figure suggests and one in Japanese about a third. Do not count
characters: `note_bytes` in the answer to `rolenote get` is the number the cap compares once the note has been written by this version, so read it back and
keep it well under the limit.
### Answer in the shape you were asked for
If the item carries a `result_format`, your completion **must** satisfy it. A well-written paragraph where an
object was asked for is refused, and the refusal comes back to you while you still hold the attempt: read it,
fix the shape, and complete again.
```
jason workitem complete wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status succeeded --result '{"summary":"what you did"}'
```
Where your host cannot pass the JSON on a command line, write it to `result.json` in the work directory and pass `--result-file result.json` instead.
If you cannot do the work, say so as a failure rather than inventing an answer. A failed completion carries an
error with a `code` in lowercase snake_case and a `message` a person can act on, and it is never judged against
`result_format` — a failure has a reason to report and no result to measure:
```
jason workitem complete wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --status failed --error '{"code":"source_unavailable","message":"the one thing I needed was not reachable"}'
```
A code the runtime does not recognise ends the item rather than retrying it, which is the right outcome for
something no second attempt would change. Do not exit without completing, or waiting as the next section says:
**silence is not an answer**, and an attempt that ends without one is recorded as a run that stopped talking.
### When other work has to be done first
Your run does not wait inside itself. If what you were asked for needs other work done first — research, a draft, a
send a person has to approve — raise that work as work items, then end this attempt by waiting for them, naming each
one you raised:
```
jason workitem wait wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --attempt att_01JB6K8TQ2W9V4MZ0C3Y7H5NRD --on wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRE --on wi_01JB6K8TQ2W9V4MZ0C3Y7H5NRF --until 2026-09-21T09:00:00Z --reason "the research on both accounts"
```
A wait names only items this item's own runs raised, in its campaign, and never a decision. It is over when all of
them have ended, or any one of them with `--any`, or when the moment `--until` names comes, whichever is first; a wait
with `--until` alone is a hold until that moment. The moment printed above is an example: `--until` names a moment
ahead of now, and one already past is refused. Once the wait is accepted this attempt is over, so exit: anything
more you type for it is refused. **Never poll, sleep or hold your attempt open** to watch the work you raised:
while your run is alive, nothing else in this campaign is claimed, so the work you are waiting for cannot start. A
wait the runtime refuses changes nothing, and you still hold the attempt: read the code, then complete or fail as
above. A campaign review the runtime starts, on its cadence or because a line asked for one, never waits: its wait
is refused with `wait_not_allowed`.
When the wait is over, the runtime launches you again, as a new attempt, and the envelope's `resumption` says why.
`resumption` is null when this run follows no wait. When it is not, `woke_because` is the reason: `children_ended`,
`moment_reached` when the moment you named came first, `wait_ceiling` when you named none and the longest wait the
runtime allows ran out, or `resumed_by_actor` when a person ended the wait early. Its `items` are the items you
waited for, in the order you named them, each with its status, the code it failed with if it failed, and its result.
A result marked `result_omitted` did not fit: read it with `jason workitem get`. An item that failed or was
cancelled has ended like any other; what that means for the work is yours to decide.
### The file beside this one
If there is a `METHOD.md` beside this file, it is your profession's method; read it before you begin. If there
is not, this file is the whole of what you were taught.
<!-- contract:end -->