create-pmos 0.143.0 → 0.145.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.143.0",
+  "version": "0.145.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@7aa3b30
+kernel-source: pmos@e7517fc
 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-12T01:40:01Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T01:59:40Z"}
 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-12T01:40:01Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T01:59:40Z"}
 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-12T01:40:01Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T01:59:40Z"}
 status: stable
 ---
 

package/workspace/c3-ib-triage-backlog-test.js

@@ -37,6 +37,7 @@ const { harness } = require('./c3-ini-harness');
   await page.fill('[data-ibt="f-more"]', 'Which trials need SSO first?');
   await page.click('[data-ibt="more-go"]');
   await until(() => store(() => window.__c3boards.asks.find((a) => a.id === 'ask-1').needMore === true));
+  await until(async () => /prompted for more detail/.test(await toast()));
   ok('T6 Ask for more records the question; the ask stays open', await store(() => { const a = window.__c3boards.asks.find((x) => x.id === 'ask-1'); return a.state === 'open' && a.moreNote === 'Which trials need SSO first?'; }) && /prompted for more detail/.test(await toast()));
 
   await page.click('[data-ibt-ask="ask-1"] .tt').catch(() => {});

package/workspace/c3-updates-test.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+'use strict';
+/* c3-updates-test.js — console3 Settings › Updates runs the app update itself, and the kit Update sends the checked version
+ * (initiative c3-app-update).
+ *
+ * The page used to say "run it from the main app" and link to /, and its kit Update posted no version, which the server
+ * refuses with "Check for updates first". Against a real server; the kit routes and /api/sessions are stood in by the
+ * page's route table, so nothing is installed and npm is never asked. Hooks only (data-c3set-*).
+ */
+const path = require('path');
+const { spawn } = require('child_process');
+const { findBrowser } = require('./lib/find-browser');
+const T = require('./test-run').configure({ name: 'c3-updates' });
+
+const BASE = T.BASE;
+const results = [];
+const ok = (name, cond, extra = '') => { results.push({ name, cond: !!cond }); console.log(`${cond ? '✓' : '✗'} ${name}${!cond && extra !== '' ? ' — ' + extra : ''}`); };
+let srv = null; let browser = null;
+const finish = async (code) => {
+  if (browser) await browser.close().catch(() => {});
+  if (srv) { try { srv.kill('SIGKILL'); } catch { /* gone */ } }
+  T.killTmux();
+  const bad = results.filter((x) => !x.cond).length;
+  console.log(`\n${results.length - bad}/${results.length} c3-updates assertions passed`);
+  process.exit(code !== undefined ? code : (bad ? 1 : 0));
+};
+process.on('unhandledRejection', (e) => { console.error(e); finish(1); });
+
+async function waitFor(page, fn, arg, ms = 8000) {
+  try { await page.waitForFunction(fn, arg, { timeout: ms }); return true; } catch { return false; }
+}
+
+(async () => {
+  const exe = findBrowser();
+  if (!exe) { console.log('✗ no Chrome/Chromium on this machine — the c3-updates suite cannot run'); return finish(1); }
+  let chromium;
+  try { ({ chromium } = require('playwright-core')); } catch { console.log('✗ playwright-core is not installed — the c3-updates suite cannot run'); return finish(1); }
+
+  srv = spawn(process.execPath, [path.join(__dirname, 'server.js')], { cwd: __dirname, stdio: 'ignore', env: T.env({ PMOS_WS_PORT: String(T.PORT) }) });
+  await T.waitForServer(BASE);
+  browser = await chromium.launch({ executablePath: exe });
+  const ctx = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
+  const page = await ctx.newPage();
+  const errors = [];
+  page.on('pageerror', (e) => errors.push(String(e && e.message || e)));
+
+  // The stand-ins: an installed app 0.1.0 and a kit 0.1.0 in every workspace, both behind 0.2.0.
+  const S = { app: '0.1.0', kit: '0.1.0', checkout: false, upgrade: { ok: true }, down: 0 };
+  const calls = [];
+  const body = (ws) => ({ ok: true, ws, app: { version: S.app, fromCheckout: S.checkout }, kit: { present: true, version: S.kit }, source: { kind: 'npm' } });
+  const wsOf = (route) => { try { return JSON.parse(route.request().postData() || '{}'); } catch { return {}; } };
+  await page.route((u) => u.pathname === '/api/kit/status', (route) => route.fulfill({ json: { ...body(new URL(route.request().url()).searchParams.get('ws')), busy: null } }));
+  await page.route((u) => u.pathname === '/api/kit/check', (route) => { const b = wsOf(route); calls.push(['check', b]); route.fulfill({ json: { ...body(b.ws), latest: '0.2.0', appBehind: S.app !== '0.2.0', kitBehind: S.kit !== '0.2.0' } }); });
+  await page.route((u) => u.pathname === '/api/kit/update', (route) => {
+    const b = wsOf(route); calls.push(['kit', b]);
+    if (b.version !== '0.2.0') return route.fulfill({ status: 502, json: { ok: false, error: 'Check for updates first' } });
+    route.fulfill({ json: { ...body(b.ws), kit: { present: true, version: '0.2.0' }, output: 'kit updated' } });
+  });
+  await page.route((u) => u.pathname === '/api/kit/upgrade-app', (route) => {
+    const b = wsOf(route); calls.push(['app', b]);
+    if (!S.upgrade.ok) return route.fulfill({ status: 403, json: S.upgrade });
+    S.down = 2;   // the server is away for two polls, then answers on the new version
+    route.fulfill({ json: { ok: true, ws: b.ws, from: '0.1.0', to: b.version, log: '/tmp/app-update.log' } });
+  });
+  let reloaded = false;
+  await page.route((u) => u.pathname === '/api/sessions', async (route) => {
+    if (!calls.some((c) => c[0] === 'app' && S.upgrade.ok)) return route.continue();
+    if (S.down > 0) { S.down -= 1; return route.abort('connectionrefused'); }
+    S.app = '0.2.0';
+    const r = await route.fetch(); const j = await r.json().catch(() => ({}));
+    return route.fulfill({ json: { ...j, version: S.app } });
+  });
+  page.on('framenavigated', (f) => { if (f === page.mainFrame() && calls.some((c) => c[0] === 'app')) reloaded = true; });
+  const named = (kind) => calls.filter((c) => c[0] === kind);
+
+  const open = async () => {
+    await page.goto(BASE + '/c3.html?tab=settings');
+    await waitFor(page, () => !!document.querySelector('[data-c3set-nav] [data-c3set-sec="updates"]'));
+    await page.click('[data-c3set-nav] [data-c3set-sec="updates"]');
+    return waitFor(page, () => !!document.querySelector('[data-c3set-section="updates"] [data-c3set-check]:not([disabled])'));
+  };
+
+  /* ── A: before a check, nothing is offered and npm is not asked ── */
+  ok('A1 Updates opens with Check now', await open());
+  ok('A2 no app Update and no Open the main app before a check', await page.evaluate(() => !document.querySelector('[data-c3set-app-update]') && !/Open the main app/.test(document.querySelector('[data-c3set-section="updates"]').textContent)));
+  ok('A3 nothing was asked of npm before the press', calls.length === 0, JSON.stringify(calls));
+
+  /* ── B: the kit Update sends the version the check found ── */
+  await page.click('[data-c3set-check]');
+  ok('B1 after the check, the app row offers Update to 0.2.0', await waitFor(page, () => { const b = document.querySelector('[data-c3set-app-update]'); return !!b && /Update to 0\.2\.0/.test(b.textContent); }));
+  ok('B2 the page no longer sends you to the main app', await page.evaluate(() => !/Open the main app/.test(document.querySelector('[data-c3set-section="updates"]').textContent)));
+  ok('B3 each workspace row offers a kit Update', await waitFor(page, () => !!document.querySelector('[data-c3set-kit-update]')));
+  const kitWs = await page.getAttribute('[data-c3set-kit-update]', 'data-c3set-kit-update');
+  await page.click(`[data-c3set-kit-update="${kitWs}"]`);
+  ok('B4 kit Update posts that workspace and the checked version', await waitFor(page, () => !!document.querySelector('[data-c3-toast]') && /Updated the kit/.test(document.querySelector('[data-c3-toast]').textContent)) && named('kit').length === 1 && named('kit')[0][1].ws === kitWs && named('kit')[0][1].version === '0.2.0', JSON.stringify(named('kit')));
+  ok('B5 that row no longer offers Update', await waitFor(page, (w) => !document.querySelector(`[data-c3set-kit-update="${w}"]`), kitWs));
+
+  /* ── C: the app update asks first, then runs, waits for the restart and reloads ── */
+  await page.click('[data-c3set-app-update]');
+  ok('C1 it asks first, and says PMOS stops while the new version installs', await waitFor(page, () => { const c = document.querySelector('[data-c3set-app-confirm]'); return !!c && /stops/.test(c.textContent) && !!document.querySelector('[data-c3set-app-go]'); }));
+  ok('C2 nothing runs before the answer', named('app').length === 0);
+  await page.click('[data-c3set-app-cancel]');
+  ok('C3 Cancel puts the Update button back', await waitFor(page, () => !document.querySelector('[data-c3set-app-confirm]') && !!document.querySelector('[data-c3set-app-update]')) && named('app').length === 0);
+  await page.click('[data-c3set-app-update]');
+  await page.click('[data-c3set-app-go]');
+  for (let i = 0; i < 40 && !named('app').length; i++) await new Promise((r) => setTimeout(r, 100));
+  ok('C4 the update posts the checked version', named('app').length === 1 && named('app')[0][1].version === '0.2.0', JSON.stringify(named('app')));
+  ok('C5 the row says it is updating and that the page reloads', await waitFor(page, () => { const b = document.querySelector('[data-c3set-app-busy]'); return !!b && /reloads/.test(b.textContent); }, null, 3000) || reloaded);
+  for (let i = 0; i < 200 && !reloaded; i++) await new Promise((r) => setTimeout(r, 100));
+  ok('C6 the page reloads by itself when the new version answers', reloaded);
+
+  /* ── D: a refusal is shown on the row ── */
+  S.app = '0.1.0'; S.upgrade = { ok: false, error: 'This page signed in with a token that changes when the workspace restarts' };
+  calls.length = 0; reloaded = false;
+  await open();
+  await page.click('[data-c3set-check]');
+  await waitFor(page, () => !!document.querySelector('[data-c3set-app-update]'));
+  await page.click('[data-c3set-app-update]');
+  await page.click('[data-c3set-app-go]');
+  ok('D1 a refused update says why, on the app row', await waitFor(page, () => { const r = document.querySelector('[data-c3set-row="upd.app"]'); return !!r && /token that changes/.test(r.textContent); }));
+  ok('D2 a refused update does not reload the page', !reloaded);
+
+  /* ── E: a checkout updates with git ── */
+  S.checkout = true; S.upgrade = { ok: true }; calls.length = 0;
+  await open();
+  await page.click('[data-c3set-check]');
+  ok('E1 a checkout says git pull and offers no app Update', await waitFor(page, () => /git pull/.test(document.querySelector('[data-c3set-row="upd.app"]').textContent)) && !(await page.$('[data-c3set-app-update]')));
+
+  ok('F1 the page throws no error', errors.length === 0, errors.slice(0, 3).join(' | '));
+  finish();
+})();

package/workspace/guide/console-calendar.md

@@ -1,14 +1,30 @@
 ---
 type: Guide
 title: "Guide: the Calendar tab of the console page"
-description: "The Calendar tab of the console page (/c3.html): the five zooms, the layer chips, the markers, the context of a meeting, free time, the tidy-up suggestions and the empty states."
-timestamp: 2026-10-11
+description: "The Calendar tab of the console page (/c3.html): Calendar and Notes, the five zooms, the layer chips, the markers, the context of a meeting, free time, the tidy-up suggestions and the empty states."
+timestamp: 2026-10-12
 ---
 
 # Guide: the Calendar tab of the console page
 
 The Calendar tab of the console page (`/c3.html`) shows time. It shows what happens and what falls due, by date. At the top it shows a short deck of headline cards about your calendar, for example a conflict or a meeting with no time to prepare. The deck shows nothing when PMOS has no card about your calendar. The tab shows no task list and no strategy panel. Your due items live in Work. The strategy and progress panels live in Reports and Initiatives.
 
+## Calendar and Notes
+
+The switch at the start of the bar has two parts. **Calendar** shows the grid. **Notes** shows your notes.
+
+In **Notes**, the list is at the left. The notes are in groups, one for each initiative. **No initiative** is the last group. The number shows how many notes the list shows. Type in **Search notes** to keep only the notes whose title, initiative or summary has the words. A row shows when the note was made and its length. A row also shows **recording** or **paused** while the note is held, **no meeting** when the note has no meeting, and a warning mark when a statement differs from a file.
+
+Press a row to open the note at the right. The note has three stages. Press **Before**, **During** or **After** to change the stage.
+
+- **Before** shows what the note kept about its meeting: the agenda, what the meeting is for, what to do to be ready, what to read first and the people. A tick shows an agenda item that was heard in the transcript. A note with no meeting says so, and has **Link to a meeting** and **Link to an initiative**.
+- **During** shows the live notes while the note is recorded or paused. At other times it shows the transcript.
+- **After** shows the overview, the decisions with why, the next steps with owner and due date, the open questions, the statements that differ from a file and the highlights. The transcript is folded at the bottom. When the final notes are written, click a text to correct it. Leave the text to save it. Press `Esc` to cancel. **Make task** adds a next step to the note's initiative.
+
+A note that is recorded now opens on **During**. Other notes open on **After**. **Show in the calendar** goes back to the grid, on the day of the meeting, with the meeting selected. The copy button puts the note on the clipboard as Markdown.
+
+In **Notes**, the zoom, the arrows and the calendar keys do nothing.
+
 ## Zoom and move
 
 Use **Day**, **Week**, **Month**, **Quarter** or **Year** to change the zoom. Use the arrows to go to the previous or the next period. Press **Today** to come back to today.
@@ -53,6 +69,8 @@ Press a meeting to show its context in the side column. Under the title, a row s
 - For a past meeting, **What came out of it** lists the decisions and actions of its note. **What moved after it** lists the items that changed within 48 hours and refer to the meeting or its initiative.
 - For a coming meeting, **Prepared** lists what is ready, and **To prepare** lists what is still open.
 
+When the meeting has a note, the detail has **Open the note**. It opens the note in **Notes**.
+
 When PMOS holds nothing for a meeting, the detail says so. It does not guess.
 
 ## Free time

package/workspace/guide/notes.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Guide: notes"
 description: "How to take notes in a meeting: one note top to bottom, typed notes as timed lines, key points written each minute and labelled by Jev, delete a note; final notes written after Stop from the whole recording, with speakers and a quote for each item, decisions with their why and who, next steps with an open question, a discussion paragraph, and Wispr Flow's notes merged in and fetched by hand when the fetch fails; listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository for conflicts, capture highlights during the meeting, create tasks from next steps, correct and tag lines, see what changed in your notes, replay the meeting, see screenshots of the shared screen beside the transcript, link a note to its meeting and its initiative, and get a summary."
-timestamp: 2026-10-11
+timestamp: 2026-10-12
 ---
 
 # Guide: notes
@@ -22,7 +22,7 @@ Starting a note, from the Record control or from **Take notes** on a calendar ev
 
 ### The Record control in the console
 
-The console (the page at `/c3.html`) has the same Record control in its top bar, beside the Sessions button. It is always there, also when nothing is recording. **Record** (the microphone) starts an untitled note and listens at once. The arrow lists the meetings of today that have not started. Press one to start a note linked to that calendar event. While a meeting records, the red group shows its name and clock, **Highlight**, **Pause** and **Stop**. While it is paused, the group shows **Resume** and **Stop**. **Stop** asks first and offers **Pause instead**. A red dot shows on the Calendar tab while a meeting is held. The console has no Notes page, so the name in the red group opens the note in the main app.
+The console (the page at `/c3.html`) has the same Record control in its top bar, beside the Sessions button. It is always there, also when nothing is recording. **Record** (the microphone) starts an untitled note and listens at once. The arrow lists the meetings of today that have not started. Press one to start a note linked to that calendar event. While a meeting records, the red group shows its name and clock, **Highlight**, **Pause** and **Stop**. While it is paused, the group shows **Resume** and **Stop**. **Stop** asks first and offers **Pause instead**. A red dot shows on the Calendar tab while a meeting is held. Press the name in the red group to open the note on the console's Calendar tab, in **Notes**, on the **During** stage. See [the Calendar tab of the console page](console-calendar.md).
 
 When Whisper or Qwen3-ASR transcribes the meeting, the red group also names the engine and the language, for example **Whisper · English**. Check it when lines come out in the wrong language: the language is set in the Notes settings.
 

package/workspace/guide/settings.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Settings in console3: one home for each setting"
 description: "How to open Settings in console3, what each section holds, what the scope tags and the environment notes mean, and where the settings are kept."
-timestamp: 2026-10-11
+timestamp: 2026-10-12
 ---
 
 # Settings in console3: one home for each setting
@@ -55,6 +55,14 @@ When a section has changed settings, **Reset section** at the top of the section
 
 Some rows show a feature that PMOS does not have yet, such as choosing calendars, mapping Jira projects, pairing a phone, the device list, and export or reset of every setting. The control on these rows is off, and the row says why.
 
+## Update PMOS and the kit
+
+Open **Updates** and press **Check now**. PMOS asks the npm registry for the latest version only when you press it.
+
+- **Update to** a version on the **PMOS app** row updates the app. The row asks first: press **Restart and update**, or **Cancel**. PMOS stops, installs the new version, and starts again. Open terminals keep running. The page reloads when the new version starts. If the update is refused, or PMOS starts again on the old version, or PMOS does not come back, the row says so and names the update log.
+- When PMOS runs from a PMOS checkout, the row says to update it with `git pull`. There is no Update button.
+- **Update** on a workspace row updates the kit in that repository. It replaces the kit files in its `pmos/` folder (AGENTS.md, skills, scripts, templates, `okf/core`, the mod and KIT-VERSION). It does not change `state/`, `planning/` or `okf/product/`, and it does not commit. Review the change in the repository as a normal pull request.
+
 ## Where the settings are kept
 
 The settings that had a home before this page keep it. For example, the recording engine is kept by the notes engine, Validate consent by the validate route, and the theme and the new-session defaults in this browser.

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.143.0",
+  "version": "0.145.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-calendar.js

@@ -21,6 +21,8 @@ import { el } from './dom.js';
 import { c3ic } from './pm-work-view.js';
 import { button, ensureComponentsCss } from './primitives.js';
 import { toast } from './c3-toast.js';
+import { notesView, openNote, noteOfEvent, primeNotes } from './c3-notes.js';   // Calendar › Notes (initiative c3-notes-place)
+import { onNotes } from './notes-links.js';
 
 const LAYERS = [
   ['meetings', 'Meetings'],
@@ -63,6 +65,8 @@ const setVar = (node, name, value) => { node.style.setProperty('--cal3-' + name,
 function state(r) {
   const st = r.page || (r.page = { on: new Set(LAYERS.map((l) => l[0]).filter((id) => !(r.ctx && r.ctx.overlay && mem.hide.includes(id)))), free: true, tidy: false, sel: null });
   if (r.sel) { st.sel = { type: 'event', id: r.sel }; r.sel = null; }   // a meeting chosen on the Briefing (openDay)
+  if (r.pendingMode) { st.mode = r.pendingMode; r.pendingMode = null; }   // a note opened before the page drew (the Record chip)
+  if (!st.mode) st.mode = 'cal';
   return st;
 }
 
@@ -99,10 +103,21 @@ export function drawCalendarPage(host, r, h) {
   ensureComponentsCss();   // the Tidy-up buttons are pmc-btn
   const st = state(r);
   const phone = r.root.classList.contains('ph');
+  const page = (b, ...kids) => el('div', { class: 'cal3' + (r.ctx.overlay ? ' ov' : ''), 'data-cal3': 'page', 'data-cal3-show': st.mode }, r.ctx.deck || null, b, ...kids);
+  const redraw0 = () => h.redraw(host, r);
+  const modes = r.ctx.overlay ? null : modeSeg(st, redraw0);
+  if (st.mode === 'notes' && modes) {   // Calendar › Notes: the list and the open note; the zoom and the period have nothing to step here
+    return page(el('div', { class: 'calbar' }, el('div', { class: 'lens' }, modes)), notesView({ host, r, h, st, redraw: redraw0 }));
+  }
+  if (!r.notesOff) {   // a meeting's "Open the note" needs the shared notes read; a new note redraws the open detail
+    r.notesOff = onNotes(() => { if (r.root.isConnected && st.mode === 'cal' && st.sel) h.redraw(host, r); });
+    primeNotes();
+  }
   const bar = h.bar(host, r, phone);
-  const page = (...kids) => el('div', { class: 'cal3' + (r.ctx.overlay ? ' ov' : ''), 'data-cal3': 'page' }, r.ctx.deck || null, bar, ...kids);
-  if (r.error) return page(fold('alert', 'The calendar could not be read: ' + r.error, { 'data-cv': 'error', role: 'status' }));
-  if (!r.data) return page(fold('clock', 'Reading the repository', { 'data-cv': 'loading', role: 'status' }));
+  if (modes) { const lens = bar.querySelector('.lens'); if (lens) lens.prepend(modes); }
+  const pageBar = (...kids) => page(bar, ...kids);
+  if (r.error) return pageBar(fold('alert', 'The calendar could not be read: ' + r.error, { 'data-cv': 'error', role: 'status' }));
+  if (!r.data) return pageBar(fold('clock', 'Reading the repository', { 'data-cv': 'loading', role: 'status' }));
 
   const d = r.data; const M = model(d, h);
   const redraw = (focusSel) => { h.redraw(host, r); if (focusSel) { const n = r.root.querySelector(focusSel); if (n) n.focus(); } };
@@ -133,7 +148,22 @@ export function drawCalendarPage(host, r, h) {
     el('div', { class: 'cal3-wrap' },
       el('div', { class: 'cal3-main' }, empty, grid),
       el('div', { class: 'cal3-side' }, detail(ui), st.tidy ? tidyList(ui) : null, st.free ? freeList(ui, range) : null, lanes(ui, range))));
-  return page(chips(ui, range), body);
+  return pageBar(chips(ui, range), body);
+}
+
+/* "Open the note": the note recorded for this meeting, on Calendar › Notes; nothing when no note names the meeting */
+function noteLink(ui, e) {
+  if (ui.r.ctx.overlay) return null;
+  const n = noteOfEvent(e); if (!n) return null;
+  return el('div', { class: 'cal3-ctx', 'data-cal3-ctx': 'note' }, el('h4', null, 'Notes'),
+    el('a', { href: '#', class: 'cal3-ref', 'data-cal3': 'open-note', 'data-cal3-open-note': n.id, title: 'Open the note: ' + (n.title || 'Untitled note'),
+      onClick: (ev) => { ev.preventDefault(); openNote(ui.r, n.id); ui.redraw(); } }, c3ic('notes', 'sm'), 'Open the note'));
+}
+
+/* the Calendar | Notes switch, before the zoom (the mockup the PM approved on 2026-10-12) */
+function modeSeg(st, redraw) {
+  const b = (id, icon, label) => { const x = button({ variant: 'ghost', attrs: { class: 'cal3-b', 'aria-pressed': String(st.mode === id), 'data-cal3-mode': id, title: label }, onClick: () => { if (st.mode !== id) { st.mode = id; redraw(); } } }); x.replaceChildren(c3ic(icon, 'sm'), el('span', null, label)); return x; };
+  return el('div', { class: 'seg', role: 'group', 'aria-label': 'Show', 'data-cal3': 'mode' }, b('cal', 'cal', 'Calendar'), b('notes', 'notes', 'Notes'));
 }
 
 function fold(icon, text, attrs) { return el('div', { class: 'fold', ...(attrs || {}) }, c3ic(icon, 'sm'), text); }
@@ -424,6 +454,7 @@ function meetingDetail(ui, hit) {
     el('div', { class: 'dim mono cal3-when' }, h.dayLabel(hit.date) + (s === null ? ', all day' : ' · ' + h.hhmm(s) + ' to ' + h.hhmm(f))),
     el('div', { class: 'chips2', 'data-cal3': 'meeting-chips' }, homeChip('Calendar'), ...peopleOf(e).map((n) => el('span', { class: 'tag' }, n)),
       e.initiative ? el('span', { class: 'tag' }, 'Initiative: ' + (((ui.d.gantt || []).find((g) => g.id === e.initiative) || {}).title || e.initiative)) : null),
+    noteLink(ui, e),
     ...body,
     el('p', { class: 'dim cal3-note' }, past ? 'Only what PMOS holds a record for: items created or closed within 48 hours of the meeting. Each line opens its source.' : 'PMOS proposes changes. It never edits your calendar.'),
   ];

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

@@ -0,0 +1,316 @@
+/* pm/c3-notes.js — Calendar › Notes on the console3 Calendar tab (initiative c3-notes-place, PRD done-criteria 1 to 7).
+ *
+ * c3-calendar.js draws it when the Calendar | Notes switch is on Notes: notesView(ui) returns one persistent box, which this
+ * file redraws on its own (a read, a choice, a stage, a search), so the grid's data call is not repeated.
+ *
+ *   the list   "By initiative" with a count and a search field, one group per initiative and "No initiative" last (dest-notes.js
+ *              groupNotes). A row: the time or day, the length, recording or paused, "no meeting", and a dot for a conflict.
+ *   the note   the Calendar stage's layout (calendar-views.js stageNode, the mockup the PM approved on 2026-10-12): a head with
+ *              Before, During and After, then the stage's cards.
+ *     Before   the meeting context the note kept (meeting.context): agenda (an item heard is ticked), what it is for, to be ready,
+ *              links and references, people. A note with no meeting says so and offers the main app's link pickers.
+ *     During   the main app's live block while the note is recorded or paused (view-notes.js renderLive), else the transcript.
+ *     After    the Notes card (decisions with why, next steps with owner, due and Make task, questions, conflicts, highlights,
+ *              the folded transcript) from final_notes, else from what was caught live (dest-notes.js partsOf).
+ *
+ * Nothing is invented: a part the note does not hold is left out or says so. The mockup's Rejected column, Settle, told and
+ * not told, Route actions and the drafts have no data or route yet, so they are not drawn.
+ *
+ *   openNote(r, id, phase)  shows a note (from the Record chip or a meeting's detail) on the instance r
+ *   noteOfEvent(e)          the note linked to a calendar event, from the shared notes read (notes-links.js), or null
+ */
+import { el } from './dom.js';
+import { button } from './primitives.js';
+import { c3ic } from './pm-work-view.js';
+import { pmGet, pmPost } from './http.js';
+import { toast } from './c3-toast.js';
+import { onNotes, notesFor, refreshNotes } from './notes-links.js';
+import { agendaHeard, peopleOf } from './notes-context.js';
+import { groupNotes, partsOf, conflictsOf, whenShort } from './dest-notes.js';
+import * as dock from './note-dock.js';
+import * as V from './view-notes.js';
+import { makeTask } from './notes-task.js';
+
+const PHASES = [['before', 'clip', 'Before'], ['during', 'mic', 'During'], ['after', 'notes', 'After']];
+const startOf = (n) => (n.meeting && n.meeting.start) || n.recorded_from || n.created_at || n.updated_at;
+const iniName = (i) => (i ? i.title || i.id : null);
+const mins = (ms) => (ms >= 60000 ? Math.round(ms / 60000) + ' min' : '');
+const lenOf = (n) => n.meeting_ms || Math.max(0, ...(n.transcript || []).map((x) => x.t || 0));
+const dayOf = (iso) => { const t = new Date(iso); return Number.isFinite(t.getTime()) ? t.toLocaleDateString('en-GB', { weekday: 'short', day: 'numeric', month: 'short' }) : ''; };
+const hm = (iso) => { const t = new Date(iso); return Number.isFinite(t.getTime()) ? String(t.getHours()).padStart(2, '0') + ':' + String(t.getMinutes()).padStart(2, '0') : ''; };
+const avatar = (name) => el('span', { class: 'av', title: name }, String(name).split(/\s+/).map((w) => w[0]).slice(0, 2).join('').toUpperCase());
+/* A native button from primitives.js drawn as the console3 control `cls` (chip2 lk, ib, sgb, …); cal3-b takes the primitive's own
+ * height, padding and hover off (console3.css), as c3-ini-ui.js btn() does with ini-b. */
+function btn(cls, attrs, kids, onClick) {
+  const b = button({ variant: 'ghost', onClick, attrs: { ...(attrs || {}), class: 'cal3-b ' + cls } });
+  b.replaceChildren(...[].concat(kids).filter((k) => k != null && k !== false));
+  return b;
+}
+const fold = (icon, text, attrs) => el('div', { class: 'fold', ...(attrs || {}) }, c3ic(icon, 'sm'), text);
+const held = (id) => { const s = dock.recordState(); return s.mode !== 'idle' && s.id === id ? s.mode : null; };
+const linked = (n) => !!(n.meeting && (n.meeting.kind === 'event' || n.meeting.kind === 'adhoc'));
+const transcriptOf = (n) => (n.final && n.final.segments && n.final.segments.length ? n.final.segments.map((g) => ({ t: g.t, text: g.text, who: g.spk })) : (n.transcript || []).filter((x) => !x.dropped).map((x) => ({ t: x.t, text: x.text, who: x.source })));
+
+/** The notes state on the calendar instance r. */
+function stateOf(r) {
+  if (!r.notes) r.notes = { box: el('div', { class: 'cal3-notes', 'data-cal3': 'notes' }), rows: null, err: null, open: null, note: null, phase: null, q: '', seq: 0, live: null, unsub: null };
+  return r.notes;
+}
+
+/** The note the Calendar shows next: from the Record chip (phase During) or a meeting's detail (its default stage). */
+export function openNote(r, id, phase) {
+  const s = stateOf(r);
+  s.open = id; s.note = null; s.phase = phase || null;
+  r.page = r.page || null;
+  if (r.page) r.page.mode = 'notes';
+  else r.pendingMode = 'notes';
+}
+
+/** The note linked to this calendar event (its id, its id without the day of a repeat, or its start and title), from the
+ * shared read. The calendar's events carry their start as `at`. Null when none is known. */
+export function noteOfEvent(e) {
+  if (!e) return null;
+  const start = e.start || e.at; const base = String(e.id || '').split('@')[0];
+  for (const x of [{ id: e.id, start, title: e.title }, { id: base, start, title: e.title }]) { const f = notesFor(x); if (f.length) return f[0]; }
+  return null;
+}
+
+/** The Notes view: the list and the note, in one box that keeps its identity across the page's redraws. */
+export function notesView(ui) {
+  const s = stateOf(ui.r);
+  s.ui = ui;
+  if (!s.unsub) s.unsub = onNotes(() => { if (s.box.isConnected) read(s); });
+  if (!s.rows || (s.open && (!s.note || s.note.id !== s.open))) read(s);
+  draw(s);
+  return s.box;
+}
+
+async function read(s) {
+  const seq = ++s.seq;
+  const [l, one] = await Promise.all([pmGet('/api/notes'), s.open ? pmGet('/api/notes/one?id=' + encodeURIComponent(s.open)) : null]);
+  if (seq !== s.seq) return;
+  if (l && l.ok) { s.rows = l.notes || []; s.err = null; } else { s.rows = s.rows || []; s.err = (l && l.error) || 'The notes could not be read.'; }
+  if (!s.open && s.rows.length) { s.open = s.rows[0].id; return read(s); }
+  if (one && one.ok && one.note && one.note.id === s.open) s.note = one.note;
+  draw(s);
+}
+
+function choose(s, id) {
+  if (s.open === id) return;
+  s.open = id; s.note = null; s.phase = null;
+  draw(s); read(s);
+}
+
+function draw(s) {
+  if (!s.box.isConnected && s.drawn) { s.drawn = false; }
+  // a field being typed in is not redrawn under the cursor; the live block keeps its own fields
+  const active = typeof document !== 'undefined' ? document.activeElement : null;
+  if (active && s.box.contains(active) && active.matches('textarea, [contenteditable="true"]') && !active.closest('[data-nt-part="live"]')) return;
+  const q = s.box.querySelector('[data-cal3-notes="search"]');
+  const typing = !!q && active === q; const caret = typing ? q.selectionStart : null;
+  s.box.replaceChildren(el('div', { class: 'cal3-nwrap' }, listCard(s), noteCol(s)));
+  s.drawn = true;
+  if (typing) { const nq = s.box.querySelector('[data-cal3-notes="search"]'); if (nq) { nq.focus(); nq.setSelectionRange(caret, caret); } }
+}
+
+/* ── the list ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function listCard(s) {
+  const qtext = s.q.trim().toLowerCase();
+  const shown = (s.rows || []).filter((r) => !qtext || String(r.title || '').toLowerCase().includes(qtext) || String(iniName(r.initiative) || '').toLowerCase().includes(qtext)
+    || (r.summary_lines || []).some((x) => String(x).toLowerCase().includes(qtext)));
+  const search = el('input', { type: 'text', class: 'cal3-nsearch', placeholder: 'Search notes', 'aria-label': 'Search notes', value: s.q, 'data-cal3-notes': 'search' });
+  search.addEventListener('input', () => { s.q = search.value; draw(s); });
+  let body;
+  if (!s.rows) body = fold('clock', 'Reading the notes', { role: 'status' });
+  else if (!s.rows.length) body = fold('mic', s.err || 'No notes yet. Press Record at the top right to start one.', { 'data-cal3-notes': 'none' });
+  else if (!shown.length) body = fold('search', 'No note matches “' + s.q.trim() + '”.', { 'data-cal3-notes': 'no-match' });
+  else body = groupNotes(shown).map((g) => el('div', { class: 'cal3-ctx', 'data-cal3-notes-group': g.label }, el('h4', null, g.label),
+    el('ul', { class: 'list', role: 'list' }, g.rows.map((r) => noteRow(s, r)))));
+  return el('section', { class: 'card sect', 'data-cal3-notes': 'list', 'aria-label': 'Notes' },
+    el('div', { class: 'sh2' }, el('h2', null, c3ic('notes', 'sm'), 'By initiative ', el('span', { class: 'bdg g', 'data-cal3-notes': 'count' }, String(shown.length)))),
+    el('div', { class: 'cal3-nsearchw' }, search), body);
+}
+
+function noteRow(s, r) {
+  const mode = held(r.id) || (r.state === 'recording' || r.state === 'paused' ? r.state : null);
+  const on = s.open === r.id;
+  const len = mins(r.meeting_ms || 0);
+  return el('li', { class: 'nrow cal3-nrow' + (on ? ' on' : ''), 'data-cal3-note-row': r.id },
+    el('span', { class: 'ki' + (mode ? ' hot' : '') }, c3ic(mode ? 'mic' : 'doc')),
+    btn('cal3-nopen', { title: 'Open ' + (r.title || 'Untitled note'), 'aria-current': on ? 'true' : 'false' }, [
+      el('span', { class: 'tt' }, r.title || 'Untitled note'),
+      el('span', { class: 'chips' }, el('span', { class: 'dim mono cal3-xs' }, [mode ? 'now' : whenShort(startOf(r)), len].filter(Boolean).join(' · ')),
+        mode ? el('span', { class: 'tag', 'data-cal3-notes': 'live' }, mode === 'paused' ? 'paused' : 'recording') : null,
+        !linked(r) && !mode ? el('span', { class: 'tag', title: 'Not linked to a meeting', 'data-cal3-notes': 'no-meeting' }, 'no meeting') : null,
+        r.conflicts ? el('span', { class: 'st warn', title: r.conflicts + (r.conflicts === 1 ? ' statement differs' : ' statements differ') + ' from a file' }, c3ic('alert', 'sm'), String(r.conflicts)) : null)],
+    () => choose(s, r.id)),
+    el('span'));
+}
+
+/* ── the note ─────────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function noteCol(s) {
+  const n = s.note;
+  if (!s.open) return el('div', { 'data-cal3-notes': 'note' }, el('section', { class: 'card' }, fold('doc', s.rows && s.rows.length ? 'Choose a note to read it.' : 'Notes you record show here.')));
+  if (!n) return el('div', { 'data-cal3-notes': 'note' }, el('section', { class: 'card' }, fold('clock', 'Reading the note', { role: 'status' })));
+  const mode = held(n.id);
+  const ph = s.phase || (mode ? 'during' : 'after');
+  const ev = n.meeting && n.meeting.kind === 'event' ? n.meeting : null;
+  const len = mins(lenOf(n));
+  const head = el('section', { class: 'card', 'data-cv': 'stage-head' },
+    el('div', { class: 'cal3-nhead' },
+      el('span', { class: 'chips2' }, el('b', { 'data-cal3-notes': 'title' }, n.title || 'Untitled note'), el('span', { class: 'mono dim cal3-sm' }, mode ? 'now' : hm(startOf(n)))),
+      el('div', { class: 'stg', role: 'group', 'aria-label': 'Note stage', 'data-cv': 'phase' },
+        PHASES.map(([k, ic, l]) => btn('sgb', { 'data-cal3-phase': k, 'aria-pressed': String(ph === k), title: l }, [c3ic(ic), el('span', null, l)], () => { s.phase = k; draw(s); })))),
+    el('div', { class: 'chips2 dim cal3-sm' },
+      [dayOf(startOf(n)), len, iniName(n.initiative) || 'No initiative'].filter(Boolean).join(' · '),
+      ev ? btn('chip2 lk', { 'data-cal3-notes': 'show-meeting', title: 'Show the meeting in the calendar' }, [c3ic('cal', 'sm'), 'Show in the calendar'], () => showMeeting(s, ev))
+        : linked(n) ? null : el('span', { class: 'tag' }, 'no meeting'),
+      btn('ib sm', { title: 'Copy as Markdown (with the meeting context)', 'aria-label': 'Copy as Markdown', 'data-cal3-notes': 'copy' }, c3ic('clip'), () => copy(n))));
+  const body = ph === 'before' ? before(s, n) : ph === 'during' ? during(s, n, mode) : after(s, n, mode);
+  return el('div', { class: 'cal3-ncol', 'data-cal3-notes': 'note', 'data-cal3-note': n.id, 'data-cal3-stage': ph }, head, ...[].concat(body));
+}
+
+const vctx = (s) => ({ state: {}, setState: () => { if (s.box.isConnected) { read(s); } } });
+const linkButtons = (s, n) => el('div', { class: 'chips2' },
+  btn('chip2 lk', { 'data-cal3-notes': 'link-meeting' }, [c3ic('cal', 'sm'), 'Link to a meeting'], () => V.linkMeeting(vctx(s), n.id)),
+  btn('chip2 lk', { 'data-cal3-notes': 'link-initiative' }, [c3ic('init', 'sm'), 'Link to an initiative'], () => V.linkInitiative(vctx(s), n.id)));
+
+/* a row of the stage's prepared list: the icon, the label, what it holds */
+const prepRow = (icon, label, detail, done) => el('div', { class: 'chips2 cal3-prep', 'data-cal3-prep': label },
+  el('span', { class: 'ki' }, c3ic(icon)),
+  el('div', { class: 'cal3-prepb' }, el('b', null, label), el('div', { class: 'dim' }, detail)),
+  done ? el('span', { class: 'st ok', title: done }, c3ic('check', 'sm')) : null);
+
+function before(s, n) {
+  const ev = n.meeting && n.meeting.kind === 'event' ? n.meeting : null;
+  const h3 = el('h3', null, c3ic('spark'), 'Before the meeting');
+  if (!ev) {
+    return el('section', { class: 'card', 'data-cv': 'stage-before' }, h3,
+      fold('info', n.meeting && n.meeting.kind === 'adhoc' ? 'A meeting that is not on the calendar, so nothing was prepared for it.' : 'Not linked to a meeting, so nothing was prepared. Link it to a meeting to bring in its people and agenda.', { 'data-cal3-notes': 'no-meeting-before' }),
+      linkButtons(s, n));
+  }
+  const c = ev.context || null;
+  const lines = transcriptOf(n).map((x) => ({ t: x.t, text: x.text }));
+  const heard = c ? agendaHeard(c, lines) : [];
+  const rows = [];
+  const isHeard = (i) => heard[i] !== null && heard[i] !== undefined;
+  if (c && c.agenda && c.agenda.length) rows.push(prepRow('spark', 'Agenda', el('span', null, c.agenda.map((a, i) => el('span', { class: 'cal3-agi', 'data-cal3-heard': isHeard(i) ? 'true' : 'false', title: isHeard(i) ? 'Heard in the transcript' : null }, (i ? ' · ' : '') + a, isHeard(i) ? c3ic('check', 'sm') : null))), heard.some((x) => x !== null) ? heard.filter((x) => x !== null).length + ' of ' + c.agenda.length + ' heard' : null));
+  if (c && c.purpose) rows.push(prepRow('target', 'What it is for', c.purpose));
+  if (c && c.prep) rows.push(prepRow('scale', 'To be ready', c.prep));
+  const files = [...((c && c.links) || []).map((l) => el('a', { class: 'chip2 lk', href: l.url, target: '_blank', rel: 'noopener noreferrer' }, c3ic('out', 'sm'), l.label)),
+    ...((c && c.refs) || []).map((x) => (x.link ? el('a', { class: 'chip2 lk', href: x.link, target: '_blank', rel: 'noopener noreferrer' }, c3ic('doc', 'sm'), x.label) : el('span', { class: 'chip2' }, c3ic('doc', 'sm'), x.label)))];
+  if (files.length) rows.push(prepRow('doc', 'Read first', el('span', { class: 'chips2 cal3-wrapl' }, files)));
+  const names = peopleOf(c);
+  if (names.length) rows.push(prepRow('user', 'People', el('span', { class: 'chips2 cal3-wrapl' }, names.map(avatar))));
+  else if (c && c.attendees) rows.push(prepRow('user', 'People', c.attendees + ' attendees. Names are not kept while calendar names are off.'));
+  const when = (ev.start ? dayOf(ev.start) + ' ' + hm(ev.start) : '') + (ev.end ? ' to ' + hm(ev.end) : '');
+  rows.push(prepRow('cal', 'Meeting', [ev.title, when, c && c.series ? 'series: ' + c.series : null, c && c.role ? 'your role: ' + c.role : null].filter(Boolean).join(' · ')));
+  return el('section', { class: 'card', 'data-cv': 'stage-before' }, h3, ...rows,
+    c ? null : el('p', { class: 'dim cal3-sm' }, 'The calendar gave no more about this meeting.'));
+}
+
+function during(s, n, mode) {
+  const head = el('div', { class: 'c3cv-head' }, el('h3', null, c3ic('mic'), mode ? 'Live notes' : 'Transcript'), recordButton(s, n, mode));
+  if (mode) {
+    if (!s.live || s.live.id !== n.id) s.live = { id: n.id, host: el('div', { 'data-cal3-notes': 'live' }) };
+    s.live.host.replaceChildren();
+    const drawn = V.renderLive(s.live.host, vctx(s), n.id);
+    return el('section', { class: 'card', 'data-cv': 'stage-during' }, head,
+      drawn ? s.live.host : fold('mic', 'This note is being recorded in another window.'),
+      el('div', { class: 'chips2 dim mono cal3-sm' }, c3ic('lock', 'sm'), 'transcribed on this machine' + (mode === 'paused' ? ' · paused' : '')));
+  }
+  const tr = transcriptOf(n);
+  return el('section', { class: 'card', 'data-cv': 'stage-during' }, head,
+    tr.length ? el('div', { class: 'term cal3-term', 'data-cal3-notes': 'transcript' }, tr.map((x) => V.fmtTime(x.t || 0) + '  ' + (x.who ? V.speakerOf(n, x.who) + ': ' : '') + x.text).join('\n'))
+      : fold('mic', 'Nothing was transcribed for this note.', { 'data-cal3-notes': 'no-transcript' }),
+    el('div', { class: 'chips2 dim mono cal3-sm' }, c3ic('lock', 'sm'), 'transcribed on this machine' + (tr.length ? ' · ' + tr.length + (tr.length === 1 ? ' line' : ' lines') : '')));
+}
+
+/* Record, Resume or Stop, as the note allows (dest-notes.js noteParts): a note being recorded stops; a paused one resumes;
+ * a note never recorded records; a stopped meeting has none. */
+function recordButton(s, n, mode) {
+  if (n.private) return null;
+  const rb = (label, icon, title, on) => btn('ib pri cal3-recb', { 'data-cal3-notes': 'rec', title, 'aria-label': label }, [c3ic(icon), label], async () => { await on(); setTimeout(() => read(s), 400); });
+  if (mode === 'recording') return rb('Stop', 'stop', 'Stop and write the final notes', () => dock.stopNow());
+  if (mode === 'paused') return rb('Resume', 'play', 'Resume the paused meeting', () => dock.resumeNow());
+  if (n.state === 'idle' || (n.state === undefined && !(n.transcript || []).length)) {
+    const busy = dock.recordState().mode === 'recording';
+    const b = rb('Record', 'mic', busy ? 'Pause or stop the meeting being recorded first' : 'Record this note. Notes stay on this machine.', () => (busy ? null : dock.recordNote(n.id)));
+    if (busy) b.disabled = true;
+    return b;
+  }
+  return null;
+}
+
+function after(s, n, mode) {
+  const p = partsOf(n);
+  const names = n.meeting && n.meeting.context ? peopleOf(n.meeting.context) : [];
+  const cf = conflictsOf(n);
+  const td = (text) => el('td', null, text);
+  const kids = [
+    el('div', { class: 'c3cv-head' }, el('h3', null, c3ic('notes'), 'Notes'), recordButton(s, n, mode)),
+    el('div', { class: 'chips2' }, el('b', null, n.title || 'Untitled note'), el('span', { class: 'dim mono cal3-sm' }, [dayOf(startOf(n)), mins(lenOf(n))].filter(Boolean).join(' · ')), ...names.map(avatar)),
+    ...cf.map((c) => el('div', { class: 'fold w', 'data-cal3-notes': 'conflict' }, c3ic('alert', 'sm'), '“' + c.text + '” differs from ', el('span', { class: 'mono' }, c.doc + (c.line ? ':' + c.line : '')))),
+    p.overview ? editable(p.from === 'final', 'p', p.overview, 'Overview', (t) => saveFinal(s, n, 'overview', 0, t), { class: 'cal3-ov', 'data-cal3-notes': 'overview' })
+      : el('p', { class: 'dim cal3-ov', 'data-cal3-notes': 'no-overview' }, mode ? 'The overview is written when you stop recording.' : 'No overview yet.'),
+  ];
+  if (p.decisions.length) kids.push(el('table', { class: 'tbl', 'data-cv': 'decisions' }, el('thead', null, el('tr', null, el('th', null, 'Decision'), el('th', null, 'Why'))),
+    el('tbody', null, p.decisions.map((d) => el('tr', { 'data-cal3-notes': 'decision' }, el('td', null, editable(p.from === 'final', 'span', d.text, 'Decision', (t) => saveFinal(s, n, d.sec, d.i, t))), el('td', { class: 'dim' }, d.why || d.by || ''))))));
+  if (p.actions.length) kids.push(el('table', { class: 'tbl', 'data-cv': 'actions' }, el('thead', null, el('tr', null, el('th', null, 'Next step'), el('th', null, 'Owner'), el('th', null, 'Due'), el('th'))),
+    el('tbody', null, p.actions.map((a) => el('tr', { 'data-cal3-notes': 'action' }, el('td', null, editable(p.from === 'final', 'span', a.text, 'Next step', (t) => saveFinal(s, n, a.sec, a.i, t))),
+      td(a.owner || el('span', { class: 'dim' }, 'No owner')), td(a.due || el('span', { class: 'dim' }, '—')),
+      el('td', { class: 'cal3-tdr' }, btn('chip2 lk', { 'data-cal3-notes': 'make-task', title: n.initiative ? 'Add this step to ' + iniName(n.initiative) + ' as a plan item' : 'Link the note to an initiative first' },
+        [c3ic('plus', 'sm'), 'Make task'], (e) => makeTask(n, a, { btn: e.currentTarget }))))))));
+  if (p.questions.length) kids.push(el('div', { class: 'cal3-ctx', 'data-cal3-notes': 'questions' }, el('h4', null, 'Open questions'),
+    el('ul', { class: 'cal3-cl', role: 'list' }, p.questions.map((x) => el('li', { class: 'cal3-ci' }, el('span', { class: 'tag' }, 'Question'), el('span', { class: 'cal3-ct' }, x.text))))));
+  const hl = n.highlights || [];
+  if (hl.length) kids.push(el('div', { class: 'cal3-ctx', 'data-cal3-notes': 'highlights' }, el('h4', null, 'Highlights'),
+    el('ul', { class: 'cal3-cl', role: 'list' }, hl.map((x) => el('li', { class: 'cal3-ci' }, el('span', { class: 'dim mono cal3-at' }, typeof x.t === 'number' ? V.fmtTime(x.t) : ''), el('span', { class: 'tag' }, x.label || 'Highlight'), el('span', { class: 'cal3-ct' }, x.text))))));
+  if (!p.overview && !p.decisions.length && !p.actions.length && !p.questions.length && !hl.length && !cf.length) kids.push(fold('moon', mode ? 'Decisions and next steps show here as they are caught, and in full after you stop.' : 'No decisions, next steps or questions are held for this note.', { 'data-cal3-notes': 'nothing' }));
+  const tr = transcriptOf(n);
+  if (!mode && tr.length) kids.push(el('details', { 'data-cal3-notes': 'transcript-fold' }, el('summary', { class: 'dim cal3-sm' }, 'Transcript · ' + tr.length + (tr.length === 1 ? ' line' : ' lines')),
+    el('div', { class: 'term cal3-term' }, tr.map((x) => V.fmtTime(x.t || 0) + '  ' + x.text).join('\n'))));
+  return el('section', { class: 'card cal3-ncard', 'data-cv': 'notes' }, kids);
+}
+
+/** A text the PM corrects in place once the notes are final: a click puts the cursor in it, leaving it saves, Esc puts it back. */
+function editable(on, tag, text, label, save, attrs) {
+  if (!on) return el(tag, attrs || null, text);
+  const node = el(tag, { ...(attrs || {}), contenteditable: 'true', spellcheck: 'true', role: 'textbox', 'aria-label': 'Edit ' + label, 'data-cal3-notes-edit': '' }, text);
+  let last = text;
+  node.addEventListener('keydown', (e) => {
+    if (e.key === 'Enter' && tag !== 'p') { e.preventDefault(); node.blur(); }
+    if (e.key === 'Escape') { e.preventDefault(); node.textContent = last; node.blur(); }
+  });
+  node.addEventListener('blur', async () => {
+    const v = node.textContent.replace(/\s+/g, ' ').trim();
+    if (!v || v === last) { node.textContent = last; return; }
+    if (await save(v)) last = v; else node.textContent = last;
+  });
+  return node;
+}
+async function saveFinal(s, n, sec, i, text) {
+  const r = await pmPost('/api/notes/final-edit', { id: n.id, sec, i, text });
+  if (!r || !r.ok) { toast('Not saved' + ((r && r.error) ? ': ' + r.error : '')); return false; }
+  n.final_notes = r.final_notes;
+  toast('Saved');
+  return true;
+}
+async function copy(n) {
+  try { await navigator.clipboard.writeText(V.noteMarkdown(n)); toast('The note is on the clipboard as Markdown, with its meeting context.'); }
+  catch { toast('The clipboard was not available.'); }
+}
+
+/* "Show in the calendar": the Calendar switch back to the grid, on the meeting's day, with the meeting selected */
+function showMeeting(s, ev) {
+  const ui = s.ui; if (!ui) return;
+  ui.st.mode = 'cal';
+  const date = String(ev.start || '').slice(0, 10);
+  ui.r.sel = ev.event_id || null;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(date)) ui.h.go(ui.host, ui.r, { view: 'day', date, anim: 'zi' }); else ui.redraw();
+}
+
+/** Read the shared notes list now (a meeting's "Open the note" needs it on the first draw). */
+export const primeNotes = () => refreshNotes();

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

@@ -15,7 +15,7 @@
  *   TypeSafe key      GET /api/typesafe (present or not; the key is never read)
  *   about you         GET and POST /api/proactive/settings {name, about:{role, work, duties}} (the Welcome page writes the same)
  *   running sessions  GET /api/sessions                         calendar import  POST /api/sources/refresh {source:'calendar'}
- *   versions          GET /api/kit/status · POST /api/kit/check, /api/kit/update
+ *   versions          GET /api/kit/status · POST /api/kit/check, /api/kit/update, /api/kit/upgrade-app (then GET /api/sessions until the new version)
  * Every other setting is in the settings store: GET /api/settings and POST /api/settings (lib/settings-store.js).
  * A board's own workflow is edited on the board; here are only the templates new boards start from.
  * Nothing here asks for or shows a key or a password. */
@@ -161,7 +161,7 @@ export function mountSettings(host, ctx = {}) {
   ensureCss();
   const M = {
     sec: SECTIONS.some((s) => s[0] === ctx.section) ? ctx.section : 'about', q: '', ws: ctx.ws || '', data: null, err: {},
-    engine: null, people: null, consent: null, online: null, profiles: null, typesafe: null, kits: {}, about: null, running: null,
+    engine: null, people: null, consent: null, online: null, profiles: null, typesafe: null, kits: {}, kitBusy: null, app: { phase: null, error: '' }, about: null, running: null,
     tplEdit: null, wsEdit: null, wsDrop: null, addPath: '',
   };
   const root = el('div', { class: 'brief c3set', 'data-c3set': '' });
@@ -607,6 +607,28 @@ export function mountSettings(host, ctx = {}) {
       lockedRow('look.icons', 'Card icons', 'Chosen from the built-in icon set by the card kind (D7).', 'Chosen by code rules', 'computer')], 'eye')];
   }
 
+  /* ── the app update (workspace-kit-update): the server stops, reinstalls and starts again, so the page waits for it ── */
+  const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+  async function updateApp(ws, from, to) {
+    M.app = { phase: 'busy', error: '', to }; draw();
+    const r = await pmPost('/api/kit/upgrade-app', { ws, version: to });
+    if (!r || r.ok === false) { M.app = { phase: null, error: (r && r.error) || 'The update did not start.' }; draw(); return; }
+    await waitForRestart(r.from || from, r.log || '');
+  }
+  /** Reload when the server is back on a new version; otherwise say what happened and name the log. */
+  async function waitForRestart(from, log) {
+    let sawDown = false;
+    const until = Date.now() + 5 * 60000;
+    while (Date.now() < until) {
+      await pause(2000);
+      const j = await pmGet('/api/sessions');
+      if (!j || j.ok === false || !j.version) { sawDown = true; continue; }
+      if (j.version !== from) { location.reload(); return; }
+      if (sawDown) { M.app = { phase: null, error: 'PMOS started again on ' + j.version + ', so the update did not finish. The update log is ' + log + '.' }; draw(); return; }
+    }
+    M.app = { phase: null, error: 'PMOS did not come back on this address. Type pmos in a terminal to open it. The update log is ' + log + '.' }; draw();
+  }
+
   function updatesSec() {
     const rows = (ctx.workspaces || []).map((w) => {
       const k = M.kits[w.id];
@@ -616,20 +638,31 @@ export function mountSettings(host, ctx = {}) {
           el('div', { class: 'chips' }, chip(!k ? 'Reading' : k.error ? k.error : kit && kit.present ? 'kit ' + (kit.version || 'vendored by hand') : 'no kit in this workspace', 'mono'),
             k && k.latest ? (behind ? tag(k.latest + ' available', 'warn') : tag('Up to date', 'ok')) : null),
           M.err['kit:' + w.id] ? fold('alert', M.err['kit:' + w.id], 'w') : null),
-        el('div', { class: 'acts' }, behind ? btn('Update', { variant: 'primary', onclick: async () => { const r = await pmPost('/api/kit/update', { ws: w.id }); if (r && r.ok) { M.kits[w.id] = { ...M.kits[w.id], ...r, kitBehind: false }; toast('Updated the kit in ' + (w.label || w.name || w.id)); } else M.err['kit:' + w.id] = (r && r.error) || 'Not updated.'; draw(); } }) : null));
+        el('div', { class: 'acts' }, behind ? btn('Update', { variant: 'primary', disabled: !!M.kitBusy, attrs: { 'data-c3set-kit-update': w.id }, onclick: async () => { M.kitBusy = w.id; delete M.err['kit:' + w.id]; draw(); const r = await pmPost('/api/kit/update', { ws: w.id, version: k.latest }); M.kitBusy = null; if (r && r.ok) { M.kits[w.id] = { ...M.kits[w.id], ...r, kitBehind: false }; toast('Updated the kit in ' + (w.label || w.name || w.id)); } else M.err['kit:' + w.id] = (r && r.error) || 'Not updated.'; draw(); } }) : null));
     });
     const first = (ctx.workspaces || [])[0];
     const st = first && M.kits[first.id];
     const app = st && st.app; const appBehind = st && st.appBehind;
-    const appRow = frame({ key: 'upd.app', label: 'PMOS app ' + ((app && app.version) || ''),
-      help: appBehind ? 'The app update restarts PMOS. Run it from the main app\'s Settings, Updates, which waits for the restart.' : 'Press Check now to ask the npm registry for the latest version.',
-      control: [st && st.latest ? tag(appBehind ? st.latest + ' available' : 'Up to date', appBehind ? 'acc' : 'ok') : null,
-        btn('Check now', { ic: 'undo', disabled: !first, attrs: { 'data-c3set-check': '' }, onclick: async () => {
+    // A checkout updates with git, unless PMOS_UPDATE_SOURCE names a local package (server.js /api/kit/upgrade-app).
+    const gitOnly = !!(app && app.fromCheckout && !(st.source && st.source.kind === 'local'));
+    const U = M.app; const busy = U.phase === 'busy';
+    const appHelp = !appBehind ? 'Press Check now to ask the npm registry for the latest version.'
+      : gitOnly ? 'This workspace runs from a PMOS checkout. Update it with git pull.'
+      : 'The update stops PMOS, installs ' + st.latest + ' in place of ' + ((app && app.version) || '?') + ', and starts it again. Sessions keep running in tmux. This page reloads when the new version starts.';
+    const asking = appBehind && !gitOnly && U.phase === 'confirm';
+    const appRow = frame({ key: 'upd.app', label: 'PMOS app ' + ((app && app.version) || ''), help: appHelp, err: U.error || null,
+      note: asking ? el('span', { 'data-c3set-app-confirm': '' }, fold('alert', 'PMOS stops for about a minute while ' + st.latest + ' installs. Open terminals keep running.', 'w'))
+        : busy ? el('span', { 'data-c3set-app-busy': '', role: 'status', 'aria-live': 'polite' }, fold('cloud', 'Updating PMOS to ' + U.to + '. This page reloads when the new version starts.')) : null,
+      control: asking ? [btn('Cancel', { variant: 'ghost', attrs: { 'data-c3set-app-cancel': '' }, onclick: () => { M.app = { phase: null, error: '' }; draw(); } }),
+        btn('Restart and update', { variant: 'primary', attrs: { 'data-c3set-app-go': '' }, onclick: () => updateApp(first.id, (app && app.version) || '', st.latest) })]
+      : [st && st.latest ? tag(appBehind ? st.latest + ' available' : 'Up to date', appBehind ? 'acc' : 'ok') : null,
+        btn('Check now', { ic: 'undo', disabled: !first || busy, attrs: { 'data-c3set-check': '' }, onclick: async () => {
+          M.app = { phase: null, error: '' };
           for (const w of ctx.workspaces || []) { const r = await pmPost('/api/kit/check', { ws: w.id }); M.kits[w.id] = r && r.ok ? r : { ...(M.kits[w.id] || {}), error: (r && r.error) || 'The check failed.' }; }
           const s2 = first && M.kits[first.id]; toast(s2 && s2.appBehind ? 'PMOS ' + s2.latest + ' is available' : 'Checked. PMOS is up to date'); draw();
         } }),
-        appBehind ? btn('Open the main app', { variant: 'primary', onclick: () => { location.href = '/'; } }) : null] });
-    return [sect('PMOS app', [list([appRow])], { ic: 'cloud' }), sect('Kit in each workspace', [list(rows)], { ic: 'repo', count: rows.length }), groupOf('updates', 'When', 'cloud')];
+        appBehind && !gitOnly && !busy ? btn('Update to ' + st.latest, { variant: 'primary', attrs: { 'data-c3set-app-update': '' }, onclick: () => { M.app = { phase: 'confirm', error: '' }; draw(); } }) : null] });
+    return [sect('PMOS app', [list([appRow])], { ic: 'cloud', attrs: { 'data-c3set-app': '' } }), sect('Kit in each workspace', [list(rows)], { ic: 'repo', count: rows.length }), groupOf('updates', 'When', 'cloud')];
   }
 
   const BUILD = { about: aboutSec, workspaces: workspacesSec, boards: boardsSec, connectors: connectorsSec, recording: recordingSec, time: timeSec, sharing: sharingSec, access: accessSec, sessions: sessionsSec, privacy: privacySec, appearance: appearanceSec, updates: updatesSec };

package/workspace/public/pm/calendar-views.js

@@ -20,6 +20,7 @@ import { mountQuarter, mountYear, dispose as disposeStrategy } from './c3-cal-st
 import { simDock, simStart, simState, isDemo } from './shell-recording.js';
 import * as dock from './note-dock.js';
 import { drawCalendarPage } from './c3-calendar.js';   // the Calendar tab as a page about time (ctx.page)
+import { openNote as showNote } from './c3-notes.js';   // the Record chip opens Calendar › Notes (c3-open-note)
 
 /* ── shared state of the /c3.html page (console3 wave C3) ──────────────────────────────────────────────────────────
  * `live` holds every mounted instance, so a press in the Briefing's ribbon can select a meeting on the Calendar tab's instance.
@@ -975,12 +976,13 @@ function wire(host, r) {
   const up = (e) => {
     delete pts[e.pointerId]; if (Object.keys(pts).length) return; pinch = null;
     if (!s) return; const dx = e.clientX - s.x; const dy = e.clientY - s.y; s = null;
+    if (r.page && r.page.mode === 'notes') return;
     if (Math.abs(dx) > 80 && Math.abs(dy) < 45) { hush(); go(host, r, { date: shift(r.view, r.date, dx < 0 ? 1 : -1), anim: dx < 0 ? 'sn' : 'sp' }); }
   };
   root.addEventListener('pointerup', up); root.addEventListener('pointercancel', (e) => { delete pts[e.pointerId]; s = null; pinch = null; });
   root.addEventListener('click', (e) => { if (sup) { sup = false; e.stopPropagation(); e.preventDefault(); } }, true);
   root.addEventListener('wheel', (e) => {
-    if (!(e.ctrlKey || e.metaKey)) return; e.preventDefault(); const n = Date.now(); if (n - wt < 350) return; wt = n; zoomBy(e.deltaY > 0 ? 1 : -1);
+    if (!(e.ctrlKey || e.metaKey) || (r.page && r.page.mode === 'notes')) return; e.preventDefault(); const n = Date.now(); if (n - wt < 350) return; wt = n; zoomBy(e.deltaY > 0 ? 1 : -1);
   }, { passive: false });
   const onKey = (e) => {
     if (e.metaKey || e.ctrlKey || e.altKey || e.defaultPrevented) return;
@@ -988,6 +990,7 @@ function wire(host, r) {
     const t = e.target; if (t && t.closest && t.closest('input,select,textarea,[contenteditable="true"]')) return;
     if (document.querySelector('[data-shell="sheet"]')) return;                  // a sheet is open
     if (!root.closest('[data-shell="calpop"]') && document.querySelector('[data-shell="calpop"]')) return;   // the calendar popup is open: it takes the keys, not the tab behind it
+    if (r.page && r.page.mode === 'notes') return;                               // Calendar › Notes has no zoom or period to step
     if ((e.key === '+' || e.key === '=') && zoomBy(-1)) e.preventDefault();
     else if ((e.key === '-' || e.key === '_') && zoomBy(1)) e.preventDefault();
     else if (rib) return;
@@ -998,6 +1001,16 @@ function wire(host, r) {
   r.off = () => { document.removeEventListener('keydown', onKey); clearTimeout(supT); };
 }
 
+/* the Record chip (shell-recording.js) asks for the note being recorded: Calendar › Notes on the During stage of the Calendar tab's
+ * instance; if that tab has not mounted yet, its instance opens the note when it does */
+let PENDING_NOTE = null;
+if (typeof window !== 'undefined') window.addEventListener('c3-open-note', (ev) => {
+  const id = (ev.detail && ev.detail.id) || null;
+  const cal = [...live].find((x) => isCalTab(x) && x.ctx.page);
+  if (cal) { showNote(cal, id, 'during'); draw(cal.host, cal); } else PENDING_NOTE = { id };
+  gotoTab('cal');
+});
+
 /* the simulated recorder (shell-recording.js, demo only): a start, a stop or a pause redraws the stage under the day's cards, and the group's title opens the During stage */
 let simOnWin = false;
 function installSim() {
@@ -1014,6 +1027,7 @@ export function mountCalendarViews(host, ctx) {
   if (!r) {
     r = { ctx: ctx || {}, root: el('section', { class: 'c3 calwrap', 'data-board': 'calendar-views', 'aria-label': 'Calendar' }), view: (ctx && ctx.view) || 'week', zoom: (ctx && ctx.view === 'day') ? 'today' : (ctx && ctx.view) || 'week', date: todayStr(), data: null, error: null, host, done: {}, ready: {}, sel: null, phase: null };
     if (PENDING && ctx && ctx.plan) { r.sel = PENDING.sel; if (PENDING.date) r.date = PENDING.date; PENDING = null; }
+    if (PENDING_NOTE && isCalTab(r)) { showNote(r, PENDING_NOTE.id, 'during'); PENDING_NOTE = null; }
     live.add(r);
     r.stopPhone = c3Phone(r.root);
     roots.set(host, r);

package/workspace/public/pm/console3.css

@@ -507,6 +507,46 @@
 .c3 .cal3-sw-mine{background:transparent;border:1px dashed var(--foreground)}
 .c3 .cal3-wrap{display:grid;grid-template-columns:minmax(0,1fr);gap:var(--sp-3);align-items:start}
 @container (min-width:1100px){.c3 .cal3-wrap{grid-template-columns:minmax(0,1fr) 340px}}
+/* Calendar › Notes (c3-notes.js): the list beside the open note; one column on a narrow page */
+.c3 .cal3-nwrap{display:grid;grid-template-columns:minmax(260px,340px) minmax(0,1fr);gap:var(--sp-3);align-items:start}
+.c3 .cal3-nwrap [data-cal3-notes="note"] .card{display:grid;gap:var(--sp-2)}
+.c3 .cal3-nwrap details>summary{cursor:pointer;padding:var(--sp-1) 0}
+.c3 .cal3-ncol{display:grid;gap:var(--sp-3);align-content:start;min-width:0}
+.c3 .cal3-nhead{display:flex;justify-content:space-between;align-items:center;gap:10px;flex-wrap:wrap}
+.c3 .cal3-nsearchw{padding:0 0 var(--sp-2)}
+.c3 .cal3-nsearch{width:100%}
+.c3 .cal3-nrow{cursor:pointer}
+.c3 .cal3-nrow.on{background:var(--muted)}
+.c3 .cal3-sm{font-size:var(--fs-2)}
+.c3 .cal3-xs{font-size:var(--fs-1)}
+.c3 .cal3-prep{align-items:flex-start;padding:6px 0;border-bottom:1px solid var(--border)}
+.c3 .cal3-prep .ki{flex:none}
+.c3 .cal3-prepb{flex:1;min-width:0;font-size:var(--fs-3)}
+.c3 .cal3-agi{display:inline-flex;align-items:center;gap:2px}
+.c3 .cal3-agi[data-cal3-heard="true"] svg{color:var(--acc)}
+.c3 .cal3-wrapl{display:inline-flex;flex-wrap:wrap}
+.c3 .cal3-term{max-height:60vh;overflow:auto}
+.c3 .cal3-ov{margin:0}
+.c3 .cal3-tdr{text-align:right}
+.c3 .cal3-ncard{display:grid;gap:var(--sp-2)}
+/* a primitives.js button drawn as a console3 control: the primitive's own height, padding, nowrap and hover come off */
+.c3 .cal3-b{height:auto;min-height:0;line-height:inherit;font-weight:inherit;justify-content:flex-start;text-align:left}
+.c3 .cal3-b.chip2{padding:0;border:0;background:transparent;white-space:nowrap}
+.c3 .cal3-b.sgb{height:auto;padding:4px 8px}
+.c3 .cal3-b.ib{padding:0;justify-content:center}
+.c3 .cal3-b.cal3-recb{width:auto;height:34px;padding:0 14px;gap:6px;display:inline-flex;align-items:center}
+.c3 .cal3-b.cal3-nopen{display:grid;gap:2px;min-width:0;padding:0;border:0;background:transparent;white-space:normal;font:inherit;color:inherit}
+.c3 .seg .cal3-b{height:auto;padding:4px 10px;border:0;white-space:nowrap}
+@media (hover:hover){
+  .c3 .cal3-b.chip2:hover:not(:disabled),.c3 .cal3-b.cal3-nopen:hover:not(:disabled),.c3 .seg .cal3-b:hover:not(:disabled){background:transparent}
+  .c3 .cal3-b.chip2.lk:hover:not(:disabled){color:var(--acc)}
+  .c3 .cal3-b.sgb:hover:not(:disabled){background:var(--card)}
+  .c3 .cal3-b.sgb[aria-pressed="true"]:hover:not(:disabled){background:var(--accw)}
+  .c3 .cal3-b.ib:hover:not(:disabled){background:var(--background);color:var(--foreground)}
+  .c3 .cal3-b.ib.pri:hover:not(:disabled){background:var(--foreground);color:var(--background)}
+  .c3 .seg .cal3-b[aria-pressed="true"]:hover:not(:disabled){background:var(--background);color:var(--foreground)}
+}
+@media (max-width:760px){.c3 .cal3-nwrap{grid-template-columns:minmax(0,1fr)}}
 .c3 .cal3-main,.c3 .cal3-side{display:grid;gap:var(--sp-3);min-width:0;align-content:start}
 .c3 .cal3-scroll{overflow-x:auto;min-width:0}
 /* a marker: glyph and short title; the left edge carries the tone */

package/workspace/public/pm/shell-recording.js

@@ -143,8 +143,12 @@ const NS_SVG = 'http://www.w3.org/2000/svg';
 const glyph = (d) => { const s = document.createElementNS(NS_SVG, 'svg'); s.setAttribute('class', 'ic sm'); s.setAttribute('viewBox', '0 0 24 24'); s.setAttribute('aria-hidden', 'true'); const p = document.createElementNS(NS_SVG, 'path'); p.setAttribute('d', d); s.appendChild(p); return s; };
 const RGL = { highlighter: () => c3ic('flag', 'sm'), pause: () => glyph('M8 5v14M16 5v14'), play: () => c3ic('play', 'sm'), square: () => c3ic('stop', 'sm'), mic: () => c3ic('mic', 'sm'), down: () => glyph('M6 9l6 6 6-6') };
 
-/** The chip opens the note. console3 has no Notes place, so it opens the main app, where the full note is. */
-const openNote = () => { try { window.open('/', '_blank', 'noopener'); } catch { /* a blocked pop-up */ } };
+/** The chip opens the note: on console3, Calendar › Notes on the During stage (calendar-views.js listens for c3-open-note);
+ * elsewhere the main app, where the full note is. */
+const openNote = (id) => {
+  if (document.querySelector('[data-c3-tab="cal"]')) { window.dispatchEvent(new CustomEvent('c3-open-note', { detail: { id: id || dock.activeId() || null } })); return; }
+  try { window.open('/', '_blank', 'noopener'); } catch { /* a blocked pop-up */ }
+};
 
 /* The engine and language the live transcript uses, on the chip (notes-recording-reliability): a meeting transcribed in the wrong
  * language because of a setting is visible while it records. Read once per recording from GET /api/notes/engine. */
@@ -206,7 +210,7 @@ function mountReal(host) {
         const v = recView(st, reducedMotion());
         rec.clock = el('span', { class: 'recclk', 'data-fr-rec-clock': '' }, chipText(st));
         const chip = button({ variant: 'ghost', onClick: () => openNote(st.id),
-          attrs: { class: 'c3rec__chip', title: (recording ? 'Recording: ' : 'Paused: ') + v.title + '. Open the note in the main app', 'aria-label': (recording ? 'Recording ' : 'Paused: ') + v.title + '. Open the note.', 'data-fr-rec': st.mode, 'data-shell-rec-open': '' },
+          attrs: { class: 'c3rec__chip', title: (recording ? 'Recording: ' : 'Paused: ') + v.title + '. Open the note', 'aria-label': (recording ? 'Recording ' : 'Paused: ') + v.title + '. Open the note.', 'data-fr-rec': st.mode, 'data-shell-rec-open': '' },
           label: [el('span', { class: 'recdot' + (v.dot === 'static' ? ' static' : ''), 'data-dot': v.dot }), rec.clock, el('span', { class: 'rt' }, v.title),
             ...(eng.text ? [el('span', { class: 'c3rec__eng', 'data-fr-rec-engine': '', title: 'The live transcript: engine and language (Notes settings)' }, eng.text)] : [])] });
         const group = [chip];

package/workspace/test-files.json

@@ -133,7 +133,8 @@
     "pm-card-layout-test.js",
     "pm-portfolio-inline-test.js",
     "pm-brief-page-test.js",
-    "c3-settings-test.js"
+    "c3-settings-test.js",
+    "c3-updates-test.js"
   ],
   "ui": [
     "ui-test.js"
@@ -263,7 +264,8 @@
     "pm-card-layout-test.js": 20,
     "pm-portfolio-inline-test.js": 15,
     "settings-store.test.js": 1,
-    "c3-settings-test.js": 25
+    "c3-settings-test.js": 25,
+    "c3-updates-test.js": 20
   },
   "_comment_seconds": "Measured wall time of each suite run alone (4-CPU sandbox, 2026-10-05). Only the ORDER uses it: the slowest suites start first, and --shard deals suites to the least-loaded shard so the shards finish together. A wrong or missing number never skips a suite; a missing one counts as 10."
 }

package/workspace/test-lists/c3-notes-place.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "Initiative c3-notes-place: Calendar › Notes on the console3 Calendar tab (the notes list, the note's Before, During and After, the Record chip and a meeting's detail opening the note).",
+  "panels": ["pm-c3-notes-test.js"],
+  "seconds": { "pm-c3-notes-test.js": 45 }
+}