create-pmos 0.156.0 → 0.157.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.156.0",
+  "version": "0.157.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@04349e3
+kernel-source: pmos@078081c
 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-12T05:09:50Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T05:27:25Z"}
 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-12T05:09:50Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T05:27:25Z"}
 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-12T05:09:50Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T05:27:25Z"}
 status: stable
 ---
 

package/workspace/guide/notes.md

@@ -123,12 +123,18 @@ To set up Qwen3-ASR, Parakeet, speech detection and speakers, open the settings
 
 The kept audio holds your microphone and the meeting apart until the final pass is done. When **Keep the audio for replay** is off, both are deleted after the final pass.
 
+When PMOS restarts (for example after you install a new version) while a note waits for its final pass, its summary or Wispr Flow's notes, PMOS starts that work again when you next open PMOS:
+
+- A final pass that was queued or running is queued again. When it can no longer run, for example because the audio is gone, the note says why, and your agent session writes the notes from the live transcript.
+- A summary that was started and never written is started again.
+- A Wispr Flow fetch continues on its own schedule. When its 20 minutes have passed, it stops and says so. Press **Fetch Wispr Flow notes now** to try again.
+
 ## Wispr Flow notes
 
 When you also record the meeting with Wispr Flow, PMOS fetches Wispr Flow's notes and shows them under **Wispr Flow notes**, below yours.
 
 1. Five minutes after **Stop**, PMOS starts an agent session that looks for this meeting in Wispr Flow, by its time and title.
-2. When Wispr Flow has no notes yet, PMOS asks again every two minutes, for up to 20 minutes.
+2. When Wispr Flow has no notes yet, PMOS asks again every two minutes, for up to 20 minutes. Each try starts a new agent session, and the previous one is closed when it is idle.
 3. When it finds them, the summary shows in the note, with **Open in Wispr Flow**. Your agent session also writes your notes again with Wispr Flow's notes added, and the Overview says **merged with Wispr Flow's notes**. What both say is written once, what only one of them has is added, and where they differ the transcript decides. An item that only Wispr Flow has shows **Said (Wispr Flow):** and no meeting time. This runs once for a note. When Wispr Flow's notes were found before your agent session wrote the notes, they are merged at once.
 4. When the fetch failed or Wispr Flow had no notes, the **Wispr Flow notes** section says so and shows **Fetch Wispr Flow notes now**. Press it: your agent session looks again at once, and every two minutes for up to 20 minutes from the press. It works when the automatic fetch is switched off.
 

package/workspace/lib/routes-notes.js

@@ -549,15 +549,13 @@ function askWispr(ctx, id) {
   const h = notes.wisprHandoff(dir, { id, until: stopped });
   if (!h.ok) return;
   const tries = (w0.tries || 0) + 1;
-  let session = w0.session || null;
-  const again = 'Try again: the Wispr Flow notes may be ready now. Read ' + h.handoff + ' again and write ' + h.out + ' as before.';
-  const sent = session && typeof ctx.sendToSession === 'function' && ctx.sendToSession(session, again + '\r');
-  if (!sent) {
-    const ws = cur.note.ws ? ctx.getWs(cur.note.ws) : null;
-    const s = ctx.spawnSession({ name: 'notes: Wispr Flow', agent: 'claude', ws: ws && ws.id === cur.note.ws ? ws.id : undefined, origin: 'notes-wispr:' + id, initialInput: h.prompt + '\r' });
-    if (!s || s.state === 'exited') { notes.setWispr(dir, { id, patch: { state: 'failed', reason: (s && s.note) || 'could not start a claude session', tries } }); return; }
-    session = s.id;
-  }
+  // every try is a fresh session: a try typed into the last one went nowhere when that session sat on a prompt. The last
+  // one is ended first when it is idle (server.js endSupersededRuns; a session still working or waiting on the PM stays).
+  if (typeof ctx.endSupersededRuns === 'function') { try { ctx.endSupersededRuns('notes-wispr:' + id); } catch { /* best effort */ } }
+  const ws = cur.note.ws ? ctx.getWs(cur.note.ws) : null;
+  const s = ctx.spawnSession({ name: 'notes: Wispr Flow', agent: 'claude', ws: ws && ws.id === cur.note.ws ? ws.id : undefined, origin: 'notes-wispr:' + id, initialInput: h.prompt + '\r' });
+  if (!s || s.state === 'exited') { notes.setWispr(dir, { id, patch: { state: 'failed', reason: (s && s.note) || 'could not start a claude session', tries } }); return; }
+  const session = s.id;
   notes.setWispr(dir, { id, patch: { state: 'asking', tries, session, asked_at: new Date().toISOString() } });
   wisprLater(ctx, id, wisprRetry(ctx), () => checkWispr(ctx, id));
 }
@@ -586,7 +584,8 @@ function fetchWisprNow(ctx, id) {
   if (listening(cur.note)) return { ok: false, status: 409, error: 'stop listening first' };
   if (typeof ctx.spawnSession !== 'function') return { ok: false, status: 409, error: 'this workspace cannot start sessions' };
   const w = cur.note.wispr;
-  if (w && (w.state === 'waiting' || w.state === 'asking')) return { ok: true, wispr: w };
+  // a check with its timer in this process is under way; one without (PMOS restarted) is stuck, so it starts again
+  if (w && (w.state === 'waiting' || w.state === 'asking') && wisprTimers.has(id)) return { ok: true, wispr: w };
   const now = new Date().toISOString();
   notes.setWispr(dir, { id, patch: { state: 'waiting', tries: 0, reason: '', manual_at: now, stopped_at: (w && w.stopped_at) || now, due_at: now } });
   askWispr(ctx, id);
@@ -607,12 +606,71 @@ function mergeWispr(ctx, id) {
   return !!(r && r.ok && r.started);
 }
 
+/* AFTER A RESTART. The final pass queue, the Wispr Flow timers and a headless summary run live in this process. A restart
+ * (an update installs a new version and starts PMOS again) dropped them, and their notes stayed "queued", "waiting" or
+ * "writing" for good. The first notes request after a start picks them up (resumeStuck), once per runtime directory:
+ *   - a final pass that was queued or running is queued again; when it can no longer run, it is marked failed with the
+ *     reason, and the agent writes the notes from the live transcript, as Stop does without an engine;
+ *   - a summary run that was started, wrote nothing and is no longer a session is started again;
+ *   - a Wispr Flow check that was waiting or asking carries on from its own clock, or ends as failed once its deadline
+ *     after Stop is past (the PM can press Fetch to try again). */
+let resumedFor = null;
+function resumeStuck(ctx) {
+  const dir = ctx.runtimeDir;
+  if (resumedFor === dir) return [];
+  resumedFor = dir;
+  const done = [];
+  const l = notes.list(dir);
+  if (!l.ok) return done;
+  let live = null;
+  const liveIds = () => {
+    if (live) return live;
+    try { live = new Set((typeof ctx.sessionList === 'function' ? ctx.sessionList() : []).filter((x) => x.state !== 'exited').map((x) => x.id)); } catch { live = new Set(); }
+    return live;
+  };
+  const wsFor = (n) => { const w = n.ws ? ctx.getWs(n.ws) : null; return w && w.id === n.ws ? w : null; };
+  for (const row of l.notes) {
+    const cur = notes.read(dir, row.id);
+    if (!cur.ok || cur.note.private || listening(cur.note)) continue;
+    const n = cur.note;
+    const fst = n.final_state && n.final_state.state;
+    if ((fst === 'queued' || fst === 'running') && !(finalRunner && finalRunner.state(n.id))) {
+      const q = queueFinal(ctx, n.id);
+      if (q.queued) done.push({ id: n.id, final: 'queued' });
+      else {
+        notes.setFinalState(dir, { id: n.id, state: { state: 'failed', reason: 'PMOS restarted before the final pass ended, and it cannot run again: ' + q.reason } });
+        const a = n.agent;
+        if (!a || (!a.imported_at && !a.started)) { startAgent(ctx, dir, n.id, wsFor(n)); done.push({ id: n.id, final: 'failed', agent: 'started' }); }
+        else done.push({ id: n.id, final: 'failed' });
+      }
+    } else if (n.agent && n.agent.started && !n.agent.imported_at && !(n.agent.out && fs.existsSync(n.agent.out)) && n.agent.session && !liveIds().has(n.agent.session)) {
+      startAgent(ctx, dir, n.id, wsFor(n));
+      done.push({ id: n.id, agent: 'started' });
+    }
+    const w = n.wispr;
+    if (w && (w.state === 'waiting' || w.state === 'asking') && !wisprTimers.has(n.id)) {
+      const stopped = Math.max(Date.parse(w.stopped_at) || 0, Date.parse(w.manual_at) || 0);
+      if (Date.now() - stopped >= wisprDeadline(ctx)) {
+        notes.setWispr(dir, { id: n.id, patch: { state: 'failed', reason: 'PMOS restarted while it waited for Wispr Flow, and the ' + Math.round(wisprDeadline(ctx) / 60000) + ' minutes after Stop are past. Press Fetch to try again.' } });
+        done.push({ id: n.id, wispr: 'failed' });
+      } else {
+        const id = n.id;
+        if (w.state === 'waiting') wisprLater(ctx, id, Math.max(0, (Date.parse(w.due_at) || 0) - Date.now()), () => askWispr(ctx, id));
+        else wisprLater(ctx, id, 0, () => checkWispr(ctx, id));
+        done.push({ id, wispr: w.state });
+      }
+    }
+  }
+  return done;
+}
+
 const send = (ctx, res, r) => ctx.json(res, r, r.ok ? 200 : (r.status || 400));
 
 async function handle(req, res, url, ctx) {
   const p = url.pathname;
   const dir = ctx.runtimeDir;
   if (!dir) { ctx.json(res, { ok: false, error: 'the notes store is not available' }, 500); return true; }
+  if (resumedFor !== dir) { try { resumeStuck(ctx); } catch { /* a note that cannot be picked up stays as it was */ } }
   if (p === '/api/notes' || p === '/api/notes/one') {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
     if (p === '/api/notes') { const l = notes.list(dir, { resumeMs: resumeMsOf(ctx) }); if (l.ok) sweepExpired(ctx, l.notes); send(ctx, res, l); return true; }
@@ -991,5 +1049,6 @@ function startAgent(ctx, dir, id, w) {
   return { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld };
 }
 
-module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr,
+module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr, resumeStuck,
+  __resetResume: () => { resumedFor = null; },
   __idle: () => Promise.all([transcriber ? transcriber.idle() : null, finalRunner ? finalRunner.idle() : null, ...chains.values()]) };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/server.js

@@ -8800,7 +8800,7 @@ async function handleRequest(req, res) {
   // pm-os-absorb Runs 2–5 — the planning layer's routes, one file per run (lib/route-modules.js). Last, so none shadows a route above.
   // meeting-notes Run 1: the Notes routes keep notes in the per-user runtime directory and start the agent-summary session.
   if (await routeModules.dispatch(req, res, url, { json, readBody, getWs, invalidateNeedsAgg, boardCache, consoleState, stateDirFor, sessionList, initiativeIndex,
-    runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession,
+    runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession, endSupersededRuns,
     // workspace-headless-jobs R6: is this session a headless run that is still working?
     headlessBusy: (id) => { const x = sessions.get(String(id || '')); return !!(x && x.headless && x.child); },
     // initiative my-work: every registered repository, the day runs, and the two presses that start sessions