create-pmos 0.38.7 → 0.38.8

package/workspace/lib/schedule-logic.js

@@ -86,10 +86,25 @@ function nextSlot(schedule, now) {
 }
 function addDays(d, n) { const x = new Date(d); x.setDate(x.getDate() + n); return x; }
 
+// R5 — an optional end. A schedule ends when it has run `max_runs` times or when the day after `until` begins
+// (the `until` day itself still runs). No `until` and no `max_runs` means it never ends on its own.
+function endOfDay(dateStr) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(String(dateStr || ''));
+  return m ? new Date(+m[1], +m[2] - 1, +m[3] + 1, 0, 0, 0, 0) : null;
+}
+function finishReason(schedule, now = new Date()) {
+  if (!schedule) return null;
+  const max = +schedule.max_runs;
+  if (max > 0 && (+schedule.runs || 0) >= max) return `max_runs reached (${max} run${max === 1 ? '' : 's'})`;
+  const end = endOfDay(schedule.until);
+  if (end && now >= end) return `until ${schedule.until} has passed`;
+  return null;
+}
 // Is the schedule due to fire at `now`? Enabled + a slot in (lastRun, now]. For bi-weekly, also
 // require ≥ 13 days since lastRun (weekly slots, fired every other week).
 function isDue(schedule, now = new Date()) {
   if (!schedule || !schedule.enabled) return false;
+  if (finishReason(schedule, now)) return false;
   const slot = lastSlot(schedule, now);
   if (!slot) return false;
   const last = schedule.lastRun ? new Date(schedule.lastRun) : null;
@@ -130,6 +145,11 @@ function normalizeSchedule(input) {
   if (!s.name || !String(s.name).trim()) return { ok: false, error: 'name is required' };
   if (!CADENCES.includes(s.cadence)) return { ok: false, error: 'invalid cadence' };
   if (!s.skill || !String(s.skill).trim()) return { ok: false, error: 'a skill-backed task is required' };
+  if (s.until != null && s.until !== '') {
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(String(s.until)) || !endOfDay(s.until) || Number.isNaN(endOfDay(s.until).getTime())) return { ok: false, error: 'until must be a date, YYYY-MM-DD' };
+    if (endOfDay(s.until) <= new Date()) return { ok: false, error: 'until is already in the past — the schedule would never run' };
+  }
+  if (s.max_runs != null && s.max_runs !== '' && !(Number.isInteger(+s.max_runs) && +s.max_runs >= 1 && +s.max_runs <= 10000)) return { ok: false, error: 'max_runs must be a whole number from 1 to 10000' };
   if (s.cadence === 'once') {
     if (!/^\d{4}-\d{2}-\d{2}$/.test(String(s.date || ''))) return { ok: false, error: 'a one-off needs a date (YYYY-MM-DD)' };
     const slot = onceSlot({ date: s.date, time: s.time });
@@ -153,9 +173,11 @@ function normalizeSchedule(input) {
       task: s.task || s.skill,
       skill: String(s.skill).trim(),
       enabled: s.enabled !== false,
+      ...(s.until ? { until: String(s.until) } : {}),
+      ...(s.max_runs ? { max_runs: Math.floor(+s.max_runs) } : {}),
     },
   };
 }
 function parseTimeStr(t) { const { h, m } = parseTime(t); return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`; }
 
-module.exports = { CADENCES, isMissed, ONCE_GRACE_MS, isDue, nextRun, humanCadence, normalizeSchedule, lastSlot, nextSlot };
+module.exports = { finishReason, endOfDay, CADENCES, isMissed, ONCE_GRACE_MS, isDue, nextRun, humanCadence, normalizeSchedule, lastSlot, nextSlot };

package/workspace/lib/skill-store.js

@@ -266,7 +266,7 @@ function retargetFiling(text, filing) {
 // Scaffold a well-formed user skill file from the New Skill flow's fields. Returns { ok, slug, content }
 // or { ok:false, error }. User skills default to run:agent — a user-authored skill reasons through a
 // claude session (the existing agent path); the deterministic fast-path is reserved for the built-ins.
-function scaffoldSkill({ name, description, output, body, filing } = {}) {
+function scaffoldSkill({ name, description, output, body, filing, work } = {}) {
   const slug = slugify(name);
   if (!NAME_RE.test(slug)) return { ok: false, error: 'name must be a short slug (letters, digits, hyphens)' };
   const label = titleCase(name) || slug;
@@ -276,7 +276,7 @@ function scaffoldSkill({ name, description, output, body, filing } = {}) {
   if (!out.length) out = ['Summary', 'Findings', 'Next steps'];   // always a valid contract
   // A hand-written body is retargeted too: a PM pasting the old contract text in gets a skill that
   // files where the console reads, not one that quietly writes into a directory nobody opens.
-  const proc = retargetFiling(String(body || '').trim(), filing) || defaultBody(label, desc, out, slug, filing);
+  const proc = retargetFiling(String(body || '').trim(), filing) || defaultBody(label, desc, out, slug, filing, work ? String(work).slice(0, 8000) : null);
   const content = [
     '---',
     `name: ${slug}`,
@@ -306,7 +306,7 @@ function scaffoldSkill({ name, description, output, body, filing } = {}) {
 // suite could not reach it. A scaffold that still said "workspace/state/deliverables/" would send
 // every scheduled agent's report to a directory the console never reads: a silent, permanent
 // no-show in the needs-you queue. The defaults keep this module usable standalone.
-function defaultBody(label, desc, out, slug, filing) {
+function defaultBody(label, desc, out, slug, filing, work) {
   const id = slug || slugify(label) || 'run';
   const deliverables = (filing && filing.deliverables) || 'workspace/state/deliverables';
   const needs = (filing && filing.needs) || 'workspace/state/needs.json';
@@ -318,9 +318,17 @@ function defaultBody(label, desc, out, slug, filing) {
     '',
     'Procedure — run the numbered steps in order; each ends on a checkable done-condition:',
     '',
+    ...(work ? [
+      '1. Repeat the work below. It was captured from an earlier terminal session by the PM: do the same job again,',
+      "   with today's dates and this repository's current files. Do not repeat one-off details (old names, old dates, old errors).",
+      '   Done when: the same kind of result exists for today, each statement traceable to a real source.',
+      '   Captured work:',
+      ...String(work).split('\n').map((l) => '   | ' + l),
+    ] : [
     "1. Gather inputs from this repo's own local sources — name the exact commands/paths the run",
     '   depends on (e.g. `git log`, `gh pr view <n> --json title,body`, a file under `planning/`).',
     '   Done when: every input the sections below need is in hand, each traceable to a real source.',
+    ]),
     '2. Produce each required section from those inputs, in the exact order of the output contract.',
     '   An empty section is the literal line "None this period." — never a dropped heading, never invented content.',
     '   Done when: every contract section is filled or explicitly "None this period.".',

package/workspace/lib/status-groups.js

@@ -0,0 +1,66 @@
+'use strict';
+// Grouping the initiative list by status (initiative-surface-batch R2).
+//
+// The status is not typed by anyone: the server derives it for every initiative from the ledgers and
+// git (`deriveState` in server.js — stopped, accepted, blocked, delivered, building, planning, unknown)
+// and, for a stopped one, the lifecycle ledger says which kind (on-hold, closed, cancelled). This maps
+// that derived pair to the PM's words and puts the groups in one order. It reads the derived value and
+// nothing else, so a hand-typed `status:` in a record can never decide where a row lands, and an
+// unreadable history is its own group instead of passing for Planning.
+//
+// Classic script (a UMD setting window.PMOSStatusGroups) like the other lib/ files the board shares
+// with node, so the order and the mapping are walkable in the test suite.
+(function (root, factory) {
+  const api = factory();
+  if (typeof module !== 'undefined' && module.exports) module.exports = api;
+  else root.PMOSStatusGroups = api;
+}(typeof self !== 'undefined' ? self : this, function () {
+
+  // In the order the PM reads them: what needs them, what is moving, what has not started, what waits on
+  // their acceptance, what is done, then what is parked. `active` marks the four that are live work.
+  const GROUPS = [
+    { key: 'needs-you', label: 'Needs you', active: true, hint: 'returned at acceptance, or has open items in the needs queue' },
+    { key: 'in-progress', label: 'In progress', active: true, hint: 'runs logged, nothing merged yet' },
+    { key: 'planning', label: 'Planning', active: true, hint: 'recorded, no run logged yet' },
+    { key: 'awaiting-acceptance', label: 'Awaiting acceptance', active: true, hint: 'delivered; the PM has not accepted it' },
+    { key: 'accepted', label: 'Accepted', active: false, hint: 'accepted by the PM' },
+    { key: 'on-hold', label: 'On hold', active: false, hint: 'paused by the PM; off the board, not gating' },
+    { key: 'closed', label: 'Closed', active: false, hint: 'closed by the PM; off the board, not gating' },
+    { key: 'cancelled', label: 'Cancelled', active: false, hint: 'cancelled by the PM; off the board, not gating' },
+    { key: 'unknown', label: 'Unknown', active: false, hint: 'the history could not be read, so the status cannot be derived' },
+  ];
+  const BY_KEY = Object.fromEntries(GROUPS.map((g) => [g.key, g]));
+
+  /** The group key for one derived status row `{status, lifecycle}`; `unknown` when the row is missing or unrecognised. */
+  function keyOf(row) {
+    if (!row || typeof row !== 'object') return 'unknown';
+    switch (row.status) {
+      case 'blocked': return 'needs-you';
+      case 'building': return 'in-progress';
+      case 'planning': return 'planning';
+      case 'delivered': return 'awaiting-acceptance';
+      case 'accepted': return 'accepted';
+      case 'stopped': {
+        const s = row.lifecycle && row.lifecycle.state;
+        return s === 'on-hold' || s === 'closed' || s === 'cancelled' ? s : 'unknown';
+      }
+      default: return 'unknown';
+    }
+  }
+
+  /**
+   * @param {string[]} slugs               every initiative on the board
+   * @param {Object<string,Object>} rows   slug → derived status row (missing → Unknown)
+   * @param {{activeOnly?:boolean}} opts
+   * @returns {Array<{key,label,hint,active,slugs:string[]}>} non-empty groups only, in order
+   */
+  function group(slugs, rows, opts) {
+    const activeOnly = !!(opts && opts.activeOnly);
+    const buckets = new Map(GROUPS.map((g) => [g.key, []]));
+    for (const slug of slugs || []) buckets.get(keyOf(rows && rows[slug])).push(slug);
+    return GROUPS.filter((g) => (!activeOnly || g.active) && buckets.get(g.key).length)
+      .map((g) => ({ ...g, slugs: buckets.get(g.key) }));
+  }
+
+  return { GROUPS, BY_KEY, keyOf, group };
+}));

package/workspace/lib/transcripts.js

@@ -0,0 +1,73 @@
+'use strict';
+/* transcripts.js — the record of a conversation that belongs to an initiative.
+ *
+ * A session's terminal text used to live and die with the session: removing it deleted the only copy,
+ * so an initiative's discussion could not be reviewed later. A session that belongs to an initiative is
+ * now saved here when it ends or is removed, and listed beside the initiative's other artifacts.
+ *
+ * WHERE: one JSON file per session under `<runtime state>/transcripts/`. The runtime state directory is
+ * machine-local and outside every repository (lib/state-root.js). A transcript can hold anything the PM
+ * typed or an agent printed — including a secret — so it is deliberately NOT written into the repository
+ * (PM ruling 2026-10-03) and is never sent anywhere. Pure of the network (D54): fs only.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const MAX_CHARS = 400000;           // the tail of a very long session; the record says when it was cut
+const ID_RE = /^[A-Za-z0-9._-]+$/;
+
+// Terminal text without its escape sequences: colours, cursor moves, the window-title and hyperlink codes.
+function stripAnsi(text) {
+  return String(text == null ? '' : text)
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b[()][A-Za-z0-9]/g, '')
+    .replace(/\r(?!\n)/g, '\n').replace(/\r/g, '');
+}
+
+const dirOf = (stateDir) => path.join(stateDir, 'transcripts');
+const fileOf = (stateDir, id) => path.join(dirOf(stateDir), id + '.json');
+
+/** Write (or refresh) one session's record. Returns {ok, path} or {ok:false, error}; never throws. */
+function save(stateDir, rec) {
+  try {
+    const id = String(rec && rec.id || '');
+    if (!ID_RE.test(id)) return { ok: false, error: 'not a session id' };
+    if (!rec.initiative || !ID_RE.test(String(rec.initiative))) return { ok: false, error: 'the session is on no initiative — nothing to record' };
+    const full = stripAnsi(rec.text);
+    const cut = full.length > MAX_CHARS;
+    const out = {
+      id, name: String(rec.name || id).slice(0, 80), agent: rec.agent || null, ws: rec.ws || null,
+      initiative: String(rec.initiative), state: rec.state || 'exited',
+      started: rec.started || null, saved: rec.saved || new Date().toISOString(),
+      cut, chars: Math.min(full.length, MAX_CHARS), text: cut ? full.slice(-MAX_CHARS) : full,
+    };
+    fs.mkdirSync(dirOf(stateDir), { recursive: true });
+    const file = fileOf(stateDir, id);
+    fs.writeFileSync(file + '.tmp', JSON.stringify(out));
+    fs.renameSync(file + '.tmp', file);
+    return { ok: true, path: file };
+  } catch (e) { return { ok: false, error: String((e && e.message) || e).slice(0, 160) }; }
+}
+
+function read(stateDir, id) {
+  if (!ID_RE.test(String(id || ''))) return null;
+  try { return JSON.parse(fs.readFileSync(fileOf(stateDir, id), 'utf8')); } catch { return null; }
+}
+
+/** Every saved record for one initiative, newest first, without the text. */
+function listFor(stateDir, initiative) {
+  let names = [];
+  try { names = fs.readdirSync(dirOf(stateDir)); } catch { return []; }
+  const out = [];
+  for (const n of names) {
+    if (!n.endsWith('.json')) continue;
+    let r = null;
+    try { r = JSON.parse(fs.readFileSync(path.join(dirOf(stateDir), n), 'utf8')); } catch { continue; }
+    if (!r || r.initiative !== initiative) continue;
+    out.push({ id: r.id, name: r.name, ws: r.ws, state: r.state, started: r.started, saved: r.saved, chars: r.chars, cut: !!r.cut });
+  }
+  return out.sort((a, b) => String(b.saved).localeCompare(String(a.saved)));
+}
+
+module.exports = { stripAnsi, save, read, listFor, dirOf, MAX_CHARS };

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.38.7",
+  "version": "0.38.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.38.7",
+  "version": "0.38.8",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",
@@ -10,12 +10,12 @@
   "scripts": {
     "start": "node server.js",
     "test": "node test.js && npm run test:modules",
-    "test:modules": "node focus.test.js && node handoff.test.js && node repo-scan.test.js && node profiles.test.js && node external-linking.test.js && node story-artifacts.test.js && node no-network.test.js && node fixture-parity.test.mjs && node markdown.test.mjs && node start-policy.test.js && node state-isolation.test.js && node sync.test.js",
+    "test:modules": "node focus.test.js && node handoff.test.js && node repo-scan.test.js && node profiles.test.js && node external-linking.test.js && node story-artifacts.test.js && node no-network.test.js && node fixture-parity.test.mjs && node markdown.test.mjs && node start-policy.test.js && node state-isolation.test.js && node sync.test.js && node schedule-cli.test.js && node initiative-surface.test.js",
     "test:ui": "node ui-test.js",
     "test:parity": "node design-parity.js --states",
     "test:all": "npm test && npm run test:panels && npm run test:ui && npm run test:parity && npm run test:offline",
     "doctor": "node doctor.js",
-    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js && node pm-r15-test.js && node pm-r16-test.js && node pm-r17-test.js",
+    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js && node pm-r15-test.js && node pm-r16-test.js && node pm-r17-test.js && node pm-r16-test.js",
     "test:offline": "node offline-tarball.test.js"
   },
   "engines": {

package/workspace/public/index.html

@@ -42,6 +42,8 @@
      — test.js requires it and walks its whole input domain. It reads window.PMOSSessionState for
      the attention order, so it must come AFTER that script. -->
 <script src="/lib/working-set.js"></script>
+<!-- Group-by-status for the initiative list: the order and the mapping from the DERIVED status, walkable in node. -->
+<script src="/lib/status-groups.js"></script>
 <!-- The phone's navigation reducer. DOM-free, loaded as a classic script (it is a UMD that sets
      window.PMOSMobileNav) and required by test.js, so the whole screen domain is walkable in node
      rather than only in a browser. pm/mobile.js reads it from the global; the module graph does not

package/workspace/public/pm/data.js

@@ -452,6 +452,11 @@ function recordFrom(payload) {
     sessions: (payload.sessions || []).map(sessionRow),
     links: linksFor(payload),
     arts: artsFor(payload),
+    // R4/R5/R6 — what remains to acceptance, the conversations that belong to it, and the files git says
+    // were changed for it. Each arrives already derived by the server; this layer only carries them.
+    nextSteps: payload.next_steps || null,
+    convs: Array.isArray(payload.conversations) ? payload.conversations : [],
+    gitFiles: payload.files || null,
     eval: evalFor(row && row.steps),
     l2: l2For(row),
   };
@@ -646,10 +651,24 @@ function foldWorkspaces(rows) {
 
 /** Load one product's board: the spine (structure) joined with the library (artifacts). */
 async function loadBoard(prod) {
-  const [spine, lib] = await Promise.all([
+  const [spine, lib, surf] = await Promise.all([
     getJson('/api/console', { name: 'spine', ws: prod.ws }),
     getJson('/api/library', { ws: prod.ws }),
+    // The DERIVED status of every initiative (server.js deriveState + the lifecycle ledger) — what "group by
+    // status" reads. A failed read is kept as a reason, never as an empty map: an empty map would file every
+    // initiative under Unknown without saying why.
+    getJson('/api/surface', { name: 'initiatives', ws: prod.ws }),
   ]);
+  {
+    const items = (surf && surf.ok !== false && ((surf.surface && surf.surface.initiatives) || surf.initiatives)) || null;
+    prod.statuses = {};
+    if (items) {
+      for (const i of items) if (i && i.id) prod.statuses[i.id] = { status: i.status, statusText: i.statusText || '', lifecycle: i.lifecycle || null };
+      prod.statusError = null;
+    } else {
+      prod.statusError = (surf && surf.error) || 'the derived status of the initiatives could not be read';
+    }
+  }
   if (spine.ok === false) {
     prod.error = spine.error || 'the initiative spine could not be read';
     prod.board = [];
@@ -722,6 +741,7 @@ function publishBoards() {
    * Scoping it by the selected workspace is how a tab in one repo attached to a shell in another
    * (tab-term.js `wsForTab`). */
   const productWs = {};
+  const statuses = {}; const statusErrors = {};
   let records = {};
   for (const name of productOrder) {
     const p = products.get(name);
@@ -729,13 +749,14 @@ function publishBoards() {
     if (p.ws) productWs[name] = p.ws;
     if (!p.board) continue;
     board[name] = p.board;
+    statuses[name] = p.statuses || {}; if (p.statusError) statusErrors[name] = p.statusError;
     records = { ...records, ...p.records };
   }
   // `wsBranches` rides the same patch as `productWs` and for the same reason: it is a fact about
   // every registered working tree, read once from /api/workspaces, that a panel needs in order to
   // draw a row. panel 2 joins it against `state.sessions` to say which initiative each live agent is
   // on — the same `initiative/<id>` join lib/four-panel.js makes per initiative on the server.
-  setState({ board, productWs, wsBranches: branchMap(), records: { ...records, ...(hydrated) } });
+  setState({ board, statuses, statusErrors, productWs, wsBranches: branchMap(), records: { ...records, ...(hydrated) } });
 }
 
 /* Hydrated (fully derived) records live apart from the light ones so that a board reload cannot

package/workspace/public/pm/modes-live.js

@@ -392,6 +392,25 @@ async function openSkillTab(sk) {
   const ini = await import('./panel-initiatives.js');
   ini.openTab({ id: 'skill:' + sk.id, kind: 'skill', title: sk.label || sk.skill || sk.id, skillId: sk.id, repo: state.product || null, slug: null, role: 'SKILL' });
 }
+/** The body of a conversation tab (panel 4): one recorded conversation, read-only. The text is the live session's, or
+ * the saved record once the session has ended; the line above it says where it is kept. */
+export function mountTranscriptTab(host, tab) {
+  const r = read('conv:' + tab.convId, '/api/transcript?id=' + encodeURIComponent(tab.convId || ''));
+  const st = status(r, 'this conversation');
+  const kids = [];
+  if (st) kids.push(st);
+  else {
+    const d = r.data;
+    kids.push(el('div', { 'data-r16': 'transcript-head', style: 'padding:12px 14px 4px;font-size:11.5px;color:var(--muted-foreground)' },
+      iv((d.live ? 'live — ' : 'ended — ') + (d.name || d.id) + (d.initiative ? ' · initiative ' + d.initiative : '') + (d.cut ? ' · the start was cut (long session)' : '') + ' · ' + (d.stored || ''))));
+    kids.push(el('button', { style: BTN, hover: 'color:var(--foreground)', 'data-r16': 'transcript-refresh', onClick: () => { reload('conv:' + tab.convId); setState({}); } }, 'refresh'));
+    kids.push(el('pre', { 'data-r16': 'transcript-text', style: 'margin:0;padding:10px 14px 18px;font-family:var(--mono);font-size:11.5px;line-height:1.5;white-space:pre-wrap;overflow-wrap:anywhere;color:var(--foreground)' },
+      iv(d.text && d.text.trim() ? d.text : '(this conversation recorded no text)')));
+  }
+  setChildren(host, [el('div', { style: 'flex:1;min-height:0;overflow-y:auto;background:var(--background);color:var(--foreground)' }, kids)]);
+  return host;
+}
+
 /** The body of a skill tab (panel 4). Rebuilt on each paint, like the task tab; the draft lives in `skillDraft`. */
 export function mountSkillTab(host, tab) {
   const body = el('div', { style: 'flex:1;min-height:0;overflow-y:auto;background:var(--background);color:var(--foreground)' }, skillDetailLive({ kind: 'skill', id: tab.skillId, tab: true }));

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

@@ -989,6 +989,85 @@ function realSyncPanel(slug, a, key, dest) {
   );
 }
 
+/* ── NEXT STEPS TO DONE (initiative-surface-batch R4) ─────────────────────────────────────────
+ * The whole remaining path, in order, from the ladder, the ledgers and the sessions — derived on the server
+ * (lib/next-steps.js), never written by a model. Each item names the fact it was read from; the first is
+ * marked. A stopped initiative says so, and an accepted one says nothing remains. */
+function nextStepsBlock(rec) {
+  const ns = rec && rec.nextSteps;
+  if (FIXTURE || !ns) return null;
+  const TONE = { blocked: 'var(--destructive)', current: 'var(--brand)', pending: 'var(--muted-foreground)', unknown: 'var(--destructive)' };
+  const rows = (ns.items || []).map((it) => el('div', { 'data-r16': 'next-item', 'data-first': it.first ? '1' : '0', 'data-kind': it.kind,
+    style: 'display:grid;grid-template-columns:22px 1fr;gap:8px;padding:6px 0;border-bottom:1px solid var(--border)' + (it.held ? ';opacity:.6' : '') },
+    el('span', { style: 'font-family:var(--mono);font-size:11px;color:' + (TONE[it.status] || 'var(--muted-foreground)') }, iv(String(it.n))),
+    el('div', { style: 'min-width:0;display:flex;flex-direction:column;gap:2px' },
+      el('div', { style: 'display:flex;gap:7px;align-items:baseline;flex-wrap:wrap' },
+        el('span', { style: 'font-size:12.5px;color:var(--foreground)' }, iv(it.text)),
+        it.first ? el('span', { 'data-r16': 'next-first', style: 'font-family:var(--mono);font-size:9.5px;letter-spacing:.1em;text-transform:uppercase;color:var(--brand)' }, 'next') : null,
+        it.status === 'blocked' ? el('span', { style: 'font-family:var(--mono);font-size:9.5px;letter-spacing:.1em;text-transform:uppercase;color:var(--destructive)' }, 'blocked') : null,
+        it.held ? el('span', { style: 'font-family:var(--mono);font-size:9.5px;letter-spacing:.1em;text-transform:uppercase;color:var(--muted-foreground)' }, 'after reopening') : null),
+      el('div', { style: 'font-size:11.5px;line-height:1.5;color:var(--foreground)' }, iv(it.action)),
+      it.why && it.why !== it.action ? el('div', { style: 'font-size:11px;line-height:1.5;color:var(--muted-foreground)' }, iv(it.why)) : null,
+      el('div', { style: 'font-family:var(--mono);font-size:10px;color:var(--muted-foreground)' }, iv('from: ' + it.source)))));
+  return el('div', { 'data-r16': 'next-steps', style: 'padding:8px 14px;border-top:1px solid var(--border)' },
+    el('div', { style: 'font-family:var(--mono);font-size:9.5px;letter-spacing:.12em;text-transform:uppercase;color:var(--muted-foreground);padding-bottom:4px' }, 'next steps to done'),
+    el('div', { 'data-r16': 'next-summary', style: 'font-size:12px;line-height:1.5;color:var(--foreground);padding-bottom:4px' }, iv(ns.summary || '')),
+    rows);
+}
+
+/* Conversations and git files, listed with the document artifacts (R5, R6). A conversation opens a read-only
+ * transcript tab; the row says where it is stored. A file read from git is marked as such and is not a link:
+ * it is evidence of what changed, not a document the reader can open here. */
+function openConversation(slug, c) {
+  const ini = iniModLazy;
+  if (!ini || typeof ini.openTab !== 'function') return;
+  ini.openTab({ id: 'conv:' + c.id, kind: 'transcript', title: c.name || c.id, convId: c.id, repo: repoOf(slug) || null, slug: slug || null, role: 'CONVERSATION' });
+}
+let iniModLazy = null;
+import('./panel-initiatives.js').then((m) => { iniModLazy = m; }).catch(() => { iniModLazy = null; });
+
+function conversationsBlock(slug, rec) {
+  if (FIXTURE) return null;
+  const cs = rec.convs || [];
+  const LAB = 'font-family:var(--mono);font-size:9.5px;letter-spacing:.12em;text-transform:uppercase;color:var(--muted-foreground)';
+  const kids = cs.map((c) => el('button', { onClick: () => openConversation(slug, c), 'data-r16': 'conv-row', 'data-id': c.id,
+    style: 'display:flex;gap:8px;align-items:center;width:100%;padding:4px 6px;margin:0 -6px;min-width:0;min-height:30px', hover: 'background:var(--accent)',
+    title: 'a recorded conversation — read-only; kept in the runtime state directory on this machine, not in the repository' },
+    el('span', { style: 'flex:none;width:52px;font-family:var(--mono);font-size:10px;letter-spacing:.1em;color:var(--info)' }, 'talk'),
+    el('span', { style: 'font-family:var(--mono);font-size:10px;color:var(--foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' }, iv(c.name || c.id)),
+    el('span', { style: 'margin-left:auto;flex:none;font-family:var(--mono);font-size:10px;color:var(--muted-foreground)' },
+      iv((c.live ? 'live' : c.state === 'exited' ? 'ended' : 'saved') + (c.saved ? ' · ' + String(c.saved).slice(0, 10) : '')))));
+  return el('div', { 'data-r16': 'conversations', style: 'display:flex;flex-direction:column;gap:2px' },
+    el('span', { style: LAB + ';padding-top:4px' }, 'conversations · ' + cs.length),
+    cs.length ? kids : el('span', { 'data-r16': 'conv-empty', style: 'font-size:11.5px;color:var(--muted-foreground);font-style:italic' },
+      'none — no session is bound to this initiative. A session on its branch, or one you bind, is recorded here and kept after it ends.'),
+    cs.length ? el('span', { style: 'font-size:10.5px;color:var(--muted-foreground)' }, 'stored in this machine’s runtime state directory — not in the repository, never sent anywhere') : null);
+}
+
+function gitFilesBlock(rec) {
+  if (FIXTURE) return null;
+  const f = rec.gitFiles;
+  const LAB = 'font-family:var(--mono);font-size:9.5px;letter-spacing:.12em;text-transform:uppercase;color:var(--muted-foreground)';
+  if (!f) return null;
+  if (f.ok === false) {
+    return el('div', { 'data-r16': 'git-files', style: 'display:flex;flex-direction:column;gap:2px' },
+      el('span', { style: LAB + ';padding-top:4px' }, 'files from git'),
+      el('span', { 'data-r16': 'git-error', style: 'font-size:11.5px;color:var(--destructive)' }, 'could not be read — ' + (f.reason || 'git did not answer')));
+  }
+  const groups = {};
+  for (const it of f.items || []) (groups[it.group] = groups[it.group] || []).push(it);
+  const order = ['code', 'tests', 'documents', 'other'].filter((g) => groups[g]);
+  return el('div', { 'data-r16': 'git-files', style: 'display:flex;flex-direction:column;gap:2px' },
+    el('span', { style: LAB + ';padding-top:4px' }, 'files from git · ' + (f.total || 0) + (f.via && f.via.length ? ' · via ' + f.via.join(', ') : '')),
+    order.length ? order.map((g) => el('div', { style: 'display:flex;flex-direction:column;gap:1px' },
+      el('span', { style: 'font-family:var(--mono);font-size:10px;color:var(--info);padding-top:2px' }, g + ' · ' + groups[g].length),
+      groups[g].map((it) => el('span', { 'data-r16': 'git-file', title: it.commits + ' commit' + (it.commits === 1 ? '' : 's') + ', last ' + it.last,
+        style: 'font-family:var(--mono);font-size:10px;color:var(--muted-foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' }, iv(it.path)))))
+      : el('span', { 'data-r16': 'git-empty', style: 'font-size:11.5px;color:var(--muted-foreground);font-style:italic' },
+        'none — git shows no commit naming this initiative and no initiative/<id> branch with changes'),
+    f.truncated ? el('span', { style: 'font-size:10.5px;color:var(--muted-foreground)' }, 'showing the first 200 of ' + f.total) : null);
+}
+
 function artifactsRow(slug, rec) {
   const arts = rec.arts || [];
   return el('div', { style: 'display:grid;grid-template-columns:76px 1fr;gap:10px;padding:8px 14px' },
@@ -998,6 +1077,8 @@ function artifactsRow(slug, rec) {
       arts.length === 0
         ? el('span', { style: 'font-size:11.5px;color:var(--muted-foreground);font-style:italic' }, 'none filed')
         : null,
+      conversationsBlock(slug, rec),
+      gitFilesBlock(rec),
     ),
   );
 }
@@ -1050,6 +1131,9 @@ function initBody(slug) {
   const sess = sessionsBlock(slug);
   if (sess) out.push(sess);
 
+  const nextB = nextStepsBlock(rec);
+  if (nextB) out.push(nextB);
+
   const phases = phaseBlock(slug, rec);
   if (phases) out.push(phases);
 

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

@@ -828,7 +828,43 @@ export function renderInitiatives(host) {
 
   const hits = searchHits(q, DATA, live);
 
-  const kids = [header, searchBox];
+  /* GROUP BY STATUS (initiative-surface-batch R2). The status is the one the server DERIVES (deriveState + the
+   * lifecycle ledger), mapped to the PM's words by lib/status-groups.js; nothing typed in a record decides where a
+   * row lands. A failed read of the statuses is said under the control and everything files under Unknown. */
+  const SG = typeof window !== 'undefined' ? window.PMOSStatusGroups : null;
+  const byStatus = state.groupBy === 'status' && !!SG;
+  const statusRows = (state.statuses && state.statuses[product]) || {};
+  const statusErr = (state.statusErrors && state.statusErrors[product]) || null;
+  const STATUS_TONE = { 'needs-you': 'var(--destructive)', 'in-progress': 'var(--brand)', planning: 'var(--muted-foreground)',
+    'awaiting-acceptance': 'var(--foreground)', accepted: 'var(--muted-foreground)', 'on-hold': 'var(--muted-foreground)',
+    closed: 'var(--muted-foreground)', cancelled: 'var(--muted-foreground)', unknown: 'var(--destructive)' };
+  if (byStatus) {
+    const seen = new Set(); const all = [];
+    for (const g of groupsFor(product)) for (const sl of g.slugs) if (!seen.has(sl)) { seen.add(sl); all.push(sl); }
+    const shown = all.filter((sl) => !q || sl.includes(q));
+    // An active search shows every match whatever its status: the "active" filter must not hide a hit.
+    const sgs = SG.group(shown, statusRows, { activeOnly: !!state.activeOnly && !q });
+    total = 0;
+    groups.length = 0;
+    for (const sg of sgs) {
+      const inits = sg.slugs.map((sl) => rowOf(sl, null));
+      total += inits.length;
+      groups.push({ gid: 'status:' + sg.key, idc: STATUS_TONE[sg.key] || 'var(--muted-foreground)', gname: sg.label, gct: String(inits.length),
+        hasKr: true, krid: '●', krname: sg.hint, krct: String(inits.length), slugs: sg.slugs, inits, isEmpty: false });
+    }
+  }
+  const CHIP = 'font-family:var(--mono);font-size:10.5px;padding:2px 8px;border:1px solid var(--border);min-height:24px';
+  const chip = (label, on, onClick, attr) => el('button', { onClick, 'data-r16': attr,
+    style: CHIP + ';' + (on ? 'color:var(--foreground);background:var(--secondary);border-color:var(--input)' : 'color:var(--muted-foreground)'),
+    hover: 'color:var(--foreground)', 'aria-pressed': on ? 'true' : 'false' }, label);
+  const groupBar = FIXTURE ? null : el('div', { 'data-r16': 'group-bar', style: 'display:flex;gap:5px;flex-wrap:wrap;align-items:center;padding:4px 12px 6px' },
+    el('span', { style: 'font-family:var(--mono);font-size:10px;letter-spacing:.08em;text-transform:uppercase;color:var(--muted-foreground)' }, 'group by'),
+    chip('objective', !byStatus, () => setState({ groupBy: 'objective' }), 'by-objective'),
+    chip('status', byStatus, () => setState({ groupBy: 'status' }), 'by-status'),
+    byStatus ? chip('active only', !!state.activeOnly, () => setState({ activeOnly: !state.activeOnly }), 'active-only') : null,
+    byStatus && statusErr ? el('span', { 'data-r16': 'status-error', style: 'flex-basis:100%;font-size:10.5px;color:var(--destructive)' }, 'status could not be read — ' + statusErr + ' (every initiative is under Unknown)') : null);
+
+  const kids = [header, searchBox, groupBar];
   /* THE WORKING SET, pinned above the Objectives.
    *
    * It is `groupNode` — the same element, the same collapse key, the same forced-open-on-search

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

@@ -42,7 +42,7 @@ import { boardOf, currentProduct } from './board-read.js';
 let termMod = null;
 let liveMod = null;
 /* Loaded lazily; a repaint is asked for only when a skill tab is already open (restored on reload) and waiting for it. */
-import('./modes-live.js').then((m) => { liveMod = m; if ((state.tabs || []).some((t) => t.kind === 'skill')) setState({}); }).catch(() => { liveMod = null; });
+import('./modes-live.js').then((m) => { liveMod = m; if ((state.tabs || []).some((t) => t.kind === 'skill' || t.kind === 'transcript')) setState({}); }).catch(() => { liveMod = null; });
 import('./tab-term.js')
   .then((m) => { termMod = m; setState({}); })
   .catch(() => { termMod = null; });
@@ -144,6 +144,40 @@ export function closeTab(id) {
   });
 }
 
+/**
+ * The terminal tabs attached to ONE session, by tab id (initiative-surface-batch R1).
+ *
+ * A terminal tab carries the SERVER's session id (`sessionId`), which is the exact join. Read it BEFORE the
+ * server is asked to end the session, not after: the moment the server drops the session it pushes the new
+ * list, and a tab whose id is no longer listed re-joins by NAME (tab-term.js `resolveSessionId`) — so when two
+ * sessions share a name the doomed tab quietly adopts its sibling and starts reporting the sibling's id, and a
+ * lookup made after the answer finds nothing to close.
+ */
+export function tabIdsOfSession(sessionId) {
+  if (!sessionId) return [];
+  return (state.tabs || []).filter((t) => t && t.kind === 'term' && t.sessionId === sessionId).map((t) => t.id);
+}
+
+/**
+ * Close tabs by id. Called only after the server said the session is gone; closing a tab by hand still only
+ * detaches. Another session's tab, and a tab that is not in `ids`, are untouched. Returns how many closed.
+ */
+export function closeTabsById(ids) {
+  const doomed = (state.tabs || []).filter((t) => t && (ids || []).includes(t.id)).map((t) => t.id);
+  if (!doomed.length) return 0;
+  setState((s) => {
+    const rest = s.tabs.filter((t) => !doomed.includes(t.id));
+    return {
+      tabs: rest,
+      active: doomed.includes(s.active) ? (rest.length ? rest[rest.length - 1].id : null) : s.active,
+      splitId: doomed.includes(s.splitId) ? null : s.splitId,
+    };
+  });
+  return doomed.length;
+}
+
+export const closeTabsOfSession = (sessionId) => closeTabsById(tabIdsOfSession(sessionId));
+
 /* The data layer's optional session-start hook. In fixture mode nothing is ever started; in real
  * mode the PTY is data.js's to create, and panel 4's part is only to show the tab for it. */
 let dataMod = null;
@@ -797,6 +831,8 @@ function paneFor(tab) {
     mountTask(host, tab);
   } else if (tab.kind === 'skill') {
     if (liveMod && typeof liveMod.mountSkillTab === 'function') liveMod.mountSkillTab(host, tab);
+  } else if (tab.kind === 'transcript') {
+    if (liveMod && typeof liveMod.mountTranscriptTab === 'function') liveMod.mountTranscriptTab(host, tab);
   } else if (tab.kind === 'web') {
     mountWeb(host, tab);              // overhaul-r5 — never falls through to an empty doc tab
   } else {
@@ -913,7 +949,7 @@ function tabNode(t, act, splitTab) {
    * fixture render keeps the design's literal — the comparator reads this text node. */
   const meta = t.kind === 'term'
     ? ((!FIXTURE && t.sessionId) ? 'session ' + t.sessionId : 'session')
-    : (t.kind === 'task' ? 'task' : t.kind === 'web' ? 'web' : t.kind === 'skill' ? 'skill' : t.role);
+    : (t.kind === 'task' ? 'task' : t.kind === 'web' ? 'web' : t.kind === 'skill' ? 'skill' : t.kind === 'transcript' ? 'conversation' : t.role);
 
   return el('div', {
     style: 'flex:none;display:flex;align-items:center;gap:8px;padding:0 10px;background:' + bg

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

@@ -23,10 +23,11 @@ const MONO = 'font-family:var(--mono);font-size:10.5px';
 const BTN = MONO + ';padding:2px 8px;border:1px solid var(--border);color:var(--muted-foreground);min-height:24px';
 const MUTED = 'color:var(--muted-foreground)';
 
-let dataMod = null; let termMod = null; let iniMod = null;
+let dataMod = null; let termMod = null; let iniMod = null; let tabsMod = null;
 import('./data.js').then((m) => { dataMod = m; }).catch(() => { dataMod = null; });
 import('./tab-term.js').then((m) => { termMod = m; }).catch(() => { termMod = null; });
 import('./panel-initiatives.js').then((m) => { iniMod = m; }).catch(() => { iniMod = null; });
+import('./panel-tabs.js').then((m) => { tabsMod = m; }).catch(() => { tabsMod = null; });
 
 const note = (name, text, tone) => setState({ treeNote: { name, text, tone: tone || null } });
 const refresh = () => (dataMod && dataMod.refreshTrees ? dataMod.refreshTrees() : Promise.resolve());
@@ -62,10 +63,16 @@ export async function startHere(name, t) {
 }
 
 async function endSession(name, s) {
+  // Which tabs are on this session, read BEFORE asking: once the server drops it, a tab re-joins by name and stops saying.
+  const tabIds = tabsMod && typeof tabsMod.tabIdsOfSession === 'function' ? tabsMod.tabIdsOfSession(s.id) : [];
   const out = dataMod ? await dataMod.removeSessionById(s.id) : null;
   setState({ treeConfirm: null });
   if (!out || out.ok === false) { note(name, (out && out.error) || 'the session could not be removed', 'bad'); return; }
-  note(name, out.removed === false ? (out.note || 'asked it to end') : 'session removed');
+  // The session is gone: the tab attached to it has nothing left to show, so it closes too (R1). A refusal returned
+  // above and leaves the tab open beside the reason; so does "asked it to end, not exited yet" — the process is still
+  // there, and pressing again removes it and closes the tab.
+  const closed = out.removed !== false && tabsMod && typeof tabsMod.closeTabsById === 'function' ? tabsMod.closeTabsById(tabIds) : 0;
+  note(name, (out.removed === false ? (out.note || 'asked it to end') : 'session removed') + (closed ? ' — its tab was closed' : ''));
 }
 
 async function removeTree(name, t) {