create-pmos 0.161.0 → 0.163.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.161.0",
+  "version": "0.163.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@ada3150
+kernel-source: pmos@aa95af9
 assembled: 2026-10-12
 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-12T07:44:14Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T10:13:23Z"}
 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-12T07:44:14Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T10:13:23Z"}
 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-12T07:44:14Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T10:13:23Z"}
 status: stable
 ---
 

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

@@ -5,7 +5,8 @@
  * Starts a real server with its own state directory. Before it starts, a session record is written whose process does not exist and
  * whose file still says it runs: the server restores it as exited, and GET /api/runs must say it ended (it read "starting · 4 d" before).
  * Then one live shell is started, and the page checks: the live row reads the server's state, not "starting"; Open the session draws the
- * session's real terminal in a sheet on /c3.html and the address does not change; End asks first, Keep it keeps it, End ends it.
+ * session's real terminal in a sheet on /c3.html and the address does not change; the message box types into the session and presses Enter;
+ * End asks first, Keep it keeps it, End ends it.
  */
 const fs = require('fs');
 const path = require('path');
@@ -31,6 +32,8 @@ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function until(fn, ms = 8000) { const end = Date.now() + ms; while (Date.now() < end) { const v = await fn(); if (v) return v; await sleep(150); } return null; }
 async function waitFor(page, fn, arg, ms = 15000) { try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; } }
 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');
 
 function startShell(name) {
   return new Promise((resolve) => {
@@ -58,7 +61,7 @@ function startShell(name) {
   fs.writeFileSync(path.join(sessDir, 'sess-900.json'), JSON.stringify({ id: 'sess-900', name: 'stale claude', agent: 'shell', state: 'working', created, tmux: 'pmos-gone-900', origin: 'manual', cwd: path.resolve(__dirname, '..'), root: path.resolve(__dirname, '..') }));
   fs.writeFileSync(path.join(sessDir, 'sess-900.scrollback'), '');
 
-  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT) }) });
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT), PMOS_CLAUDE_HOME: CLAUDE_HOME }) });
   await T.waitForServer(BASE);
 
   /* ── A: /api/runs believes the server, not a stale file ── */
@@ -102,10 +105,60 @@ function startShell(name) {
   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-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);
+  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());
+  const vw = await page.evaluate(() => window.innerWidth);
+  const wid = () => page.evaluate(() => document.querySelector('[data-shell="sheet"] .sheet').getBoundingClientRect().width);
+  ok('G2 Normal is the 600px sheet', Math.abs((await wid()) - 600) < 2, String(await wid()));
+  await page.click('[data-c3-size="half"]');
+  await sleep(200);
+  ok('G3 Half makes the sheet half of the window', Math.abs((await wid()) - vw / 2) < 3, (await wid()) + ' of ' + vw);
+  ok('G3b Half is shown as pressed', await page.evaluate(() => document.querySelector('[data-c3-size="half"]').getAttribute('aria-pressed') === 'true'));
+  await page.click('[data-c3-size="whole"]');
+  await sleep(200);
+  ok('G3c Whole fills the window minus the margins', Math.abs((await wid()) - (vw - 24)) < 3, String(await wid()));
+  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 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'));
+  const termH = await page.evaluate(() => document.querySelector('[data-c3-session-term]').getBoundingClientRect().height);
+  ok('G5 the terminal has room above the scratchpad', termH > 120 && await page.evaluate(() => { const t = document.querySelector('[data-c3-session-term]').getBoundingClientRect(); const p = document.querySelector('[data-c3-pad="box"]').getBoundingClientRect(); return t.bottom <= p.top + 1; }));
+  await page.fill('[data-c3-pad="text"]', 'echo from-the-pad-7');
+  ok('G6 typing in the pad saves it for the session', !!(await until(async () => (await get('/api/scratchpad?session=' + id)).text === 'echo from-the-pad-7', 4000)));
+  await page.click(`[data-c3-session-term="${id}"] .xterm`);
+  await page.keyboard.press('Backspace');   // the Esc in C3 left the shell's readline waiting for a meta key: this key answers it
+  await page.fill('[data-c3-pad="text"]', 'echo from-the-pad-7');
+  await page.click('[data-c3-pad="send"]');
+  await sleep(800);
+  const noEnter = !/^from-the-pad-7/m.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || '');
+  await page.click(`[data-c3-session-term="${id}"] .xterm`);
+  await page.keyboard.press('Enter');
+  ok('G7 Send to terminal types the text into the session, without pressing Enter', noEnter && !!(await until(async () => /^from-the-pad-7/m.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || ''), 8000)));
+  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 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'));
+  await page.click('[data-c3-pad="toggle"]');
+  ok('G10 the toggle hides the pad and the terminal gets the room', await page.evaluate(() => document.querySelector('[data-c3-pad="text"]').hidden === true && localStorage.getItem('pmos.workspace.c3.term-pad') === 'closed'));
+  await page.click('[data-c3-pad="toggle"]');
+  await page.click('[data-shell="sheet"] [aria-label="Close"]');
+  await waitFor(page, () => !document.querySelector('[data-c3-session-term]'));
+
   /* ── D: End asks first, then ends ── */
   await page.click('[data-c3pg="agent-button"]');
   ok('D0 the panel opens again', await waitFor(page, (s) => !!document.querySelector(s), sel));
@@ -114,6 +167,45 @@ function startShell(name) {
   ok('D1 End asks first', await waitFor(page, (i) => !!document.querySelector(`[data-end-confirm="${i}"]`), id));
   await page.click(`[data-end-confirm="${id}"] button:not([data-end-yes])`);
   ok('D2 Keep it keeps the session', await waitFor(page, (i) => !document.querySelector(`[data-end-confirm="${i}"]`), id) && ((await get('/api/sessions')).sessions || []).some((s) => s.id === id));
+
+  /* ── M: the message box types into the session and presses Enter ── */
+  const box = `[data-blank-panel="${id}"] [data-run-chat]`;
+  ok('M0 the message box is enabled', await page.isEnabled(box).catch(() => false));
+  const pidFile = path.join(T.STATE_DIR, 'c3-shell.pid');
+  await page.fill(box, 'echo $$ > ' + pidFile + '; echo c3-msg-$((6*7))');
+  await page.press(box, 'Enter');
+  ok('M2 the message shows in the panel as it is sent', await waitFor(page, (i) => /c3-msg/.test((document.querySelector(`[data-blank-panel="${i}"] [data-chat-feed] [data-chat="me"]`) || {}).textContent || ''), id, 5000));
+  const m1 = await until(async () => /c3-msg-42/.test((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || ''), 8000);
+  if (!m1) console.log('  transcript:', JSON.stringify(((await get('/api/sessions/transcript?id=' + id + '&max=4000')).text || '').slice(-300)));
+  ok('M1 the message reaches the session and Enter runs it', !!m1);
+  /* the conversation: a transcript for this shell, as claude writes one, shows in the panel as messages */
+  const shellPid = (() => { try { return fs.readFileSync(pidFile, 'utf8').trim(); } catch { return ''; } })();
+  const sessRow = ((await get('/api/sessions')).sessions || []).find((x) => x.id === id) || {};
+  const root = sessRow.root || sessRow.cwd || path.resolve(__dirname, '..');
+  fs.mkdirSync(path.join(CLAUDE_HOME, 'sessions'), { recursive: true });
+  fs.writeFileSync(path.join(CLAUDE_HOME, 'sessions', shellPid + '.json'), JSON.stringify({ pid: +shellPid, sessionId: 'conv-test-1', cwd: root, version: 'test' }));
+  const proj = path.join(CLAUDE_HOME, 'projects', root.replace(/\//g, '-'));
+  fs.mkdirSync(proj, { recursive: true });
+  const rec = (o) => JSON.stringify({ isSidechain: false, timestamp: new Date().toISOString(), ...o });
+  fs.writeFileSync(path.join(proj, 'conv-test-1.jsonl'), [
+    rec({ type: 'user', isMeta: true, message: { role: 'user', content: '<system-reminder>not shown</system-reminder>' } }),
+    rec({ type: 'user', message: { role: 'user', content: 'What changed today?' } }),
+    rec({ type: 'assistant', message: { id: 'msg_1', model: 'claude-test', role: 'assistant', content: [{ type: 'tool_use', id: 't1', name: 'Bash', input: { command: 'git log' } }] } }),
+    rec({ type: 'user', message: { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'ok' }] } }),
+    rec({ type: 'assistant', message: { id: 'msg_2', model: 'claude-test', role: 'assistant', content: [{ type: 'text', text: 'Two things changed:\n- the **panel** reads the transcript\n- `send` works' }] } }),
+  ].join('\n') + '\n');
+  const feedSel = `[data-blank-panel="${id}"] [data-chat-feed]`;
+  // the server re-resolves a session's transcript at most every 2 s
+  const conv = (await until(async () => { const c = await get('/api/sessions/conversation?id=' + id); return c.messages && c.messages.length ? c : null; }, 8000)) || {};
+  ok('M3 the server reads the conversation from the transcript', conv.ok && (conv.messages || []).map((m) => m.role).join(',') === 'user,tool,assistant', JSON.stringify(conv).slice(0, 300));
+  ok('M4 the panel shows the prompt, the tool line and the reply', await waitFor(page, (sel) => {
+    const f = document.querySelector(sel); if (!f) return false;
+    const me = [...f.querySelectorAll('[data-chat="me"]')].some((n) => n.textContent === 'What changed today?');
+    const tool = [...f.querySelectorAll('[data-chat="tool"]')].some((n) => /Used Bash/.test(n.textContent));
+    const bot = f.querySelector('[data-chat="bot"]');
+    return me && tool && !!bot && !!bot.querySelector('li b') && !!bot.querySelector('li code') && !/not shown/.test(f.textContent);
+  }, feedSel, 10000));
+
   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);

package/workspace/guide/console3-sessions.md

@@ -1,11 +1,11 @@
 ---
 type: Guide
-title: "Sessions in console3: start, open, 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, and how to end a session."
+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-12
 ---
 
-# Sessions in console3: start, open, read and end your sessions
+# 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**.
 
@@ -44,8 +44,47 @@ If the server finds that the process of a session stopped (for example, after a
 
 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 scratchpad
+
+Below the terminal is a scratchpad. It keeps text for this session only. The text is saved on this machine as you type, and it is there when you open the terminal again.
+
+- To send the text to the session, press **Send to terminal**. The text is typed into the terminal. Enter is not pressed, so you can read it and press Enter yourself.
+- To hide the pad, press **Scratchpad** above it. The text is kept. The terminal gets the room back. The page remembers if the pad was hidden.
+- Esc in the pad closes the panel. Esc in the terminal goes to the terminal.
+
+### The size of the terminal
+
+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.
+
 The **Open the session** link in the sessions dock opens the same panel.
 
+## Send a message to a session
+
+1. Press the row to open it.
+2. Type your message in the message box.
+3. Press Enter.
+
+Your message is typed into the session, and Enter is pressed. The message shows in the panel at once.
+
+## Read the conversation
+
+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.
+- 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.
+
+A session that is not a Claude session, or a shell where Claude has not started, has no conversation. The panel shows what you sent, and the output is in the terminal. To read it, press **Open the session**.
+
+The **Message** box in the dock and the reply line below a card do the same.
+
+If the connection to the workspace server is down, the message is not sent. The message stays in the box, and a notice tells you.
+
+**Try again** on a session that has not started is not available. The session can wait for a question, for example whether to trust the folder. Open the session and read the question first.
+
 ## End a session
 
 1. Press the row to open it.

package/workspace/lib/transcript-read.js

@@ -315,5 +315,90 @@ function readHarness(file, clean = (x) => x) {
   return out;
 }
 
-module.exports = { findTranscript, readHarness, prettyTool, slugFor, resolvePid, descendants,
+/* ── The conversation (console3's session panel) ──────────────────────────────────────────────
+ * The PM's prompts and the agent's words, read from the same transcript, so the panel can show the
+ * conversation without parsing terminal bytes. Only what a person would call the conversation:
+ *   · a `user` record with string content (or text blocks) that is not meta, a sidechain or a compact
+ *     summary, and is not the CLI's own command bookkeeping — a slash command shows as `/name`;
+ *   · an `assistant` record's text blocks, from a real model turn (never `<synthetic>`);
+ *   · tool calls fold into one activity line between them ("Used Bash, Read ×2"), never their input,
+ *     which can hold anything.
+ * Every string goes through `clean` (server.js's scrub, D08). The newest `limit` items are returned. */
+const CONV_LIMIT = 80;
+const CONV_TEXT_MAX = 8000;
+const CLI_NOISE = /^\s*<(local-command-stdout|local-command-stderr|command-message|command-args|system-reminder|bash-input|bash-stdout|bash-stderr)>|^\s*Caveat: The messages below/;
+
+function userText(r) {
+  const m = r.message || {};
+  let t = '';
+  if (typeof m.content === 'string') t = m.content;
+  else if (Array.isArray(m.content)) t = m.content.filter((c) => c && c.type === 'text' && typeof c.text === 'string').map((c) => c.text).join('\n');
+  if (!t.trim()) return '';
+  const cmd = /<command-name>\s*\/?([^<\s]+)\s*<\/command-name>/.exec(t);
+  if (cmd) {
+    const args = /<command-args>([\s\S]*?)<\/command-args>/.exec(t);
+    return '/' + cmd[1] + (args && args[1].trim() ? ' ' + args[1].trim() : '');
+  }
+  if (CLI_NOISE.test(t)) return '';
+  return t.trim();
+}
+
+function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
+  let raw;
+  try {
+    const st = fs.statSync(file);
+    const fd = fs.openSync(file, 'r');
+    try {
+      const start = Math.max(0, st.size - MAX_BYTES);
+      const len = st.size - start;
+      const buf = Buffer.allocUnsafe(len);
+      fs.readSync(fd, buf, 0, len, start);
+      raw = buf.toString('utf8');
+      if (start > 0) raw = raw.slice(raw.indexOf('\n') + 1);
+    } finally { fs.closeSync(fd); }
+  } catch {
+    return { messages: [], missing: "can't read the conversation — the transcript could not be read" };
+  }
+  const out = [];
+  const cap = (t) => (t.length > CONV_TEXT_MAX ? t.slice(0, CONV_TEXT_MAX) + ' …' : t);
+  const push = (role, text, at) => { out.push({ role, text: clean(cap(text)), at: at || null }); };
+  const tool = (name, at) => {
+    const last = out[out.length - 1];
+    const n = clean(prettyTool(name));
+    if (last && last.role === 'tool') {
+      last.tools[n] = (last.tools[n] || 0) + 1;
+      last.at = at || last.at;
+    } else out.push({ role: 'tool', tools: { [n]: 1 }, at: at || null });
+  };
+  for (const line of raw.split('\n')) {
+    if (!line) continue;
+    let r;
+    try { r = JSON.parse(line); } catch { continue; }
+    if (r.isSidechain) continue;
+    if (r.type === 'user') {
+      if (r.isMeta || r.isCompactSummary || r.isVisibleInTranscriptOnly) continue;
+      const t = userText(r);
+      if (t) push('user', t, r.timestamp);
+      continue;
+    }
+    if (r.type !== 'assistant') continue;
+    const m = r.message || {};
+    if (!m.model || m.model === SYNTHETIC) continue;
+    for (const c of (Array.isArray(m.content) ? m.content : [])) {
+      if (!c) continue;
+      if (c.type === 'text' && typeof c.text === 'string' && c.text.trim()) {
+        const last = out[out.length - 1];
+        // one model turn can stream its text in several records: join them into one bubble
+        if (last && last.role === 'assistant' && last.msgId && last.msgId === m.id) last.text = clean(cap(last.text + '\n\n' + c.text.trim()));
+        else { push('assistant', c.text.trim(), r.timestamp); out[out.length - 1].msgId = m.id || null; }
+      } else if (c.type === 'tool_use' && c.name) tool(c.name, r.timestamp);
+    }
+  }
+  const messages = out.slice(-limit).map((x) => (x.role === 'tool'
+    ? { role: 'tool', tools: x.tools, at: x.at }
+    : { role: x.role, text: x.text, at: x.at }));
+  return { messages };
+}
+
+module.exports = { findTranscript, readHarness, readConversation, CONV_LIMIT, prettyTool, slugFor, resolvePid, descendants,
   MAX_BYTES, MAX_WALK_DEPTH, PS_SNAPSHOT_MS, defaultChildren };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.161.0",
+  "version": "0.163.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.161.0",
+      "version": "0.163.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.161.0",
+  "version": "0.163.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/c3-dock.js

@@ -8,7 +8,7 @@
  *   GET /api/sessions/transcript     the output tail, already stripped of terminal codes
  *   GET /api/runs                    the needs-you count only (a run that asks, holds a permission or needs the terminal); the cards are on the Terminal page
  *   GET and POST /api/scratchpad     the session's pad
- * The Message box, Send and End are DISABLED (drawn as the mockup's): no page press route sends a prompt to a session, and none is invented here.
+ * The Message box and Send type the message into the session and press Enter (c3-terminal-data.js send: the terminal's own socket). End asks first.
  * Icon language (c3-terminal-icons.js): the header's AGENT button (spark) opens the Terminal page, the full agent surfaces; the TERMINAL glyph (`>_`) is every "Open the session" link.
  * A folded dock leaves no rail (PM, 2026-10-12): Ctrl J and the More menu open it again. */
 import { el } from './dom.js';
@@ -29,7 +29,6 @@ const shownOf = (s, ended) => (ended && ended.has(s.id) ? 'exited' : s.shown);
 const PI = { claude: 'term', cloud: 'cloud', codex: 'bolt', shell: 'term', local: 'term' };   // spark is reserved for the agent surfaces
 const PN = { claude: 'Claude', cloud: 'Claude cloud', codex: 'Codex', shell: 'Shell', local: 'Local' };
 const NOEND = 'Ending a session needs the page route /api/session/remove, which did not answer. Use the terminal in the classic app (/classic.html).';
-const MORE = 'Sending a prompt is not available on this page: no safe route sends one. Use the session\'s terminal in the classic app (/classic.html).';
 const MAX_TREES = 10;
 
 const ago = (ms) => {
@@ -105,6 +104,15 @@ export function createDock(opts) {
       const r = await pmPost('/api/scratchpad', { session: s.id, text: pad.value });
       saveBtn.title = r && r.ok ? 'Saved' : 'Not saved: ' + ((r && r.error) || 'unreadable');
     } }, c3ic('notes', 'sm'));
+    const ended = s.shown === 'exited';
+    const msg = el('input', { type: 'text', disabled: ended, placeholder: s.shown === 'needs' ? 'Your answer' : 'Message', 'aria-label': 'Message', title: 'Types this into the session and presses Enter', 'data-c3pg': 'dock-msg' });
+    async function sendMsg() {
+      const v = msg.value.trim(); if (!v) return;
+      msg.value = '';
+      const r = await source().send(s.id, { verb: 'free', text: v });
+      if (r && r.ok) toast({ text: 'Sent to ' + s.name + '.' }); else msg.value = v;
+    }
+    msg.addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.isComposing) { e.preventDefault(); sendMsg(); } });
     detail.replaceChildren(...[
       el('div', { class: 'chips2' }, el('b', { style: 'font-size:var(--fs-3)' }, s.name), el('span', { class: 'chips2 dim mono', style: 'font-size:var(--fs-1)' }, c3ic(PI[s.agent] || 'term', 'sm'), (PN[s.agent] || s.agent) + ' · ' + ((t && t.branch) || 'no branch'))),
       el('div', { class: 'dim mono', style: 'font-size:var(--fs-1)' }, facts),
@@ -113,8 +121,8 @@ export function createDock(opts) {
         onclick: (e) => { if (e.metaKey || e.ctrlKey || e.shiftKey || e.button > 0) return; e.preventDefault(); import('./c3-session-term.js').then((m) => m.openSessionTerm({ id: s.id, name: s.name })); } }, ic('term', 'sm'), 'Open the session'),
       term,
       el('div', { class: 'form' },
-        el('input', { type: 'text', readonly: true, 'data-off': '', placeholder: s.shown === 'needs' ? 'Your answer' : 'Message', 'aria-label': 'Message', title: MORE, 'data-c3pg': 'dock-msg' }),
-        el('button', { type: 'button', class: 'ib pri sm', disabled: true, title: MORE, 'aria-label': 'Send (not available here)', 'data-c3pg': 'dock-send' }, c3ic('out', 'sm')),
+        msg,
+        c3btn({ class: 'ib pri sm', disabled: ended, title: 'Send: types this into the session and presses Enter', 'aria-label': 'Send', 'data-c3pg': 'dock-send' }, sendMsg, c3ic('out', 'sm')),
         s.shown === 'exited' ? null : el('button', { type: 'button', class: 'ib sm', title: 'End the session', 'aria-label': 'End the session', 'aria-expanded': String(S.confirm === s.id), 'data-c3pg': 'dock-end', onclick: () => { S.confirm = S.confirm === s.id ? null : s.id; drawDetail(); } }, c3ic('stop', 'sm'))),
       S.confirm === s.id ? el('div', { class: 'dk-confirm', role: 'group', 'aria-label': 'End this session?', 'data-c3pg': 'dock-confirm' }, el('span', { class: 'dim mono' }, 'End it? Any pending change stays a proposal.'),
         el('button', { type: 'button', class: 'chip2 lk', 'data-c3pg': 'dock-end-yes', onclick: () => endSession(s) }, c3ic('stop', 'sm'), 'End'),

package/workspace/public/pm/c3-session-chat.js

@@ -0,0 +1,103 @@
+/* pm/c3-session-chat.js — a session's conversation in console3's session panel: what the PM typed and what the agent answered.
+ *   chatFeed(id)   -> { node, sending(text) -> { done(ok) } }   one feed per session, kept across the panel's redraws
+ *   renderMd(text) -> Node                   the agent's markdown as nodes (fences, headings, lists, **bold**, `code`); no innerHTML
+ * The words come from GET /api/sessions/conversation (the agent CLI's own transcript, read by the server; nothing is parsed from terminal
+ * bytes). The feed polls while it is on the page and stops when the panel is gone. A message the PM just sent shows at once as
+ * "sending"; it is replaced by the transcript's copy when the agent CLI records it. Tool calls show as one quiet line ("Used Bash, Read ×2"),
+ * never their input. */
+import { el } from './dom.js';
+import { pmGet } from './http.js';
+
+const POLL_MS = 1500;
+const feeds = new Map();   // session id -> feed
+
+const bold = (s) => String(s).split(/(\*\*[^*\n]+\*\*|`[^`\n]+`)/).map((p) => (/^\*\*[^*]+\*\*$/.test(p) ? el('b', null, p.slice(2, -2))
+  : /^`[^`]+`$/.test(p) ? el('code', null, p.slice(1, -1)) : p));
+
+export function renderMd(text) {
+  const out = []; let list = null; let fence = null; let para = [];
+  const flush = () => { if (para.length) { out.push(el('p', null, ...bold(para.join(' ')))); para = []; } };
+  for (const l of String(text || '').replace(/\r\n?/g, '\n').split('\n')) {
+    if (fence) {
+      if (/^\s*```/.test(l)) { out.push(el('pre', null, el('code', null, fence.join('\n')))); fence = null; } else fence.push(l);
+      continue;
+    }
+    if (/^\s*```/.test(l)) { flush(); list = null; fence = []; continue; }
+    const li = /^\s*(?:[-*]|\d+[.)])\s+(.*)$/.exec(l);
+    if (li) {
+      flush();
+      const ordered = /^\s*\d/.test(l);
+      if (!list || list.ordered !== ordered) { list = { ordered, node: el(ordered ? 'ol' : 'ul') }; out.push(list.node); }
+      list.node.append(el('li', null, ...bold(li[1])));
+      continue;
+    }
+    list = null;
+    const h = /^#{1,6}\s+(.*)$/.exec(l);
+    if (h) { flush(); out.push(el('h4', null, ...bold(h[1]))); continue; }
+    if (!l.trim()) { flush(); continue; }
+    para.push(l.trim());
+  }
+  if (fence) out.push(el('pre', null, el('code', null, fence.join('\n'))));
+  flush();
+  return el('div', { class: 'c3t-md' }, ...out);
+}
+
+const toolLine = (tools) => 'Used ' + Object.entries(tools || {}).map(([n, k]) => (k > 1 ? n + ' ×' + k : n)).join(', ');
+const WORKING = { agent: 'Claude is working…', tool: 'Claude is running a tool, or waits for your allow in the terminal…' };
+
+function paint(f) {
+  const atEnd = f.node.scrollHeight - f.node.scrollTop - f.node.clientHeight < 40;
+  const d = f.data;
+  const msgs = d && Array.isArray(d.messages) ? d.messages : [];
+  const kids = msgs.map((m) => (m.role === 'user' ? el('div', { class: 'm me', 'data-chat': 'me' }, m.text)
+    : m.role === 'assistant' ? el('div', { class: 'm bot', 'data-chat': 'bot' }, renderMd(m.text))
+      : el('div', { class: 'm st', 'data-chat': 'tool' }, toolLine(m.tools))));
+  for (const p of f.pending) kids.push(el('div', { class: 'm me', 'data-chat': 'me', 'data-pending': '' }, p.text), p.sent ? null : el('div', { class: 'm st', 'data-chat': 'st' }, 'Sending…'));
+  // no transcript (a plain shell, another agent): what was sent stays here, and the output is in the terminal
+  if (d && d.missing && f.pending.some((p) => p.sent)) kids.push(el('div', { class: 'm st', 'data-chat': 'st' }, 'Sent. ' + d.missing + ' The output is in its terminal: press Open the session.'));
+  const working = d && WORKING[d.turn];
+  if (working && !f.pending.length) kids.push(el('div', { class: 'm st', 'data-chat': 'working', role: 'status' }, working));
+  if (!kids.filter(Boolean).length) kids.push(el('div', { class: 'm st', 'data-chat': 'empty' }, !d ? 'Reading the conversation…'
+    : d.missing ? d.missing : 'No messages yet. Type below to talk to the session.'));
+  f.node.replaceChildren(...kids.filter(Boolean));
+  if (atEnd || f.stick) { f.node.scrollTop = f.node.scrollHeight; f.stick = false; }
+}
+
+async function poll(f) {
+  if (f.busy) return;
+  f.busy = true;
+  try {
+    const r = await pmGet('/api/sessions/conversation?id=' + encodeURIComponent(f.id)).catch(() => null);
+    if (!r || !r.ok) { if (!f.data) { f.data = { messages: [], missing: (r && r.error) || 'The conversation could not be read.' }; paint(f); } return; }
+    const msgs = r.messages || [];
+    // a pending message is done when the transcript holds a user message with its text, newer than the send
+    const before = f.pending.length;
+    // (a session with no transcript keeps them: they are the only record here of what was sent)
+    f.pending = f.pending.filter((p) => !msgs.some((m) => m.role === 'user' && m.text.trim() === p.text.trim() && (!m.at || Date.parse(m.at) >= p.at - 5000))
+      && (r.missing || !p.sent || Date.now() - p.at < 60000));
+    if (r.stamp && f.data && f.data.stamp === r.stamp && f.data.turn === r.turn && before === f.pending.length) return;
+    f.data = r;
+    paint(f);
+  } finally { f.busy = false; }
+}
+
+export function chatFeed(id) {
+  let f = feeds.get(id);
+  if (f) return f;
+  f = { id, data: null, pending: [], busy: false, gone: 0, stick: true, node: el('div', { class: 'feed conv', 'data-chat-feed': id, 'aria-live': 'polite' }) };
+  // sending(text) shows the message at once and returns its handle: done(true) when it reached the session, done(false) takes it back
+  f.sending = (text) => {
+    const p = { text: String(text), at: Date.now(), sent: false };
+    f.pending.push(p); f.stick = true; paint(f);
+    return { done: (ok) => { if (ok) p.sent = true; else f.pending = f.pending.filter((x) => x !== p); paint(f); if (ok) setTimeout(() => poll(f), 400); } };
+  };
+  f.timer = setInterval(() => {
+    // the panel redraws by rebuilding its tree and appending this same node again; only a node that stays off the page ends the feed
+    if (!f.node.isConnected) { if (++f.gone > 2) { clearInterval(f.timer); feeds.delete(id); } return; }
+    f.gone = 0; poll(f);
+  }, POLL_MS);
+  feeds.set(id, f);
+  paint(f);
+  poll(f);
+  return f;
+}

package/workspace/public/pm/c3-session-term.js

@@ -6,7 +6,21 @@
 import { el } from './dom.js';
 import { openSheet } from './c3-sheet.js';
 import { toast } from './c3-toast.js';
-import { pmGet } from './http.js';
+import { pmGet, pmPost } from './http.js';
+import { button } from './primitives.js';
+import { c3ic } from './pm-work-view.js';
+
+/* a primitives button (keyboard, role) carrying the console3 look and children (the pattern c3-dock.js uses) */
+const c3btn = (attrs, onClick, ...kids) => { const b = button({ variant: 'ghost', attrs, onClick }); b.replaceChildren(...kids); return b; };
+const store = {
+  get(k) { try { return localStorage.getItem(k); } catch { return null; } },
+  set(k, v) { try { localStorage.setItem(k, v); } catch { /* no storage */ } },
+};
+export const SIZE_KEY = 'pmos.workspace.c3.term-size';
+export const PAD_KEY = 'pmos.workspace.c3.term-pad';
+/* the sheet widths: Normal is the 600px wide sheet; the others are classes in console3.css (desktop only) */
+export const SIZES = [['normal', 'Normal', 'Normal'], ['half', 'Half', 'Half of the window'], ['two-thirds', '2/3', 'Two-thirds of the window'], ['whole', 'Whole', 'Whole window']];
+export const sizeOf = (v) => (SIZES.some((x) => x[0] === v) ? v : 'normal');
 
 const VENDOR = ['/vendor/xterm.js', '/vendor/addon-fit.js', '/vendor/addon-web-links.js'];
 let vendor = null;
@@ -29,6 +43,43 @@ function loadVendor() {
   return vendor;
 }
 
+/* the scratchpad under the terminal: the classic app's per-session pad (panel-tabs.js), kept through /api/scratchpad */
+function makePad(id, term, tab) {
+  const url = '/api/scratchpad?session=' + encodeURIComponent(id);
+  let typed = false; let timer = null; let pending = null; let closed = false;
+  const flush = () => {
+    if (timer) { clearTimeout(timer); timer = null; }
+    if (pending === null) return;
+    const text = pending; pending = null;
+    pmPost('/api/scratchpad', { session: id, text }).catch(() => { /* the text stays in the box */ });
+  };
+  const ta = el('textarea', { class: 'c3t-pad-ta', rows: '4', placeholder: 'Scratchpad. One pad for each session. Saved on this machine.', 'aria-label': 'Scratchpad', 'data-c3-pad': 'text',
+    oninput: () => { typed = true; pending = ta.value; if (timer) clearTimeout(timer); timer = setTimeout(flush, 500); sync(); } });
+  const send = c3btn({ class: 'pill', 'data-c3-pad': 'send', title: 'Type the pad into this session. Enter is not pressed.' }, () => {
+    if (!ta.value.trim()) return;
+    if (!term.sendToTerm(tab, ta.value)) { toast({ text: 'The text was not sent. The terminal is not connected.', tone: 'error' }); return; }
+    if (typeof term.focusTerm === 'function') term.focusTerm(tab);
+  }, c3ic('out', 'sm'), 'Send to terminal');
+  const open0 = store.get(PAD_KEY) !== 'closed';
+  const box = el('div', { class: 'c3t-pad', 'data-c3-pad': 'box' });
+  const toggle = c3btn({ class: 'chip2 lk', 'data-c3-pad': 'toggle' }, () => { const on = box.dataset.open !== 'true'; store.set(PAD_KEY, on ? 'open' : 'closed'); set(on); },
+    c3ic('edit', 'sm'), 'Scratchpad');
+  function set(on) {
+    box.dataset.open = String(on);
+    toggle.setAttribute('aria-expanded', String(on));
+    toggle.title = on ? 'Hide the scratchpad. The text is kept.' : 'Show the scratchpad';
+    ta.hidden = !on;
+    requestAnimationFrame(() => term.refitVisible());
+  }
+  function sync() { send.disabled = !ta.value.trim(); }
+  box.append(el('div', { class: 'c3t-pad-h' }, toggle, send), ta);
+  set(open0); sync();
+  pmGet(url).then((r) => { if (!typed && r && typeof r.text === 'string') { ta.value = r.text; sync(); } }).catch(() => { /* an empty pad */ });
+  const onHide = () => flush();
+  window.addEventListener('pagehide', onHide);
+  return { box, ta, dispose() { if (closed) return; closed = true; window.removeEventListener('pagehide', onHide); flush(); } };
+}
+
 export async function openSessionTerm({ id, name } = {}) {
   if (!id) return null;
   if (!name) { const r = await pmGet('/api/sessions').catch(() => null); const x = r && Array.isArray(r.sessions) ? r.sessions.find((y) => y.id === id) : null; name = x ? x.name : id; }
@@ -36,8 +87,23 @@ export async function openSessionTerm({ id, name } = {}) {
   if (!ok || !term) { toast({ text: 'The terminal could not be loaded on this page.', tone: 'error' }); return null; }
   const tab = { id: 'c3-session:' + id, kind: 'term', sessionId: id, spawn: false, sess: id };
   const host = el('div', { class: 'c3t-term', 'data-c3-session-term': id });
-  // Esc and Tab belong to the shell while the terminal has focus (Esc interrupts an agent); the close button and a press outside still close
-  const sheet = openSheet({ title: name || id, icon: 'term', wide: true, body: host, onClose: () => term.disposeTerm(tab), passKeys: (e) => host.contains(e.target) });
+  const pad = makePad(id, term, tab);
+  const wrap = el('div', { class: 'c3t-tw' }, host, pad.box);
+  // the size control: Normal is the 600px sheet, the others are the classic dock's presets. Hidden on a phone, where the sheet is full width.
+  let size = sizeOf(store.get(SIZE_KEY));
+  const sizeBtns = SIZES.map(([k, label, title]) => c3btn({ 'aria-pressed': String(k === size), 'data-c3-size': k, title, 'aria-label': title }, () => setSize(k), label));
+  const seg = el('div', { class: 'seg c3t-size', role: 'group', 'aria-label': 'Terminal size', 'data-c3-size-seg': '' }, ...sizeBtns);
+  const cls = (k) => 'tsz-' + k;
+  // Esc and Tab belong to the shell while the terminal has focus (Esc interrupts an agent); the close button and a press outside still close.
+  // The scratchpad is outside the terminal host, so its keys are the page's own.
+  const sheet = openSheet({ title: name || id, icon: 'term', wide: true, body: wrap, actions: seg, cls: cls(size),
+    onClose: () => { pad.dispose(); term.disposeTerm(tab); }, passKeys: (e) => host.contains(e.target) });
+  function setSize(k) {
+    sheet.sheet.classList.remove(cls(size)); size = sizeOf(k); sheet.sheet.classList.add(cls(size));
+    store.set(SIZE_KEY, size);
+    sizeBtns.forEach((b) => b.setAttribute('aria-pressed', String(b.dataset.c3Size === size)));
+    requestAnimationFrame(() => { term.refitVisible(); requestAnimationFrame(() => term.refitVisible()); });
+  }
   term.mountTerm(host, tab);
   requestAnimationFrame(() => { term.refitVisible(); term.focusTerm(tab); });
   return sheet;

package/workspace/public/pm/c3-sheet.js

@@ -1,7 +1,8 @@
 /* pm/c3-sheet.js — the console3 sheet, as a primitive (console3.html: bsHtml line 2502, the .sheet rules 143 to 145, 180, 496 to 502,
  * the Esc handler 2536 and the phone drag 2538 to 2540).
  *
- *   openSheet({ title, icon, body, wide, dw, scrim, onClose, passKeys }) -> { close, root, sheet, body }   passKeys(e): true leaves that key to the page
+ *   openSheet({ title, icon, body, wide, dw, scrim, onClose, passKeys, actions, cls }) -> { close, root, sheet, body }   passKeys(e): true leaves that key to the page
+ *                                                          actions: a Node or an array of Nodes placed in the header before the close button; cls: extra class names on the sheet
  *   closeSheet()                                          closes the open sheet, if any
  *
  * On a desktop window the sheet is the right-hand panel (340px; `wide` 600px; `dw` the document sheet, up to 780px) over a
@@ -50,7 +51,7 @@ export function closeSheet() {
   if (typeof c.onClose === 'function') { try { c.onClose(); } catch { /* the caller reports its own errors */ } }
 }
 
-export function openSheet({ title = '', icon = 'doc', body, wide = false, dw = false, scrim = true, onClose, passKeys } = {}) {
+export function openSheet({ title = '', icon = 'doc', body, wide = false, dw = false, scrim = true, onClose, passKeys, actions, cls = '' } = {}) {
   closeSheet();
   ensureC3Css();
   const opener = document.activeElement && document.activeElement !== document.body ? document.activeElement : null;
@@ -60,8 +61,8 @@ export function openSheet({ title = '', icon = 'doc', body, wide = false, dw = f
   const sbb = el('div', { class: 'brief sbb' }, ...bodyNodes(body));
   const closeBtn = el('button', { type: 'button', class: 'ib sm', 'aria-label': 'Close', title: 'Close (Esc)', onclick: close }, c3ic('x', 'sm'));
   const grab = el('div', { class: 'grab' });
-  const head = el('div', { class: 'sh2' }, el('span', { class: 'chips2' }, c3ic(icon), el('b', null, title)), el('span', { class: 'chips2' }, closeBtn));
-  const sheet = el('div', { class: 'sheet bs' + (wide ? ' wide' : '') + (dw ? ' dw' : ''), role: 'dialog', 'aria-modal': String(!!scrim), 'aria-label': title, tabindex: '-1' },
+  const head = el('div', { class: 'sh2' }, el('span', { class: 'chips2' }, c3ic(icon), el('b', null, title)), el('span', { class: 'chips2' }, ...bodyNodes(actions), closeBtn));
+  const sheet = el('div', { class: 'sheet bs' + (wide ? ' wide' : '') + (dw ? ' dw' : '') + (cls ? ' ' + cls : ''), role: 'dialog', 'aria-modal': String(!!scrim), 'aria-label': title, tabindex: '-1' },
     grab, head, el('div', { class: 'sb' }, sbb));
   /* the mockup's person and playbooks sheets have no scrim (they are panels beside the page, closed by their own button or Esc): `scrim: false` */
   root.append(...(scrim ? [el('div', { class: 'scrim', onclick: close })] : []), sheet);

package/workspace/public/pm/c3-terminal-data.js

@@ -1,19 +1,41 @@
 /* pm/c3-terminal-data.js — where the agent surfaces read and press, in one place.
  *   source()  -> { demo, getRuns(), answer(body), correct(body), canPrompt, why, ... }
- * REAL: GET /api/runs; POST /api/runs/answer and /api/runs/correction (a page press; the server refuses any other caller). Nothing here sends
- * a prompt to a session: no page route does. `canPrompt` is false and `why` says so; every control that would send one is drawn disabled with it.
+ * REAL: GET /api/runs; POST /api/runs/answer and /api/runs/correction (a page press; the server refuses any other caller). send(id, m) types
+ * the message into the session and presses Enter, on the page's terminal socket (tab-term.js typeIntoSession: the frame the terminal's own keys
+ * use, under the page's launch nonce). The reply is in the session's terminal, which Open the session shows.
  * DEMO: the fixtures of c3-demo-term.js, in the real response shapes, answers from memory and advances its own state; nothing is sent.
  *
  * needsYou(runs) is the one count for the needs-you badge: a run that asks, holds a permission, needs the terminal or did not start. */
 import { pmGet, pmPost } from './http.js';
+import { toast } from './c3-toast.js';
 
-export const WHY_PROMPT = 'Sending a prompt to a session is not available on this page: no safe route sends one. To type to the session, press Open the session.';
+export const SENT = 'Sent to the session. The reply shows in the session panel and in its terminal.';
+const NOT_SENT = 'Not sent: the connection to the workspace server is down. Your message is still here.';
+
+/* what each verb types into the session */
+function textOf(m) {
+  if (!m) return '';
+  if (m.verb === 'free') return String(m.text || '');
+  if (m.verb === 'suggest') return String(m.prompt || m.label || '');
+  if (m.verb === 'revise') return 'Revise it: ' + String(m.arg || '') + '.';
+  if (m.verb === 'retry') return 'Please try that again.';
+  return '';
+}
+async function sendToSession(id, m) {
+  const text = textOf(m).trim();
+  if (!id || !text) return { ok: false, error: 'nothing to send' };
+  const term = await import('./tab-term.js').catch(() => null);
+  const sent = !!(term && typeof term.typeIntoSession === 'function' && await term.typeIntoSession(id, text));
+  if (!sent) toast({ text: NOT_SENT, tone: 'error' });
+  return sent ? { ok: true, say: { text: SENT } } : { ok: false, error: NOT_SENT };
+}
 
 const real = {
-  demo: false, canPrompt: false, why: WHY_PROMPT,
+  demo: false, canPrompt: true, why: '',
   getRuns: () => pmGet('/api/runs'),
   answer: (b) => pmPost('/api/runs/answer', b),
   correct: (b) => pmPost('/api/runs/correction', b),
+  send: sendToSession,
 };
 /* demo: c3-demo.js registers the fixtures' factory (window.__c3termfx_make) by importing c3-demo-term.js; the page is in demo when installDemo() ran (window.__c3demo). */
 export const isDemo = () => typeof window !== 'undefined' && !!window.__c3demo && typeof window.__c3termfx_make === 'function';

package/workspace/public/pm/console3.css

@@ -1660,10 +1660,34 @@
 .c3 .c3t-panel{display:grid;gap:var(--sp-2);border:1px solid var(--border);border-radius:10px;padding:var(--sp-3)}
 /* a session's terminal in a sheet (c3-session-term.js) */
 .c3 .c3t-term{height:calc(100vh - 150px);min-height:240px;display:flex;flex-direction:column}
+/* the terminal plus its scratchpad (c3-session-term.js): the terminal shrinks to make room for the pad */
+.c3 .c3t-tw{height:calc(100vh - 150px);min-height:240px;display:flex;flex-direction:column;gap:var(--sp-2);min-width:0}
+.c3 .c3t-tw .c3t-term{height:auto;flex:1 1 0;min-height:120px}
+.c3 .c3t-pad{display:grid;gap:var(--sp-2);flex:none;border-top:1px solid var(--border);padding-top:var(--sp-2)}
+.c3 .c3t-pad-h{display:flex;gap:var(--sp-2);align-items:center;justify-content:space-between}
+.c3 .c3t-pad-h .pill:disabled{opacity:.35;cursor:not-allowed}
+.c3 .c3t-pad-ta{width:100%;min-height:72px;max-height:40vh;resize:vertical;font:var(--fs-2) var(--mono);box-sizing:border-box}
+/* terminal sheet sizes, as the classic dock has them; the phone sheet is already full width */
+.c3 .c3t-size{flex:none}
+.c3 .c3t-size button{padding:4px 8px}
+.c3.ph .c3t-size{display:none}
+@media (min-width:761px){
+  .c3 .sheet.wide.tsz-half{width:50vw}
+  .c3 .sheet.wide.tsz-two-thirds{width:66.667vw}
+  .c3 .sheet.wide.tsz-whole{width:calc(100vw - 24px)}
+}
 .c3 .c3t-panel .feed{display:flex;flex-direction:column;gap:var(--sp-2);max-height:220px;overflow:auto}
 .c3 .c3t-panel .m{padding:6px 12px;border-radius:12px;max-width:88%;overflow-wrap:anywhere}
 .c3 .c3t-panel .m.me{align-self:flex-end;background:var(--acc);color:var(--on-accent)}.c3 .c3t-panel .m.bot{background:var(--muted)}
 .c3 .c3t-panel .m.st{color:var(--muted-foreground);font:var(--fs-2) var(--mono);padding:0}
+/* a real session's conversation (c3-session-chat.js): taller than the demo feed, the agent's markdown inside its bubble */
+.c3 .c3t-panel .feed.conv{max-height:min(460px,55vh);padding-right:4px}
+.c3 .c3t-panel .m.me{white-space:pre-wrap}
+.c3 .c3t-panel .m.bot .c3t-md{display:grid;gap:6px}
+.c3 .c3t-panel .m.bot .c3t-md>*{margin:0}
+.c3 .c3t-panel .m.bot ul,.c3 .c3t-panel .m.bot ol{padding-left:18px}
+.c3 .c3t-panel .m.bot code{font:var(--fs-2) var(--mono)}
+.c3 .c3t-panel .m.bot pre{margin:0;padding:8px 10px;border-radius:8px;background:var(--background);border:1px solid var(--border);overflow:auto;max-height:240px}
 .c3 .c3t-tl2 .tlr{display:flex;gap:var(--sp-2);align-items:baseline;padding:6px 0;border-bottom:1px solid var(--border)}
 .c3 .c3t-tl2 .tlr .lab{width:78px}
 .c3 .c3t-edge{display:grid;grid-template-columns:minmax(0,260px) minmax(0,1fr);gap:var(--sp-4);align-items:start}

package/workspace/public/pm/run-card.js

@@ -8,8 +8,8 @@
  * Gestures (c3-swipe.js, card-state.swipeAction): swipe right = the card's primary move (Accept, on a finished result), swipe left = the reply tray
  * (the agent's suggested chips and a free line). A swipe sends nothing outward. Keys: ArrowRight, ArrowLeft on the focused card.
  * Presses: Accept is POST /api/runs/answer {behavior:'accept'}; Revise and Reject are POST /api/runs/correction (the correction signal); a permission
- * is POST /api/runs/answer {allow|deny}; the agent's question is {answer, message: an offered option}. Every one is the PM's press. Anything that
- * would send a prompt to the session (a suggestion, a revision, the free line, the mic) is drawn disabled with the reason: ctx.src.canPrompt.
+ * is POST /api/runs/answer {allow|deny}; the agent's question is {answer, message: an offered option}. Every one is the PM's press. A suggestion,
+ * a revision, the free line and Retry are typed into the session (ctx.src.send); a source that cannot send says why (ctx.src.canPrompt, ctx.src.why).
  * Per-run UI state (the open tray, the Revise chips, the flipped face) lives in `UI`, outside the render, so a poll never closes it. */
 import { el } from './dom.js';
 import { button } from './primitives.js';
@@ -89,7 +89,8 @@ function failBox(ctx, card, ui) {
   if (card.state === 'degraded' && card.fallbackText) nodes.push(el('div', { class: 'draft' }, card.fallbackText));
   if (ui.raw && (card.problems || []).length) nodes.push(el('div', { class: 'raw' }, (card.problems || []).map((p) => el('div', null, '> ' + p))));
   nodes.push(el('div', { class: 'c3t-tray' },
-    (retry || asAgain) ? el('button', { type: 'button', class: 'pill rec', 'data-retry': '', disabled: !can, title: can ? '' : ctx.src.why, onclick: async () => { const r = await ctx.src.send(ctx.id, { verb: 'retry' }); if (r && r.ok) ctx.refresh(); } }, asAgain ? 'Ask again in the format' : card.state === 'not_started' ? 'Try again' : 'Retry') : null,
+    (retry || asAgain) ? button({ label: asAgain ? 'Ask again in the format' : card.state === 'not_started' ? 'Try again' : 'Retry', disabled: !can || card.state === 'not_started', onClick: async () => { const r = await ctx.src.send(ctx.id, { verb: 'retry' }); if (r && r.ok) ctx.refresh(); },
+      attrs: { class: 'pill rec', 'data-retry': '', title: !can ? ctx.src.why : card.state === 'not_started' ? NOSTART : 'Types "Please try that again." into the session' } }) : null,
     openBtn(ctx),
     (card.problems || []).length ? el('button', { type: 'button', class: 'pill', 'aria-pressed': String(!!ui.raw), onclick: () => { ui.raw = !ui.raw; ctx.redraw(); } }, ui.raw ? 'Hide' : 'What it said') : null,
     el('button', { type: 'button', class: 'ib', 'aria-label': 'Dismiss', title: 'Dismiss this notice', onclick: () => { ui.hidden = card.state + ':' + (code || ''); ctx.redraw(); } }, ic('x', 'sm'))));
@@ -100,6 +101,8 @@ function pausedBox(ctx, card) {
   return el('div', { class: 'ask', 'data-run-paused': '' }, el('b', { class: 'chips2' }, ic('run', 'sm'), 'Paused: usage limit'), dim(at ? 'Resumes by itself at about ' + at + '. Everything done so far is kept.' : 'The run is paused, not failed. Everything done so far is kept.'),
     el('div', { class: 'prog', 'aria-hidden': 'true' }, el('i', { class: 'd' }), el('i', { class: 'd' }), el('i'), el('i')), el('div', { class: 'c3t-tray' }, openBtn(ctx)));
 }
+// a session that has not started may be at the CLI's trust-the-folder question, where a typed Enter would answer it
+const NOSTART = 'Open the session to see what it waits for: typing into it now could answer a question you have not read.';
 export function openBtn(ctx) {
   const b = button({ label: 'Open the session', onClick: () => ctx.openSession && ctx.openSession(ctx.id), attrs: { class: 'pill c3t-open', 'data-open-session': '', title: 'Open the session: its real terminal, on this page' } });
   b.prepend(ic('term', 'sm'));

package/workspace/public/pm/sessions-panel.js

@@ -15,6 +15,7 @@ import { attachExpand, makeXp } from './c3-expand.js';
 import { toast } from './c3-toast.js';
 import { pmPost } from './http.js';
 import { button } from './primitives.js';
+import { chatFeed } from './c3-session-chat.js';
 
 const live = new WeakMap();
 const DOT = { working: 'w', queued: 'w', asking: 'n', permission: 'n', attention: 'n', not_started: 'n', failed: 'b', quiet: '', paused: 'n', done: '' };
@@ -61,15 +62,31 @@ function row(st, s, card, parts) {
 const dim = (t) => el('span', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, t);
 
 function blankPanel(st, s, card) {
-  const ui = uiFor(s.id); const can = st.src.canPrompt;
-  const chat = ui.chat || (ui.chat = [['bot', 'What would you like to look at?']]);
+  const ui = uiFor(s.id); const can = st.src.canPrompt; const demo = !!st.src.demo;
+  // the demo answers in the panel from its fixtures; a real session's conversation is read from the agent CLI's transcript (c3-session-chat.js)
+  const chat = ui.chat || (ui.chat = demo ? [['bot', 'What would you like to look at?']] : []);
+  const feed = !demo && can ? chatFeed(s.id) : null;
   const redraw = () => { st.redraw(); };
-  const say = async (v) => { chat.push(['me', v], ['st', 'Reading planning/ …']); redraw(); const r = await st.src.send(s.id, { verb: 'free', text: v }); chat.pop(); chat.push(['bot', (r && r.say && r.say.text) || 'Done.']); redraw(); };
-  const input = el('input', { type: 'text', 'aria-label': 'Message to the agent', placeholder: can ? 'Message the agent' : 'Message (not available here)', readonly: !can, disabled: !can, title: can ? '' : st.src.why, 'data-run-chat': '' });
-  input.addEventListener('keydown', (e) => { if (e.key === 'Enter' && input.value.trim()) say(input.value.trim()); });
+  const say = async (v) => {
+    if (feed) {
+      const h = feed.sending(v);
+      const r = await st.src.send(s.id, { verb: 'free', text: v });
+      h.done(!!(r && r.ok));
+      if (!(r && r.ok)) { ui.draft = v; redraw(); }
+      return;
+    }
+    chat.push(['me', v], ['st', 'Reading planning/ …']); redraw();
+    const r = await st.src.send(s.id, { verb: 'free', text: v });
+    chat.pop();
+    if (r && r.ok) chat.push(['bot', (r.say && r.say.text) || 'Done.']); else { chat.pop(); ui.draft = v; }
+    redraw();
+  };
+  const input = el('input', { type: 'text', 'aria-label': 'Message to the agent', placeholder: can ? 'Message the agent' : 'Message (not available here)', readonly: !can, disabled: !can, title: can ? 'Types this into the session and presses Enter' : st.src.why, 'data-run-chat': '' });
+  if (ui.draft) { input.value = ui.draft; ui.draft = ''; }
+  input.addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.isComposing && input.value.trim()) { const v = input.value.trim(); input.value = ''; say(v); } });
   return el('div', { class: 'c3t-panel', 'data-blank-panel': s.id },
-    can ? el('div', { class: 'feed' }, chat.map((m) => el('div', { class: 'm ' + m[0] }, m[1]))) : null,
-    can ? el('div', { class: 'c3t-tray' }, ["Review this week's slips", 'Draft the monthly report'].map((t, i) => el('button', { type: 'button', class: 'pill' + (i ? '' : ' rec'), onclick: () => say(t) }, t))) : null,
+    feed ? feed.node : can && chat.length ? el('div', { class: 'feed' }, chat.map((m) => el('div', { class: 'm ' + m[0] }, m[1]))) : null,
+    can && demo ? el('div', { class: 'c3t-tray' }, ["Review this week's slips", 'Draft the monthly report'].map((t, i) => pill(t, null, () => say(t), { class: i ? '' : 'rec' }))) : null,
     el('div', { class: 'c3t-tray' }, input, openBtn({ id: s.id, openSession: st.openSession }), endBtn(st, s)),
     st.confirm === s.id ? endConfirm(st, s) : null,
     can ? null : dim(st.src.why));

package/workspace/public/pm/tab-term.js

@@ -1081,6 +1081,23 @@ export function sendToTerm(tab, data) {
   return send({ t: 'input', id: rec.sessionId, data });
 }
 
+/**
+ * Type a message into a running session, by id, and press Enter — for console3, which shows a session without a pane.
+ *
+ * The same socket and `input` frame the terminal's own keys use (the socket carries this page's launch nonce), so it is
+ * exactly as safe as typing into the terminal. The Enter goes in its own frame a moment later: an agent's screen reads
+ * text and Enter that arrive together as a paste, and a pasted Enter is a new line, not a send. Resolves false when the
+ * socket did not open, so a caller can say "not sent".
+ */
+export async function typeIntoSession(id, text) {
+  if (FIXTURE || !id || !text) return false;
+  connect();
+  for (let i = 0; i < 50 && !socketOpen(); i++) await new Promise((r) => setTimeout(r, 100));
+  if (!send({ t: 'input', id, data: text })) return false;
+  await new Promise((r) => setTimeout(r, 150));
+  return send({ t: 'input', id, data: '\r' });
+}
+
 /**
  * End a running session, by id — the `＋ session` chooser's one destructive action.
  *

package/workspace/server.js

@@ -2755,6 +2755,33 @@ function agentPid(s) {
 // the CLI never PRINTS its model, effort, token usage or skill set to the terminal, so parsing
 // scrollback for them returned four empty rows. Scrollback still owns the one thing it is
 // actually the source of — the agent's last words. Re-read on transcript mtime/size change.
+// Which transcript is this session's (shared by the harness drill-in and console3's conversation). Re-resolved at most every ~2s.
+function txFound(s, now = Date.now()) {
+  if (!s.txFound || (now - (s.txFoundAt || 0)) > 2000) {
+    s.txFound = transcript.findTranscript(agentPid(s), s.root);
+    s.txFoundAt = now;
+  }
+  return s.txFound;
+}
+// console3's session conversation: the PM's prompts and the agent's words from the transcript (transcript-read.readConversation).
+// Re-parsed only when the file moves; `stamp` lets the page skip a redraw when nothing changed. Read-only and local.
+function sessionConversation(s) {
+  if (s.agent !== 'claude' && s.agent !== 'shell') return { messages: [], missing: 'Only Claude sessions show a conversation here.' };
+  const found = txFound(s);
+  if (found.missing) {
+    if (s.agent === 'shell' && /wrote no session record/.test(found.missing)) return { messages: [], missing: 'No agent is running in this shell yet.' };
+    return { messages: [], missing: found.missing };
+  }
+  let stamp = null;
+  try { const st = fs.statSync(found.file); stamp = `${st.size}:${st.mtimeMs}`; } catch {}
+  if (s.conv && s.convStamp === stamp) return s.conv;
+  const c = transcript.readConversation(found.file, scrub);
+  const h = transcriptHarness(s);
+  c.turn = h && h.turn ? h.turn : null;
+  c.stamp = stamp;
+  s.conv = c; s.convStamp = stamp;
+  return c;
+}
 function transcriptHarness(s) {
   if (s.state === 'exited') return { missing: { all: 'the session has exited' } };
   // A `shell` session is included: the PM launches `claude` INSIDE the default shell pane, so the
@@ -2767,11 +2794,7 @@ function transcriptHarness(s) {
   // spawn a ps per session per push. Re-resolving every ~2s also picks up a claude the PM restarts
   // inside the same shell (a new child pid) without a stale cache pinning the old transcript.
   const now = Date.now();
-  if (!s.txFound || (now - (s.txFoundAt || 0)) > 2000) {
-    s.txFound = transcript.findTranscript(agentPid(s), s.root);
-    s.txFoundAt = now;
-  }
-  const found = s.txFound;
+  const found = txFound(s, now);
   if (found.missing) {
     // R4 — VERIFIED ABSENT IS NOT A FAILED SEARCH. A `shell` pane is walked for a descendant claude
     // because the PM often starts one there; when none is running, findTranscript's answer ("the CLI
@@ -6404,6 +6427,14 @@ async function handleRequest(req, res) {
   }
   // The tail of one session's terminal text, escape codes stripped, so a CLI can turn "what I just did" into a skill.
   // Read-only, local, and capped; it names the session it read or says there is none.
+  // console3's session panel: the conversation (prompts and replies) of one session, from the agent CLI's own transcript.
+  if (p === '/api/sessions/conversation' && req.method === 'GET') {
+    const sess = sessions.get(String(url.searchParams.get('id') || ''));
+    if (!sess) return json(res, { ok: false, error: 'no such session' }, 404);
+    if (sess.state === 'exited') return json(res, { ok: true, id: sess.id, messages: [], missing: 'The session has ended.', turn: null, stamp: null });
+    const c = sessionConversation(sess);
+    return json(res, { ok: true, id: sess.id, messages: c.messages, missing: c.missing || null, turn: c.turn || null, stamp: c.stamp || null });
+  }
   if (p === '/api/sessions/transcript' && req.method === 'GET') {
     const sess = sessions.get(String(url.searchParams.get('id') || ''));
     if (!sess) return json(res, { ok: false, error: 'no such session' }, 404);