create-pmos 0.59.0 → 0.59.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.59.0",
+  "version": "0.59.2",
   "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@e9f1bd9
+kernel-source: pmos@fdeb915
 assembled: 2026-10-06
 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-06T13:15:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T14:07:26Z"}
 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-06T13:15:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T14:07:26Z"}
 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-06T13:15:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T14:07:26Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -95,6 +95,8 @@ The bar at the top has Back (when you are deeper than a tab), Repository, the na
 
 Every row has a visible ⋯ button. Every control is at least 44 pixels high. Nothing works only when you hover.
 
+When the keyboard opens or closes, or you turn the phone, the terminal fits itself to the new space. The session is told its new size when the keyboard stops moving, not at every step, so an agent redraws its screen once. Scrolling the page does not resize the terminal.
+
 ## The older layout
 
 The address options `?layout=legacy` and `?fixture=cockpit` keep the older layouts. The rest of this page describes them. In the cockpit, the workspace has four columns: the repository rail, the list, the detail and the tabs. With `?layout=legacy` it has three columns: navigation, detail and tabs.

package/workspace/guide/today.md

@@ -20,6 +20,16 @@ If the morning-brief session stops before it submits a brief, the Read step says
 
 Each agent job runs in its own session, so you can open any job and follow or steer it. The workspace types the job's prompt into the session when the agent is ready to read, and presses Enter for you. When you approve or revise a job and its session is still open, the workspace uses that same session again. Prepare again works the same way: when the morning-brief session is still open and has finished its read, or has printed nothing for two minutes, the workspace types the read into that session and runs it again.
 
+An agent job can stop with its session still open, for example when the agent asks a question or stops without a draft. When a job's session prints nothing for five minutes and has no draft, the job fails with that reason, so the other jobs can start. Press **Open session** to see what the agent waits on, or **Run it again** to start the job in a new session. **Prepare again** also starts each of these jobs again in a new session. If the first session still delivers its draft, the job takes it.
+
+### What Prepare again, Check now and deleting a session change
+
+- **Prepare again** reads every source again. For each source it reads, the new read replaces that source's items, digests and, for the calendar, the events. The notes of a meeting stay with the meeting. A source it cannot read this time keeps what it gave before. Your goals and every job stay: a job that has a draft, an approval or a result keeps it, and a new item becomes a new job.
+- **Check now** adds what is new since the last read. It also looks once at each open item: it takes off an item that is done or no longer true, and updates an item whose facts changed, for example a new ask or a new due date. It replaces nothing else, and every job stays.
+- **Deleting a session** does not delete its job. A job that was working fails with "the session ended without a draft", so press **Run it again** to start it in a new session. A job that has a draft keeps it. A job that was sending after your approval fails too, so check the place it was for before you run it again: the workspace cannot tell whether it sent.
+
+Each job session is named "Job ·" and the first words of the job, so the session list stays short.
+
 **Agent results**, at the top of the left column, counts the jobs and lists each finished one with its draft summary or the reason it failed. Your goals for today come under it, above the calendar. The other things that wait for you, such as outcome checks, report drafts and sessions, are in **Also waiting for you** at the end of the left column. When the day is folded, they show under it.
 
 ### One day for every repository

package/workspace/lib/brief.js

@@ -387,5 +387,37 @@ function mergeBrief(stored, incoming, { now = Date.now() } = {}) {
   } };
 }
 
+/**
+ * A second full read of the same day (Prepare again) over the stored brief. Pure. The new read wins for every source
+ * it READ; what came from a source it could not read this time is kept, so a source that fails once does not wipe
+ * what it gave before.
+ *   items     the incoming ones, plus the stored ones from a source the incoming brief did not read (and not resolved).
+ *   calendar  the incoming events when it read the calendar (notes of an event with the same id are kept), else the
+ *             stored events.
+ *   digests   the incoming ones, plus the stored ones from a source it did not read.
+ *   places    a service's list is replaced when the incoming brief lists that service.
+ *   resolved  kept.
+ * @returns {{ok:true, brief:object, kept:number}|{ok:false, error:string}}
+ */
+function rereadBrief(stored, incoming) {
+  if (!incoming || typeof incoming !== 'object') return { ok: false, error: 'nothing to read again' };
+  if (!stored || typeof stored !== 'object' || stored.date !== incoming.date) return { ok: true, brief: { ...incoming, resolved: [] }, kept: 0 };
+  const read = (k) => k === 'derived' || (incoming.sources || {})[k] === 'read';
+  const gone = new Set(stored.resolved || []);
+  const inItems = [...(incoming.priorities || []), ...(incoming.worth_asking || [])];
+  const ids = new Set(inItems.map((x) => x.id));
+  const keep = [...(stored.priorities || []), ...(stored.worth_asking || [])].filter((x) => !read(x.source) && !ids.has(x.id) && !gone.has(x.id));
+  const items = sortItems([...inItems, ...keep]).slice(0, MAX_ITEMS);
+  const oldEv = new Map((stored.calendar || []).map((e) => [e.id, e]));
+  const calendar = read('calendar')
+    ? (incoming.calendar || []).map((e) => { const o = oldEv.get(e.id); return o && o.notes ? { ...e, notes: { ...o.notes, ...(e.notes || {}) } } : e; })
+    : (stored.calendar || []);
+  const digests = [...(incoming.digests || []), ...(stored.digests || []).filter((d) => !read(d.source))].slice(0, MAX_DIGESTS);
+  const listed = new Set((incoming.places || []).map((x) => x.source));
+  const places = [...(stored.places || []).filter((x) => !listed.has(x.source)), ...(incoming.places || [])];
+  return { ok: true, kept: keep.length, brief: { ...incoming, calendar, priorities: items.filter((x) => !x.worth_asking), worth_asking: items.filter((x) => x.worth_asking),
+    digests, places, resolved: [...gone].slice(-MAX_RESOLVED) } };
+}
+
 module.exports = { SOURCES, ITEM_SOURCES, SOURCE_STATES, OWNERS, EFFORTS, KINDS, DIGEST_SOURCES, WORTH_ASKING, MAX_ITEMS, MAX_EVENTS, MAX_DIGESTS, MAX_PLACES,
-  isUrl, validateBrief, mergeBrief, greeting, localDate };
+  isUrl, validateBrief, mergeBrief, rereadBrief, greeting, localDate };

package/workspace/lib/day-run.js

@@ -15,13 +15,17 @@
  *   newRun(date, now) · readRun(raw, date)
  *   addTasks(run, brief)                       agent priorities (kind approve|auto) → waiting tasks
  *   toStart(run, limit)                        the tasks to start now, each with its mode (do | revise | send)
- *   started · deliver · decide · sent · fail · sessionEnded
+ *   started · deliver · decide · sent · fail · sessionEnded · sessionStalled
  *   stage(run, brief)                          reading | working | review | done
  *   checkDue(run, {settings, now, events}) · checkStarted · checkDone
  *
  * Status of a task:  waiting → working → review (approve) | done (auto)
  *                    review --approve--> sending → sent        review|done --revise--> waiting (with the note)
  *                    working|sending --fail or session ended--> failed --retry--> waiting
+ *                    working|sending --session quiet too long--> failed (stalled) --retry--> waiting, in a NEW session
+ *
+ * A stalled task keeps its session in `stalled_session`, so the PM can open it. When that session still delivers its
+ * draft (or reports sent) the task takes it, as if it had never stalled.
  */
 
 const MAX_PARALLEL = 5;
@@ -134,6 +138,7 @@ function started(run, taskId, sessionId, now) {
 /** The task session's ONE draft. An `auto` task is then done; an `approve` task waits for the PM. */
 function deliver(run, taskId, d, now) {
   return withTask(run, taskId, (t) => {
+    revive(t);
     if (t.status !== 'working') return `task ${taskId} is ${t.status} — only a working task can deliver a draft`;
     const b = d && typeof d === 'object' ? d : {};
     const summary = text(b.summary); const body = typeof b.body === 'string' ? b.body.trim() : '';
@@ -183,7 +188,9 @@ function decide(run, taskId, op, now) {
       return null;
     }
     if (t.status !== 'failed') return `task ${taskId} is ${t.status} — only a failed task can be run again`;
+    const stalled = !!t.stalled_session;
     t.status = 'waiting'; keepSession(t); t.error = null; t.decided = { action: 'retry', at };
+    if (stalled) { t.prev_session = null; delete t.stalled_session; delete t.stalled_status; }
     return null;
   });
 }
@@ -191,6 +198,7 @@ function decide(run, taskId, op, now) {
 /** The send session reports the approved step done, with the link to what it posted. */
 function sent(run, taskId, s, now) {
   return withTask(run, taskId, (t) => {
+    revive(t);
     if (t.status !== 'sending') return `task ${taskId} is ${t.status} — only an approved task being sent can be reported sent`;
     const link = s && s.link;
     if (link !== undefined && link !== null && link !== '' && !isUrl(link)) return 'the link must be an http(s) address of at most 500 characters';
@@ -226,6 +234,29 @@ function sessionEnded(run, sessionId, now) {
   return { ok: true, run: next, changed };
 }
 
+/** A stalled task whose session reports after all goes back to the step it stalled in. */
+function revive(t) {
+  if (t.status !== 'failed' || !t.stalled_session || !t.stalled_status) return;
+  t.status = t.stalled_status; t.session_id = t.stalled_session; t.error = null;
+  delete t.stalled_session; delete t.stalled_status; delete t.failed_at;
+}
+
+/**
+ * A task session is open but has printed nothing for a long time and delivered nothing: it waits on a question, or its
+ * agent stopped without reporting. The task fails with `why`, which frees its place, and a retry starts a NEW session.
+ */
+function sessionStalled(run, sessionId, why, now) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  const next = clone(run);
+  let changed = false;
+  for (const t of next.tasks) {
+    if (!sessionId || t.session_id !== sessionId || (t.status !== 'working' && t.status !== 'sending')) continue;
+    t.stalled_status = t.status; t.stalled_session = sessionId; t.session_id = null; t.prev_session = null;
+    t.status = 'failed'; t.error = text(why).slice(0, 240) || 'the session stopped without a draft'; t.failed_at = iso(now); changed = true;
+  }
+  return { ok: true, run: next, changed };
+}
+
 /** Where the run is: reading (no brief for the day yet), working, review (drafts wait for the PM) or done. */
 function stage(run, brief) {
   if (!run) return null;
@@ -299,5 +330,5 @@ function checkDone(run, { found = 0, resolved = 0 } = {}, now) {
 }
 
 module.exports = { MAX_PARALLEL, MAX_REVISIONS, MAX_CHECK_LOG, MAX_INTERVAL_MIN, STATUSES, KINDS, ACTIONS, TASK_RE,
-  newRun, readRun, findTask, modeOf, addTasks, toStart, started, deliver, decide, sent, fail, sessionEnded, stage, intervalMin,
+  newRun, readRun, findTask, modeOf, addTasks, toStart, started, deliver, decide, sent, fail, sessionEnded, sessionStalled, stage, intervalMin,
   checkDue, checkStarted, checkDone };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/mobile.js

@@ -505,10 +505,11 @@ export function mountMobile(context) {
   if (theme) theme.addEventListener('click', toggleTheme);
   document.addEventListener('click', onChromeClick);
 
-  if (window.visualViewport) {
-    window.visualViewport.addEventListener('resize', refit);
-    window.visualViewport.addEventListener('scroll', refit);
-  }
+  /* `resize` only. A visual-viewport SCROLL moves the page under the keyboard and changes no box,
+   * so there is nothing to re-fit — but it fires on every frame of a touch scroll, and each one used
+   * to become a synthetic window `resize` that every resize listener on the page answered. That was
+   * the terminal stuttering under a finger on a phone. */
+  if (window.visualViewport) window.visualViewport.addEventListener('resize', refit);
   window.addEventListener('orientationchange', () => setTimeout(refit, 250));
 
   // Crossing the breakpoint (rotate a tablet, drag a window narrow) has to re-decide whether the

package/workspace/public/pm/tab-term.js

@@ -678,7 +678,25 @@ function syncSize(rec) {
   if (!rec.sessionId || rec.attachedId !== rec.sessionId) return;
   const cols = rec.term.cols, rows = rec.term.rows;
   if (!cols || !rows) return;
-  if (rec.sentCols === cols && rec.sentRows === rows) return;
+  if (rec.sentCols === cols && rec.sentRows === rows) { clearTimeout(rec.sizeTimer); rec.sizeTimer = null; return; }
+  /* The FIRST statement on an attach goes out at once: until it does, the shell is drawing into the
+   * 80×24 it was spawned with. A CHANGE after that waits for the grid to settle. A phone's soft
+   * keyboard slides in over about a quarter of a second and the pane is re-fitted on every frame of
+   * it; each `resize` the PTY gets makes a full-screen agent CLI repaint everything it shows, so
+   * stating every intermediate grid buried the session under a dozen redraws of screens that were
+   * gone before they arrived. The local fit is not delayed — only what the shell is told. */
+  if (rec.sentCols == null) { sendSize(rec); return; }
+  clearTimeout(rec.sizeTimer);
+  rec.sizeTimer = setTimeout(() => { rec.sizeTimer = null; sendSize(rec); }, RESIZE_SETTLE_MS);
+}
+
+/** How long the grid must hold still before a change is stated to the PTY. See syncSize. */
+const RESIZE_SETTLE_MS = 120;
+
+function sendSize(rec) {
+  if (!rec.term || !rec.sessionId || rec.attachedId !== rec.sessionId) return;
+  const cols = rec.term.cols, rows = rec.term.rows;
+  if (!cols || !rows || (rec.sentCols === cols && rec.sentRows === rows)) return;
   if (send({ t: 'resize', id: rec.sessionId, cols, rows })) { rec.sentCols = cols; rec.sentRows = rows; }
 }
 
@@ -694,19 +712,40 @@ function note(rec, line, force) {
  * The single entry point. Coalesced into one animation frame so the six triggers below cost one
  * measure per frame rather than six. A pane that is not in the document, or has no box yet, is
  * skipped — fitting a zero-sized element is how a terminal ends up 1×1 and stays there.
+ *
+ * A pane whose box has not moved since it was last fitted is NOT re-measured. Every state change
+ * in the app lands here (the `subscribe` below), and a fit is a getComputedStyle round-trip on the
+ * terminal's parent per pane — on a phone, that was a forced style pass on every render for a grid
+ * that could not have changed. The grid depends on the box and on the cell size; the box is the key
+ * here, and the one event that moves the cell size without moving the box (the web font arriving)
+ * passes `force`.
  */
 let refitQueued = false;
+let refitForce = false;
 
-export function refitVisible() {
+export function refitVisible(force) {
+  if (force === true) refitForce = true;
   if (refitQueued) return;
   refitQueued = true;
   const run = () => {
     refitQueued = false;
+    const forced = refitForce;
+    refitForce = false;
     for (const rec of panes.values()) {
       if (rec.kind !== 'real' || !rec.fit || !rec.host) continue;
       if (!rec.host.isConnected) continue;
-      if (!rec.host.offsetWidth || !rec.host.offsetHeight) continue;
-      try { rec.fit.fit(); } catch { /* a terminal mid-teardown */ }
+      const w = rec.host.offsetWidth, h = rec.host.offsetHeight;
+      if (!w || !h) continue;
+      if (!forced && rec.fitW === w && rec.fitH === h) { syncSize(rec); continue; }
+      try {
+        // Measured first, so a pane whose renderer cannot measure yet is retried next time rather
+        // than remembered as fitted at a grid it never reached.
+        const dims = rec.fit.proposeDimensions();
+        if (dims && dims.cols > 0 && dims.rows > 0) {
+          if (dims.cols !== rec.term.cols || dims.rows !== rec.term.rows) rec.fit.fit();
+          rec.fitW = w; rec.fitH = h;
+        }
+      } catch { /* a terminal mid-teardown */ }
       // …and state the resulting grid to the PTY. `fit()` only fires xterm's `onResize` when the
       // grid MOVES, so a pane that was measured before it had a session would otherwise never tell
       // the shell how wide it is. See the `attached` handler.
@@ -724,7 +763,8 @@ if (typeof window !== 'undefined') {
   subscribe(() => refitVisible());
   window.addEventListener('resize', () => refitVisible());
   document.addEventListener('visibilitychange', () => { if (!document.hidden) refitVisible(); });
-  if (document.fonts && document.fonts.ready) document.fonts.ready.then(() => refitVisible()).catch(() => {});
+  // The face changes the CELL, not the box, so this one re-measures every pane regardless.
+  if (document.fonts && document.fonts.ready) document.fonts.ready.then(() => refitVisible(true)).catch(() => {});
 }
 
 /* ── fixture pane ──────────────────────────────────────────────────────────────────────────── */
@@ -931,6 +971,7 @@ export function disposeTerm(tab) {
    * pane for the id and detaches from the orphan instead. */
   if (rec.kind !== 'real') return;
   if (rec.ro) { try { rec.ro.disconnect(); } catch { /* ignore */ } }
+  if (rec.sizeTimer) { clearTimeout(rec.sizeTimer); rec.sizeTimer = null; }
   if (rec.sessionId) {
     send({ t: 'detach', id: rec.sessionId });
     SOCK.attached.delete(rec.sessionId);
@@ -1058,6 +1099,9 @@ export function termProbe() {
  */
 export function __handleForTest(m) { return handle(m); }
 
-if (typeof window !== 'undefined') window.pmTerm = { refitVisible, termProbe, panes, requestSpawn };
+/* `fit` is the name mobile.js asks for when the soft keyboard or a rotation moves the box. Without it
+ * that module fell back to dispatching a synthetic window `resize`, which every resize listener on
+ * the page answered — not only this one. */
+if (typeof window !== 'undefined') window.pmTerm = { refitVisible, fit: () => refitVisible(), termProbe, panes, requestSpawn };
 
 export default mountTerm;

package/workspace/public/pm/today-day.js

@@ -553,7 +553,8 @@ function jobCard(ctx, j) {
   acts.push(extLink(D.openConversation, j.link, { 'data-day-link': 'conversation' }));
   if (t && t.draft) acts.push(extLink(D.openDraft, t.draft.link, { 'data-day-link': 'draft' }));
   if (t && t.sent) acts.push(extLink(D.openSent, t.sent.link, { 'data-day-link': 'sent' }));
-  if (t && t.session_id) acts.push(button({ label: D.openSession, size: 'sm', variant: 'ghost', attrs: { 'data-day-act': 'session' }, onClick: () => openSession({ id: t.session_id, name: 'day-task' }) }));
+  const sid = t && (t.session_id || t.stalled_session);
+  if (sid) acts.push(button({ label: D.openSession, size: 'sm', variant: 'ghost', attrs: { 'data-day-act': 'session' }, onClick: () => openSession({ id: sid, name: 'day-task' }) }));
   let form = null;
   if (t && ui.revising.has(t.id) && canRevise) {
     const f = field({ label: D.noteLabel, kind: 'textarea', value: ui.notes.get(t.id) || '', placeholder: D.noteHint, hideLabel: true, attrs: { maxlength: '500', 'data-day-input': 'note-' + t.id } });

package/workspace/server.js

@@ -453,6 +453,13 @@ function profileOverlay(profile) {
 }
 
 const SCROLLBACK = 200_000;                            // bytes of ring buffer per session
+const SCROLLBACK_SLACK = 32_768;                       // how far the ring may run over before a trim (appendBuf)
+// PTY output goes on the wire at most once per this window per session (queueOutput). node-pty
+// hands over whatever one read() returned, which for an agent CLI repainting its screen is many
+// small chunks — each one a JSON frame, a WebSocket message and a parse in the browser. The first
+// chunk after a quiet spell is sent at once, so a keystroke's echo is never delayed by it.
+const OUTPUT_COALESCE_MS = 4;
+const OUTPUT_COALESCE_MAX = 64 * 1024;                 // …and flushed at once past this, so a flood stays bounded
 // How often the server re-broadcasts the session list while anything is alive (see heartbeat()).
 // 2s is chosen against what it drives: the state dot and the quiet clock. QUIET_AFTER_MS is 30s, so
 // a 2s cadence puts the worst-case error in "quiet 31s" at one tick — under the rounding the UI
@@ -2836,7 +2843,11 @@ function trimBuf(buf, limit) {
 
 function appendBuf(s, data) {
   s.buf += data;
-  if (s.buf.length > SCROLLBACK) s.buf = trimBuf(s.buf, SCROLLBACK);
+  // Trimmed with SLACK, not on every byte past the limit. Once a busy session's ring is full, a trim
+  // per chunk flattens and scans the whole 200 KB string for each few bytes an agent CLI repaints —
+  // a spinner alone is dozens of chunks a second. Letting the ring run SCROLLBACK_SLACK over and then
+  // cutting it back to SCROLLBACK does the same work once per 32 KB of output.
+  if (s.buf.length > SCROLLBACK + SCROLLBACK_SLACK) s.buf = trimBuf(s.buf, SCROLLBACK);
   s.bufDirty = true;                    // the periodic writer skips a session that is not dirty
   // Parser 2's whole input: the moment output last arrived. `quiet` is derived from this, never
   // from reading the bytes — which is why it is the only one of the five that cannot misread.
@@ -2844,6 +2855,46 @@ function appendBuf(s, data) {
   s.parsed = null;                      // buffer moved; the cached parse is stale
 }
 
+/**
+ * Put PTY output on the wire as at most ONE frame per OUTPUT_COALESCE_MS per session.
+ *
+ * Leading edge, then a window: a chunk that arrives when nothing has been sent recently goes out at
+ * once — a keystroke's echo is never held back — and opens a window in which further chunks are
+ * gathered and sent together when it closes. A burst (an agent CLI repainting its screen) therefore
+ * costs one frame per window instead of one per node-pty read, and a lone echo costs nothing.
+ *
+ * The bytes reach the ring (`appendBuf`) at the same moment they reach the clients, never before:
+ * a client that attaches in between gets `buf` without the pending bytes and then the flush, so it
+ * sees every byte exactly once and in order. Anything that writes to `buf` directly while output may
+ * be pending (the exit note) calls `flushOutput` first for the same reason.
+ */
+function queueOutput(s, data) {
+  if (!data) return;
+  if (s._out) s._out += data; else s._out = data;
+  if (!s._outTimer) { sendOutput(s); s._outTimer = setTimeout(() => closeOutputWindow(s), OUTPUT_COALESCE_MS); return; }
+  if (s._out.length >= OUTPUT_COALESCE_MAX) sendOutput(s);
+}
+function closeOutputWindow(s) {
+  s._outTimer = null;
+  if (!s._out) return;
+  // Output kept arriving through the window: send it, and keep gathering for one more window.
+  sendOutput(s);
+  s._outTimer = setTimeout(() => closeOutputWindow(s), OUTPUT_COALESCE_MS);
+}
+function flushOutput(s) {
+  if (s._outTimer) { clearTimeout(s._outTimer); s._outTimer = null; }
+  sendOutput(s);
+}
+function sendOutput(s) {
+  const data = s._out;
+  if (!data) return;
+  s._out = '';
+  appendBuf(s, data);
+  if (!s.clients || !s.clients.size) return;
+  const frame = JSON.stringify({ t: 'data', id: s.id, data });
+  for (const c of s.clients) if (c.readyState === 1) c.send(frame);
+}
+
 // Platform-correct guidance when a spawn fails. On macOS `posix_spawnp failed` is almost always
 // node-pty's prebuilt `spawn-helper` missing its executable bit (prebuild extraction drops it) —
 // the binary is fine, just not +x. The server auto-restores it at startup and `npm run doctor`
@@ -3077,8 +3128,7 @@ function attachPty(s, { seed = false } = {}) {
     onOutput: (pane, text) => {
       if (paneId && pane !== paneId) return;              // only this session's pane
       if (s._reattempts) s._reattempts = 0;               // a working attach clears the retry budget
-      appendBuf(s, text);
-      for (const c of s.clients) if (c.readyState === 1) c.send(JSON.stringify({ t: 'data', id: s.id, data: text }));
+      queueOutput(s, text);
     },
   });
   p.onData((d) => parser.feed(d));
@@ -3086,6 +3136,7 @@ function attachPty(s, { seed = false } = {}) {
   // on the client PTY's own window size.
   client.resize(s.cols || 80, s.rows || 24);
   p.onExit(({ exitCode }) => {
+    flushOutput(s);   // whatever the pane said last lands before a reconnect or the exit note
     s.pty = null;
     // Our PTY is the tmux CLIENT: it exits when the pane process ends AND on a mere detach. If
     // the tmux session is still alive, the process lives on — reconnect (bounded, to never spin).
@@ -3327,11 +3378,9 @@ function spawnSession({ name, agent, cwd, ws, origin, initialInput, profile, ini
   announceStateHealth(s);
   announceTree(s);   // registered first: a session's co-tenancy question includes itself in the map
   announceModel(s);
-  p.onData((d) => {
-    appendBuf(s, d);
-    for (const c of s.clients) if (c.readyState === 1) c.send(JSON.stringify({ t: 'data', id, data: d }));
-  });
+  p.onData((d) => queueOutput(s, d));
   p.onExit(({ exitCode }) => {
+    flushOutput(s);   // the last bytes the process wrote come before the exit note, in the ring and on the wire
     s.state = 'exited'; s.pty = null;
     const fast = Date.now() - startedMs < 800;   // exited almost immediately → surface a hint
     s.note = fast
@@ -3707,7 +3756,8 @@ function readDayRun(date) {
   return run;
 }
 function writeDayRun(run) {
-  try { fs.mkdirSync(GOALS_DIR(), { recursive: true }); fs.writeFileSync(dayRunFile(run.date), JSON.stringify(run) + '\n'); return true; }
+  // Written to a side file and renamed into place, so a reader (the page, the CLI, a suite) never sees a half-written run.
+  try { fs.mkdirSync(GOALS_DIR(), { recursive: true }); const f = dayRunFile(run.date); const tmp = `${f}.${process.pid}.tmp`; fs.writeFileSync(tmp, JSON.stringify(run) + '\n'); fs.renameSync(tmp, f); return true; }
   catch (e) { warnWriteFail('day run (goals/<date>.run.json)', e); return false; }
 }
 function briefOfDay(date) {
@@ -3726,6 +3776,20 @@ function briefSessionDone(run, date, now) {
   if (now - Math.max(s.lastOutputAt || 0, Date.parse(bs.started_at || 0) || 0) >= BRIEF_IDLE_MS) return 'idle';
   return null;
 }
+// A day-task session that is open but has printed nothing for TASK_IDLE_MS, without a draft, waits on a question or
+// stopped without reporting. Its task fails with that reason, so its place frees and Retry or Prepare again starts a new
+// session. A working agent redraws its spinner many times a second, so a quiet of minutes is not work in progress.
+const TASK_IDLE_MS = Number(process.env.PMOS_DAY_TASK_IDLE_MS || 5 * 60 * 1000);
+const TASK_STALLED_WHY = 'the session has printed nothing for five minutes and has not delivered a draft. Open the session to see what it waits on, or run the job again.';
+function stallQuietTasks(run, now) {
+  for (const t of run.tasks) {
+    if ((t.status !== 'working' && t.status !== 'sending') || !t.session_id) continue;
+    const s = sessions.get(t.session_id);
+    if (!s || s.state === 'exited') continue;
+    if (now - Math.max(s.lastOutputAt || 0, Date.parse(t.started_at || 0) || 0) >= TASK_IDLE_MS) run = dayRunLib.sessionStalled(run, t.session_id, TASK_STALLED_WHY, now).run;
+  }
+  return run;
+}
 // The skill's own body is the prompt, as fireSchedule hands it over; the line after it names this run's task and mode.
 function daySkillPrompt(run, skillId) {
   const w = getWs(run.ws);
@@ -3733,6 +3797,13 @@ function daySkillPrompt(run, skillId) {
   if (!task || task.kind !== 'agent' || !task.prompt) return { error: `the ${skillId} skill is not installed for this repository` };
   return { w, task, prompt: skillStore.retargetFiling(task.prompt, filingContract(w)) };
 }
+/** A short session name for a job, so the session list stays readable: "Job · " and the first words of its title. */
+function jobSessionName(title) {
+  const t = String(title || '').replace(/\s+/g, ' ').trim();
+  if (t.length <= 28) return 'Job · ' + (t || 'untitled');
+  const cut = t.slice(0, 28); const sp = cut.lastIndexOf(' ');
+  return 'Job · ' + (sp > 12 ? cut.slice(0, sp) : cut).replace(/[\s,.;:·—-]+$/, '') + '…';
+}
 /** Start one task session; a start that fails marks the task failed with the reason. Returns the new run. */
 function startDayTask(run, t, now) {
   const sk = daySkillPrompt(run, 'day-task');
@@ -3746,7 +3817,7 @@ function startDayTask(run, t, now) {
   }
   if (!sk.error && !s) {
     const prompt = `${sk.prompt}\n\n${line}`;
-    s = spawnSession({ name: `${t.title} · day task`, agent: sk.task.agent || 'claude', ws: sk.w ? sk.w.id : run.ws, origin: 'day-task', initialInput: prompt + '\r',
+    s = spawnSession({ name: jobSessionName(t.title), agent: sk.task.agent || 'claude', ws: sk.w ? sk.w.id : run.ws, origin: 'day-task', initialInput: prompt + '\r',
       modelAsk: { scheduleTier: null, skillTier: sk.task.tier || null, skill: sk.task.skill } });
   }
   const live = s && s.state !== 'exited';
@@ -3797,6 +3868,7 @@ function dayTick() {
   const ids = new Set([...run.tasks.filter((t) => (t.status === 'working' || t.status === 'sending') && t.session_id).map((t) => t.session_id),
     run.brief_session && !run.brief_session.ended_at ? run.brief_session.id : null, run.checks.session_id].filter(Boolean));
   for (const id of ids) if (!daySessionAlive(id)) run = dayRunLib.sessionEnded(run, id, now).run;
+  run = stallQuietTasks(run, now);
   const brief = briefOfDay(date);
   const a = dayRunLib.addTasks(run, brief);
   if (a.ok) run = a.run;
@@ -7482,6 +7554,15 @@ async function handleRequest(req, res) {
     const open = readGoalsDay(pdate).goals.filter((g) => g.status === 'open');
     let run = readDayRun(pdate) || dayRunLib.newRun(pdate, pnow);
     run.ws = w.id;
+    // Prepare again also runs again every job whose session went quiet, each in a new session: the PM pressed it to
+    // get the day moving, and a job stuck on a silent session would otherwise hold the day at "working".
+    if (run.tasks.length) {
+      run = stallQuietTasks(run, pnow);
+      for (const t of run.tasks.filter((x) => x.status === 'failed' && x.stalled_session)) {
+        const d = dayRunLib.decide(run, t.id, { action: 'retry' }, pnow); if (d.ok) run = d.run;
+      }
+      run = startDayTasks(run, pnow);
+    }
     if (run.brief_session && !run.brief_session.ended_at) {
       // A session that finished its read (or sits idle) is used again: the skill's prompt is typed into it and run.
       const done = daySessionAlive(run.brief_session.id) ? briefSessionDone(run, pdate, pnow) : null;
@@ -7652,7 +7733,7 @@ async function handleRequest(req, res) {
   }
   if (p === '/api/proactive/brief') {
     // The brief is submitted by a scheduled skill in an agent session and only CHECKED and stored here. One file per day;
-    // a second submission for the same day replaces the first. Nothing is sent, started or changed.
+    // a second submission for the same day replaces what it read, and keeps what came from a source it could not read. Nothing is sent, started or changed.
     const dir = path.join(STATE, 'briefs');
     if (req.method === 'POST') {
       let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
@@ -7661,8 +7742,10 @@ async function handleRequest(req, res) {
       if (!v.ok) return json(res, { ok: false, error: v.error }, 400);
       // `merge: true` (a daytime check, G22) merges into the stored brief of that day; with none stored it is stored as it is.
       let out = { ...v.brief, resolved: [] }; let merged = null;
+      let stored = null; try { stored = JSON.parse(fs.readFileSync(path.join(dir, v.brief.date + '.json'), 'utf8')); } catch { /* none yet */ }
+      // A second full read of the day (Prepare again) keeps what came from a source it could not read this time.
+      if (body.merge !== true && stored) { const rr = briefLib.rereadBrief(stored, v.brief); if (rr.ok) out = rr.brief; }
       if (body.merge === true) {
-        let stored = null; try { stored = JSON.parse(fs.readFileSync(path.join(dir, v.brief.date + '.json'), 'utf8')); } catch { /* none yet */ }
         const m = briefLib.mergeBrief(stored, v.brief, { now: Date.now() });
         if (!m.ok) return json(res, { ok: false, error: m.error }, 400);
         out = m.brief; merged = { found: m.added, resolved: m.removed };
@@ -8461,7 +8544,7 @@ module.exports = { server, online: { ONLINE, applyOnline, tunnel, publicHost },
   stripLegacyClientScreen,
   // the scrollback ring's front trim, exported pure so the suite can assert that a cut never lands
   // inside an escape sequence or between the halves of a surrogate pair.
-  trimBuf, SCROLLBACK,
+  trimBuf, SCROLLBACK, queueOutput, flushOutput, OUTPUT_COALESCE_MS,
   // the liveness heartbeat's guard, exported pure so the "idle machine stays idle" half can be
   // asserted without a server that has no clients (the suite always has both).
   shouldHeartbeat, LIVENESS_MS, TX_REREAD_MS,

package/workspace/skills/day-check.skill

@@ -1,7 +1,7 @@
 ---
 name: day-check
 label: "Day check"
-description: "The daytime check of today's run: read only what changed since the last check, and merge new items, resolved items, meeting notes and updated digests into the stored brief. Read-only on every source; it sends nothing."
+description: "The daytime check of today's run: read only what changed since the last check, check the open items once, and merge new, changed and resolved items, meeting notes and updated digests into the stored brief. Read-only on every source; it sends nothing."
 run: agent
 agent: claude
 output:
@@ -14,7 +14,7 @@ output:
 
 Rules that always hold:
 1. READ-ONLY on every source. Never send, reply, forward, post, react, comment, create, edit, accept, decline, transition, label, archive, mark read or delete anything in mail, Slack, Jira, Confluence, GitHub, Drive, Figma, a website, calendar, Wispr Flow or any other source.
-2. ONLY WHAT CHANGED. Do not read the day again. Read only what is new since the last check. The time of the last check is in `pmos proactive day`.
+2. ONLY WHAT CHANGED. Do not read the day again. Read only what is new since the last check, and look once at each open item of the stored brief. The time of the last check is in `pmos proactive day`.
 3. SETTINGS DECIDE THE SOURCES AND THE SCOPES, as in the morning brief. Read a source only if it is on. In Slack, Jira and Confluence, read a place with scope watch since the last check, look in a place with scope search only for mentions of the PM and the words of the goals, and do not touch a place with scope ignore.
 4. LIGHT ON CONTENT. Never copy a message body, an attachment, a token or a credential. Paraphrase in the limits of each field. Skip anything marked private, personal, confidential or HR.
 5. NOTHING INVENTED. Add an item only for something you read. A check that finds nothing is a correct check.
@@ -28,10 +28,12 @@ Procedure:
    - Mentions of the PM since the last check, in Slack, Jira and Confluence, in every place that is not ignored. Keep where, who, the link to the conversation itself and a short paraphrase of what is asked. To tie a Jira issue to an initiative, run `pmos jira which <KEY>` (it reads local files only) and use the initiative it names. A status change of a ticket that `pmos jira which` names is not an item: the Jira status check shows it on the initiative's Jira tickets tab.
    - Places with scope watch: read every message or comment since the last check. Update the digest of the place (decisions, open questions, what touches a goal). A digest you submit replaces the stored digest of that place, so carry over what still holds.
    - GitHub, Drive, Figma and websites, if on: only what changed since the last check and matters to a goal or a meeting.
+   - The open items of the stored brief: look once at each item that has a link, in a source that is on. Note an item that is now done or no longer true, and an item whose facts changed: a new ask, a new due date, a new owner, or an answer that changes what the PM must do.
    - Wispr Flow: notes for meetings that ended since the last check. Read the summary, the decisions and the actions. Read the related mail for the same meeting only if mail is on, and keep the subject, the sender and a gist.
 3. Decide what the brief needs.
    - New items: a thing the PM should act on that is not in the stored brief. Fill the fields as the morning-brief skill does: link, where, who, about, ask, reply_needed, how and kind (you, approve or auto, with the same meaning). Set "mention": true on an item that comes from a mention. Only give an item a source that is "read".
    - Resolved items: an item in the stored brief that is now done, answered or no longer true, for example a thread the PM answered, an issue that was closed, a meeting that was cancelled. List its id in "resolved". Never resolve an item only because it is old.
+   - Changed items: an open item whose facts changed. Submit it again with the SAME "title" and "source" as in the stored brief, because the workspace derives its id from them, and with the fields updated. The workspace replaces the stored item. Do not submit an item that did not change.
    - Event notes: for a meeting that ended, add "notes": {"wispr": {"link", "summary", "decisions", "actions"}, "mail": {"subject", "from", "gist", "link"}} to that event, and mark the "after" steps that are now done with "done": true. Give the event by the same "start", "end" and "title" it has in the stored brief, because the workspace derives its id from them.
    - Updated digests: only for the places you read.
 4. Write one JSON file in the scratch folder of this session, in the shape of the morning brief, with only what is new or changed, and a list of resolved ids: