create-pmos 0.214.0 → 0.216.0

package/workspace/lib/transcript-read.js

@@ -50,7 +50,36 @@ const cp = require('child_process');
 // refusal stands (an honest floor, not a silent truncation — the pane pid still had no record).
 const MAX_WALK_DEPTH = 2;
 
-const HOME = () => process.env.PMOS_CLAUDE_HOME || path.join(os.homedir(), '.claude');
+/*
+ * Every folder Claude Code may keep its session records in. A PM with profiles runs Claude with CLAUDE_CONFIG_DIR set
+ * (`alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'`), so its records are in ~/.claude-work/sessions, not
+ * ~/.claude/sessions: reading only ~/.claude made every such session "wrote no session record". The folders: the server's
+ * own CLAUDE_CONFIG_DIR, ~/.claude, each ~/.claude-* folder that has a `sessions` folder, and each PMOS profile's
+ * CLAUDE_CONFIG_DIR. PMOS_CLAUDE_HOME, when set, is the only one (tests). A pid has at most one live record, so looking in
+ * several folders does not weaken the identity proof: the record still has to name a cwd inside the workspace root.
+ */
+const HOMES_MS = 30000;
+let homesSnap = null;
+function claudeHomes(now = Date.now()) {
+  if (process.env.PMOS_CLAUDE_HOME) return [process.env.PMOS_CLAUDE_HOME];
+  if (homesSnap && now - homesSnap.at < HOMES_MS) return homesSnap.list;
+  const hd = os.homedir();
+  const list = [];
+  const add = (d) => { if (d && typeof d === 'string' && path.isAbsolute(d) && !list.includes(path.resolve(d))) list.push(path.resolve(d)); };
+  add(process.env.CLAUDE_CONFIG_DIR);
+  add(path.join(hd, '.claude'));
+  try {
+    for (const n of fs.readdirSync(hd).sort()) {
+      if (/^\.claude-./.test(n) && fs.existsSync(path.join(hd, n, 'sessions'))) add(path.join(hd, n));
+    }
+  } catch { /* no home listing: ~/.claude alone */ }
+  try {
+    const r = require('./profiles').readProfiles(hd, { detect: true });
+    for (const pf of (r && r.profiles) || []) add(pf && pf.env && pf.env.CLAUDE_CONFIG_DIR);
+  } catch { /* profiles unreadable: the folders above */ }
+  homesSnap = { at: now, list };
+  return list;
+}
 // A transcript can grow large; cap what we read so a long session cannot stall a broadcast.
 const MAX_BYTES = 8 * 1024 * 1024;
 // Synthetic assistant records are the CLI's own bookkeeping, not model turns — never counted,
@@ -128,6 +157,15 @@ function descendants(pid, listChildren, maxDepth = MAX_WALK_DEPTH) {
  * consider, pane or descendant, identically.
  */
 function resolvePid(pid, root, home) {
+  if (Array.isArray(home)) {
+    let first = null;
+    for (const h of home) {
+      const r = resolvePid(pid, root, h);
+      if (!r.noRecord) return r;   // the folder that holds this pid's record answers
+      first = first || r;
+    }
+    return first || { noRecord: true };
+  }
   let reg;
   try {
     reg = JSON.parse(fs.readFileSync(path.join(home, 'sessions', `${pid}.json`), 'utf8'));
@@ -150,7 +188,7 @@ function resolvePid(pid, root, home) {
  * process levels for a descendant that resolves in-root — see the child-walk note at the head.
  * `listChildren` is injectable for tests; it defaults to a real `ps` snapshot.
  */
-function findTranscript(pid, root, home = HOME(), listChildren = defaultChildren) {
+function findTranscript(pid, root, home = claudeHomes(), listChildren = defaultChildren) {
   if (!pid) return { missing: "can't identify this session's transcript — no process id" };
   const direct = resolvePid(pid, root, home);
   if (direct.sessionId) return direct;
@@ -321,8 +359,8 @@ function readHarness(file, clean = (x) => x) {
  *   · 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.
+ *   · tool calls fold into one activity line between them ("Used Bash, Read ×2"); each call keeps a short
+ *     target (callTarget: the file, pattern or first command line), never the whole 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;
@@ -343,7 +381,29 @@ function userText(r) {
   return t.trim();
 }
 
-function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
+/* What one tool call worked on, in a few words: the file, the pattern, the first line of the command, the address. Only these
+ * named fields are read, never the whole input, and the result is at most TARGET_MAX characters (a path inside `root` is shown
+ * relative to it). The caller scrubs it (D08). Anything else gives ''. */
+const TARGET_MAX = 120;
+const CALLS_MAX = 40;
+function callTarget(input, root) {
+  if (!input || typeof input !== 'object') return '';
+  const str = (v) => (typeof v === 'string' ? v : '');
+  const rel = (p) => { const r = root && path.isAbsolute(p) ? path.relative(root, p) : ''; return r && !r.startsWith('..') && !path.isAbsolute(r) ? r : p; };
+  let t = '';
+  const file = str(input.file_path) || str(input.notebook_path);
+  if (file) t = rel(file);
+  else if (str(input.command)) t = str(input.command).split('\n')[0];
+  else if (str(input.pattern)) t = str(input.pattern) + (str(input.path) ? ' in ' + rel(str(input.path)) : '');
+  else if (str(input.url)) t = str(input.url);
+  else if (str(input.query)) t = str(input.query);
+  else if (str(input.description)) t = str(input.description);
+  else if (str(input.path)) t = rel(str(input.path));
+  t = t.replace(/\s+/g, ' ').trim();
+  return t.length > TARGET_MAX ? t.slice(0, TARGET_MAX - 1) + '…' : t;
+}
+
+function readConversation(file, clean = (x) => x, limit = CONV_LIMIT, root = null) {
   let raw;
   try {
     const st = fs.statSync(file);
@@ -362,13 +422,15 @@ function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
   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 tool = (name, input, at) => {
     const last = out[out.length - 1];
     const n = clean(prettyTool(name));
+    const call = { tool: n, target: clean(callTarget(input, root)) };
     if (last && last.role === 'tool') {
       last.tools[n] = (last.tools[n] || 0) + 1;
+      if (last.calls.length < CALLS_MAX) last.calls.push(call);
       last.at = at || last.at;
-    } else out.push({ role: 'tool', tools: { [n]: 1 }, at: at || null });
+    } else out.push({ role: 'tool', tools: { [n]: 1 }, calls: [call], at: at || null });
   };
   for (const line of raw.split('\n')) {
     if (!line) continue;
@@ -391,14 +453,35 @@ function readConversation(file, clean = (x) => x, limit = CONV_LIMIT) {
         // 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);
+      } else if (c.type === 'tool_use' && c.name) tool(c.name, c.input, r.timestamp);
     }
   }
   const messages = out.slice(-limit).map((x) => (x.role === 'tool'
-    ? { role: 'tool', tools: x.tools, at: x.at }
+    ? { role: 'tool', tools: x.tools, calls: x.calls, 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,
+/*
+ * Claude Code's permission prompt, read from the pane's visible screen (tmux capture-pane -p, plain text). The transcript has
+ * the open call but not the question or its choices, which exist only on the screen. Returns { question, options:[{n, label}] }
+ * when the screen's last "Do you want to …" line is followed by numbered options, else null. The page types an option's
+ * number to answer, which is the key Claude Code's own menu takes. Box-drawing borders are dropped; labels are scrubbed.
+ */
+const ASK_RE = /^Do you want to .+\?$/;
+function permissionAsk(screen, clean = (x) => x) {
+  const lines = String(screen || '').split('\n').map((l) => l.replace(/[│┃]/g, ' ').replace(/\s+$/, '').trim());
+  let at = -1;
+  for (let i = lines.length - 1; i >= 0; i--) if (ASK_RE.test(lines[i])) { at = i; break; }
+  if (at < 0) return null;
+  const options = [];
+  for (const l of lines.slice(at + 1, at + 12)) {
+    const m = /^(?:[❯›>]\s*)?(\d)[.)]\s+(.+)$/.exec(l);
+    if (m) { if (options.length < 6 && !options.some((o) => o.n === m[1])) options.push({ n: m[1], label: clean(m[2].trim()).slice(0, 160) }); }
+    else if (options.length && l) break;
+  }
+  return options.length >= 2 ? { question: clean(lines[at]).slice(0, 200), options } : null;
+}
+
+module.exports = { permissionAsk, claudeHomes, callTarget, findTranscript, readHarness, readConversation, CONV_LIMIT, prettyTool, slugFor, resolvePid, descendants,
   MAX_BYTES, MAX_WALK_DEPTH, PS_SNAPSHOT_MS, defaultChildren };

package/workspace/lib/work-assigned.js

@@ -31,7 +31,7 @@ function agentOf(x) {
   if (!state) return null;
   return {
     state, suggest: x.suggest || null, instruction: x.instruction || null,
-    draft: t && (t.draft || t.body) ? { summary: t.draft || null, body: t.body || null } : null,
+    draft: t && (t.draft || t.body) ? { summary: t.draft || null, body: t.body || null, edited_at: t.edited_at || null } : null,
     sent: t && t.sent ? { link: t.sent.link || null, at: t.sent.at || null } : null,
     error: t ? t.error || null : null, session: t && t.session ? String(t.session) : null, asks: t ? t.asks || null : null, revisions: t ? t.revisions || 0 : 0, started_at: t ? t.started_at || null : null, decided_at: x.decided_at || null,
   };
@@ -77,7 +77,7 @@ function taskAgent(taskId, suggest, run) {
   const base = { suggest, instruction: null, draft: null, sent: null, error: null, session: null, asks: null, revisions: 0, started_at: null, decided_at: null };
   if (!t) return { state: 'suggest', ...base };
   return { ...base, state: TASK_STATE[t.status] || 'queued', instruction: t.instruction || null,
-    draft: t.draft ? { summary: t.draft.summary || null, body: t.draft.body || null } : null,
+    draft: t.draft ? { summary: t.draft.summary || null, body: t.draft.body || null, edited_at: t.draft.edited_at || null } : null,
     sent: t.sent ? { link: t.sent.link || null, at: t.sent.at || null } : null, error: t.error || null,
     session: t.stalled_session ? String(t.stalled_session) : null, asks: t.asks || null, revisions: Array.isArray(t.revisions) ? t.revisions.length : 0,
     started_at: t.started_at || null, decided_at: (t.decided && t.decided.at) || null };
@@ -100,17 +100,29 @@ function localDraftSpec(item, instruction) {
 const localAgent = (item, run) => taskAgent(localTaskId(item), localSuggest(item), run);
 /** The newest of `runs` (newest first) that holds task `taskId`, or null. An item the PM added keeps its draft across days. */
 const runWith = (runs, taskId) => (runs || []).find((r) => r && Array.isArray(r.tasks) && r.tasks.some((t) => t && t.id === taskId)) || null;
+/** The local dates of the last `days` days, newest first. */
+function recentDates(nowMs, days = 7) {
+  const pad = (n) => String(n).padStart(2, '0');
+  const out = [];
+  for (let i = 0; i < days; i++) { const d = new Date(nowMs); d.setDate(d.getDate() - i); out.push(`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`); }
+  return out;
+}
 /** The day runs of the last `days` days, newest first, through `readDayRun(date)`. */
 function recentRuns(readDayRun, nowMs, days = 7) {
-  const out = [];
-  if (typeof readDayRun !== 'function') return out;
-  const pad = (n) => String(n).padStart(2, '0');
-  for (let i = 0; i < days; i++) {
-    const d = new Date(nowMs); d.setDate(d.getDate() - i);
-    let r = null; try { r = readDayRun(`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`); } catch { r = null; }
-    if (r) out.push(r);
+  if (typeof readDayRun !== 'function') return [];
+  return recentDates(nowMs, days).map((d) => { try { return readDayRun(d); } catch { return null; } }).filter(Boolean);
+}
+/** The brief item `id` the PM owns, from the newest brief of the last `days` days that holds it (`readBrief(date)` → brief or
+ *  null), or null. An item of yesterday's brief that the PM kept in Work keeps its agent offer (amendment 12). */
+function findBriefItem(readBrief, id, nowMs, days = 7) {
+  if (typeof readBrief !== 'function') return null;
+  for (const d of recentDates(nowMs, days)) {
+    let b = null; try { b = readBrief(d); } catch { b = null; }
+    if (!b || b.date !== d) continue;
+    const x = [...(Array.isArray(b.priorities) ? b.priorities : []), ...(Array.isArray(b.items) ? b.items : [])].find((y) => y && y.id === id);
+    if (x) return x.owner === 'pm' && !x.worth_asking ? x : null;
   }
-  return out;
+  return null;
 }
 
 function fromBrief(brief, todayIso, run = null) {
@@ -148,4 +160,4 @@ function overlay(item, byId) {
   return out;
 }
 
-module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, briefAgent, briefSuggest, briefDraftSpec, taskAgent, localTaskId, localOffer, localSuggest, localDraftSpec, localAgent, runWith, recentRuns, AGENT };
+module.exports = { fromMyWork, fromBrief, addable, createdEvent, overlay, agentOf, briefAgent, briefSuggest, briefDraftSpec, taskAgent, localTaskId, localOffer, localSuggest, localDraftSpec, localAgent, runWith, recentRuns, recentDates, findBriefItem, AGENT };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.214.0",
+  "version": "0.216.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-case.js

@@ -4,6 +4,8 @@
  *   normalizeCase(model)            -> the canonical case (pure; accepts the mockup's field names and the descriptive ones)
  *   slideFor(caseModel, pickedId)   -> { enabled, reason, label } for the slide under the case (pure)
  *   renderCase(model, opts)         -> the `.case` element; opts: { picked, onPick(id, option), onConfirm({ option, hash, case }),
+ *                                      noConf (no confidence figure: the recommended option says "Suggested", the others nothing),
+ *                                      renderQuote(text) → nodes (the quote drawn as rich text, for example a markdown draft),
  *                                      outbox: boolean, onGo(go) }
  *
  * What the mockup's case file holds, top to bottom, and what this draws:
@@ -114,6 +116,7 @@ const fxList = (a) => el('div', { class: 'fx' }, ...a.map((f) => el('span', { cl
 export function renderCase(model, opts = {}) {
   const c = normalizeCase(model);
   const outbox = !!opts.outbox;
+  const noConf = !!opts.noConf;
   let picked = c.options.some((o) => o.id === opts.picked) ? opts.picked : c.recId;
   const root = el('div', { class: 'case', 'data-case': c.id || null, style: '--tc:' + c.tc });
   const optsHost = c.options.length ? el('div', { class: 'opts', role: 'radiogroup', 'aria-label': 'Options' }) : null;
@@ -125,11 +128,14 @@ export function renderCase(model, opts = {}) {
       return el('button', { type: 'button', class: 'opt' + (o.rec ? ' rec' : ''), role: 'radio', 'aria-checked': String(on), 'aria-pressed': String(on), 'data-opt': o.id,
         onclick: () => pick(o.id) },
       el('span', { class: 'pk' }, c3ic('check', 'sm')),
-      el('span', { class: 'rk', title: 'Confidence from the sources listed above' }, o.rec ? [c3ic('spark', 'sm'), 'Recommended · ' + c.confidence + '%'] : null),
+      // `noConf`: a real item has no confidence figure, so only the recommended option is marked, "Suggested", with no bar
+      noConf ? (o.rec ? el('span', { class: 'rk' }, c3ic('spark', 'sm'), 'Suggested') : null)
+        : el('span', { class: 'rk', title: 'Confidence from the sources listed above' }, o.rec ? [c3ic('spark', 'sm'), 'Recommended · ' + c.confidence + '%'] : null),
       el('b', null, o.label),
       fxList(o.effects),
       o.rec ? el('div', { class: 'conf' }, el('i', { style: 'width:' + c.confidence + '%' })) : null);
     }));
+    if (noConf) optsHost.querySelectorAll('.conf').forEach((n) => n.remove());   // no figure, no bar
   };
   let disposeHold = null;
   const drawSlide = () => {
@@ -164,7 +170,7 @@ export function renderCase(model, opts = {}) {
     if (opts.onPick) opts.onPick(id, c.options.find((o) => o.id === id));
   }
 
-  if (c.quote) root.append(el('blockquote', { class: 'qd' }, c.quote));
+  if (c.quote) root.append(el('blockquote', { class: 'qd' + (opts.renderQuote ? ' qd-md' : '') }, opts.renderQuote ? opts.renderQuote(c.quote) : c.quote));
   root.append(el('p', { class: 'sit' }, c.situation));
   if (c.move) root.append(el('div', { class: 'c3ag' }, el('div', { class: 'dim mono', style: 'font-size:var(--fs-2)' }, c3ic('spark', 'sm'), ' Suggested move: ' + c.move)));
   if (c.evidence.length) {

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

@@ -0,0 +1,164 @@
+/* pm/c3-session-conv.js — a session as a conversation, the first view of the session sheet (c3-session-term.js).
+ * The approved mockup (2026-10-14, version 1) without its side-by-side layout; see planning/prd/c3-session-conversation-prd.md.
+ *   convView({ id, onTerminal }) -> { node, input, start(), stop() }
+ * The words come from GET /api/sessions/conversation: Claude Code's own transcript, word for word (nothing is summarised and
+ * nothing is read from terminal bytes). A run of tool calls is one line that opens to list each call and its target. While a
+ * tool call is open and Claude Code's "Do you want to …" prompt is on the pane's screen, the reply's `ask` draws a card whose
+ * buttons type the option's number. Sends go over the page's terminal socket (tab-term.js typeIntoSession), as the Sessions
+ * panel's message box does; Stop types Esc. A plain shell, an unreadable record and an ended session each say so plainly. */
+import { el } from './dom.js';
+import { pmGet } from './http.js';
+import { toast } from './c3-toast.js';
+import { c3ic } from './pm-work-view.js';
+import { renderMd } from './c3-session-chat.js';
+import { button } from './primitives.js';
+
+const POLL_MS = 1500;
+const NOT_SENT = 'Not sent: the connection to the workspace server is down. Your message is still in the box.';
+
+/** "Used Read ×2, Edit" for a run of tool calls. Pure, for Node. */
+export const toolSummary = (tools) => 'Used ' + Object.entries(tools || {}).map(([n, k]) => (k > 1 ? n + ' ×' + k : n)).join(', ');
+/** The status tag for a reply: [label, tone]. Pure, for Node. */
+export function statusOf(r) {
+  if (!r) return ['Reading', 'muted'];
+  if (r.state === 'ended') return ['Ended', 'muted'];
+  if (r.state === 'shell') return ['Shell', 'muted'];
+  if (r.state !== 'conv') return ['Running', 'acc'];
+  if (r.ask) return ['Needs you', 'warning'];
+  if (r.turn === 'agent' || r.turn === 'tool') return ['Working', 'acc'];
+  if (r.turn === 'user') return ['Your turn', 'muted'];
+  return ['Running', 'acc'];
+}
+
+const keys = async (id, data) => { const t = await import('./tab-term.js').catch(() => null); return !!(t && typeof t.pressKeys === 'function' && await t.pressKeys(id, data)); };
+const type = async (id, text) => { const t = await import('./tab-term.js').catch(() => null); return !!(t && typeof t.typeIntoSession === 'function' && await t.typeIntoSession(id, text)); };
+/* a primitives button (keyboard, role) carrying the console3 look and children (the pattern c3-dock.js uses) */
+const c3btn = (attrs, onClick, ...kids) => { const b = button({ variant: 'ghost', attrs, onClick }); b.replaceChildren(...kids); return b; };
+const pill = (label, onClick, attrs = {}) => c3btn({ class: 'pill', ...attrs }, onClick, label);
+
+export function convView({ id, onTerminal } = {}) {
+  const st = { data: null, pending: [], busy: false, timer: null, stick: true, sig: '' };
+  const tag = el('span', { class: 'tg', 'data-cv': 'status' });
+  const metaRest = el('span', { class: 'chips2', 'data-cv': 'meta' });
+  const meta = el('div', { class: 'c3t-cv-meta' }, tag, metaRest);
+  const feed = el('div', { class: 'c3t-cv-feed', 'data-cv': 'feed', 'aria-live': 'polite' });
+  const input = el('textarea', { rows: '1', 'aria-label': 'Message', placeholder: 'Message Claude', 'data-cv': 'msg',
+    onkeydown: (e) => { if (e.key === 'Enter' && !e.shiftKey && !e.isComposing) { e.preventDefault(); send(); } },
+    oninput: () => grow() });
+  const stopBtn = c3btn({ class: 'ib sm', title: 'Stop Claude (types Esc)', 'aria-label': 'Stop Claude', 'data-cv': 'stop', hidden: '' },
+    async () => { if (!await keys(id, '\x1b')) toast({ text: NOT_SENT, tone: 'error' }); else toast({ text: 'Stopped. Claude waits for your next message.' }); }, c3ic('stop', 'sm'));
+  const sendBtn = c3btn({ class: 'ib pri sm', title: 'Send (Enter)', 'aria-label': 'Send', 'data-cv': 'send' }, () => send(), c3ic('out', 'sm'));
+  const slash = el('span', { class: 'chips2' },
+    pill('/compact', () => { input.value = '/compact'; input.focus(); grow(); }, { title: 'Claude summarises the conversation so far to free room', 'data-cv-slash': '/compact' }),
+    pill('/clear', () => { input.value = '/clear'; input.focus(); grow(); }, { title: 'Start a fresh conversation in this session', 'data-cv-slash': '/clear' }));
+  const comp = el('div', { class: 'c3t-cv-comp', 'data-cv': 'composer' },
+    el('div', { class: 'box' }, input, stopBtn, sendBtn),
+    el('div', { class: 'hint' }, slash, el('span', { class: 'kb' }, 'Enter sends · Shift Enter for a new line')));
+  const node = el('div', { class: 'c3t-cv-main', 'data-c3-conv': id }, meta, feed, comp);
+
+  // the box grows with its lines, up to eight, by its own rows (no inline style)
+  function grow() { input.rows = Math.max(1, Math.min(8, input.value.split('\n').length)); }
+
+  async function send() {
+    const text = input.value.trim();
+    if (!text) return;
+    const p = { text, at: Date.now() };
+    st.pending.push(p); st.stick = true; input.value = ''; grow(); paint();
+    if (!await type(id, text)) {
+      st.pending = st.pending.filter((x) => x !== p); input.value = text; grow(); paint();
+      toast({ text: NOT_SENT, tone: 'error' });
+      return;
+    }
+    setTimeout(poll, 400);
+  }
+
+  function toolsRow(m) {
+    const calls = Array.isArray(m.calls) ? m.calls : [];
+    return el('details', { class: 'tools', 'data-chat': 'tool' },
+      el('summary', null, el('span', { class: 'car' }, c3ic('next', 'sm')), c3ic('tree', 'sm'), toolSummary(m.tools)),
+      calls.length ? el('ul', null, ...calls.map((c) => el('li', null, el('b', null, c.tool), c.target ? el('span', { title: c.target }, c.target) : null))) : null);
+  }
+  function askCard(a) {
+    return el('div', { class: 'perm', role: 'group', 'aria-label': 'Claude asks before it runs a tool', 'data-cv': 'ask' },
+      el('b', { class: 'chips2' }, c3ic('alert', 'sm'), st.data && st.data.openCall ? 'Claude wants to run ' + st.data.openCall : 'Claude asks before it goes on'),
+      el('div', { class: 'q' }, a.question),
+      el('div', { class: 'c3t-tray' },
+        ...a.options.map((o) => pill(o.label, async () => { if (!await keys(id, o.n)) toast({ text: NOT_SENT, tone: 'error' }); else setTimeout(poll, 500); },
+          { 'data-cv-opt': o.n, title: 'Answer "' + o.label + '" (types ' + o.n + ')' })),
+        c3btn({ class: 'chip2 lk', 'data-cv': 'ask-term' }, () => onTerminal && onTerminal(), c3ic('term', 'sm'), 'Answer in the terminal')));
+  }
+  function none(icon, title, text, ...btns) {
+    return el('div', { class: 'none', 'data-cv': 'none' }, c3ic(icon), el('b', null, title), el('span', { class: 'dim' }, text), el('div', { class: 'chips2' }, ...btns));
+  }
+  const termBtn = () => c3btn({ class: 'pill', 'data-cv': 'open-term' }, () => onTerminal && onTerminal(), c3ic('term', 'sm'), 'Open the terminal');
+
+  function paint() {
+    const d = st.data;
+    const [label, tone] = statusOf(d);
+    tag.dataset.tone = tone;
+    tag.textContent = label;
+    metaRest.replaceChildren(...[d && d.agent ? (d.agent === 'shell' ? 'Shell' : d.agent === 'claude' ? 'Claude' : d.agent) : null, d && d.model]
+      .filter(Boolean).map((t) => el('span', null, t)));
+    const conv = d && d.state === 'conv';
+    comp.hidden = !d || d.state === 'ended' || d.state === 'unlinked' || d.state === 'other';
+    input.placeholder = d && d.state === 'shell' ? 'Type a command for the shell' : d && d.ask ? 'Answer above, or type to tell Claude something else' : 'Message Claude';
+    slash.hidden = !conv;
+    stopBtn.hidden = !(conv && (d.turn === 'agent' || d.turn === 'tool') && !d.ask);
+
+    const kids = [];
+    if (!d) kids.push(el('div', { class: 'm st' }, 'Reading the conversation…'));
+    else if (d.state === 'shell') {
+      kids.push(none('term', 'No Claude in this shell yet', 'This is a plain shell. Start Claude here and its conversation shows in this view.',
+        c3btn({ class: 'pill', 'aria-pressed': 'true', 'data-cv': 'start-claude' },
+          async () => { if (!await type(id, 'claude')) toast({ text: NOT_SENT, tone: 'error' }); else setTimeout(poll, 1500); }, c3ic('spark', 'sm'), 'Start Claude here'),
+        termBtn()));
+    } else if (d.state === 'unlinked') {
+      kids.push(none('alert', "Claude's conversation can't be read here", d.missing + '. PMOS will not guess which transcript is this session\'s, because that could show another session\'s words.', termBtn()));
+    } else if (d.state === 'other') {
+      kids.push(none('term', 'This agent keeps no Claude transcript', 'Its output is in the terminal.', termBtn()));
+    } else if (d.state === 'ended') {
+      kids.push(none('clock', 'This session has ended', 'Its terminal output is kept in the Sessions panel under Past.'));
+    } else {
+      for (const m of d.messages || []) {
+        if (m.role === 'user') kids.push(el('div', { class: 'who me' }, 'You'), el('div', { class: 'm me', 'data-chat': 'me' }, m.text));
+        else if (m.role === 'assistant') kids.push(el('div', { class: 'who' }, c3ic('spark', 'sm'), 'Claude'), el('div', { class: 'm bot', 'data-chat': 'bot' }, renderMd(m.text)));
+        else kids.push(toolsRow(m));
+      }
+      if (!(d.messages || []).length && !st.pending.length) kids.push(el('div', { class: 'm st', 'data-chat': 'empty' }, 'No messages yet. Type below to talk to Claude.'));
+    }
+    for (const p of st.pending) kids.push(el('div', { class: 'who me' }, 'You'), el('div', { class: 'm me', 'data-chat': 'me', 'data-pending': '' }, p.text));
+    if (conv && d.ask) kids.push(askCard(d.ask));
+    else if (conv && (d.turn === 'agent' || d.turn === 'tool' || st.pending.length)) {
+      kids.push(el('div', { class: 'live', role: 'status', 'data-chat': 'working' }, el('span', { class: 'c3spin' }, c3ic('clock', 'sm')),
+        d.turn === 'tool' && d.openCall ? 'Running ' + d.openCall + ', or waiting for your allow in the terminal' : 'Claude is working…'));
+    }
+    const atEnd = feed.scrollHeight - feed.scrollTop - feed.clientHeight < 60;
+    feed.replaceChildren(el('div', { class: 'wrap' }, ...kids));
+    if (atEnd || st.stick) { feed.scrollTop = feed.scrollHeight; st.stick = false; }
+  }
+
+  async function poll() {
+    if (st.busy) return;
+    st.busy = true;
+    try {
+      const r = await pmGet('/api/sessions/conversation?id=' + encodeURIComponent(id)).catch(() => null);
+      if (!r || !r.ok) { if (!st.data) { st.data = { state: 'unlinked', messages: [], missing: (r && r.error) || 'The conversation could not be read' }; paint(); } return; }
+      const msgs = r.messages || [];
+      // a message sent from here is done when the transcript holds it; one Claude never recorded goes after a minute
+      st.pending = st.pending.filter((p) => !msgs.some((m) => m.role === 'user' && m.text.trim() === p.text && (!m.at || Date.parse(m.at) >= p.at - 5000))
+        && Date.now() - p.at < 60000);
+      const sig = [r.stamp, r.state, r.turn, r.ask ? JSON.stringify(r.ask) : '', st.pending.length].join('|');
+      if (sig === st.sig) return;
+      st.sig = sig; st.data = r;
+      paint();
+    } finally { st.busy = false; }
+  }
+
+  paint();
+  return {
+    node, input,
+    start() { if (!st.timer) { poll(); st.timer = setInterval(() => { if (!node.isConnected) return; poll(); }, POLL_MS); } },
+    stop() { if (st.timer) { clearInterval(st.timer); st.timer = null; } },
+    get state() { return st.data ? st.data.state : null; },
+  };
+}

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

@@ -1,5 +1,7 @@
-/* pm/c3-session-term.js — a session's real terminal inside console3, in a sheet, so "Open the session" no longer leaves /c3.html.
- *   openSessionTerm({ id, name })
+/* pm/c3-session-term.js — a session inside console3, in a sheet, so "Open the session" no longer leaves /c3.html.
+ *   openSessionTerm({ id, name, view })   view: 'conv' (the default) or 'term'
+ * The sheet opens on the conversation (c3-session-conv.js); Terminal shows the session's real terminal and Conversation comes back.
+ * The terminal is mounted on first use and stays attached while the sheet is open, so switching never restarts anything.
  * The terminal is tab-term.js's own (the one the main app draws): the same socket, attach, resize and input. Closing the sheet detaches the
  * pane and leaves the session running, as closing a tab in the main app does. xterm and its addons are the main app's vendored globals,
  * loaded here on the first open because /c3.html does not load them up front. */
@@ -9,6 +11,7 @@ import { toast } from './c3-toast.js';
 import { pmGet, pmPost } from './http.js';
 import { button } from './primitives.js';
 import { c3ic } from './pm-work-view.js';
+import { convView } from './c3-session-conv.js';
 
 /* a primitives button (keyboard, role) carrying the console3 look and children (the pattern c3-dock.js uses) */
 const c3btn = (attrs, onClick, ...kids) => { const b = button({ variant: 'ghost', attrs, onClick }); b.replaceChildren(...kids); return b; };
@@ -135,35 +138,79 @@ function makePad(id, term, tab) {
   return { box, ta, dispose() { if (closed) return; closed = true; window.removeEventListener('pagehide', onHide); flush(); } };
 }
 
-export async function openSessionTerm({ id, name } = {}) {
+/* the sheet's two views: the conversation (c3-session-conv.js) first, the live terminal one press away. VIEWS: [key, label, title] */
+export const VIEWS = [['conv', 'Conversation', 'The conversation: your messages and Claude\'s replies'], ['term', 'Terminal', 'The live terminal of this session']];
+/** Which view a session opens on: the one asked for, else Terminal for an agent that keeps no Claude transcript, else Conversation. Pure. */
+export const firstView = (agent, asked) => (asked === 'term' || asked === 'conv' ? asked : agent && agent !== 'claude' && agent !== 'shell' ? 'term' : 'conv');
+/* the running sessions the sheet's list shows (at 2/3 and Whole): newest first, background runs left out */
+const listed = (all) => (Array.isArray(all) ? all : []).filter((x) => x && x.id && x.state !== 'exited' && x.shown !== 'exited' && !x.headless && !x.automatic)
+  .sort((a, b) => String(b.created || '').localeCompare(String(a.created || '')));
+
+/** The session sheet: Conversation | Terminal, All sessions and the sizes. `view` 'term' opens straight on the terminal (Set up Laya). */
+export async function openSessionTerm({ id, name, view } = {}) {
   if (!id) return null;
   rememberSession(id);
-  if (!name) { const r = await pmGet('/api/sessions').catch(() => null); const x = r && Array.isArray(r.sessions) ? r.sessions.find((y) => y.id === id) : null; name = x ? x.name : id; }
-  const [ok, term] = await Promise.all([loadVendor(), import('./tab-term.js').catch(() => null)]);
-  if (!ok || !term) { toast({ text: 'The terminal could not be loaded on this page.', tone: 'error' }); return null; }
+  const r = await pmGet('/api/sessions').catch(() => null);
+  const all = r && Array.isArray(r.sessions) ? r.sessions : [];
+  const me = all.find((y) => y.id === id) || null;
+  if (!name) name = me ? me.name : id;
   const tab = { id: 'c3-session:' + id, kind: 'term', sessionId: id, spawn: false, sess: id };
   const host = el('div', { class: 'c3t-term', 'data-c3-session-term': id });
-  const pad = makePad(id, term, tab);
-  const wrap = el('div', { class: 'c3t-tw' }, host, pad.box);
+  let term = null; let pad = null; let mounted = false;
+  const wrap = el('div', { class: 'c3t-tw', 'data-c3-view-pane': 'term' }, host);
+  const conv = convView({ id, onTerminal: () => show('term') });
+  conv.node.setAttribute('data-c3-view-pane', 'conv');
+  const list = el('nav', { class: 'c3t-cv-list', 'aria-label': 'Running sessions', 'data-c3-sess-list': '' },
+    el('div', { class: 'eyebrow' }, 'Running'),
+    ...listed(all).map((x) => c3btn({ 'aria-current': String(x.id === id), 'data-c3-sess-pick': x.id, title: x.name },
+      () => { if (x.id !== id) openSessionTerm({ id: x.id, name: x.name }); },
+    el('span', { class: 'nm' }, x.name || x.id), el('span', { class: 'sub' }, [x.agent === 'shell' ? 'Shell' : x.agent, x.shown || x.state].filter(Boolean).join(' · ')))));
+  const body = el('div', { class: 'c3t-cv', 'data-c3-session': id }, list, el('div', { class: 'c3t-cv-panes' }, conv.node, wrap));
+
   // the size control: Normal is the 600px sheet, the others are the classic dock's presets. Hidden on a phone, where the sheet is full width.
   let size = sizeOf(store.get(SIZE_KEY));
   const sizeBtns = SIZES.map(([k, label, title]) => c3btn({ 'aria-pressed': String(k === size), 'data-c3-size': k, title, 'aria-label': title }, () => setSize(k), label));
   const seg = el('div', { class: 'seg c3t-size', role: 'group', 'aria-label': 'Terminal size', 'data-c3-size-seg': '' }, ...sizeBtns);
+  let cur = firstView(me && me.agent, view);
+  const viewBtns = VIEWS.map(([k, label, title]) => c3btn({ 'aria-pressed': String(k === cur), 'data-c3-view': k, title, 'aria-label': label }, () => show(k),
+    c3ic(k === 'conv' ? 'reply' : 'term', 'sm'), el('span', { class: 'lb' }, label)));
+  const views = el('div', { class: 'seg c3t-views', role: 'group', 'aria-label': 'View', 'data-c3-view-seg': '' }, ...viewBtns);
   // the way back to every session: the Sessions panel, in place of this sheet
-  const all = c3btn({ class: 'chip2 lk', 'data-c3-all-sessions': '', title: 'All sessions: the Sessions panel' }, () => { sheet.close(); import('./c3-terminal.js').then((m) => m.openTerminalPage()); },
-    c3ic('menu', 'sm'), 'All sessions');
+  const allBtn = c3btn({ class: 'chip2 lk c3t-all', 'data-c3-all-sessions': '', title: 'All sessions: the Sessions panel', 'aria-label': 'All sessions' }, () => { sheet.close(); import('./c3-terminal.js').then((m) => m.openTerminalPage()); },
+    c3ic('menu', 'sm'), el('span', { class: 'lb' }, 'All sessions'));
   const cls = (k) => 'tsz-' + k;
   // Esc and Tab belong to the shell while the terminal has focus (Esc interrupts an agent); the close button and a press outside still close.
-  // The scratchpad is outside the terminal host, so its keys are the page's own.
-  const sheet = openSheet({ title: name || id, icon: 'term', wide: true, body: wrap, actions: [all, seg], cls: cls(size),
-    onClose: () => { pad.dispose(); term.disposeTerm(tab); }, passKeys: (e) => host.contains(e.target) });
+  // The scratchpad and the conversation are outside the terminal host, so their keys are the page's own.
+  const sheet = openSheet({ title: name || id, icon: 'term', wide: true, body, actions: [views, allBtn, seg], cls: 'c3t-ss ' + cls(size),
+    onClose: () => { conv.stop(); if (pad) pad.dispose(); if (term && mounted) term.disposeTerm(tab); }, passKeys: (e) => host.contains(e.target) });
+
+  async function mountTerminal() {
+    if (mounted) return true;
+    const [ok, t] = await Promise.all([loadVendor(), import('./tab-term.js').catch(() => null)]);
+    if (!ok || !t) { toast({ text: 'The terminal could not be loaded on this page.', tone: 'error' }); return false; }
+    if (mounted || !host.isConnected) return mounted;
+    term = t; mounted = true;
+    pad = makePad(id, term, tab);
+    wrap.append(pad.box);
+    term.mountTerm(host, tab);
+    return true;
+  }
+  async function show(k) {
+    cur = k === 'term' ? 'term' : 'conv';
+    viewBtns.forEach((b) => b.setAttribute('aria-pressed', String(b.dataset.c3View === cur)));
+    body.dataset.view = cur;
+    conv.node.hidden = cur !== 'conv'; wrap.hidden = cur !== 'term';
+    if (cur === 'conv') { conv.start(); requestAnimationFrame(() => conv.input.focus()); return; }
+    conv.stop();   // the hidden conversation does not read the transcript; it reads it again on the way back
+    if (!await mountTerminal()) return;
+    requestAnimationFrame(() => { term.refitVisible(); term.focusTerm(tab); });
+  }
   function setSize(k) {
     sheet.sheet.classList.remove(cls(size)); size = sizeOf(k); sheet.sheet.classList.add(cls(size));
     store.set(SIZE_KEY, size);
     sizeBtns.forEach((b) => b.setAttribute('aria-pressed', String(b.dataset.c3Size === size)));
-    requestAnimationFrame(() => { term.refitVisible(); requestAnimationFrame(() => term.refitVisible()); });
+    if (term) requestAnimationFrame(() => { term.refitVisible(); requestAnimationFrame(() => term.refitVisible()); });
   }
-  term.mountTerm(host, tab);
-  requestAnimationFrame(() => { term.refitVisible(); term.focusTerm(tab); });
+  await show(cur);
   return sheet;
 }

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

@@ -613,7 +613,7 @@ export function mountSettings(host, ctx = {}) {
         M.typesafe = r.key; delete M.err['typesafe.local'];
         M.localTest = { ok: !!r.started, text: r.started ? 'A terminal named Set up Laya opened with the commands typed in. Press Enter there, wait until Laya says it is running, then press Test.' : 'No terminal opened (' + (r.reason || 'unknown') + '). Run this in a terminal: ' + r.command };
         // the server only starts the session; the page must open it, or nothing appears to happen
-        if (r.started && r.session) import('./c3-session-term.js').then((m) => m.openSessionTerm({ id: r.session, name: 'Set up Laya' })).catch(() => {});
+        if (r.started && r.session) import('./c3-session-term.js').then((m) => m.openSessionTerm({ id: r.session, name: 'Set up Laya', view: 'term' })).catch(() => {});
       } else { M.localTest = null; M.err['typesafe.local'] = (r && r.error) || 'Not started.'; }
       draw();
     };