create-pmos 0.109.0 → 0.111.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.109.0",
+  "version": "0.111.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@3e0aefb
+kernel-source: pmos@2e6cfaa
 assembled: 2026-10-08
 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-08T03:57:21Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T04:27:20Z"}
 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-08T03:57:21Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T04:27:20Z"}
 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-08T03:57:21Z"}
+generated: {by: process:create-pmos, at: "2026-10-08T04:27:20Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -26,6 +26,9 @@ The Notes view shows one meeting, top to bottom. A bar at the top shows whether
 2. Press **Start**. The header shows a red dot, the time, and the sources. Tell people that you are taking notes.
 3. Each line shows in the transcript a few seconds after it is said, with who said it, the time and its label. Your lines are **You**. The meeting's lines are **Meeting**: click the name to change it. The transcript cannot tell the people in the meeting apart.
 4. Press **Stop** to end. The summary shows at the top of your notes. To carry on, press **Listen again**: the clock carries on from where it stopped, and the time between does not count. Line times and the kept audio use the same clock.
+5. If the workspace does not take a part of the audio, the page sends it again two times. If it still fails, a red message tells you how many seconds were not saved. Listening goes on. That part of the recording has a gap.
+
+To avoid an echo, listen to the meeting through headphones. When the meeting plays from a speaker, your microphone hears it a second time, and the replay has two copies of each voice.
 
 The meeting can only be heard when local transcription is set up. Until then, **Listen** hears your microphone only, through the browser's own recognition on this device.
 
@@ -123,6 +126,8 @@ When a meeting was heard with local transcription, its audio is kept on this mac
 2. While it plays, the transcript line, its item and the line of your notes that you wrote at that moment are highlighted. Your notes cannot be edited while it plays: pause to edit them.
 3. Press a time in the transcript to play from there.
 
+The replay is your microphone and the meeting added together. When both are loud at the same moment, the workspace lowers the peaks softly, so the sound does not distort. A quiet voice is not changed. The transcript is made from each source on its own, so this does not change what is written.
+
 To stop keeping audio, clear **Keep the audio for replay** in the settings. To delete one note's audio, press **Delete this note's audio** in the settings; the notes and the transcript stay. The browser's own recognition keeps no audio, so a meeting heard that way cannot be replayed.
 
 ## Capture highlights during the meeting
@@ -163,7 +168,7 @@ The task appears in your My Work view and on the initiative's board when the not
 Under the title, a note shows two lines: **Meeting** and **Initiative**.
 
 - **Meeting** is the calendar event the note was taken in, or **Not on the calendar** for a hallway chat or a call. Press **Change** to select an event of the note's day or the day before, or **Not on the calendar**.
-- **Initiative** is the initiative the meeting was about. It says how it was set: **from the calendar event**, **suggested from what was said**, or **chosen by you**. Press **Change** to select a suggestion, any open initiative of the selected repository, or **None**. Press the initiative's name to open it.
+- **Initiative** is the initiative the meeting was about. It says how it was set: **from the calendar event**, **suggested from what was said**, or **chosen by you**. Press **Change** to open the list. The list shows the suggestion first, then the initiatives that are active now, then **None**. Initiatives planned for Next and Later are in the menu under them, each marked with its horizon. When more than one repository is open, a **Repository** menu at the top of the list changes which repository's initiatives you see. If the repository is still being read, the list says so and fills in by itself. Press the initiative's name to open it.
 
 When a note has no initiative, the summary suggests one: the open initiative that shares 3 or more words with what was said, when no other initiative shares as many. A suggestion never replaces an initiative you chose.
 

package/workspace/lib/notes-audio.js

@@ -50,8 +50,21 @@ function setKeep(runtimeDir, keep) {
   return { ok: true, keep };
 }
 
-/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, and clipped. With `mixed:
- * false` only the source's own file is written: the PM keeps no audio for replay, and the final pass deletes it when done. */
+// The mixed file passes every sample through this soft knee (notes-audio-quality R1, R2). Below KNEE the sample is unchanged, so one
+// source alone is not made quieter. Above it the sample bends towards CEILING and never reaches full scale, so two loud sources
+// are limited and not hard-clipped. It has no memory, so the order in which the two sources arrive does not matter.
+const KNEE = 0.7 * 32768;
+const CEILING = 0.98 * 32768;
+function softLimit(x) {
+  const a = Math.abs(x);
+  if (a <= KNEE) return x;
+  const y = KNEE + (CEILING - KNEE) * Math.tanh((a - KNEE) / (CEILING - KNEE));
+  return Math.round(x < 0 ? -y : y);
+}
+
+/** Add one chunk at meeting time `t`. Samples already there (the other source) are added to, then limited by softLimit. With
+ * `mixed: false` only the source's own file is written: the PM keeps no audio for replay, and the final pass deletes it when done.
+ * The per-source files are never limited: they are what the transcription reads. */
 function write(runtimeDir, { id, source, pcm, t, mixed = true }) {
   if (!ID_RE.test(String(id || '')) || !pcm || !pcm.length || pcm.length % 2) return { ok: false, error: 'nothing to keep' };
   const f = fileOf(runtimeDir, id);
@@ -69,7 +82,7 @@ function write(runtimeDir, { id, source, pcm, t, mixed = true }) {
       const old = Buffer.alloc(len);
       fs.readSync(fd, old, 0, len, at);
       const out = Buffer.alloc(len);
-      for (let i = 0; i < len; i += 2) out.writeInt16LE(Math.max(-32768, Math.min(32767, old.readInt16LE(i) + pcm.readInt16LE(i))), i);
+      for (let i = 0; i < len; i += 2) out.writeInt16LE(softLimit(old.readInt16LE(i) + pcm.readInt16LE(i)), i);
       fs.writeSync(fd, out, 0, len, at);
     } finally { fs.closeSync(fd); }
   }
@@ -138,4 +151,4 @@ function serve(req, res, runtimeDir, id) {
   fs.createReadStream(fileOf(runtimeDir, id), { start: from, end: to }).on('error', () => res.end()).pipe(res);
 }
 
-module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, wavHeader, RATE, BYTES_PER_MS, MAX_BYTES };
+module.exports = { write, info, remove, removeSources, sources, serve, getKeep, setKeep, wavHeader, softLimit, RATE, BYTES_PER_MS, MAX_BYTES };

package/workspace/lib/routes-notes.js

@@ -269,6 +269,32 @@ function glossaryOf(root) {
   glossaryCache.set(root, { at: Date.now(), terms: out });
   return out;
 }
+/** The open initiatives of one repository, the active ones first. The Initiatives view reads the repository's documents
+ *  (lib/initiative-rows.js) and places each one Now, Next or Later; a repository kept as documents has no planning/initiatives
+ *  records, so those alone left the picker empty. Placed rows come first in horizon order; records the view does not place follow
+ *  as Now. `pending` is true while the first read of the documents is still running. */
+function openInitiativesOf(w) {
+  const legacy = notesLinks.initiativesOf(w.root);
+  let placed = []; let pending = false;
+  try {
+    const rowsLib = require('./initiative-rows.js');
+    const ri = require('./routes-initiatives.js');
+    const got = rowsLib.rowsFor(w.root);
+    if (got.pending) pending = true;
+    else if (got.ok) {
+      const rm = ri.roadmapOf(w, ri.frameOf(w, got.rows, { now: Date.now() }));
+      const byId = new Map(got.rows.map((r) => [r.id, r]));
+      for (const h of ['now', 'next', 'later']) {
+        for (const r of rm.horizons[h]) { const rec = byId.get(r.id); if (!(rec && rec.stopped)) placed.push({ id: r.id, title: r.title, anchor: r.anchor, intent: '', horizon: h }); }
+      }
+    }
+  } catch { placed = []; }
+  const seen = new Set(placed.map((i) => i.id));
+  const rest = legacy.filter((i) => !seen.has(i.id)).map((i) => ({ ...i, horizon: 'now' }));
+  const order = { now: 0, next: 1, later: 2 };
+  const open = [...placed, ...rest].sort((a, b) => order[a.horizon] - order[b.horizon]);
+  return { open, pending };
+}
 /** The repository's terms for a note: its initiative's title, the glossary, and the product terms in the open initiatives' titles. */
 function repoTermsFor(ctx, note) {
   const w = note && note.ws && typeof ctx.getWs === 'function' ? ctx.getWs(note.ws) : null;
@@ -500,12 +526,12 @@ async function handle(req, res, url, ctx) {
     const wsId = url.searchParams.get('ws');
     const w = wsId ? ctx.getWs(wsId) : null;
     if (!w || w.id !== wsId) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
-    const open = notesLinks.initiativesOf(w.root);
+    const { open, pending } = openInitiativesOf(w);
     const nid = url.searchParams.get('id');
     const r = nid ? notes.read(dir, nid) : null;
     if (r && !r.ok) { send(ctx, res, r); return true; }
     const s = r ? notesLinks.suggest(r.note, open) : { pick: null, ranked: [] };
-    ctx.json(res, { ok: true, open: open.map((i) => ({ id: i.id, title: i.title })), pick: s.pick });
+    ctx.json(res, { ok: true, open: open.map((i) => ({ id: i.id, title: i.title, horizon: i.horizon })), pick: s.pick, pending });
     return true;
   }
   if (p === '/api/notes/engine') {

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.109.0",
+  "version": "0.111.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",

package/workspace/public/pm/audio-capture.js

@@ -0,0 +1,88 @@
+/* audio-capture.js — how the Notes view takes sound from the browser (notes-audio-quality Run 1, R4 and R6).
+ *
+ *   makeResampler(inRate)      a stateful low-pass resampler: push(float32 block) → Int16Array at 16 kHz, flush() → the tail
+ *   toInt16(input, inRate)     one block, whole: the same filter, run once. Pure.
+ *   openCapture(ac, src, sink, onBlock) → { mode, node }   an AudioWorklet that hands float32 blocks to onBlock;
+ *                              a ScriptProcessor does the same where the browser has no worklet
+ *
+ * WHY A FILTER. A context that cannot run at 16 kHz gives 44.1 or 48 kHz blocks. Averaging the samples under each output sample
+ * is a poor low-pass: sound above 8 kHz folds back into the speech band as a hiss. The windowed-sinc filter below cuts at 7.2 kHz and
+ * keeps its state between blocks, so a block edge leaves no click. At 16 kHz the samples pass through unchanged.
+ */
+export const RATE = 16000;
+const CUT = 0.45;             // the filter cuts at this share of the output rate
+const CROSSINGS = 16;         // zero crossings of the sinc on each side of the centre
+
+const toS16 = (v) => { const c = v > 1 ? 1 : v < -1 ? -1 : v; return c < 0 ? c * 0x8000 : c * 0x7fff; };
+
+export function makeResampler(inRate, outRate = RATE) {
+  const ratio = inRate / outRate;
+  if (ratio === 1) {
+    return { push(x) { const o = new Int16Array(x.length); for (let i = 0; i < x.length; i++) o[i] = toS16(x[i]); return o; }, flush() { return new Int16Array(0); } };
+  }
+  const fc = CUT / Math.max(1, ratio);          // cycles per input sample
+  const half = Math.ceil(CROSSINGS / (2 * fc)); // input samples either side of the centre
+  let buf = new Float64Array(0);                // input not yet used up; buf[0] is input sample `base`
+  let base = 0;
+  let centre = 0;                               // the next output sample sits at this input position
+  let seen = 0;                                 // input samples received
+  const weight = (d) => {
+    const x = 2 * fc * d;
+    const sinc = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+    const w = 0.42 + 0.5 * Math.cos(Math.PI * d / half) + 0.08 * Math.cos(2 * Math.PI * d / half);   // Blackman, centred
+    return sinc * w;
+  };
+  const w = new Float64Array(2 * half + 2);
+  function run(limit, out) {
+    while (centre < limit && Math.floor(centre) + half < base + buf.length) {
+      const lo = Math.ceil(centre - half); const hi = Math.floor(centre + half);
+      let sum = 0; let norm = 0;
+      for (let i = lo; i <= hi; i++) { const k = weight(i - centre); w[i - lo] = k; norm += k; }
+      for (let i = lo; i <= hi; i++) { const j = i - base; if (j >= 0 && j < buf.length) sum += buf[j] * w[i - lo]; }
+      out.push(toS16(sum / norm));
+      centre += ratio;
+    }
+  }
+  function trim() {
+    const keep = Math.max(base, Math.floor(centre) - half);
+    if (keep > base) { buf = buf.slice(keep - base); base = keep; }
+  }
+  return {
+    push(x) {
+      const merged = new Float64Array(buf.length + x.length); merged.set(buf); merged.set(x, buf.length); buf = merged; seen += x.length;
+      const out = []; run(Infinity, out); trim();
+      return Int16Array.from(out);
+    },
+    flush() {
+      const pad = new Float64Array(buf.length + half + 1); pad.set(buf); buf = pad;
+      const out = []; run(seen, out); trim();
+      return Int16Array.from(out);
+    },
+  };
+}
+
+/** Float samples at `inRate` as 16 kHz 16-bit samples. Pure. */
+export function toInt16(input, inRate) {
+  const r = makeResampler(inRate);
+  const a = r.push(input); const b = r.flush();
+  const out = new Int16Array(a.length + b.length); out.set(a); out.set(b, a.length);
+  return out;
+}
+
+/** Take blocks of the first channel from `src` and give each to onBlock as a Float32Array. `sink` is a muted node that keeps the
+ * graph pulling. Returns { mode: 'worklet' | 'script', node }. */
+export async function openCapture(ac, src, sink, onBlock) {
+  if (ac.audioWorklet && typeof AudioWorkletNode === 'function') {
+    try {
+      await ac.audioWorklet.addModule(new URL('./notes-capture-worklet.js', import.meta.url).href);
+      const node = new AudioWorkletNode(ac, 'notes-capture', { numberOfInputs: 1, numberOfOutputs: 1, channelCount: 1, channelCountMode: 'explicit' });
+      node.port.onmessage = (e) => onBlock(e.data);
+      src.connect(node); node.connect(sink);
+      return { mode: 'worklet', node };
+    } catch { /* the module did not load: the older route below */ }
+  }
+  const node = ac.createScriptProcessor(4096, 1, 1);
+  node.onaudioprocess = (e) => onBlock(new Float32Array(e.inputBuffer.getChannelData(0)));
+  src.connect(node); node.connect(sink);
+  return { mode: 'script', node };
+}

package/workspace/public/pm/notes-capture-worklet.js

@@ -0,0 +1,15 @@
+/* notes-capture-worklet.js — runs on the audio thread (notes-audio-quality R4). It copies the first channel of what it hears into
+ * blocks of 2048 samples and posts each block to the page, which resamples and sends it. It makes no sound. */
+class NotesCapture extends AudioWorkletProcessor {
+  constructor() { super(); this.block = new Float32Array(2048); this.at = 0; }
+  process(inputs) {
+    const ch = inputs[0] && inputs[0][0];
+    if (!ch) return true;
+    for (let i = 0; i < ch.length; i++) {
+      this.block[this.at++] = ch[i];
+      if (this.at === this.block.length) { this.port.postMessage(this.block, [this.block.buffer]); this.block = new Float32Array(2048); this.at = 0; }
+    }
+    return true;
+  }
+}
+registerProcessor('notes-capture', NotesCapture);

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

@@ -45,12 +45,15 @@ import { pmGet, pmPost } from './http.js';
 import { mdRender } from './markdown.js';
 import { icon } from './icons.js';
 import { button, iconButton, field, row, sheet, empty, menu, toast, ensureComponentsCss } from './primitives.js';
+import { toInt16, makeResampler, openCapture } from './audio-capture.js';
 
 const SAVE_MS = 700;          // a pause this long in typing saves the note
 const POLL_MS = 1500;         // while listening, and until the last line is labelled, the note is read this often
 const AGENT_POLL_MS = 3000;
 const CHUNK_SAMPLES = 16000;  // one second at 16 kHz
 const RATE = 16000;
+const SEND_TRIES = 3;         // a chunk that the server did not take is sent again this many times in all …
+const SEND_BACKOFF_MS = 400;  // … after 400 ms, then 1200 ms
 const SECTIONS = [['decision', 'Decisions'], ['action', 'Next steps'], ['question', 'Open questions']];
 
 /* ── module state: survives the redraw every setState causes ─────────────────────────────── */
@@ -194,19 +197,8 @@ export function noteMarkdown(n) {
   if ((n.transcript || []).length) out.push('## Transcript', '', ...n.transcript.map((x) => '[' + fmtTime(x.t) + '] ' + speakerOf(n, x.source) + ': ' + x.text + tagWords(x)), '');
   return out.join('\n');
 }
-/** Float samples at `inRate` as 16 kHz 16-bit samples. Each output sample averages the input samples it covers. Pure. */
-export function toInt16(input, inRate) {
-  const ratio = inRate / RATE;
-  const n = Math.floor(input.length / ratio);
-  const out = new Int16Array(n);
-  for (let i = 0; i < n; i++) {
-    const a = Math.floor(i * ratio); const b = Math.max(a + 1, Math.floor((i + 1) * ratio));
-    let s = 0; for (let k = a; k < b && k < input.length; k++) s += input[k];
-    const v = Math.max(-1, Math.min(1, s / (b - a)));
-    out[i] = v < 0 ? v * 0x8000 : v * 0x7fff;
-  }
-  return out;
-}
+/** Float samples at `inRate` as 16 kHz 16-bit samples, through a low-pass filter (pm/audio-capture.js). Pure. */
+export { toInt16 };
 function b64(int16) {
   const u = new Uint8Array(int16.buffer, int16.byteOffset, int16.byteLength);
   let s = '';
@@ -581,7 +573,7 @@ async function openSource(kind) {
   return new MediaStream(tracks);
 }
 async function startAudio(ctx, n, want) {
-  const a = { id: n.id, state: 'starting', sources: [], streams: [], ctx: null, started: Date.now(), clock: null, msg: null, queue: {}, buf: {}, ended: 0 };
+  const a = { id: n.id, state: 'starting', sources: [], streams: [], ctx: null, started: Date.now(), clock: null, msg: null, queue: {}, buf: {}, rs: {}, lost: 0, ended: 0 };
   const opened = [];
   // the meeting first, straight from the press: the browser lets a page share a screen only right after a click
   for (const kind of want.slice().sort((x, y) => (x === 'meeting' ? -1 : y === 'meeting' ? 1 : 0))) {
@@ -603,14 +595,13 @@ async function startAudio(ctx, n, want) {
   for (const [kind, stream] of opened) {
     a.streams.push(stream); a.sources.push(kind); a.buf[kind] = []; a.queue[kind] = Promise.resolve();
     const src = ac.createMediaStreamSource(stream);
-    const proc = ac.createScriptProcessor(4096, 1, 1);
-    proc.onaudioprocess = (e) => {
+    const rs = a.rs[kind] = makeResampler(ac.sampleRate);
+    await openCapture(ac, src, sink, (block) => {
       if (audio !== a) return;
-      const s = toInt16(e.inputBuffer.getChannelData(0), ac.sampleRate);
+      const s = rs.push(block);
       const b = a.buf[kind]; for (let i = 0; i < s.length; i++) b.push(s[i]);
       if (b.length >= CHUNK_SAMPLES) sendChunk(ctx, a, kind, false);
-    };
-    src.connect(proc); proc.connect(sink);
+    });
     for (const t of stream.getTracks()) t.addEventListener('ended', () => { if (audio !== a) return; a.ended++; if (a.ended >= a.streams.length) stopAudio(ctx); });
   }
   a.state = 'on';
@@ -621,9 +612,23 @@ async function startAudio(ctx, n, want) {
 function sendChunk(ctx, a, kind, final) {
   const b = a.buf[kind] || []; a.buf[kind] = [];
   const pcm = b64(Int16Array.from(b));
+  const seconds = b.length / RATE;
   a.queue[kind] = a.queue[kind].then(async () => {
-    const r = await pmPost('/api/notes/audio', { id: a.id, source: kind, pcm, final });
-    if (r && !r.ok && (r.status === 409 || r.status === 404) && audio === a) { banner = { tone: 'bad', text: 'Listening stopped: ' + r.error + '.' }; stopAudio(ctx); }
+    let r = null;
+    for (let tries = 0; tries < SEND_TRIES; tries++) {
+      r = await pmPost('/api/notes/audio', { id: a.id, source: kind, pcm, final });
+      if (r && r.ok) return;
+      if (r && (r.status === 409 || r.status === 404)) break;   // the server refused this note's audio: sending again changes nothing
+      if (tries + 1 < SEND_TRIES) await new Promise((res) => setTimeout(res, SEND_BACKOFF_MS * 3 ** tries));
+    }
+    if (r && (r.status === 409 || r.status === 404)) {
+      if (audio === a) { banner = { tone: 'bad', text: 'Listening stopped: ' + r.error + '.' }; stopAudio(ctx); }
+      return;
+    }
+    a.lost += seconds;   // not silent: the recording has a gap, and the PM is told how long
+    banner = { tone: 'bad', text: 'About ' + Math.max(1, Math.round(a.lost)) + ' s of the recording was not saved, because the workspace server did not take it'
+      + (r && r.error ? ' (' + r.error + ')' : '') + '.' + (audio === a ? ' Listening goes on.' : '') };
+    ctx.setState({});
   }).catch(() => {});
   return a.queue[kind];
 }
@@ -636,6 +641,7 @@ async function stopAudio(ctx, { discard = false } = {}) {
   try { if (a.ctx) await a.ctx.close(); } catch { /* closed */ }
   if (discard) { ctx.setState({}); return; }
   // the rest of what was said, then the summary once the last line is transcribed
+  for (const k of a.sources) { const tail = a.rs[k] ? a.rs[k].flush() : []; const b = a.buf[k]; for (let i = 0; i < tail.length; i++) b.push(tail[i]); }
   await Promise.all(a.sources.map((k) => sendChunk(ctx, a, k, true)));
   await pmPost('/api/notes/pause', { id: a.id });
   ctx.setState({});
@@ -1067,32 +1073,69 @@ async function meetingSheet(ctx, n) {
   }), evs.length ? null : el('p', { class: 'nt-hint' }, 'No calendar events on these days.'),
   opt('adhoc', 'Not on the calendar', 'a hallway chat, a call', pick === 'adhoc'));
 }
+const HORIZON_WORDS = { now: 'Now', next: 'Next', later: 'Later' };
+/** The repositories the notes can be about, one row per repository (its main tree), from the workspace server. */
+async function reposForNotes() {
+  const r = await pmGet('/api/workspaces');
+  const seen = new Map();
+  for (const w of (r && r.workspaces) || []) {
+    if (!w || !w.id) continue;
+    const key = w.repo_key || w.root;
+    if (!seen.has(key) || w.root === key) seen.set(key, { ws: w.id, name: w.label || w.repo_name || w.name || w.id });
+  }
+  return [...seen.values()];
+}
 async function initiativeSheet(ctx, n) {
-  const ws = n.ws || wsOf(ctx);
+  let ws = n.ws || wsOf(ctx);
+  let repo = (n.initiative && n.initiative.repo) || (ctx.state && ctx.state.product) || ctx.repo || null;
   const box = el('div', { class: 'nt-picks' }, el('p', { class: 'nt-hint' }, 'reading the initiatives …'));
+  const where = el('div', { 'data-nt-ini-where': '' });
   let pick = n.initiative ? n.initiative.id : '';
   let open = [];
-  const h = sheet({ title: 'Which initiative is this note about?', sub: 'The note shows on the initiative\'s page.', body: [box], attrs: { 'data-nt-ini-sheet': '' },
+  let radios = [];
+  let sel = null;
+  let loadId = 0;
+  const h = sheet({ title: 'Which initiative is this note about?', sub: 'The note shows on the initiative\'s page.', body: [where, box], attrs: { 'data-nt-ini-sheet': '' },
     actions: [button({ label: 'Cancel', variant: 'ghost', onClick: () => h.close() }), button({ label: 'Save', variant: 'primary', attrs: { 'data-nt-ini-save': '' }, onClick: () => {
       h.close();
       if (pick === (n.initiative ? n.initiative.id : '') && (!n.initiative || n.initiative.by === 'pm')) return;
       if (!pick) return link(ctx, n, { initiative: null }, () => 'Not linked to an initiative.');
       const i = open.find((x) => x.id === pick) || { id: pick, title: pick };
-      return link(ctx, n, { initiative: { id: i.id, ws, repo: (ctx.state && ctx.state.product) || ctx.repo || null, title: i.title } }, () => 'Now on ' + i.title + '. The note shows on its page.');
+      return link(ctx, n, { initiative: { id: i.id, ws, repo, title: i.title } }, () => 'Now on ' + i.title + '. The note shows on its page.');
     } })] });
-  if (!ws) { box.replaceChildren(el('p', { class: 'nt-hint' }, 'Open a repository first: its initiatives are the ones a note can belong to.')); return; }
-  const r = await pmGet('/api/notes/initiatives?ws=' + encodeURIComponent(ws) + '&id=' + encodeURIComponent(n.id));
-  if (!h.open) return;
-  if (!r || !r.ok) { box.replaceChildren(el('p', { class: 'nt-hint', role: 'alert' }, (r && r.error) || 'The initiatives could not be read.')); return; }
-  open = r.open || [];
-  const radios = [];
-  const choose = (v) => { pick = v; for (const b of radios) b.setAttribute('aria-checked', b.dataset.ntIniPick === v ? 'true' : 'false'); if (sel.control.value !== v) sel.control.value = open.some((x) => x.id === v) ? v : ''; };
+  const choose = (v) => { pick = v; for (const b of radios) b.setAttribute('aria-checked', b.dataset.ntIniPick === v ? 'true' : 'false'); if (sel && sel.control.value !== v) sel.control.value = open.some((x) => x.id === v && x.horizon !== 'now') ? v : ''; };
   const opt = (v, title, sub) => { const b = button({ label: el('span', { class: 'nt-pick__txt' }, el('b', null, title), el('span', { class: 'nt-hint' }, sub)), variant: 'ghost', attrs: { class: 'nt-pick', role: 'radio', 'aria-checked': pick === v ? 'true' : 'false', 'data-nt-ini-pick': v }, onClick: () => choose(v) }); radios.push(b); return b; };
-  const sel = field({ label: 'Or choose any open initiative', kind: 'select', value: open.some((x) => x.id === pick) ? pick : '', options: [{ value: '', label: 'Choose …' }, ...open.map((x) => ({ value: x.id, label: x.title }))], attrs: { 'data-nt-ini-all': '' } });
-  sel.control.addEventListener('change', () => choose(sel.control.value));
-  const sugg = r.pick ? [el('h3', { class: 'nt-sec__h' }, 'Suggested from what was said'), opt(r.pick.id, r.pick.title, r.pick.shared + ' words in common')] : [];
-  const current = n.initiative && (!r.pick || r.pick.id !== n.initiative.id) ? [opt(n.initiative.id, n.initiative.title || n.initiative.id, BY_WORDS[n.initiative.by] || '')] : [];
-  box.replaceChildren(el('div', { role: 'radiogroup', 'aria-label': 'Initiative' }, ...sugg, ...current, opt('', 'None', 'not about an initiative')), open.length ? sel : el('p', { class: 'nt-hint' }, 'This repository has no open initiatives.'));
+  async function load(tries = 0) {
+    const mine = ++loadId;
+    open = []; radios = []; sel = null;
+    if (!ws) { box.replaceChildren(el('p', { class: 'nt-hint' }, 'Choose a repository: its initiatives are the ones a note can belong to.')); return; }
+    box.replaceChildren(el('p', { class: 'nt-hint' }, 'reading the initiatives …'));
+    const r = await pmGet('/api/notes/initiatives?ws=' + encodeURIComponent(ws) + '&id=' + encodeURIComponent(n.id));
+    if (!h.open || mine !== loadId) return;
+    if (!r || !r.ok) { box.replaceChildren(el('p', { class: 'nt-hint', role: 'alert' }, (r && r.error) || 'The initiatives could not be read.')); return; }
+    open = r.open || [];
+    if (r.pending && !open.length && tries < 8) { setTimeout(() => load(tries + 1), 1500); return; }
+    // the active initiatives (Now) are listed as choices; Next and Later are in the list below them
+    const active = open.filter((x) => x.horizon === 'now' && !(r.pick && r.pick.id === x.id));
+    const later = open.filter((x) => x.horizon !== 'now');
+    sel = field({ label: later.length ? 'Or choose a later initiative' : 'Or choose any open initiative', kind: 'select', value: later.some((x) => x.id === pick) ? pick : '',
+      options: [{ value: '', label: 'Choose …' }, ...later.map((x) => ({ value: x.id, label: (HORIZON_WORDS[x.horizon] || 'Now') + ' · ' + x.title }))], attrs: { 'data-nt-ini-all': '' } });
+    sel.control.addEventListener('change', () => choose(sel.control.value));
+    const sugg = r.pick ? [el('h3', { class: 'nt-sec__h' }, 'Suggested from what was said'), opt(r.pick.id, r.pick.title, r.pick.shared + ' words in common')] : [];
+    const current = n.initiative && (!r.pick || r.pick.id !== n.initiative.id) && !active.some((x) => x.id === n.initiative.id) ? [opt(n.initiative.id, n.initiative.title || n.initiative.id, BY_WORDS[n.initiative.by] || '')] : [];
+    const now = active.length ? [el('h3', { class: 'nt-sec__h' }, 'Active now'), ...active.map((x) => opt(x.id, x.title, 'active'))] : [];
+    box.replaceChildren(el('div', { role: 'radiogroup', 'aria-label': 'Initiative' }, ...sugg, ...current, ...now, opt('', 'None', 'not about an initiative')),
+      later.length ? sel : (open.length ? null : el('p', { class: 'nt-hint' }, 'This repository has no open initiatives. Choose another repository above, or open the Initiatives tab to add one.')));
+  }
+  const repos = await reposForNotes();
+  if (!h.open) return;
+  if (repos.length > 1) {
+    const rs = field({ label: 'Repository', kind: 'select', value: ws || '', options: [...(ws && !repos.some((x) => x.ws === ws) ? [{ value: ws, label: repo || ws }] : []), ...repos.map((x) => ({ value: x.ws, label: x.name }))], attrs: { 'data-nt-ini-repo': '' } });
+    rs.control.addEventListener('change', () => { ws = rs.control.value; const f = repos.find((x) => x.ws === ws); repo = f ? f.name : repo; pick = ''; load(); });
+    where.replaceChildren(rs);
+  }
+  if (!ws && repos.length) { ws = repos[0].ws; repo = repos[0].name; if (where.firstChild) where.firstChild.control && (where.firstChild.control.value = ws); }
+  await load();
 }
 async function openInitiativeOf(ctx, ini) {
   const reg = await import('./registry.js');