create-pmos 0.214.0 → 0.216.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.214.0",
+  "version": "0.216.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@e529926
+kernel-source: pmos@da1c3aa
 assembled: 2026-10-14
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-14T03:12:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T04:16:13Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-14T03:12:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T04:16:13Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-14T03:12:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-14T04:16:13Z"}
 status: stable
 ---
 

package/workspace/c3-sessions-panel-test.js

@@ -37,6 +37,17 @@ async function openPanel(page) {
   if (got && await page.$('[data-c3-all-sessions]')) await page.click('[data-c3-all-sessions]');
 }
 async function waitFor(page, fn, arg, ms = 15000) { try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; } }
+/* the session sheet opens on the conversation (c3-session-conv.js); Terminal shows the live terminal */
+const sheetOf = (i) => `[data-c3-session="${i}"]`;
+async function toTerm(page, i) {
+  if (!await waitFor(page, (s) => !!document.querySelector(s), sheetOf(i))) return false;
+  await page.click('[data-c3-view="term"]');
+  return waitFor(page, (x) => !!document.querySelector(`[data-c3-session-term="${x}"] .xterm`), i);
+}
+async function openTerm(page, i) {
+  await page.evaluate((x) => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: { id: x } })), i);
+  return toTerm(page, i);
+}
 const get = (p) => fetch(BASE + p).then((r) => r.json());
 // the agent CLI's home for this run: the conversation test writes a session record and a transcript here, as claude would
 const CLAUDE_HOME = path.join(T.STATE_DIR, 'claude-home');
@@ -104,23 +115,30 @@ function startShell(name) {
   /* ── C: Open the session stays on this page ── */
   const url0 = page.url();
   await page.click(`[data-blank-panel="${id}"] [data-open-session]`);
-  ok('C1 the session opens in a terminal sheet', await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), id));
+  ok('C1 the session opens in a sheet, on its conversation', await waitFor(page, (i) => { const c = document.querySelector(`[data-c3-session="${i}"] [data-c3-conv]`); return !!c && !c.hidden && !document.querySelector('.xterm'); }, id));
+  ok('C1b a shell with no Claude in it says so and offers Start Claude here', await waitFor(page, () => /No Claude in this shell yet/.test((document.querySelector('[data-cv="none"]') || {}).textContent || '') && !!document.querySelector('[data-cv="start-claude"]')));
+  ok('C1c the view control has Conversation and Terminal, Conversation pressed', await page.evaluate(() => [...document.querySelectorAll('[data-c3-view]')].map((b) => b.dataset.c3View + ':' + b.getAttribute('aria-pressed')).join() === 'conv:true,term:false'));
+  ok('C1d Terminal shows the live terminal in the same sheet', await toTerm(page, id) && await page.evaluate(() => document.querySelector('[data-c3-conv]').hidden === true));
   ok('C2 the page stays on console3', page.url() === url0, page.url());
   await sleep(800);
   await page.click(`[data-c3-session-term="${id}"] .xterm`);
-  await page.keyboard.type('echo c3-typed-$((40+2))\n');
+  // a claude that only echoes, so Start Claude here can be checked without a real agent
+  await page.keyboard.type('claude() { echo c3-start-$((3*3)); }; echo c3-typed-$((40+2))\n');
   ok('C2b what is typed in the sheet reaches the shell', !!(await until(async () => /c3-typed-42/.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || ''), 8000)));
   await page.keyboard.press('Escape');
   await sleep(300);
   ok('C3 Esc in the terminal goes to the shell, not the sheet', await page.evaluate((i) => !!document.querySelector(`[data-c3-session-term="${i}"]`), id));
   await page.keyboard.press('Control+u');   // the shell read that Esc as a Meta prefix: this key takes it, so the next line starts clean
+  await page.click('[data-c3-view="conv"]');
+  ok('C3b Conversation comes back, the terminal stays mounted but hidden', await waitFor(page, (i) => { const c = document.querySelector('[data-c3-conv]'); const t = document.querySelector(`[data-c3-session-term="${i}"]`); return !!c && !c.hidden && !!t && !!t.querySelector('.xterm') && t.closest('[data-c3-view-pane]').hidden; }, id));
+  await page.click('[data-cv="start-claude"]');
+  ok('C3c Start Claude here types claude into the shell', !!(await until(async () => /c3-start-9/.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || ''), 8000)));
   await page.click('[data-shell="sheet"] [aria-label="Close"]');
   ok('C4 the close button closes the terminal sheet', await waitFor(page, () => !document.querySelector('[data-c3-session-term]')));
   ok('C5 closing the sheet leaves the session running', await until(async () => ((await get('/api/sessions')).sessions || []).some((s) => s.id === id && s.state !== 'exited')));
 
   /* ── G: the scratchpad and the size control on the terminal sheet (c3-term-pad-size) ── */
-  await page.evaluate((i) => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: { id: i } })), id);
-  const g0 = await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), id);
+  const g0 = await openTerm(page, id);
   ok('G0 the terminal sheet opens for the pad checks', g0 || !!(await page.$('[data-c3-size-seg]')));
   const sizes = await page.$$eval('[data-c3-size-seg] [data-c3-size]', (b) => b.map((x) => x.dataset.c3Size));
   ok('G1 the size control has 4 options', sizes.join() === 'normal,half,two-thirds,whole', sizes.join());
@@ -137,8 +155,7 @@ function startShell(name) {
   await page.click('[data-c3-size="half"]');
   await page.click('[data-shell="sheet"] [aria-label="Close"]');
   await waitFor(page, () => !document.querySelector('[data-c3-session-term]'));
-  await page.evaluate((i) => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: { id: i } })), id);
-  await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), id);
+  await openTerm(page, id);
   await sleep(200);
   ok('G4 the size choice is kept after closing and opening again', Math.abs((await wid()) - vw / 2) < 3, String(await wid()));
   ok('G4b it is kept in localStorage', await page.evaluate(() => localStorage.getItem('pmos.workspace.c3.term-size') === 'half'));
@@ -158,7 +175,7 @@ function startShell(name) {
   await page.fill('[data-c3-pad="text"]', 'flushed-on-close');
   await page.click('[data-shell="sheet"] [aria-label="Close"]');
   ok('G8 closing the sheet saves a pad edit at once', !!(await until(async () => (await get('/api/scratchpad?session=' + id)).text === 'flushed-on-close', 2000)));
-  await page.evaluate((i) => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: { id: i } })), id);
+  await openTerm(page, id);
   await waitFor(page, () => !!document.querySelector('[data-c3-pad="text"]'));
   ok('G9 the pad loads its text when the terminal opens again', await waitFor(page, () => document.querySelector('[data-c3-pad="text"]').value === 'flushed-on-close'));
   /* the grip above the pad resizes it: a drag up makes the pad taller and the terminal shorter; the height is kept */
@@ -183,9 +200,9 @@ function startShell(name) {
   /* ── D: End asks first, then ends ── */
   // Sessions opens the terminal of the session opened last while it runs (PM, 2026-10-13); its "All sessions" opens the panel
   await page.click('[data-c3pg="agent-button"]');
-  ok('D0 Sessions opens the terminal of the session opened last', await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), id));
+  ok('D0 Sessions opens the session opened last', await waitFor(page, (s) => !!document.querySelector(s + ' [data-c3-conv]'), sheetOf(id)));
   await page.click('[data-c3-all-sessions]');
-  ok('D0a All sessions in the terminal sheet opens the panel', await waitFor(page, (s) => !!document.querySelector(s), sel) && !(await page.$('[data-c3-session-term]')));
+  ok('D0a All sessions in the session sheet opens the panel', await waitFor(page, (s) => !!document.querySelector(s), sel) && !(await page.$('[data-c3-session]')));
   ok('D0b it opens on the session opened last: its row is open and marked', await waitFor(page, (i) => { const li = document.querySelector(`[data-c3t="mine"] [data-run="${i}"]`); const end = document.querySelector(`[data-end-session="${i}"]`); return !!li && li.hasAttribute('data-last-open') && !!end && end.offsetParent !== null; }, id)
     && await page.evaluate((i) => localStorage.getItem('pmos.workspace.c3.last-session') === i, id));
   if (!(await page.isVisible(`[data-end-session="${id}"]`).catch(() => false))) await page.click(sel + ' .nb');
@@ -232,6 +249,47 @@ function startShell(name) {
     return me && tool && !!bot && !!bot.querySelector('li b') && !!bot.querySelector('li code') && !/not shown/.test(f.textContent);
   }, feedSel, 10000));
 
+  /* ── S: the session sheet's conversation, from the same transcript ── */
+  await page.evaluate((i) => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: { id: i } })), id);
+  const cvSel = sheetOf(id) + ' [data-c3-conv]';
+  ok('S1 the sheet shows the prompt, a folded tool line and the reply', await waitFor(page, (s) => {
+    const f = document.querySelector(s); if (!f) return false;
+    const me = [...f.querySelectorAll('[data-chat="me"]')].some((n) => n.textContent === 'What changed today?');
+    const tool = f.querySelector('details[data-chat="tool"]');
+    const bot = f.querySelector('[data-chat="bot"]');
+    return me && !!tool && !tool.open && /Used Bash/.test(tool.textContent) && !!bot && !!bot.querySelector('li b') && !/not shown/.test(f.textContent);
+  }, cvSel, 10000));
+  ok('S2 the tool line lists each call with its target', await page.evaluate((s) => [...document.querySelectorAll(s + ' details[data-chat="tool"] li')].map((li) => li.querySelector('b').textContent + ' ' + ((li.querySelector('span') || {}).textContent || '')).join() === 'Bash git log', cvSel));
+  ok('S3 the status reads Your turn and the meta names the model', await page.evaluate(() => (document.querySelector('[data-cv="status"]') || {}).textContent === 'Your turn' && /claude-test/.test((document.querySelector('[data-cv="meta"]') || {}).textContent || '')));
+  await page.fill('[data-cv="msg"]', 'echo c3-conv-$((5*5))');
+  await page.press('[data-cv="msg"]', 'Enter');
+  ok('S4 a sent message shows at once', await waitFor(page, () => [...document.querySelectorAll('[data-c3-conv] [data-chat="me"]')].some((n) => /c3-conv-/.test(n.textContent)), null, 3000));
+  ok('S4b the send box types into the session and presses Enter', !!(await until(async () => /^c3-conv-25/m.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || ''), 8000)));
+  // Claude asks before a tool: the transcript holds an open call and the pane shows Claude Code's prompt
+  fs.appendFileSync(path.join(proj, 'conv-test-1.jsonl'), rec({ type: 'assistant', message: { id: 'msg_3', model: 'claude-test', role: 'assistant', content: [{ type: 'tool_use', id: 't2', name: 'Bash', input: { command: 'rm notes.txt' } }] } }) + '\n');
+  await page.fill('[data-cv="msg"]', "clear; printf 'Do you want to proceed?\\n> 1. Yes\\n  2. No, and tell Claude what to do differently\\n'");
+  await page.press('[data-cv="msg"]', 'Enter');
+  ok('S5 the allow prompt shows as a card with its options', await waitFor(page, () => {
+    const c = document.querySelector('[data-c3-conv] [data-cv="ask"]'); if (!c) return false;
+    const o = [...c.querySelectorAll('[data-cv-opt]')].map((b) => b.dataset.cvOpt + ':' + b.textContent).join('|');
+    return /Do you want to proceed\?/.test(c.textContent) && o === '1:Yes|2:No, and tell Claude what to do differently' && !!c.querySelector('[data-cv="ask-term"]');
+  }, null, 20000));
+  if (!results[results.length - 1].cond) { const c = await get('/api/sessions/conversation?id=' + id); console.log('  conversation:', JSON.stringify({ state: c.state, turn: c.turn, openCall: c.openCall, ask: c.ask }), JSON.stringify(((await get('/api/sessions/transcript?id=' + id + '&max=600')).text || '').slice(-300))); }
+  ok('S5b the status reads Needs you', await page.evaluate(() => (document.querySelector('[data-cv="status"]') || {}).textContent === 'Needs you'));
+  await page.click('[data-cv-opt="2"]', { timeout: 3000 }).catch(() => {});
+  await sleep(500);
+  await page.fill('[data-cv="msg"]', '; echo c3-opt-$((2*4))');
+  await page.press('[data-cv="msg"]', 'Enter');
+  ok('S5c an option button types its number into the session', !!(await until(async () => /2; echo c3-opt/.test((await get('/api/sessions/transcript?id=' + id + '&max=6000')).text || ''), 8000)));
+  await page.click('[data-cv="ask-term"]').catch(() => {});
+  ok('S6 Answer in the terminal switches to the terminal', await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`) && document.querySelector('[data-c3-view="term"]').getAttribute('aria-pressed') === 'true', id));
+  await page.click('[data-shell="sheet"] [aria-label="Close"]');
+  await waitFor(page, () => !document.querySelector('[data-c3-session]'));
+  // the panel row was open before the sheet: open it again for End
+  // (it opens on the session opened last, with its row open)
+  await openPanel(page);
+  if (!await waitFor(page, (i) => { const b = document.querySelector(`[data-end-session="${i}"]`); return !!b && b.offsetParent !== null; }, id, 5000)) await page.click(sel + ' .nb');
+
   await page.click(`[data-end-session="${id}"]`);
   await page.click(`[data-end-yes="${id}"]`);
   const gone = async () => !((await get('/api/sessions')).sessions || []).some((s) => s.id === id);
@@ -255,9 +313,9 @@ function startShell(name) {
   const made = await until(async () => ((await get('/api/sessions')).sessions || []).find((s) => !before.has(s.id) && s.name === 'c3 new shell'), 10000);
   ok('F3 Start starts the session on the server', !!made);
   ok('F3b it starts on the board chosen in the sheet', !!made && made.ws === opts.find((o) => o.on).v, JSON.stringify(made && made.ws));
-  ok('F4 its terminal opens in a sheet on console3', !!made && await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), made.id) && page.url() === url0, page.url());
+  ok('F4 it opens in a sheet on console3', !!made && await waitFor(page, (s) => !!document.querySelector(s + ' [data-c3-conv]'), sheetOf(made.id)) && page.url() === url0, page.url());
   await page.click('[data-shell="sheet"] [aria-label="Close"]');
-  await waitFor(page, () => !document.querySelector('[data-c3-session-term]'));
+  await waitFor(page, () => !document.querySelector('[data-c3-session]'));
   await page.evaluate(() => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: {} })));
   ok('F5 an open-session request with no session opens the new-session sheet, not the classic app', await waitFor(page, () => !!document.querySelector('[data-c3ns="form"]')) && page.url() === url0, page.url());
   await page.click('[data-shell="sheet"] [aria-label="Close"]');

package/workspace/c3-work-test.js

@@ -87,8 +87,8 @@ const W = '[data-pm-work]';
   if (!ready) return finish(1);
 
   /* the six views and their counts (R1) */
-  const readBar = () => st((w) => [...document.querySelectorAll(w + ' [data-pm-lenses] [data-lens]')].map((b) => [b.getAttribute('data-lens'), b.textContent.replace(/\d+$/, '').trim()]), W);
-  // A redraw puts a new bar in the header and the quiet layout moves it beside Add work 50 ms later; read it once it has settled.
+  // only the bar on screen: a redraw puts a new bar in the header, hidden there (.calbar.qt-moved), until the quiet layout moves it beside Add work
+  const readBar = () => st((w) => [...document.querySelectorAll(w + ' [data-pm-lenses] [data-lens]')].filter((b) => b.offsetParent !== null).map((b) => [b.getAttribute('data-lens'), b.textContent.replace(/\d+$/, '').trim()]), W);
   await until(async () => (await readBar()).length === VIEWS.length, 10000, 100);
   const bar = await readBar();
   ok('the bar has the six views in order: Inbox, Today, Upcoming, Waiting, Someday, Review', JSON.stringify(bar.map((b) => b[0])) === JSON.stringify(VIEWS) && JSON.stringify(bar.map((b) => b[1])) === JSON.stringify(LABELS), JSON.stringify(bar));

package/workspace/guide/console3-sessions.md

@@ -1,15 +1,15 @@
 ---
 type: Guide
 title: "Sessions in console3: start, open, message, read and end your sessions"
-description: "How the Sessions panel in console3 groups your sessions, how to start a session, how to open a session's terminal without leaving console3, how to send a message to a session, and how to end a session."
-timestamp: 2026-10-13
+description: "How the Sessions panel in console3 groups your sessions, how to start a session, how to open a session as a conversation or as its terminal without leaving console3, how to send a message to a session, and how to end a session."
+timestamp: 2026-10-14
 ---
 
 # Sessions in console3: start, open, message, read and end your sessions
 
 Press the **Sessions** button in the console3 header to open the panel. It is the bolt icon with no label. Point at it to see its name. When a session needs you, a count shows on it. It shows your sessions in four groups: **On a card**, **Started by me**, **Past (7 days)** and **Automatic**.
 
-When the session that you opened last is still running, the **Sessions** button opens its terminal directly. To see all your sessions, press **All sessions** at the top of the terminal sheet. If that session has ended, the button opens the panel.
+When the session that you opened last is still running, the **Sessions** button opens that session directly, on its conversation. To see all your sessions, press **All sessions** at the top of the session sheet. If that session has ended, the button opens the panel.
 
 The panel opens on the session that you opened last. Its row is open, so you can read the conversation and send a message without searching for it. A session counts as opened when you open its row or its terminal.
 
@@ -32,7 +32,7 @@ You start a session in console3. You do not need the classic app.
    - **Automatic**: the server selects the tree.
    - A listed tree: the session runs in that working tree.
    - **New branch**: type the branch name. The session runs in its own working copy of the new branch.
-6. Press **Start**. The session starts, and its terminal opens in a sheet on the same page. If you selected a different board, the dock changes to that board.
+6. Press **Start**. The session starts, and it opens in a sheet on the same page. If you selected a different board, the dock changes to that board.
 
 If the server cannot start the session, the sheet shows the reason.
 
@@ -47,7 +47,31 @@ If the server finds that the process of a session stopped (for example, after a
 1. Press the row to open it.
 2. Press **Open the session**.
 
-The terminal of the session opens in a panel on the same page. You can type in it. When the terminal has focus, Esc and Tab go to the terminal. To close the panel, press its close button. The session continues to run.
+The session opens in a sheet on the same page, on its conversation. To close the sheet, press its close button. The session continues to run.
+
+Two buttons at the top of the sheet change the view:
+
+- **Conversation**: your messages and the replies of Claude, with a box to send a message. This is the view that opens first.
+- **Terminal**: the live terminal of the session. You can type in it. When the terminal has focus, Esc and Tab go to the terminal. Use it for the things that the conversation does not show, for example a menu of Claude Code or the full output of a command.
+
+Press **Conversation** to go back. The terminal stays connected while the sheet is open, so nothing restarts when you change the view.
+
+### The conversation
+
+The conversation comes from the transcript that Claude Code writes on this computer. It shows the words of Claude as Claude wrote them. Nothing is summarised, and nothing is sent to a different place.
+
+- Your messages are on the right. The replies of Claude are on the left. Lists, bold text and code show as formatted text.
+- A grey line, for example "Used Bash, Read ×2", shows a run of tool calls. Press it to see each call and its target, for example the file or the command.
+- While Claude works, a line says so. Press the stop button next to the message box to stop Claude. It types Esc into the session.
+- When Claude asks before it uses a tool, a card shows the question and its options, for example **Yes** and **No**. Press an option to answer. You can also press **Answer in the terminal**.
+- Type a message in the box and press Enter to send it. Shift Enter starts a new line. **/compact** and **/clear** put that command in the box.
+- The tag above the conversation shows the state: **Working**, **Needs you**, **Your turn**, **Shell** or **Ended**.
+
+A shell where Claude has not started says "No Claude in this shell yet". Press **Start Claude here** to start Claude in that shell. Its conversation then shows in this view.
+
+If PMOS cannot find the transcript of a Claude session, the view says so, and it does not show the transcript of a different session. Read the session in the terminal. PMOS looks for transcripts in `~/.claude`, in each `~/.claude-*` profile folder, and in the folder that `CLAUDE_CONFIG_DIR` names.
+
+At **2/3** and **Whole**, the sheet also shows a list of your running sessions at the left. Press a session to open it.
 
 ### The scratchpad
 
@@ -58,11 +82,11 @@ Below the terminal is a scratchpad. It keeps text for this session only. The tex
 - To make the pad taller or shorter, drag the grip on the line above it. Or select the grip and press the up arrow or the down arrow. The terminal gets the remaining room. The page remembers the height. To go back to the default height, double-click the grip.
 - Esc in the pad closes the panel. Esc in the terminal goes to the terminal.
 
-### The size of the terminal
+### The size of the sheet
 
-Four buttons in the header of the panel set its width: **Normal**, **Half**, **2/3** and **Whole**. Half is half of the window. 2/3 is two thirds of the window. Whole is the full window. The terminal fits the new size. The page remembers your choice for the next terminal you open. On a phone the panel is already full width, so the buttons are not shown.
+Four buttons in the header of the sheet set its width: **Normal**, **Half**, **2/3** and **Whole**. Half is half of the window. 2/3 is two thirds of the window. Whole is the full window. The terminal fits the new size. The page remembers your choice for the next session you open. On a phone the panel is already full width, so the buttons are not shown.
 
-The **Open the session** link in the sessions dock opens the same panel.
+The **Open the session** link in the sessions dock opens the same sheet.
 
 ## Send a message to a session
 
@@ -78,7 +102,7 @@ The panel shows the conversation of a Claude session:
 
 - Your messages are on the right.
 - The replies of Claude are on the left. Lists, bold text and code show as formatted text.
-- A grey line, for example "Used Bash, Read ×2", shows the tools that Claude used. The input of a tool does not show.
+- A grey line, for example "Used Bash, Read ×2", shows the tools that Claude used. The session sheet also shows the target of each call.
 - While Claude works, a grey line says so.
 
 The panel reads the conversation from the transcript that Claude Code writes on this computer. Nothing is sent to a different place. The panel updates while it is open.

package/workspace/guide/my-work.md

@@ -100,7 +100,7 @@ An item goes to the first view that fits these rules, in this order. Parked is S
 
 Open an item that shows **Agent can:**. The case file shows **What the agent will do**.
 
-The offer is on Jira and WBS items with a suggestion, and on each item the morning brief suggests for you (for example a Slack reply or an email). On a brief item the offer is the reply or the note that the item asks for, and the draft goes back to the place the item came from, only when you post it.
+The offer is on Jira and WBS items with a suggestion, and on each item the morning brief suggests for you (for example a Slack reply or an email), also on the days after, while you keep the item in Work. On a brief item the offer is the reply or the note that the item asks for, and the draft goes back to the place the item came from, only when you post it.
 
 An item you added yourself shows **Agent can draft a first version**. The agent drafts what the item asks for (a document, a plan or a recommendation), and the draft stays on the item. It has no place to post to: read it, keep it, or send it back with a note.
 
@@ -121,11 +121,14 @@ The row chip then shows the agent's state:
 
 The page reads the state again every 15 seconds while an agent is queued, working or posting.
 
-When the draft is ready, the case file quotes it. Select **Open the draft** to read all of it. Then choose one option:
+When the draft is ready, the case file shows it as a document, with its headings, lists and tables. Select **Open the draft** to read all of it. Then choose one option:
 
 - **Post it to** the ticket posts the exact text. Nothing goes out until you hold to confirm.
 - **Send it back with a note** returns the draft to the agent. Type what to change and press Enter.
 - **Keep it as a draft** leaves the draft as it is.
+- **Mark it done** closes the item. Nothing is posted.
+
+To change the text yourself before you post it, select **Edit the draft**, change the text and select **Save the draft**. The case file then says **Edited by you**, and **Post it to** the ticket posts exactly your text.
 
 The agent only drafts. It never posts to Jira until you approve the draft.
 

package/workspace/lib/day-run.js

@@ -249,6 +249,35 @@ function decide(run, taskId, op, now) {
   });
 }
 
+/** The PM's own edit of a draft that waits for them (initiative c3-work-agent, amendment 13). The edited text replaces the
+ *  body, so an approve posts exactly what the PM saved. The agent's first text stays in `agent_body`. */
+function edit(run, taskId, body, now) {
+  const b = typeof body === 'string' ? body.trim() : '';
+  return withTask(run, taskId, (t) => {
+    if (t.status !== 'review' || !t.draft) return `task ${taskId} is ${t.status} — only a draft waiting for you can be edited`;
+    if (!b) return 'the draft cannot be empty — keep some text, or send it back with a note';
+    if (b.length > 8000) return 'the draft is over 8000 characters';
+    if (b === t.draft.body) return null;
+    if (t.draft.agent_body === undefined) t.draft.agent_body = t.draft.body;
+    t.draft.body = b; t.draft.edited_at = iso(now);
+    return null;
+  });
+}
+
+/** Approve a draft of an earlier day's run (amendment 13). The job CLI reads today's run only, so the approved task joins
+ *  today's run as `sending`, with its draft as it is. `task` is the task of the earlier run. */
+function carry(run, task, now) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  if (!task || !TASK_RE.test(String(task.id || ''))) return { ok: false, error: 'no task to carry' };
+  if (task.status !== 'review' || !task.draft) return { ok: false, error: `task ${task.id} is ${task.status} — only a draft waiting for you can be approved` };
+  const next = clone(run);
+  if (findTask(next, task.id)) return { ok: false, error: `task ${task.id} is already in today's run` };
+  const t = clone(task);
+  Object.assign(t, { status: 'sending', session_id: null, prev_session: null, started_at: null, error: null, decided: { action: 'approve', at: iso(now) } });
+  next.tasks.push(t);
+  return { ok: true, run: next, task: task.id };
+}
+
 /** The send session reports the approved step done, with the link to what it posted. */
 function sent(run, taskId, s, now) {
   return withTask(run, taskId, (t) => {
@@ -413,5 +442,5 @@ function checkDone(run, { found = 0, resolved = 0 } = {}, now) {
 }
 
 module.exports = { MAX_PARALLEL, MAX_REVISIONS, MAX_CHECK_LOG, MAX_INTERVAL_MIN, STATUSES, KINDS, ACTIONS, TASK_RE,
-  newRun, readRun, findTask, modeOf, addTasks, addBriefed, addSend, toStart, started, deliver, decide, sent, fail, stop, withdraw, sessionEnded, sessionStalled, stage, intervalMin,
+  newRun, readRun, findTask, modeOf, addTasks, addBriefed, addSend, toStart, started, deliver, decide, edit, carry, sent, fail, stop, withdraw, sessionEnded, sessionStalled, stage, intervalMin,
   checkDue, checkStarted, checkDone };

package/workspace/lib/my-work.js

@@ -194,7 +194,7 @@ function stateOf(item, presses, runs) {
   if (!last || last.action === 'reopen') return { state: 'brief', sub: null, task: null, instruction: null };
   if (last.action === 'handle') return { state: 'yours', sub: null, task: null, instruction: null, decided_at: last.at };
   const t = taskOf(runs, last);
-  const task = t ? { id: t.id, status: t.status, error: t.error || null, draft: t.draft ? t.draft.summary : null, body: t.draft ? t.draft.body || null : null,
+  const task = t ? { id: t.id, status: t.status, error: t.error || null, draft: t.draft ? t.draft.summary : null, body: t.draft ? t.draft.body || null : null, edited_at: t.draft ? t.draft.edited_at || null : null,
     sent: t.sent || null, started_at: t.started_at || null, revisions: Array.isArray(t.revisions) ? t.revisions.length : 0,
       session: t.stalled_session || null, asks: t.asks || null } : null;
   const base = { task, instruction: last.instruction, decided_at: last.at };

package/workspace/lib/proactive-cli.js

@@ -296,13 +296,19 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
       else {
         // an item the PM added in Work (initiative c3-work-agent, amendment 11): the PM's item is the ask
         const c = t.context || {};
-        say(`from Work: ${t.title}${c.due ? ' · due ' + c.due : ''}${c.from ? ' · with ' + c.from : ''}`);
+        say(`from Work: ${t.title}${c.due ? ' · due ' + c.due : ''}${c.from ? ' · with ' + c.from : ''}${t.link ? ' · link ' + t.link : ''}`);
+        for (const k of ['where', 'about', 'ask', 'how', 'why_now']) if (c[k] && c[k] !== t.title) say(`${k.replace('_', ' ')}: ${c[k]}`);
       }
       // the PM's ask, as Work or Your day gave it, including a changed ask (c3-work-agent amendments 10 and 11)
       if (t.instruction && !t.my_work) say(`instruction from the PM (this is the ask): ${t.instruction}`);
       if (t.kind === 'approve') say('kind approve: deliver ONE draft; nothing goes out until the PM approves it.');
       else say('kind auto: deliver ONE draft; nothing leaves this machine.');
-      if (t.draft) { say(`draft (${t.draft.at}): ${t.draft.summary}${t.draft.link ? ' · ' + t.draft.link : ''}`); say(t.draft.body); }
+      if (t.draft) {
+        say(`draft (${t.draft.at}): ${t.draft.summary}${t.draft.link ? ' · ' + t.draft.link : ''}`);
+        // the PM edited the draft (c3-work-agent amendment 13): the body below is the PM's text, to post as it is
+        if (t.draft.edited_at) say(`edited by the PM (${t.draft.edited_at}): the text below is the PM's own. Post it exactly as written.`);
+        say(t.draft.body);
+      }
       t.revisions.forEach((rv, i) => say(`revision note ${i + 1} (${rv.at}): ${rv.note}`));
       if (t.decided) say(`decided: ${t.decided.action} at ${t.decided.at}${t.decided.note ? ' — ' + t.decided.note : ''}`);
       if (t.sent) say(`sent ${t.sent.at}${t.sent.link ? ' · ' + t.sent.link : ''}`);

package/workspace/lib/routes-my-work.js

@@ -7,9 +7,10 @@
  *   POST /api/my-work/act   { action: brief|handle|reopen, item, instruction?, ws }
  *                                        → { ok, item, task? }      the PM's press; a brief adds one day task (R5)
  *   POST /api/my-work/refresh { ws }     → { ok, session }          Read again: starts the my-work-read skill
- *   POST /api/my-work/decide { item, action: approve|revise|retry, note? }
+ *   POST /api/my-work/decide { item, action: approve|revise|retry|edit, note?, body? }
  *                                        → { ok, item, task }      the PM's decision on the agent's draft (initiative c3-work-agent):
- *                                          approve posts exactly the draft, revise sends it back with the note, retry runs a failed task again
+ *                                          approve posts exactly the draft, revise sends it back with the note, retry runs a failed task
+ *                                          again, edit saves the PM's own text as the draft (approve with body: edit, then approve)
  *   POST /api/my-work/stop   { item }    → { ok, item }            ends the item's working or queued task and offers the suggestion again
  *
  * STATE. The latest read is <runtime>/my-work/read.json and the presses are <runtime>/my-work/actions.jsonl, append-only.
@@ -156,11 +157,13 @@ const nextDay = (d) => new Date(Date.parse(d + 'T00:00:00Z') + DAY_MS).toISOStri
 /** The day run that holds the task of the item's last brief: the brief's day (UTC, as the press records it) up to today. */
 function runOfTask(ctx, brief, today) {
   const id = myWork.taskSpec({ id: brief.item }, brief).id;
+  // the newest: an approved draft of an earlier day joins today's run (amendment 13)
+  let found = null;
   for (let d = String(brief.at).slice(0, 10), n = 0; d <= today && n < 400; d = nextDay(d), n++) {
     let run = null; try { run = ctx.readDayRun ? ctx.readDayRun(d) : null; } catch { run = null; }
-    if (run && dayRun.findTask(run, id)) return { run, id };
+    if (run && dayRun.findTask(run, id)) found = { run, id };
   }
-  return null;
+  return found;
 }
 
 /** decide (approve | revise | retry) or stop, on the task of the item's last brief. */
@@ -175,12 +178,10 @@ function taskPress(ctx, res, verb, body, now) {
   const found = runOfTask(ctx, brief, list.today);
   if (verb === 'decide') {
     if (!found) { ctx.json(res, { ok: false, error: 'the agent has not started this item yet' }, 409); return; }
-    const r = dayRun.decide(found.run, found.id, { action: body.action, note: body.note }, now);
-    if (!r.ok) { ctx.json(res, { ok: false, error: r.error }, 400); return; }
-    const run = ctx.startDayTasks ? ctx.startDayTasks(r.run, now) : r.run;
-    if (!ctx.writeDayRun || !ctx.writeDayRun(run)) { ctx.json(res, { ok: false, error: 'could not save — nothing changed' }, 500); return; }
+    const d = decideDraft(ctx, found.run, found.id, body, now);
+    if (!d.ok) { ctx.json(res, { ok: false, error: d.error }, d.status || 400); return; }
     const after = listFor(ctx, Date.now()).items.find((x) => x.id === item) || null;
-    ctx.json(res, { ok: true, item: after, task: dayRun.findTask(run, found.id) });
+    ctx.json(res, { ok: true, item: after, task: dayRun.findTask(d.run, found.id) });
     return;
   }
   // stop: only a task that has not delivered yet; its session ends and the item offers the suggestion again
@@ -200,6 +201,32 @@ function taskPress(ctx, res, verb, body, now) {
   ctx.json(res, { ok: true, item: after });
 }
 
+/**
+ * The PM's decision on a draft in `run` (amendment 13): edit saves the PM's text as the draft; approve posts the draft,
+ * with the PM's text first when the press carries `body`; revise and retry as lib/day-run.js decide. A draft of an earlier
+ * day is approved in today's run, because the job CLI reads today's run only. Returns { ok, run } (the run that holds the
+ * task now) or { ok: false, error, status }.
+ */
+function decideDraft(ctx, run, taskId, body, now) {
+  const save = (r) => (ctx.writeDayRun && ctx.writeDayRun(r) ? { ok: true, run: r } : { ok: false, status: 500, error: 'could not save — nothing changed' });
+  let cur = run;
+  if (body.action === 'edit' || (body.action === 'approve' && typeof body.body === 'string')) {
+    const e = dayRun.edit(cur, taskId, body.body, now);
+    if (!e.ok) return { ok: false, error: e.error };
+    if (body.action === 'edit') return save(e.run);
+    cur = e.run;
+  }
+  if (body.action === 'approve' && cur.date !== localDate(now)) {
+    const t = dayRun.findTask(cur, taskId);
+    if (cur !== run) { const w = save(cur); if (!w.ok) return w; }
+    const b = ctx.myWorkBrief(t, String(body.ws || cur.ws || ''), (today, spec, at) => dayRun.carry(today, spec, at));
+    return b.ok ? { ok: true, run: b.run } : { ok: false, status: b.status || 500, error: b.error };
+  }
+  const r = dayRun.decide(cur, taskId, { action: body.action, note: body.note }, now);
+  if (!r.ok) return { ok: false, error: r.error };
+  return save(ctx.startDayTasks ? ctx.startDayTasks(r.run, now) : r.run);
+}
+
 /* ── the agent on an item the morning brief suggests for the PM (c3-work-agent amendment 10) and on an item the PM added
  * in Work (amendment 11). Item `brief:<id>`: its task is `t-<id>` in today's day run, added as Your day's "Have the agent
  * draft it" adds it. Item `item-<hex>`: its task is `t-<hex>`, in the newest day run of the last 7 days that holds it. */
@@ -208,13 +235,13 @@ const LOCAL_ITEM = /^item-[0-9a-f]{12}$/;
 
 /** The item the press names, as the agent sees it: its task id, the offer, the spec a press adds and its agent field. */
 function targetOf(ctx, itemId, now) {
-  const today = localDate(now);
   const bm = BRIEF_ITEM.exec(itemId);
   if (bm) {
-    let brief = null; try { brief = JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', today + '.json'), 'utf8')); } catch { brief = null; }
-    const x = brief && brief.date === today ? [...(brief.priorities || []), ...(brief.items || [])].find((y) => y && y.id === bm[1]) : null;
-    if (!x || x.owner !== 'pm') return { error: 'no item of yours with that id in today\'s brief' };
-    const run = ctx.readDayRun ? ctx.readDayRun(today) : null;
+    // today's brief, or an earlier one of the last 7 days when the PM kept the item in Work (amendment 12)
+    const readBriefOf = (d) => { try { return JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', d + '.json'), 'utf8')); } catch { return null; } };
+    const x = assigned.findBriefItem(readBriefOf, bm[1], now);
+    if (!x) return { error: 'no item of yours with that id in a brief of the last 7 days' };
+    const run = assigned.runWith(assigned.recentRuns(ctx.readDayRun, now), 't-' + x.id);
     return { postable: true, taskId: 't-' + x.id, suggest: assigned.briefSuggest(x), spec: (own) => assigned.briefDraftSpec(x, own), run, agent: (r) => assigned.briefAgent(x, r) };
   }
   // an item the PM added in Work (amendment 11): its draft is kept across days, so the newest run that holds its task decides
@@ -257,9 +284,9 @@ function agentItemPress(ctx, res, verb, body, itemId, now) {
     after(b.run, b.task); return;
   }
   if (verb === 'decide') {
-    const r = dayRun.decide(run, taskId, { action: body.action, note: body.note }, now);
-    if (!r.ok) { ctx.json(res, { ok: false, error: r.error }, 400); return; }
-    next = ctx.startDayTasks ? ctx.startDayTasks(r.run, now) : r.run;
+    const d = decideDraft(ctx, run, taskId, body, now);
+    if (!d.ok) { ctx.json(res, { ok: false, error: d.error }, d.status || 400); return; }
+    after(d.run, dayRun.findTask(d.run, taskId)); return;
   } else {
     // stop: only a task that has not delivered; its session ends and the task leaves the run, so the item offers the draft again
     if (t.status !== 'waiting' && t.status !== 'working' && t.status !== 'failed') { ctx.json(res, { ok: false, error: `the agent's task is ${t.status} — there is nothing to stop` }, 409); return; }

package/workspace/lib/routes-pm-items.js

@@ -349,6 +349,14 @@ module.exports = {
       // an item the PM added: the agent can draft a first version of it (c3-work-agent amendment 11)
       const runs = assigned.recentRuns(ctx.readDayRun, c.now.getTime());
       for (const it of v.items) if (!it.agent && assigned.localOffer(it)) it.agent = assigned.localAgent(it, assigned.runWith(runs, assigned.localTaskId(it)));
+      // an item of an earlier brief the PM kept in Work keeps its offer (amendment 12): it is no longer in today's brief
+      const readBriefOf = (d) => { try { return JSON.parse(fs.readFileSync(path.join(ctx.runtimeDir, 'briefs', d + '.json'), 'utf8')); } catch { return null; } };
+      for (const it of v.items) {
+        const m = /^brief:([0-9a-f]{12})$/.exec(String(it.id || ''));
+        if (!m || it.agent || it.done || !ctx.runtimeDir) continue;
+        const x = assigned.findBriefItem(readBriefOf, m[1], c.now.getTime());
+        if (x) { it.agent = assigned.briefAgent(x, assigned.runWith(runs, 't-' + x.id)); if (!it.place) it.place = x.source || null; }
+      }
       ctx.json(res, v);
       return true;
     }