create-pmos 0.160.0 → 0.162.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.160.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@dd003f0
+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-12T06:29:58Z"}
+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-12T06:29:58Z"}
+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-12T06:29:58Z"}
+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);
@@ -121,6 +164,30 @@ function startShell(name) {
   ok('D3 End ends the session', !!(await until(gone, 8000)));
   ok('D4 its row leaves Started by me', await waitFor(page, (s) => !document.querySelector(s), sel));
 
+  /* ── F: New session starts on console3 and opens its terminal here (c3-new-session; it went to the classic app before) ── */
+  const before = new Set(((await get('/api/sessions')).sessions || []).map((s) => s.id));
+  if (!(await page.isVisible('[data-c3t="new"]').catch(() => false))) await page.click('[data-c3pg="agent-button"]');
+  ok('F1 Started by me has a New button', await waitFor(page, () => !!document.querySelector('[data-c3t="new"]')));
+  await page.click('[data-c3t="new"]');
+  ok('F2 New opens the new-session sheet on this page', await waitFor(page, () => !!document.querySelector('[data-c3ns="form"]')) && page.url() === url0, page.url());
+  await page.fill('[data-c3ns="name"]', 'c3 new shell');
+  await page.selectOption('[data-c3ns="agent"]', 'shell');
+  await page.click('[data-c3ns="start"]');
+  const made = await until(async () => ((await get('/api/sessions')).sessions || []).find((s) => !before.has(s.id) && s.name === 'c3 new shell'), 10000);
+  ok('F3 Start starts the session on the server', !!made);
+  ok('F4 its terminal opens in a sheet on console3', !!made && await waitFor(page, (i) => !!document.querySelector(`[data-c3-session-term="${i}"] .xterm`), made.id) && page.url() === url0, page.url());
+  await page.click('[data-shell="sheet"] [aria-label="Close"]');
+  await waitFor(page, () => !document.querySelector('[data-c3-session-term]'));
+  await page.evaluate(() => window.dispatchEvent(new CustomEvent('pmos:open-session', { detail: {} })));
+  ok('F5 an open-session request with no session opens the new-session sheet, not the classic app', await waitFor(page, () => !!document.querySelector('[data-c3ns="form"]')) && page.url() === url0, page.url());
+  await page.click('[data-shell="sheet"] [aria-label="Close"]');
+  await waitFor(page, () => !document.querySelector('[data-c3ns="form"]'));
+  if (await page.isVisible('[data-c3pg="dock-new"]').catch(() => false)) {
+    await page.click('[data-c3pg="dock-new"]');
+    ok('F6 the dock\'s + opens the new-session sheet on this page', await waitFor(page, () => !!document.querySelector('[data-c3ns="form"]')) && page.url() === url0, page.url());
+    await page.click('[data-shell="sheet"] [aria-label="Close"]');
+  }
+
   ok('E1 the page threw no error', errors.length === 0, errors.join(' | '));
   return finish();
 })().catch((e) => { console.error(e); finish(1); });

package/workspace/guide/console3-sessions.md

@@ -1,11 +1,11 @@
 ---
 type: Guide
-title: "Sessions in console3: open, read and end your sessions"
-description: "How the Sessions panel in console3 groups your sessions, 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: 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**.
 
@@ -13,6 +13,24 @@ Press the **Sessions** button in the console3 header to open the panel. It is th
 
 The dock is open on the Briefing. On the other tabs it is folded away, and no rail of buttons is left at the right edge. To open the dock again, press Ctrl J (⌘J on a Mac), or use **Open the dock** in the **More** menu.
 
+## Start a session
+
+You start a session in console3. You do not need the classic app.
+
+1. Do one of these steps:
+   - Press **+** in the header of the dock.
+   - Press **+ session** on a branch that has no session.
+   - Press **New** next to **Started by me** in the Sessions panel.
+2. The **New session** sheet opens. Type a name, or leave it empty to use `Shell` or `Claude`.
+3. Select the **Agent**: Shell or Claude. A Claude session uses the profile, the launch flags and the tier from Settings.
+4. Select where the session runs in **Runs on**:
+   - **Automatic**: the server selects the tree.
+   - A listed tree: the session runs in that working tree.
+   - **New branch**: type the branch name. The session runs in its own working copy of the new branch.
+5. Press **Start**. The session starts, and its terminal opens in a sheet on the same page.
+
+If the server cannot start the session, the sheet shows the reason.
+
 ## Read a row
 
 Each row under **Started by me** shows the state of the session, how long ago it started, and its tree. The state comes from the workspace server, for example `working` or `quiet`.
@@ -28,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/guide/layout.md

@@ -7,7 +7,7 @@ timestamp: 2026-10-12
 
 # Guide: layout
 
-This page describes the classic workspace, at `/classic.html`. The address `/` opens the console (see [the Briefing](briefing.md)). The console's More menu has **Open the classic app**, and a session or branch is started there.
+This page describes the classic workspace, at `/classic.html`. The address `/` opens the console (see [the Briefing](briefing.md)). The console's More menu has **Open the classic app**. You can start a session in the console too (see [Sessions in console3](console3-sessions.md)).
 
 On a desktop screen the workspace is one frame. It has one top bar, the place on screen under it, the detail when you open one, and the agent dock at the right. There is no left sidebar.
 

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.160.0",
+  "version": "0.162.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.160.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.160.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

@@ -1,5 +1,5 @@
 /* pm/c3-dock.js — the console3 dock on /c3.html: the mockup's repository, branch and session tree (console3.html renderDock, line 1957).
- * Header: the repository select, a start link and the fold button. Tree: one .br per working tree of the repository, its branch on
+ * Header: the repository select, the New session button (c3-new-session.js) and the fold button. Tree: one .br per working tree of the repository, its branch on
  * top and the sessions that run in that tree under it, each with a state glyph, a provider icon and a name. Below the tree: the
  * selected session's detail (what it is, where it runs, how long, the output tail, the Message box) and a scratchpad.
  * Real data only:
@@ -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';
@@ -17,6 +17,10 @@ import { c3ic } from './pm-work-view.js';
 import { ic, TIPS } from './c3-terminal-icons.js';
 import { source, needsYou } from './c3-terminal-data.js';
 import { toast } from './c3-toast.js';
+import { button } from './primitives.js';
+
+/* a primitives button (keyboard, role) carrying the dock's own look and children */
+const c3btn = (attrs, onClick, ...kids) => { const b = button({ variant: 'ghost', attrs, onClick }); b.replaceChildren(...kids); return b; };
 
 /* the mockup's SM (line 1953): glyph and class by state. The server's `shown` words map onto them. */
 const SM = { working: ['●', 'w'], needs: ['◆', 'n'], quiet: ['◼', ''], blocked: ['◇', 'b'], exited: ['○', ''] };
@@ -25,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) => {
@@ -50,13 +53,15 @@ export function createDock(opts) {
   const side = el('aside', { class: 'c3dock dock', 'aria-label': 'Sessions', 'data-c3pg': 'dock' },
     el('div', { class: 'dk-h' }, c3ic('repo', 'sm'), sel,
       listBtn,
-      el('a', { class: 'ib sm', href: '/classic.html', title: 'Start a branch and session in the classic app. A session starts over the terminal connection; the page has no route for it.', 'aria-label': 'Start a branch and session in the classic app' }, c3ic('plus', 'sm')),
+      c3btn({ class: 'ib sm', title: 'New session', 'aria-label': 'New session', 'data-c3pg': 'dock-new' }, () => newSession(), c3ic('plus', 'sm')),
       el('button', { type: 'button', class: 'ib sm', title: 'Fold the dock (Ctrl J)', 'aria-label': 'Fold the dock', onclick: () => o.setOpen && o.setOpen(false) }, c3ic('fold'))),
     body);
 
   const withEnd = (s) => (S.ended.has(s.id) ? { ...s, shown: 'exited', label: 'ended' } : s);
   const mine = () => S.sessions.filter((s) => s.ws === S.ws && !s.automatic).map(withEnd);
   const inTree = (dir) => mine().filter((s) => s.tree === dir).sort((a, b) => (a.shown === 'exited') - (b.shown === 'exited') || String(b.created).localeCompare(String(a.created)));
+  /* a new session: the sheet asks name, agent and where it runs, starts it over the terminal connection and opens its terminal here (c3-new-session) */
+  const newSession = (on) => import('./c3-new-session.js').then((m) => m.openNewSession({ ws: S.ws, trees: (S.trees || []).filter((t) => t.ws === S.ws || t.main), on, onStarted: (id) => { S.sel = id; refresh(); } }));
   const pick = (id) => { S.sel = id; S.selTree = null; S.confirm = null; drawTree(); drawDetail(); if (o.setOpen) o.setOpen(true); };
 
   function row(s) {
@@ -73,7 +78,7 @@ export function createDock(opts) {
       const ss = inTree(t.dir);
       const body = ss.length ? ss.slice(0, 4).map(row)
         : [t.main ? el('span', { class: 'dim mono', style: 'font-size:var(--fs-1);padding:2px 6px' }, 'no session')
-          : el('a', { class: 'chip2 lk', href: '/classic.html', title: 'Start a session on this branch in the classic app' }, c3ic('plus', 'sm'), 'session')];
+          : c3btn({ class: 'chip2 lk', title: 'Start a session on this branch', 'data-c3pg': 'dock-new-here' }, () => newSession('ws:' + t.ws), c3ic('plus', 'sm'), 'session')];
       if (ss.length > 4) body.push(el('span', { class: 'dim mono', style: 'font-size:var(--fs-1);padding:2px 6px' }, '+' + (ss.length - 4) + ' more'));
       return el('div', { class: 'br', 'data-c3-tree': t.dir }, el('button', { type: 'button', class: 'bn', 'data-c3-branch': t.dir, 'aria-current': String(!!S.sel && ss.some((x) => x.id === S.sel)), title: ss.length ? 'Open the session on this branch' : 'This branch has no session', onclick: () => { if (ss[0]) pick((ss.find((x) => x.shown !== 'exited') || ss[0]).id); else { S.sel = null; S.selTree = t.dir; drawTree(); drawDetail(); } },
       style: 'border:0;background:none;text-align:left;width:100%;cursor:pointer' }, c3ic('branch', 'sm'), t.branch || '(detached)'), el('div', { class: 'ss' }, ...body));
@@ -88,7 +93,7 @@ export function createDock(opts) {
 
   async function drawDetail() {
     const s = mine().find((x) => x.id === S.sel);
-    if (!s) { const bt = S.selTree && S.trees && S.trees.find((x) => x.dir === S.selTree); detail.replaceChildren(el('p', { class: 'dim mono dk-empty', 'data-c3pg': 'dock-empty' }, bt ? (bt.branch || 'This branch') + ' has no session. A session starts in the classic app.' : mine().length ? 'Pick a session above.' : 'No session runs in this repository.')); return; }
+    if (!s) { const bt = S.selTree && S.trees && S.trees.find((x) => x.dir === S.selTree); detail.replaceChildren(el('p', { class: 'dim mono dk-empty', 'data-c3pg': 'dock-empty' }, bt ? (bt.branch || 'This branch') + ' has no session. Press + session to start one.' : mine().length ? 'Pick a session above.' : 'No session runs in this repository.')); return; }
     const t = S.trees && S.trees.find((x) => x.dir === s.tree);
     const started = ago(Date.now() - Date.parse(s.created));
     const last = Number.isFinite(s.lastOutputAt) ? ago(Date.now() - s.lastOutputAt) : null;
@@ -99,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),
@@ -107,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'),
@@ -169,6 +183,7 @@ export function createDock(opts) {
     start() { document.addEventListener('keydown', onKey); drawTree(); refresh(); timer = setInterval(refresh, 15000); if (source().subscribe) S.unsub = source().subscribe(refresh); },
     stop() { if (timer) clearInterval(timer); if (S.unsub) S.unsub(); document.removeEventListener('keydown', onKey); },
     refresh,
+    newSession,
   };
   return api;
 }

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

@@ -0,0 +1,94 @@
+/* pm/c3-new-session.js — start a session from console3, in a sheet, and open its terminal in the console (c3-new-session).
+ *   openNewSession({ ws, trees, initiative, on, onStarted })   on: 'auto' (default), 'ws:<id>' (that tree) or 'new'
+ * Before this, every "start a session" press on console3 went to the classic app (/classic.html), because the page had no way
+ * to start one. A session starts over the terminal connection, so this uses the same request as the classic dock's new-session
+ * sheet (tab-term.js requestSpawn) and then opens the terminal with c3-session-term.js. Nothing opens unless the server says the
+ * session started; a refusal stays in the sheet as the server's sentence.
+ * Fields: name (empty: Shell or Claude, numbered when taken), agent (the Settings default first), and where it runs:
+ *   Automatic      the server's start policy picks the tree (the initiative's own working copy, or the main tree)
+ *   a listed tree  that working tree as it is
+ *   New branch     a new branch in its own working copy
+ * A Claude session takes the server's default profile and the Settings launch flags and tier, as the classic dock does. */
+import { el } from './dom.js';
+import { openSheet } from './c3-sheet.js';
+import { button } from './primitives.js';
+import { toast } from './c3-toast.js';
+import { pmGet } from './http.js';
+import { sessionDefaults, adoptProfileDefault, CLIS } from './dock.js';
+
+const AGENT = { shell: 'Shell', claude: 'Claude' };
+
+/** A free name: `base`, else `base 2`, `base 3`, … among the sessions that have not ended. Pure, for Node. */
+export function freeName(base, sessions) {
+  const taken = new Set((sessions || []).filter((s) => s && s.state !== 'exited' && s.shown !== 'exited').map((s) => s.name));
+  if (!taken.has(base)) return base;
+  for (let i = 2; ; i += 1) if (!taken.has(base + ' ' + i)) return base + ' ' + i;
+}
+
+/** What requestSpawn is sent, from the form. Pure, for Node. Returns { error } when the form is not complete. */
+export function spawnOpts(f, d) {
+  const claude = f.agent === 'claude';
+  const common = {
+    name: f.name, agent: f.agent, initiative: f.initiative || null,
+    profile: claude ? (f.profile === undefined ? null : f.profile) : null,
+    flags: claude && d && Array.isArray(d.flags) && d.flags.length ? d.flags.map((x) => ({ flag: x.flag, ...(x.value ? { value: x.value } : {}) })) : undefined,
+    tier: claude && d && d.tier && d.tier !== 'auto' ? d.tier : null,
+    workType: 'general',
+  };
+  if (f.on === 'new') {
+    const b = String(f.branch || '').trim();
+    if (!b) return { error: 'Type a name for the new branch.' };
+    return { ...common, ws: f.ws, branch: b, createBranch: true, isolate: true };
+  }
+  if (f.on && f.on.startsWith('ws:')) return { ...common, ws: f.on.slice(3), branch: null, createBranch: false, isolate: null };
+  return { ...common, ws: f.ws, start: true };
+}
+
+export function openNewSession(opts) {
+  const o = opts || {};
+  const d = sessionDefaults();
+  const trees = (o.trees || []).filter((t) => t && !t.missing && t.ws);
+  const F = { agent: CLIS.includes(d.cli) ? d.cli : 'shell', on: o.on && (o.on === 'new' || trees.some((t) => 'ws:' + t.ws === o.on)) ? o.on : 'auto', busy: false };
+
+  const name = el('input', { type: 'text', 'aria-label': 'Name', placeholder: 'Empty: Shell or Claude', 'data-c3ns': 'name' });
+  const agent = el('select', { 'aria-label': 'Agent', 'data-c3ns': 'agent', onchange: (e) => { F.agent = e.target.value; } },
+    ...CLIS.map((c) => el('option', { value: c, selected: c === F.agent }, AGENT[c] || c)));
+  const branch = el('input', { type: 'text', 'aria-label': 'New branch', placeholder: 'feature/…', 'data-c3ns': 'branch' });
+  const branchRow = el('label', { class: 'c3ns-f', hidden: F.on !== 'new' }, el('span', { class: 'dim mono' }, 'New branch'), branch);
+  const where = el('select', { 'aria-label': 'Runs on', 'data-c3ns': 'on', onchange: (e) => { F.on = e.target.value; branchRow.hidden = F.on !== 'new'; } },
+    el('option', { value: 'auto', selected: F.on === 'auto' }, o.initiative ? 'Automatic: the working copy of initiative/' + o.initiative : 'Automatic: the main working tree'),
+    ...trees.map((t) => el('option', { value: 'ws:' + t.ws, selected: F.on === 'ws:' + t.ws }, (t.main ? 'Main tree' : '⑂') + ' ' + (t.branch || 'detached'))),
+    el('option', { value: 'new', selected: F.on === 'new' }, 'New branch'));
+  const err = el('p', { class: 'c3ns-err', role: 'alert', 'data-c3ns': 'error' });
+  const go = button({ label: 'Start', variant: 'primary', size: 'sm', onClick: () => start(), attrs: { 'data-c3ns': 'start' } });
+  const body = el('div', { class: 'c3ns', 'data-c3ns': 'form' },
+    el('label', { class: 'c3ns-f' }, el('span', { class: 'dim mono' }, 'Name'), name),
+    el('label', { class: 'c3ns-f' }, el('span', { class: 'dim mono' }, 'Agent'), agent),
+    el('label', { class: 'c3ns-f' }, el('span', { class: 'dim mono' }, 'Runs on'), where),
+    branchRow, err, el('div', { class: 'c3ns-go' }, go));
+  const sheet = openSheet({ title: o.initiative ? 'New session for ' + o.initiative : 'New session', icon: 'term', body });
+  requestAnimationFrame(() => name.focus());
+
+  async function start() {
+    if (F.busy) return;
+    if (!o.ws) { err.textContent = 'Pick a repository first.'; return; }
+    F.busy = true; go.disabled = true; err.textContent = '';
+    const sessions = await pmGet('/api/sessions').then((r) => (r && Array.isArray(r.sessions) ? r.sessions : []), () => []);
+    const base = (AGENT[F.agent] || 'Shell') + (o.initiative ? ' · ' + o.initiative : '');
+    // the default profile is the server's; this browser's copy can be old, so a Claude start reads it first
+    const profile = F.agent === 'claude' ? adoptProfileDefault(await pmGet('/api/profiles').catch(() => null)) : null;
+    const req = spawnOpts({ name: name.value.trim() || freeName(base, sessions), agent: F.agent, initiative: o.initiative, profile, on: F.on, branch: branch.value, ws: o.ws }, d);
+    if (req.error) { err.textContent = req.error; F.busy = false; go.disabled = false; return; }
+    const term = await import('./tab-term.js').catch(() => null);
+    const res = term ? await term.requestSpawn(req) : { ok: false, error: 'The terminal connection could not be loaded on this page.' };
+    F.busy = false; go.disabled = false;
+    if (!res || !res.ok) { err.textContent = (res && res.error) || 'The session was not started.'; return; }
+    sheet.close();
+    if (o.onStarted) o.onStarted(res.id);
+    const m = await import('./c3-session-term.js');
+    m.openSessionTerm({ id: res.id, name: req.name });
+    // a session that shares its working tree with a running one is told so: their edits land in the same files
+    if (res.notice && /already running/.test(res.notice)) toast({ text: res.notice, timeout: 12000 });
+  }
+  return sheet;
+}

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-shell.js

@@ -425,7 +425,9 @@ function dock() {
   });
   S.dockEl = S.dock.side;
   // a session opens in its own terminal sheet on this page (c3-session-term.js), not in the main app
-  window.addEventListener('pmos:open-session', (e) => { const id = e.detail && e.detail.id; if (!id) { location.assign('/classic.html'); return; } import('./c3-session-term.js').then((m) => m.openSessionTerm({ id, name: e.detail.name })); });
+  // no id means "start one": the new-session sheet opens on this page (c3-new-session.js), not the classic app
+  window.addEventListener('pmos:open-session', (e) => { const id = e.detail && e.detail.id; if (!id) { S.dock.newSession(); return; } import('./c3-session-term.js').then((m) => m.openSessionTerm({ id, name: e.detail.name })); });
+  window.addEventListener('pmos:new-session', (e) => { e.preventDefault(); S.dock.newSession(e.detail && e.detail.on); });
   return [S.dock.side];
 }
 /* The dock is open on the Briefing and folded away on the other tabs. A folded dock leaves no rail (PM, 2026-10-12): the header's Sessions button, Ctrl J and the More menu reach it. */

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}
@@ -2218,3 +2226,11 @@
 /* the dock's note under the branch list and its empty detail (c3-dock.js) */
 .c3dock .dk-more { font-size: var(--fs-1); padding: 4px; }
 .c3dock .dk-empty { font-size: var(--fs-2); }
+
+/* the new-session sheet (c3-new-session.js) */
+.c3ns { display: flex; flex-direction: column; gap: var(--sp-3); }
+.c3ns-f { display: flex; flex-direction: column; gap: var(--sp-1); }
+.c3ns-f input, .c3ns-f select { width: 100%; }
+.c3ns-err { color: var(--destructive); font-size: var(--fs-2); margin: 0; }
+.c3ns-err:empty { display: none; }
+.c3ns-go { display: flex; justify-content: flex-end; }

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));
@@ -130,10 +147,15 @@ function draw(host, st) {
     : none('None running. A result appears on its card.')));
   /* Started by me */
   const mine = g.startedByMe || [];
-  const add = el('a', { class: 'chip2 lk c3t-new', href: '/classic.html', title: 'Start a session in the classic app. A session starts over the terminal connection; this page has no route for it.' }, ic('plus', 'sm'), 'New');
+  // console3 answers pmos:new-session with its new-session sheet; a page that does not (the classic app) opens its own dock sheet
+  const add = button({ variant: 'ghost', attrs: { class: 'chip2 lk c3t-new', 'data-c3t': 'new', title: 'Start a new session' }, onClick: () => {
+    const ev = new CustomEvent('pmos:new-session', { cancelable: true, detail: {} });
+    if (window.dispatchEvent(ev)) Promise.all([import('./dock-sessions.js'), import('./board-read.js')]).then(([ds, br]) => ds.openNewSessionSheet(br.currentProduct(), { initiative: null })).catch(() => {});
+  } });
+  add.replaceChildren(ic('plus', 'sm'), 'New');
   root.append(section('term', 'Started by me', mine.length, add, mine.length
     ? el('ul', { class: 'list', 'data-c3t': 'mine' }, mine.map((s) => { const c = cards[s.id]; return row(st, s, c, { sub: liveWord(s, c) + ' · ' + ago(s.startedAt) + ' · main tree', body: [plain(s, c) ? null : cardHost(st, s, c || { state: 'working', title: 'Working', nextMoves: [], claims: [], steps: [] }), blankPanel(st, s, c)].filter(Boolean) }); }))
-    : none('None. Start one in the classic app (/classic.html).')));
+    : none('None. Press New to start one.')));
   /* Past */
   const past = g.past || [];
   root.append(section('clock', 'Past (7 days)', past.length, null, past.length

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);