create-pmos 0.161.0 → 0.162.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.161.0",
+  "version": "0.162.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@4dfe5a0
 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-12T09:50:47Z"}
 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-12T09:50:47Z"}
 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-12T09:50:47Z"}
 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,6 +105,7 @@ 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')));
@@ -114,6 +118,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**.
 
@@ -46,6 +46,33 @@ The terminal of the session opens in a panel on the same page. You can type in i
 
 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.162.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.161.0",
+      "version": "0.162.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.162.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-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

@@ -1664,6 +1664,14 @@
 .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);