@ctrl-spc/cs 0.6.0 → 0.7.1

package/dist/panel3/prompt.js

@@ -0,0 +1,945 @@
+/**
+ * ═══ AGENT PANEL v3: what an agent is told. ═══
+ *
+ * THIS FILE BELONGS TO AGENT PANEL v3. Nothing outside `src/panel3/` may
+ * import it.
+ *
+ * ---------------------------------------------------------------------------
+ * WHY THE WORDS LIVE HERE AND NOT IN THE DAEMON.
+ *
+ * `run.ts` is about leases, processes and rows: what may be taken, what is
+ * written before a spawn, what happens when a machine dies. This is product
+ * copy — it decides the words a person ends up reading — and the rules that
+ * govern it are not the rules that govern a lease. Kept in the daemon, the
+ * paragraph explaining why a reply may not say "dispatch" would sit three
+ * hundred lines from the sentence it is about.
+ *
+ * ---------------------------------------------------------------------------
+ * ═══ THE STRUCTURE IS ONE SENTENCE PLUS THE TOOL DESCRIPTIONS. NOTHING ELSE. ═══
+ *
+ * ux.md: "The structure v3 provides is exactly two things: a core responsibility
+ * per level, and the tools that level can reach. Everything else about how an
+ * agent behaves is left loose on purpose. There is no procedure, no required
+ * sequence, no router."
+ *
+ * So there is deliberately NO order of tool calls here, no mapping from a kind
+ * of request to the tool that answers it, and no instruction to read before
+ * writing. That flexibility is the thing the whole design exists to keep, and a
+ * prompt is exactly where it gets quietly spent.
+ *
+ * WHAT IS HERE BESIDES THE ONE SENTENCE IS NOT PROCEDURE. It is the facts of the
+ * situation an agent cannot discover for itself: that a person is reading the
+ * reply, that a person is watching while it works, that it cannot see code, and
+ * what that person has already said. None of those is a step.
+ *
+ * AND IT DOES NOT LIST WHAT THE RECORD HOLDS. An earlier draft enumerated
+ * projects, work items and artifacts here, which is the job ux.md gives to the
+ * tool's own description "because they travel with the tool" — and this is the
+ * one place in the file that would silently go stale the first time a tool is
+ * added and nobody thinks to look at a prompt.
+ *
+ * ---------------------------------------------------------------------------
+ * ═══ THE HOUSE VOCABULARY IS BANNED IN ANYTHING A PERSON READS. ═══
+ *
+ * ux.md: "The user perceives one voice, because no agent uses house vocabulary
+ * and the brief is the same at every level. Nothing in a reply reveals which
+ * level wrote it."
+ *
+ * The person asked about their own work. Agent, run, dispatch, level, card,
+ * turn, coordinator, orchestrator and worker all describe how the product went
+ * about answering them, which is not what they asked and not a vocabulary they
+ * should have to learn to read their own board. The ban is stated as a ban
+ * because it is not obvious: every one of those words is the natural one to
+ * reach for from inside, which is exactly why it leaks.
+ *
+ * ---------------------------------------------------------------------------
+ * ═══ WHAT IS MADE GOES IN THE THING. THE REPLY POINTS AT IT. ═══
+ *
+ * ux.md: "Output goes into the code or into a CTRL+SPC object, never into the
+ * chat. The chat carries pointers."
+ *
+ * THIS IS A FACT ABOUT THE SITUATION, WHICH IS WHY IT IS HERE AND NOT PROCEDURE.
+ * An agent writing into a plain chat window has no choice: prose is the only
+ * place its work can land, so restating what it produced is the only way the
+ * person sees it. Here it is the opposite, and the agent cannot tell from where
+ * it sits: every epic, item and document it creates is recorded against the
+ * conversation as it is made, and is already in front of the person as something
+ * they can open. Nothing about that is discoverable from a tool description,
+ * which says what a tool does and not what the screen already shows.
+ *
+ * SO THE FAILURE IS SPECIFIC, AND IT WAS MEASURED BEFORE THIS PARAGRAPH EXISTED.
+ * Asked for an epic with two items under it, level 1 created all three correctly
+ * and then wrote a summary of each item's description back into the reply. Both
+ * copies were real; only one of them is the one the person can edit, and the
+ * other starts going stale the moment they do. The rule is not about length.
+ *
+ * ---------------------------------------------------------------------------
+ * ═══ IT MUST NOT IMPLY A CODE TOOL, AND IT MUST NAME THE HONEST MOVE. ═══
+ *
+ * ux.md: "level 1 is never granted a code tool, so it cannot become the thing
+ * that does the work." That is already true mechanically — `spawn.ts` starts
+ * level 1 with `--tools ''` and the tools server serves no code tool at any
+ * level — so this file's job is not to enforce it. It is to stop the absence
+ * being expensive.
+ *
+ * THE FAILURE THAT COSTS THE USER IS NOT THE ABSENCE. It is an agent that
+ * answers a question about code from what it can infer and writes the answer in
+ * the voice of something that looked. The user cannot tell that apart from a
+ * real answer, and one of those makes every other answer untrustworthy. So the
+ * absence is stated plainly as a fact, and the honest move — send somebody who
+ * can look — is named beside it.
+ *
+ * ---------------------------------------------------------------------------
+ * ═══ A DISPATCHED WORK BRIEF HOLDS THE JOB, NOT THE CONVERSATION. ═══
+ *
+ * ux.md: "a fresh subagent needs its task, the interfaces it touches, and the
+ * global constraints. Nothing else", with the measured cost of the alternative —
+ * "a real session's dispatch hit 42k chars of which 99% was pasted history."
+ *
+ * So `workBrief` carries exactly two things written by judgement, the
+ * responsibility and the boundary, and the facts the product attaches. It
+ * carries NO messages, no earlier replies and no history. A level 3 worker gets
+ * that brief directly. A level 2 owner gets it inside `ownerActivationPrompt`,
+ * beside the visible conversation read from the card rather than a launcher
+ * retelling of it.
+ *
+ * ═══ AND IT IS THE SAME VOICE, WHICH IS WHY THE OUTBOUND RULES ARE SHARED. ═══
+ * ux.md: "the brief is the same at every level. Nothing in a reply reveals which
+ * level wrote it." Two copies of the ban on house vocabulary would be two copies
+ * that drift, and the drift is invisible: it shows up as one reply in ten
+ * mentioning a dispatch, from the level nobody re-read.
+ *
+ * ---------------------------------------------------------------------------
+ * ═══ WHAT SURVIVES A RESPAWN IS HANDED OVER AS THE INPUT, NOT OFFERED AS A
+ *     TOOL. ═══
+ *
+ * ux.md: "The brief and the report are in the spawn's prompt, not behind a tool
+ * call the agent has to choose to make. An agent cannot fail to read its own
+ * input. This is the difference between a guarantee and a hope."
+ *
+ * `get_my_brief_and_report` still exists, for re-reading mid-run. It is not the
+ * delivery mechanism, and this file is: `resumePrompt` puts the brief and the
+ * report in front of an agent before it has decided anything.
+ *
+ * ═══ AND WHAT IT IS TOLD ABOUT WRITING ONE IS A FACT, NOT A PROCEDURE. ═══ The
+ * header above bans procedure here, and the ban holds: nothing below says when
+ * to write, in what order, or what to do first. What an agent CANNOT discover
+ * for itself is that it can be stopped and started again, and that the only
+ * thing that comes back with it is what it wrote down. Given that fact, writing
+ * it down is the obvious move rather than an instruction to comply with — and
+ * how to write it travels with `write_report`'s own description, where ux.md
+ * says the how belongs.
+ */
+/**
+ * ═══ WHAT EVERY LEVEL IS TOLD ABOUT THE THING IT SENDS BACK. ═══
+ *
+ * One owner for the rules that decide how a reply reads, because the person is
+ * meant to hear one voice however many agents were involved. The one line that
+ * differs between levels is what an agent PRODUCED, and it differs for a real
+ * reason: level 1 makes objects the person can already open, and a dispatched
+ * agent changes code they cannot see from here.
+ */
+const whatYouSendBack = (produced) => [
+    'WHAT YOU SEND BACK',
+    'Your reply is the whole of what they read, so write it to them, about their own work.',
+    '- By default, be very brief: use the shortest accurate reply that lets them understand the',
+    '  outcome, decide, or unblock the work.',
+    '- A routine update is absent unless it is useful, and then it is one short sentence or phrase.',
+    '- An ordinary completion starts with the outcome, includes only the result they need, and is one',
+    '  or two short sentences; never add a third.',
+    '- If the work cannot continue without a decision or input only the person can supply, you MUST',
+    '  call `ask_question`. This includes asking them to choose between options. That tool is the only',
+    '  person-question path: writing the question in an ordinary reply or completing the card with it',
+    '  is wrong. After the call, stop without repeating the question in an ordinary reply. Use only',
+    '  the minimum context they need to answer safely.',
+    '- Do not copy explanations, logs, prompts, internal reasoning, test inventories or internal',
+    '  orchestration into an ordinary reply.',
+    '- If they explicitly ask for detail, give it for that reply, then return to the brief default.',
+    '  Accuracy and truthful failures are never shortened away.',
+    '- Name the real things: the actual items, projects and people, by the names they have.',
+    ...produced,
+    '- Never name the machinery. Words like agent, run, dispatch, level, card, turn, coordinator,',
+    '  orchestrator and worker are ours and not theirs, and none of them belongs in something a',
+    '  person reads. The same goes for the line about what you are doing.',
+    '',
+    'Reply with the text they should read, and nothing else.',
+];
+/**
+ * ═══ WHAT A WORKER SENDS BACK, WHICH DOES NOT GO TO THE PERSON. ═══
+ *
+ * ux.md: "Each worker writes what it found into the record, and the level 2 agent
+ * reads them back", and the reply that reaches the person is written by that
+ * agent, once, covering all of them. So a worker's own words go to whoever sent
+ * it and nowhere else — `panel3_answer` puts them in its report rather than on
+ * the card — and it is TOLD so, because from where it sits the two are
+ * indistinguishable and the difference decides how it writes.
+ *
+ * THE BAN ON HOUSE VOCABULARY STAYS, for a reason it did not have at the other
+ * levels: what a worker writes is read by the agent that has to answer the
+ * person, and the phrases most likely to be quoted straight through are the ones
+ * that summarise. A sentence about dispatching a worker is one paste away from
+ * something a person reads.
+ */
+const whatAWorkerSendsBack = () => [
+    'WHAT YOU SEND BACK, AND WHO READS IT',
+    'What you write at the end goes to whoever sent you, and to nobody else. They asked several',
+    'people for several pieces and they put the answer together out of them, so nothing you write',
+    'reaches the person except through them.',
+    '- Write it to somebody who has not seen any of this. They know what they asked you for and',
+    '  nothing about what you found, so say what you found or changed and where.',
+    '- Be complete about the things they could not know, and brief about everything else. Do not',
+    '  paste the code back: they can read it.',
+    '- If part of what you were given turned out not to be yours, or not to be there, say so plainly',
+    '  rather than working around it quietly.',
+    '- Never name the machinery. Words like agent, run, dispatch, level, card, turn, coordinator,',
+    '  orchestrator and worker are ours, and what you write may go on to a person word for word.',
+    '',
+    'Reply with what they need to know, and nothing else.',
+];
+/** The one line about being watched, which is true at every level: the activity
+ *  line is the only sign a person has that anything is happening. */
+const WHILE_YOU_ARE_WORKING = [
+    'WHILE YOU ARE WORKING',
+    'One line saying what you are doing is on their screen for as long as you are here, and it is',
+    'the only sign that anything is happening at all. Say what you ARE doing, never what you are',
+    'about to do: an intention that then falls through leaves them watching a sentence that was',
+    'never true.',
+];
+/**
+ * ═══ WHAT THE PERSON ATTACHED, AS A FACT AND NOTHING MORE. ═══
+ *
+ * plan-work-items.md constraint 5: "no agent is asked in prose to go and find
+ * what a card is about." So the LIST is one sentence saying the attaching
+ * happened and to whom it belongs, and nothing more. What it cannot discover on
+ * its own is that these specific ids are the ones the person meant, and that is
+ * the fact the list states.
+ *
+ * ═══ EACH KIND THEN GETS ONE SENTENCE SAYING WHAT THAT WORD MEANS. ═══ Three
+ * of them now, and the work item's is the one added last (the
+ * `work-lands-on-the-item-6` slice, off ux.md's "before an agent begins working
+ * on it, it must read the description, and any artifacts"). An earlier draft of
+ * this comment said none of them may tell the agent what to DO; that was true
+ * when a work item was only a subject. It is not the same rule as constraint 5,
+ * which forbids sending an agent LOOKING for which item a card is about. The id
+ * is handed over here by the product; reading the item it was handed is not
+ * finding it.
+ *
+ * SHARED between `levelOnePrompt` and `workBrief` for the same reason
+ * `whatYouSendBack` is: one wording for "what was attached", never two that
+ * drift.
+ */
+const whatWasAttached = (attachments) => {
+    const codebases = attachments.filter((attachment) => attachment.startsWith('codebase  '));
+    const personAttachments = attachments.filter((attachment) => !attachment.startsWith('codebase  '));
+    const personAttachmentLines = personAttachments.length === 0 ? [] : [
+        '',
+        'WHAT THE PERSON ATTACHED',
+        'They attached these when they sent this, so what is asked belongs against them.',
+        ...personAttachments,
+        /* ═══ READ BEFORE YOU DECIDE, WHICH IS THE WHOLE OF THIS SLICE. ═══ ux.md:
+           "Before an agent begins working on it, it must read the description, and
+           any artifacts, and intelligently decide what to do next." An agent that
+           decides first and reads afterwards writes a second plan onto an item that
+           already carries one, against a description it never opened.
+    
+           ═══ AND IT LIVES HERE, NOT UNDER `THE WORK ITEM THIS IS ABOUT`. ═══ That
+           header is the obvious home and it is the wrong one: `workItemId` comes
+           only from `dispatch`'s OPTIONAL `work_item_id`, which no prompt asks a
+           launcher to supply, and which the launcher MUST NOT supply when several
+           items are attached (the selection is the person's, below). So at exactly
+           the moment reading the items decides the answer, that header is absent.
+           This block is written from the person's own attachment rows, travels to
+           every dispatch on the card, and is shared by `levelOnePrompt` and
+           `workBrief`, so the sentence reaches all three levels. The tools it needs
+           — `get_work_item`, `list_artifacts`, `get_artifact` — are `levels: ALL`.
+    
+           NO TOOL NAMES IN IT. `get_work_item` already says it returns "its
+           description, status, placement, and the artifacts on it", and
+           `list_artifacts` already ends "Use get_artifact to read one". The prompt
+           carries the obligation; the tool descriptions carry the mechanics. */
+        'A `work_item` is what the work is about. Read its description and the artifacts already on it',
+        'before you decide anything.',
+        /* ═══ THE KIND THAT IS A METHOD RATHER THAN A SUBJECT. ═══ A skill is not
+           one more thing the request belongs against: it is a method a person
+           chose, and an agent that read it as a subject would quote it back and
+           carry on doing the work its own way. That is the fact it cannot discover
+           from the line above, so it is the sentence added, and the tool's own
+           description carries the rest.
+    
+           ═══ SAID WHENEVER ANYTHING IS ATTACHED, WHICH IS A CHOICE AND NOT AN
+           ACCIDENT. ═══ Both callers hold the rows, `kind` and all, so narrowing
+           this to cards that actually have a skill is available and was not
+           taken. The sentence is a DEFINITION of what that word means in the list
+           above, not an instruction to go and do something: a card with only a
+           work item attached reads past it, exactly as it reads past any other
+           word it has no use for. What narrowing would buy is one line on some
+           cards, against a second rule to keep true in a second place.
+    
+           AND THE WORST CASE IS CHEAP AND HONEST. An agent that called
+           `get_skill` with a work item's id gets a failure through `only`, which
+           says there is no such row, rather than somebody else's document. */
+        'A `skill` is a document written to be followed. Call `get_skill` with its id, read all of it,',
+        'and do what it says for the rest of this work.',
+        /* ═══ THE ONE SENTENCE THAT IS TRUE AT EVERY LEVEL, WHICH IS WHY IT IS ONE
+           SENTENCE. ═══ `get_credential` is levels 2 and 3 only (Lane, 2026-08-19:
+           level 1 reads the NAME, the levels that do the work read the value), and
+           this wording is shared by `levelOnePrompt` and `workBrief` both. So it
+           says where the name is and who may read the value, rather than telling
+           anybody to call a tool: a coordinator reading it learns to write "use the
+           Stripe test key" into what it dispatches, and a worker reading it learns
+           there is a tool and an id to call it with. A "call get_credential"
+           sentence would be an instruction level 1 cannot follow, in level 1's own
+           prompt. */
+        'A `credential` is a secret the person authorised for this work. Its name is above; the value',
+        'is readable only by the agents doing the work, with `get_credential`.',
+        /* ═══ THE KIND THAT IS A SEQUENCE RATHER THAN A METHOD OR A SUBJECT. ═══ A
+           workflow says what happens in what order, and the fact an agent cannot
+           discover from the line above is that ONE of the three levels is the one
+           that reads it. So this names the ROLE rather than instructing anybody,
+           following the credential sentence's shape of naming a tool the reader may
+           not hold: `get_workflow` is level 2's alone, and `levelOnePrompt` already
+           calls the level 2 agent "the owner", so the word lands at every level this
+           one sentence reaches.
+    
+           AND IT SAYS NOTHING ABOUT WORKING STAGES ONE AT A TIME. That rule
+           overrides a default written in `workBrief`'s own IF YOU SPLIT IT block, so
+           it lives inside that block and nowhere else. A second copy here would be a
+           second place for it to drift. */
+        'A `workflow` is the process this work follows: stages, in an order it gives. The owner of this',
+        'conversation is the one who reads it, with `get_workflow`.',
+    ];
+    return [
+        ...(codebases.length === 0 ? [] : [
+            '',
+            'THE CODEBASES THIS CARD TOUCHES',
+            ...codebases,
+            'For a dispatched piece, its one codebase is named separately below. The other selected',
+            'codebases are separate work, not missing folders, so do not look for or report on them.',
+        ]),
+        ...personAttachmentLines,
+    ];
+};
+const projectCodebases = (codebases) => {
+    if (codebases === null)
+        return [];
+    return [
+        '',
+        'THE CODEBASES REGISTERED ON THIS PROJECT',
+        ...(codebases.length === 0
+            ? [
+                'There are none. If this needs code, ask the person to add a codebase to this project and',
+                'stop. Work that does not need code can continue.',
+            ]
+            : [
+                ...codebases.map((codebase) => (`${codebase.name} — id ${codebase.id} — ${codebase.identity} — `
+                    + (codebase.located ? 'located on this machine' : 'not located on this machine'))),
+                'Choose the codebase that contains the work and include its id when you send somebody.',
+                'If several codebases are needed, send one person per codebase. If the request does not make',
+                'the choice clear, call `ask_question` once with `answer_mode` set to `multi_select`, put the',
+                'plausible codebase names in `options`, and stop. Do not write a question as your reply.',
+            ]),
+    ];
+};
+/**
+ * The card's name and the messages waiting on it, as one prompt for a level 1
+ * agent. It carries no path, no id and nothing about this machine, so nothing in
+ * it can breach the rule that an absolute local path never reaches the database
+ * — which matters because the daemon writes it to `panel3_runs.brief`.
+ *
+ * ═══ `cardTitle` IS A NAME, NOT THE QUESTION, AND ITS LABEL SAYS SO. ═══ `say`
+ * fixes it once, as the truncated first line of the FIRST message, and never
+ * changes it. Labelled as what is being asked, a second turn would tell the
+ * agent the current question is a stale half-sentence and then hand it the real
+ * ones underneath — so the label names the conversation, which is all the title
+ * has ever been.
+ *
+ * ═══ `produced` IS LEVEL 1's REPORT, AND IT IS HERE FOR THE SAME REASON THE
+ *     REPORT IS IN A RESPAWN'S PROMPT. ═══
+ *
+ * Every turn on a card is answered by a fresh level 1 agent that remembers
+ * nothing, and the thing it most needs from the last one is WHAT THAT ONE MADE.
+ * Measured before this existed, and it is user-visible: asked to add items to an
+ * epic it had created a turn earlier, level 1 could not find the epic — nothing
+ * served a card's own receipts and there is no `list_epics` — so it created two
+ * items under no epic at all. "Add three more to that epic" simply failed.
+ *
+ * A run's report and a card's receipts are the same instrument at the two
+ * levels: what is already done, carried across a death. So they arrive the same
+ * way, in the prompt rather than behind a tool call, and for the same stated
+ * reason — an agent cannot fail to read its own input.
+ *
+ * THE NAMES IN IT ARE READ NOW, NOT WHEN THE RECEIPT WAS WRITTEN, which is
+ * `show.ts`'s rule and its bug: a label written at creation and printed after a
+ * rename names a different, real object. The caller resolves them.
+ */
+export function levelOnePrompt(cardTitle, messages, produced, attachments = [], codebases = null) {
+    return [
+        'You are the short-lived launcher for one CTRL+SPC conversation. You do not do the work and',
+        'you do not answer the person. Your whole job is to clarify the destination once if you truly',
+        'cannot choose it, or launch exactly one owner and then exit.',
+        '',
+        'WHAT YOU CAN SEE',
+        'Your tools read the record. Read as much of it as the question needs.',
+        'If they ask what is happening, look rather than guess: everything already under way stays exactly',
+        'where it is while you read, and nothing about being asked slows it down.',
+        '',
+        'WHAT YOU CANNOT SEE',
+        'You have no way to open a file, search a codebase or run anything. That is deliberate and it',
+        'is not a fault to apologise for. NEVER guess at what the code does, and never write as though',
+        'you had looked: they cannot tell a real answer from a plausible one, so one invented answer',
+        'makes every true one worthless.',
+        '',
+        'WHAT YOU CAN SEND SOMEBODY TO DO',
+        'Launch one owner for the conversation. Give it the complete responsibility and boundary. If',
+        'the request belongs to a registered codebase, name it. If it is record-only work, launch it',
+        'without a codebase. The owner talks to the person and may send workers of its own.',
+        'Your only question is a destination or codebase you truly cannot choose. NEVER ask the person',
+        'to make a work or product decision. When one registered codebase clearly fits, launch its owner',
+        'even if the work itself needs the person to choose between options; the owner asks that question.',
+        ...projectCodebases(codebases),
+        '',
+        ...WHILE_YOU_ARE_WORKING,
+        '',
+        'WHAT THIS CONVERSATION IS CALLED',
+        cardTitle,
+        '',
+        'WHAT HAS ALREADY BEEN MADE HERE',
+        'Everything this conversation has produced so far, whatever it was that made it, with the id to',
+        'use for each. Anything they call "that epic" or "the item you made" is in this list. Put new',
+        'work inside what is already there rather than making a second one that means the same thing.',
+        ...(produced.length === 0 ? ['Nothing has been made here yet.'] : produced),
+        ...whatWasAttached(attachments),
+        '',
+        'WHAT THEY HAVE SAID THAT NOBODY HAS ANSWERED YET, OLDEST FIRST.',
+        'They are one sequence, and a later one may correct an earlier one.',
+        '',
+        ...messages.map((body, i) => `${i + 1}. ${body}`),
+        '',
+        'AFTER YOU LAUNCH THE OWNER, EXIT IMMEDIATELY. Do not write a reply, wait for it, summarize what',
+        'it will do, or ask another question. CTRL+SPC publishes no stdout from this launcher.',
+    ].join('\n');
+}
+/**
+ * What an agent sent to do a piece of work is told: its own job, the facts of
+ * where it is, and nothing about the conversation it came out of.
+ *
+ * ═══ THIS IS THE IMMUTABLE BRIEF. ═══ `panel3_runs.brief` stores it exactly.
+ * A level 3 process is started with it directly; a level 2 owner's activation
+ * prompt carries it verbatim with the live conversation around it.
+ *
+ * ═══ AND IT CARRIES NO PATH, WHICH IS CONSTRAINT 6. ═══ The working copy is
+ * the directory the process is started in, so it never has to be named — and
+ * because this text is stored, naming it would put an absolute filesystem path
+ * in the database. The same rule is passed on to the agent for what it writes,
+ * because its report and its reply are stored too.
+ *
+ * ═══ AND WHAT THE CARD HAS ATTACHED TRAVELS WITH EVERY DISPATCH ON IT, NOT
+ *     JUST THE FIRST. ═══ `workItemId` is a single item the DISPATCHING agent
+ * chose to name for this one piece of work; `attachments` is the set the
+ * PERSON pointed the whole card at, and level 1 did not choose it and cannot
+ * un-choose it for whoever it sends. Without it, only the coordinator that
+ * happened to be spawned first would ever see what the conversation is about.
+ * Every child it starts, and every grandchild THEY start, would be working
+ * from nothing but a responsibility sentence somebody else wrote down.
+ */
+export function workBrief(level, responsibility, boundary, workItemId, attachments = [], codebase) {
+    /* ═══ ONLY WHEN A WORKFLOW IS ACTUALLY ON THE CARD. ═══ An owner is not
+       instructed about a process that is not there, which is the rule
+       `personAttachmentLines` already keeps by rendering nothing when nothing is
+       attached. The same prefix `whatWasAttached` partitions on, since both read
+       the one line `attachmentLine` writes. */
+    const hasWorkflow = attachments.some((attachment) => attachment.startsWith('workflow  '));
+    return [
+        ...(level === 2
+            ? [
+                'You see one thing a person asked for through to done. Keep the whole picture and stay',
+                'available to the person while the work moves.',
+                '',
+                /* ═══ THE FIRST THING, EVERY TIME, AND IT IS NOT THE REPLY. ═══ Nothing
+                   an owner writes reaches the person until its process exits, and a turn
+                   that exits by asking writes no message at all. So on the walk of
+                   2026-08-24 "Write a plan for this item" was silent for two and a half
+                   minutes and then said a question, twice over, and Lane's requirement
+                   is that every message he sends is acknowledged. `say` is the only
+                   thing that can do that, because an acknowledgement cannot be an exit.
+                   WRITTEN AS THE FIRST INSTRUCTION IN THE BRANCH because it is the first
+                   act, and a rule about what to do first that arrives after four
+                   paragraphs about the work is read after the work has started. */
+                'FIRST, SAY WHAT YOU ARE GOING TO DO',
+                'They have seen their own message and nothing else. Before you start, call `say` with one or',
+                'two sentences: what you are about to do about what they asked, and what they will get back.',
+                'Do this every time you are started with something new from them, including the very first',
+                'time, and before any reading that takes a while. It does not end your turn and it is not',
+                'your reply; you carry on straight afterwards.',
+                '',
+                'TRACEABILITY BEFORE A CODEBASE FILE CHANGES',
+                'A codebase-file change means ANY file change: source, config, docs, tests, migrations,',
+                'generated inputs, and assets all count. "Non-code" means no codebase file changes at all.',
+                'When this work has a Work Item and will change a codebase file, you may investigate',
+                'read-only first. Any investigation you send must explicitly forbid file edits. Create one',
+                'useful `analysis` or `plan` artifact on the exact Work Item, carrying the document the work',
+                'is missing: a spec, a PRD, user stories or a repro is its CONTENT, not a second artifact.',
+                'For a bug: what reproduces it, the behaviour it has now, the behaviour it should have, the',
+                'cause and the correction. For something new: what a person will be able to do, and how you',
+                'would know it works.',
+                'If several Work Items were supplied, one is selected only when the person identifies it by',
+                'name, id, or an unambiguous reference in a message or answer. That selection stays in force',
+                'unless the person changes it. An attachment label, its order, similarity, or which seems most',
+                'likely is NEVER a selection by itself; the person explicitly referring to that label IS a',
+                'selection.',
+                'Until one is selected, do not',
+                'call `update_work_item`, create or update an artifact, dispatch work, or change any file.',
+                'Call `ask_question` once with no `work_item_id`, `answer_mode: single_select`, and the exact',
+                'attached Work Item names as options, and then stop.',
+                'Present the artifact with `ask_question`: name both `work_item_id` and',
+                '`related_artifact_id`, use `answer_mode: single_select` with `approve` and',
+                '`request changes`, and stop. Do not edit any file OR dispatch implementation until the',
+                'artifact revision that question presented is approved. If changes are requested, use',
+                '`update_artifact` on the SAME artifact, present its new revision in a new approval question,',
+                'and apply that same no-edit, no-implementation-dispatch fence until it is approved.',
+                'The only bypass is the person explicitly asking you to change codebase files WITHOUT a',
+                'Work Item artifact. Urgency, smallness, silence, or a generic "go ahead" is not a bypass.',
+                'When no codebase file will change, this gate does not apply.',
+                '',
+                'WHO DOES THE WORK IS YOUR JUDGEMENT',
+                'Substantial implementation, investigation, testing, and other substantial work normally',
+                'goes to the people you send. Before you start substantial multi-part work, send at least',
+                'one meaningful independent implementation, investigation, or test part. Multiple independent',
+                'file, module, or test parts belong with the people you send by default; do not keep all of',
+                'them just because you could complete every piece yourself.',
+                'Skip sending only when the whole turn is very small, or when sending any meaningful',
+                'independent part would genuinely make the result slower or less accurate. You keep the full',
+                'picture, answer the person, and put the results together.',
+                /* ═══ SENDING COMES BEFORE READING, AND THAT IS ABOUT THE PERSON RATHER
+                   THAN ABOUT THROUGHPUT. ═══ The person reads nothing until this process
+                   exits, so every minute the owner spends reading the codebase before it
+                   sends anybody is a minute of pulse and no words. Measured on
+                   2026-08-24: 101 seconds to the first message, of which about 80 were
+                   the owner reading first and sending second.
+                   IT IS STILL NOT A GATE. `ux.md` deleted the manager that never touches
+                   code because that shape "required the coordinator to predict, at
+                   dispatch time, whether a request was big. It cannot", and Issue 3 made
+                   this judgement "never a mechanical gate". So this is which order to do
+                   two things the owner was already going to do, not a rule about
+                   whether. The paragraph above still decides whether. */
+                '',
+                'WHEN YOU ARE GOING TO SEND SOMEBODY, SEND THEM FIRST',
+                'Read what you need to write their piece, and no more; the rest of the reading is theirs to',
+                'do. Nothing you write reaches the person until you stop, so every minute you spend reading',
+                'before you send anybody is a minute they watch a line with no answer coming.',
+                '',
+                'IF YOU SPLIT IT',
+                'Everybody you send works in the SAME copy of the codebase as everybody else, at the same',
+                'time. Nothing keeps them out of each other\'s way, so anybody CHANGING files needs a piece',
+                'that touches nobody else\'s files, or has to be sent on their own.',
+                /* ═══ AND A WORKFLOW OVERRIDES THAT DEFAULT, INSIDE THE BLOCK THAT SETS
+                   IT. ═══ Six lines above, the owner is told the opposite: multiple
+                   independent parts belong with the people it sends, all working at the
+                   same time. A workflow's stages ARE multiple parts, so without a
+                   precedence rule the owner sends them all at once, the read-back
+                   barrier restarts it ONCE, and the order the person chose the workflow
+                   for is gone. Nothing in the record refuses a second dispatch before
+                   the first has ended — the barrier re-arms an owner when EVERY child
+                   has finished, which sequences stages only because the owner sends one
+                   at a time. So the rule is here, in the immutable brief that is
+                   replayed verbatim on every restart, and therefore in front of the
+                   owner at every stage boundary rather than only the first.
+        
+                   THE SECOND SENTENCE IS NOT DECORATION. A dispatched worker gets a
+                   working copy and the responsibility and boundary AND NOTHING ELSE, and
+                   `get_workflow` is this level's alone. Without it, the product takes
+                   deliberate trouble to hand the owner an untruncated stage document and
+                   the agent that performs the stage receives a paraphrase of it. */
+                ...(hasWorkflow
+                    ? [
+                        'A WORKFLOW IS ATTACHED, AND ITS STAGES GO OUT ONE AT A TIME. Send somebody for the',
+                        'first stage only, and do not start the next stage until the one before it has come',
+                        'back. When you send somebody for a stage, put that stage\'s own document into what you',
+                        'give them, in full: they cannot read the workflow themselves.',
+                    ]
+                    : []),
+                'What you have already sent somebody to do is written down, and you are handed that list',
+                'rather than having to remember it. Anything on it has been sent. Nothing on it is sent again.',
+                'When every one of them has finished you are started again, with what each of them wrote,',
+                'to put it together and answer. Nothing any of them writes reaches the person except',
+                'through you, so the reply that covers all of it is yours to write and nobody else\'s.',
+                'WHICH MEANS THE REPLY YOU WRITE NOW IS NOT THAT ANSWER. If you have sent anybody, you are',
+                'stopping in the middle, and what you write as you stop goes to the person as a message from',
+                'you. Write it. One short sentence, naming what has gone out and what you are waiting on:',
+                'the real answer is the one you write when you come back. Never stop silently. What you said',
+                'with `say` was about to happen; this is what has happened and what is still to come.',
+            ]
+            : [
+                'You own one piece of the work, the one below, and nothing else. Whoever sent you is doing',
+                'the rest. If your responsibility is investigation-only, read and report without changing',
+                'any file. The conversation owner handles the Work Item artifact and approval; do not',
+                'duplicate that record. If you were given approved implementation work, make that change.',
+                '',
+                'Somebody else may be working in this same copy of the codebase at the same time as you, on',
+                'a different piece. Stay inside what you were given and leave the rest of it alone.',
+            ]),
+        '',
+        'WHAT YOU OWN',
+        responsibility,
+        '',
+        'WHAT YOU MUST LEAVE ALONE',
+        boundary,
+        ...(workItemId ? ['', 'THE WORK ITEM THIS IS ABOUT', workItemId] : []),
+        ...whatWasAttached(attachments),
+        ...(codebase ? [
+            '',
+            'THE CODEBASE THIS WORK BELONGS TO',
+            `${codebase.name} — id ${codebase.id} — ${codebase.identity}`,
+        ] : []),
+        '',
+        'WHERE YOU ARE',
+        ...(codebase
+            ? [
+                'The directory you are in is a working copy of the codebase. Read it, run things in it, and',
+                'change it where that is what you were asked for. Name a file by its path inside this copy,',
+                'never by the full path from the root of this machine: the full one means nothing to the person',
+                'reading and is not ours to hand around.',
+            ]
+            : [
+                'The directory you are in is an empty private workspace. No codebase checkout was attached to',
+                'this conversation. Work from the record and the tools you have; do not claim to have read or',
+                'changed project files.',
+            ]),
+        '',
+        'WHAT YOU WERE AND WERE NOT GIVEN',
+        ...(level === 2
+            ? [
+                'This brief is your immutable responsibility and boundary. The visible conversation is',
+                'handed to you separately, in chronological order, whenever you are started. Read it as the',
+                'person wrote it; the launcher does not stand in for it. If something you genuinely need is',
+                'missing and only the person can supply it, you MUST call `ask_question` and stop instead',
+                'of saying it in your reply. Otherwise say what is missing plainly rather than guessing.',
+            ]
+            : [
+                'What is above is the whole of it. You have not seen what anybody said, and you are not meant',
+                'to: what matters was written into what you own. If something you genuinely need is missing,',
+                'say so plainly in your reply rather than guessing at it.',
+            ]),
+        '',
+        'WHAT CANNOT BE DECIDED HERE',
+        'Some things are not yours to settle, and guessing at one of those quietly is worse than any',
+        'delay: the work goes on top of an assumption nobody made and nobody can see. Asking stops you',
+        'where you are, and you are started again with the answer when there is one, so nothing you have',
+        'done is lost by asking. Questions already asked on this work, and what they were answered with,',
+        'are there to be read, and one of them may be yours.',
+        '',
+        'YOU CAN BE STOPPED, AND WHAT YOU WROTE DOWN IS ALL THAT COMES BACK WITH YOU',
+        'This machine can go down and take you with it, mid-sentence, with no warning and no chance to',
+        'tidy up. When that happens you are started again with what is above and with the notes you last',
+        'wrote down, and with nothing else: not what you had in your head, not what you had just decided,',
+        'not what you were halfway through. Notes written at the end of the work are notes that were',
+        'never written.',
+        '',
+        ...WHILE_YOU_ARE_WORKING,
+        '',
+        ...(level === 2
+            ? whatYouSendBack([
+                '- Nobody rewrites what you send. It goes to them as you wrote it, so it has to stand on its',
+                '  own: answer the thing that was asked, and say what you changed and where, without pasting',
+                '  the code back. They can read the code; they cannot read your reasoning.',
+            ])
+            : whatAWorkerSendsBack()),
+    ].join('\n');
+}
+export const presentedArtifactAnswerContext = (artifact) => artifact === null
+    ? []
+    : artifact.answer === 'request changes'
+        ? [
+            '',
+            'ARTIFACT REVISION THIS ANSWER SENT BACK FOR CHANGES',
+            `Artifact ${artifact.id}, revision ${artifact.revision}.`,
+            'Do not edit any codebase file or dispatch implementation. Revise this SAME artifact as the',
+            'person requested, present its new revision in a new approval question, and stop.',
+        ]
+        : [
+            '',
+            'ARTIFACT REVISION THIS ANSWER APPROVED',
+            `Artifact ${artifact.id}, revision ${artifact.revision}.`,
+            'Before editing any file or dispatching implementation, call `get_artifact` and compare its',
+            'current revision with this one. If they differ, this answer does not approve the current body:',
+            'present the current revision in a new approval question and stop.',
+        ];
+/**
+ * ═══ WHAT A RUN IS TOLD WHEN A PROCESS OF ITS OWN ENDED BEFORE IT FINISHED.
+ *     ═══
+ *
+ * Named once here rather than written inline, because `respawnPrompt` says both
+ * of these too, in its own longer wording (`WHAT YOU ALREADY SENT SOMEBODY TO
+ * DO`, and `CARRY ON FROM WHERE THAT LEAVES YOU`). **The two must move
+ * together.** They are not folded into one string because doing that would
+ * rewrite prose that is already shipped and proven on the retry and recovery
+ * paths, which is not this slice's assignment; naming them is what makes the
+ * pairing findable by the next person to edit either.
+ *
+ * ═══ THEY SAY WHAT TO DO, AND NEVER WHY IT HAPPENED. ═══ Three things end a
+ * process early and they are not the same event: a harness that crashed, a
+ * machine that went down, and a person who said the work was going the wrong
+ * way. `resumePrompt` and `retryPrompt` exist as two functions precisely
+ * because telling an agent an untrue reason for its restart is what this file
+ * exists to prevent, so a sentence shared by all three may only say the part
+ * that is true of all three.
+ */
+const DO_NOT_SEND_SOMEBODY_TWICE = 'Do not send somebody to do a piece of work that is already in this list. Anything of theirs '
+    + 'still going is still going, and asking again for what they are already doing costs the person twice.';
+const LOOK_AT_THE_WORK_ITSELF = 'A process of yours ended before it finished, so what you last wrote down is what you had time to '
+    + 'write, not everything that happened. Where your notes are silent, look at the work itself rather '
+    + 'than starting it over.';
+/**
+ * The complete one-shot context for the durable conversational owner.
+ *
+ * Visible history is supplied as one ordered list. A newly leased message is
+ * marked in place rather than appended, and a question plus its canonical
+ * answer is one event, so neither can occur twice in the prompt.
+ */
+export function ownerActivationPrompt(brief, report, events, children, childQuestion, currentArtifactAnswer = null, 
+/** A process of this run's own ended before it finished, so the working copy
+ *  may hold work no report mentions and the worker list may hold one it
+ *  dispatched a moment before. Never says WHICH ending it was: see
+ *  `LOOK_AT_THE_WORK_ITSELF`. */
+afterAProcessEnded = false) {
+    const history = events.map((event) => {
+        if (event.kind === 'question') {
+            return [
+                `CTRL+SPC QUESTION  ${event.body}`,
+                event.answer ? `PERSON ANSWER  ${event.answer}` : 'PERSON ANSWER  waiting',
+                ...(event.relatedArtifactId && event.relatedArtifactRevision
+                    ? [`PRESENTED ARTIFACT  ${event.relatedArtifactId}, revision ${event.relatedArtifactRevision}`]
+                    : []),
+                ...presentedArtifactAnswerContext(currentArtifactAnswer?.questionId === event.id
+                    ? currentArtifactAnswer
+                    : null),
+            ].join('\n');
+        }
+        const who = event.kind === 'user' ? 'PERSON' : 'CTRL+SPC';
+        return `${who}${event.needsReply ? ` — REPLY TO THIS NOW (turn ${event.id})` : ''}\n${event.body}`;
+    });
+    return [
+        'YOU OWN THIS CTRL+SPC CONVERSATION.',
+        'You are this conversation\'s one owner, started for one serialized activation. Speak directly to the',
+        'person as CTRL+SPC. The launcher is finished and cannot answer or receive an escalation.',
+        '',
+        'VISIBLE CONVERSATION, OLDEST FIRST',
+        ...(history.length === 0 ? ['Nothing has been said yet.'] : history),
+        ...(childQuestion === null ? [] : [
+            '',
+            'A WORKER NEEDS YOUR DECISION',
+            `Question ${childQuestion.id}: ${childQuestion.question}`,
+            'Answer it with answer_escalation if you can. If the person must decide, ask them directly.',
+        ]),
+        '',
+        'WHAT YOU LAST WROTE DOWN',
+        report ?? 'Nothing yet.',
+        '',
+        'PRIVATE WORKER SNAPSHOT',
+        ...(children.length === 0 ? ['You have sent nobody.'] : children),
+        ...(afterAProcessEnded ? ['', LOOK_AT_THE_WORK_ITSELF, DO_NOT_SEND_SOMEBODY_TWICE] : []),
+        '',
+        // THE BRIEF IS LAST, and these go before it: the brief ends with how to
+        // write the reply, and anything after it pushes that ending into the middle.
+        'YOUR IMMUTABLE BRIEF',
+        brief,
+    ].join('\n');
+}
+/**
+ * What an agent that was stopped is started again with: the same brief, its own
+ * notes, and what it already sent others to do.
+ *
+ * ═══ THE BRIEF IS CARRIED VERBATIM AND IS THE LAST THING IN IT. ═══ Verbatim
+ * because ux.md fixes it at dispatch — "a respawn is given the same instruction
+ * the first attempt was" — so this must not summarise, shorten or re-derive it.
+ * Last because the brief ENDS with how to write the reply, and that ending is
+ * the one an ordinary spawn has: putting the resumption after it would push the
+ * outbound rules into the middle of the prompt and leave a note about a dead
+ * process as the final word.
+ *
+ * ═══ THE REPORT IS WHAT THE RUN WROTE, AND NOTHING ELSE. ═══ It is deliberately
+ * lossy (ux.md), because the record holds the detail — the receipts, the
+ * activity and the commits are all still there to be read. This carries the
+ * state to resume from, not an archive.
+ *
+ * ═══ `children` IS READ LIVE BY THE CALLER, WHICH IS THE RULE THAT DECIDES
+ *     WHAT GOES IN A REPORT AT ALL. ═══ ux.md: "anything that can change while
+ * you are not running is read live and never carried in your report." What was
+ * dispatched changes while a run is dead — its children finish — so it is a fact
+ * to be read rather than something to be remembered, and the sentence below says
+ * so out loud. NULL means this agent cannot have sent anybody: at the deepest
+ * level there is no `dispatch` at all, and printing "you sent nobody" would
+ * describe an absence as a choice.
+ */
+export function resumePrompt(brief, report, children) {
+    return respawnPrompt([
+        'YOU WERE ALREADY DOING THIS, AND YOU WERE STOPPED BEFORE YOU FINISHED.',
+        'Not by anybody: the machine went down and took you with it. You are the same agent, started',
+        'again, and everything below is what survived. Nothing about what you were sent to do has',
+        'changed, and nothing you did before you stopped has been undone.',
+    ], brief, report, children);
+}
+/**
+ * ═══ WHAT AN AGENT IS STARTED AGAIN WITH WHEN THE PROCESS IT WAS RUNNING IN
+ *     DIED ON SOMETHING UPSTREAM. ═══
+ *
+ * recovery-1/ux.md, Slice 3: "the agent's harness fails on something that is
+ * nobody's fault: a rate limit, a dropped connection, a provider outage. The
+ * product tries again rather than failing the card."
+ *
+ * ═══ IT EXISTS BECAUSE `resumePrompt`'s OPENING IS FALSE HERE. ═══ That one
+ * says "the machine went down and took you with it", and on this path the
+ * machine did not go down: it is the same daemon, still running, that watched
+ * the harness exit. Telling an agent something untrue about why it is running is
+ * what this file exists to prevent, and a fifth opening onto the one respawn
+ * body is the shape the other four already established rather than a new idea.
+ *
+ * ═══ AND IT SAYS THE FAILURE WAS NOT THE AGENT'S, BECAUSE THE ALTERNATIVE IS
+ *     WORSE. ═══ An agent told only that it stopped has no way to tell a harness
+ * that died from work it got wrong, and the cheapest guess from inside is that
+ * the last thing it tried was the problem. That is how a resume turns into a
+ * rewrite of work that was already right.
+ */
+export function retryPrompt(brief, report, children) {
+    return respawnPrompt([
+        'YOU WERE ALREADY DOING THIS, AND THE PROCESS YOU WERE RUNNING IN DIED BEFORE YOU FINISHED.',
+        'Not because of anything you did, and not because anybody stopped you: the harness itself',
+        'failed, which is what a rate limit, a dropped connection or a provider outage looks like from',
+        'here. You are the same agent, started again, and everything below is what survived. Nothing',
+        'about what you were sent to do has changed, and nothing you did before it died has been undone.',
+    ], brief, report, children);
+}
+/**
+ * ═══ WHAT AN AGENT THAT ASKED IS STARTED AGAIN WITH. ═══
+ *
+ * ux.md: "The run that asked is spawned again, fresh, with the question and the
+ * answer in its brief. Not level 1 passing it down through level 2. Not a
+ * message. A respawn, which is the same mechanism as redirect." So this is
+ * `resumePrompt` with one more thing in it, and the sameness is the point: the
+ * agent picks up where the old one left off for the same reason a crash resume
+ * does, because the work was never inside the process.
+ *
+ * ═══ AND IT SAYS OUT LOUD THAT AN ANSWER CAN BE BIGGER THAN THE QUESTION. ═══
+ * ux.md: "If the answer turns out to change more than that worker's own piece,
+ * it escalates again rather than proceeding. Whether an answer is local or global
+ * is judgement, and building a classifier for it would be the product deciding
+ * something the agent is better placed to see." So it is named as a judgement
+ * the agent makes, in one sentence, rather than a rule about when to ask.
+ */
+export function answerPrompt(brief, report, children, question, answer, relatedArtifact = null) {
+    return respawnPrompt([
+        'YOU STOPPED BECAUSE YOU COULD NOT GO ON WITHOUT KNOWING SOMETHING. HERE IT IS.',
+        'You are the same agent, started again, and everything you did before you asked is still there.',
+        '',
+        'WHAT YOU ASKED',
+        question,
+        '',
+        'WHAT CAME BACK',
+        answer,
+        ...presentedArtifactAnswerContext(relatedArtifact),
+        '',
+        'If this answers less than you asked, or turns out to change more than the piece you were sent',
+        'to do, ask again rather than deciding it yourself. Carrying on from a guess about something this',
+        'big is how work gets done twice.',
+    ], brief, report, children);
+}
+/**
+ * ═══ WHAT AN AGENT IS STARTED AGAIN WITH WHEN EVERYBODY IT SENT HAS FINISHED.
+ *     ═══
+ *
+ * ux.md's third re-arm, and the one nothing else could fire: "every child of a
+ * run has finished → that run, so it can read them back and carry on."
+ *
+ * ═══ WHAT THEY FOUND IS IN THE PROMPT, NOT BEHIND A TOOL CALL. ═══ This is the
+ * one respawn whose entire purpose is reading them back, and ux.md is explicit
+ * about the difference between a guarantee and a hope: "an agent cannot fail to
+ * read its own input." `childrenOf` carries each of their reports, so the
+ * synthesis starts from what they wrote rather than from remembering to ask.
+ *
+ * ═══ AND IT SAYS OUT LOUD THAT NOBODY ELSE WILL SAY IT. ═══ A worker's words go
+ * into the record and stop there, by `panel3_answer`. From inside, an agent
+ * cannot tell whether the person has already read three replies; told wrongly it
+ * writes a covering note over answers nobody ever saw. So it is told, as a fact
+ * about the situation rather than as an instruction.
+ */
+export function readBackPrompt(brief, report, children) {
+    return respawnPrompt([
+        'EVERYBODY YOU SENT HAS FINISHED, AND YOU ARE STARTED AGAIN TO READ WHAT THEY FOUND.',
+        'You are the same agent, started again, and nothing you did before has been undone. Nothing you',
+        'sent anybody to do is still running.',
+        '',
+        'WHAT THEY WROTE IS BELOW, and it has gone nowhere else. The person has not seen any of it and',
+        'will not: what reaches them about this is what you write now. If what came back leaves the',
+        'work finished, answer with the whole of it in one piece. If it leaves something undone, that',
+        'is still yours, and you may do it or send somebody for it exactly as before.',
+    ], brief, report, children);
+}
+/**
+ * ═══ WHAT AN AGENT IS STARTED AGAIN WITH WHEN SOMEBODY IT SENT CANNOT GO ON.
+ *     ═══
+ *
+ * ux.md: "the level 2 agent is spawned, sees a child asked something, and either
+ * answers it or escalates and exits... Each hop is one cheap spawn that reads and
+ * decides. Against a question that waits on a human, three spawns are noise, and
+ * each one is a real chance to settle it without interrupting anyone."
+ *
+ * THE COST OF PASSING IT ON IS STATED, because that is the whole reason the hop
+ * exists: an agent that passes everything up is a level that bought nothing.
+ */
+export function escalationPrompt(brief, report, children, questionId, question) {
+    return respawnPrompt([
+        'SOMEBODY YOU SENT CANNOT GO ON UNTIL SOMETHING IS DECIDED, AND IT CAME TO YOU.',
+        'You are the same agent, started again to deal with it. Nothing you did before has been undone.',
+        '',
+        'WHAT THEY NEED TO KNOW',
+        question,
+        '',
+        `Its id is ${questionId}. That is what you answer it by, and it is also what you name if you`,
+        'cannot settle it either and have to send it further up: name it, and it goes up as one question',
+        'with your wording. Leave it out and you have asked a second, separate question of your own,',
+        'and this one stays here with nobody dealing with it.',
+        '',
+        'ANSWER IT IF YOU CAN. You know what this work is for and they do not, so most of what reaches',
+        'you is yours to settle. Read what you need to first. Only what you genuinely cannot decide goes',
+        'further up, and everything that goes up eventually stops a person and asks them instead.',
+        'Whichever you do, you stop afterwards: they are started again with the answer, not by you.',
+    ], brief, report, children);
+}
+/**
+ * What every respawn shares: what it wrote down, what it already sent others to
+ * do, and the brief it was given, verbatim and last.
+ *
+ * ONE OWNER, because the three reasons a run is started again — the machine went
+ * down, its question was answered, somebody it sent needs a decision — differ
+ * only in what is NEW. Everything else about resuming is the same fact, and two
+ * copies of it would drift in the way ux.md's own note about the brief describes:
+ * invisibly, in whichever one nobody re-read.
+ */
+function respawnPrompt(opening, brief, report, children) {
+    return [
+        ...opening,
+        '',
+        'WHAT YOU WROTE DOWN, THE LAST TIME YOU WROTE ANYTHING DOWN',
+        report ?? 'Nothing. You were stopped before you wrote anything down, so what you did before that '
+            + 'is not known here — check the work itself before you assume any of it is undone.',
+        '',
+        ...(children === null ? [] : [
+            'WHAT YOU ALREADY SENT SOMEBODY TO DO, AS IT STANDS RIGHT NOW, AND WHAT EACH OF THEM WROTE',
+            'Read from the record a moment ago, not from your notes, so it is right even where they are',
+            'silent: this is what exists, whatever you meant to do. Do not send somebody to do a piece of',
+            'work that is already in this list. Anything of theirs still going is still going, and asking',
+            'again for what they are already doing costs the person twice. What is under each one is what',
+            'that one wrote down, in its own words.',
+            ...(children.length === 0 ? ['You have sent nobody.'] : children),
+            '',
+        ]),
+        'CARRY ON FROM WHERE THAT LEAVES YOU. What your notes say is done is done and is not to be done',
+        'again; what they leave open is what is left. Where they are silent, look at the work itself',
+        'rather than starting it over: they are what you had time to write down, not everything that',
+        'happened. And write them again as you go, for the same reason.',
+        '',
+        'WHAT YOU WERE SENT TO DO, WORD FOR WORD AS YOU WERE SENT IT',
+        '',
+        brief,
+    ].join('\n');
+}