create-pmos 0.58.0 → 0.59.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.58.0",
+  "version": "0.59.1",
   "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@e8fcb2a
+kernel-source: pmos@2d3ee9f
 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-06T11:54:59Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T13:37:09Z"}
 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-06T11:54:59Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T13:37:09Z"}
 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-06T11:54:59Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T13:37:09Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -25,7 +25,7 @@ Each place is drawn when its run is built. Until then the place says which run b
 
 ## Settings
 
-Settings holds settings only, in six sections:
+Settings holds settings only, in seven sections:
 
 - **Repositories**: every registered repository. Press a repository to make it the current one. Press its ⋯ for **Rename** or **Remove from PMOS**. Each asks in a sheet, and a remove asks you to confirm. **Add repository** shows the scan of a folder before you add it.
 - **Profiles**: the Claude profiles a session can start with. They open in the detail.
@@ -33,6 +33,9 @@ Settings holds settings only, in six sections:
 - **Validate consent**: the consent of the current repository. Turn it on or off here. **Open Validate** opens the Validate page as a tab.
 - **Online**: puts this workspace at your own address, such as `pmos.pm-os.app`, through a Cloudflare tunnel. Enter the public address, the tunnel name, your Cloudflare team domain, the Access audience (AUD) tag and your email, then press **Turn on**. The workspace runs the tunnel and remembers the switch when it restarts. On your phone, open the address and sign in with Cloudflare Access (Google or an email code). The workspace does not ask for its token there. Only the computer that runs the workspace can change this section. A phone sees whether it is on. [REMOTE.md](../REMOTE.md) has the one-time Cloudflare steps.
 - **Theme**: Dark or Light.
+- **Updates**: the version of the workspace app and the version of the kit in the current repository. Press **Check for updates** to compare them with the latest published version of PMOS. This is the only time the workspace asks the internet for a version, and it asks only when you press. When a newer version is available, a button shows for each part that is older:
+  - **Update the kit** does what `npx create-pmos@latest --update` does in a terminal. It changes only the kit's own files under `pmos/` (skills, scripts, templates and guides). Your records in `state/`, `planning/` and `okf/product/` do not change. The last lines of the output show under the button. The changed files are under `pmos/`, which Sync treats as records, so Sync (or automatic sync) sends them with your other records. To read them first, look at `git diff pmos/` before you sync.
+  - **Update the workspace** does what `pmos upgrade` does in a terminal. It asks you first. The workspace stops, installs the new version and starts again, and the page reloads when the new version starts. Sessions keep running in tmux. Press it on the computer that runs the workspace. From a phone it is refused, because the phone cannot see the restart through. When the workspace runs from a PMOS checkout, update it with `git pull` instead.
 
 Your work is never in Settings. It is in Today, Initiatives, Board and Reports.
 

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/lib/kit-update.js

@@ -0,0 +1,161 @@
+'use strict';
+/* kit-update.js — check for a newer create-pmos, and update the kit or the workspace app, from the page (workspace-kit-update).
+ *
+ *   readKit(root)                           → { present:false } | { present:true, version, kernelSource, installed, mode }
+ *   status({ root, appVersion, appDir })    → { app: { version, fromCheckout }, kit }       local only, no network
+ *   latest({ exec })                        → Promise<{ ok, version } | { ok:false, error }>   npm view create-pmos version
+ *   compare(st, latestVersion)              → { appBehind, kitBehind }
+ *   updateKit(root, { version, exec })      → Promise<{ ok, output, kit } | { ok:false, error, output }>
+ *   upgradeApp(root, { version, logFile, spawn }) → { ok, log } | { ok:false, error }
+ *
+ * The page does what the terminal does, and nothing more. Each action runs the command the README tells the PM to type:
+ *   check        npm view create-pmos version
+ *   kit          npx -y create-pmos@<version> --update <repo>            (the kernel only; state/ and planning/ untouched)
+ *   app          npx -y create-pmos@<version> workspace --reinstall <repo> (what `pmos upgrade` runs)
+ * The version is the one the check found, so what is installed is what the PM was shown, not whatever `latest` is a
+ * minute later. The app upgrade stops this server (create-pmos runs `pmos stop`), so it runs DETACHED, writes its output
+ * to a log file, and the page waits for the server to come back.
+ *
+ * NETWORK. These are the workspace's only egress to the npm registry. No HTTP client is opened here: npm and npx open
+ * their own. Every call is reached only from a POST the page sends when the PM presses a button (server.js
+ * /api/kit/check, /api/kit/update, /api/kit/upgrade-app); no timer and no GET reaches them. no-network.test.js holds
+ * that.
+ */
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const PKG_NAME = 'create-pmos';
+const IS_WIN = process.platform === 'win32';
+const NPM = IS_WIN ? 'npm.cmd' : 'npm';
+const NPX = IS_WIN ? 'npx.cmd' : 'npx';
+const CHECK_TIMEOUT_MS = 30000;
+const UPDATE_TIMEOUT_MS = 5 * 60000;
+const VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
+const OUTPUT_LINES = 20;
+
+/** -1 when a < b, 0 when equal, 1 when a > b. Dotted numeric; a missing or non-numeric part counts as 0. */
+function cmpVer(a, b) {
+  const pa = String(a || '0').split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b || '0').split('-')[0].split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const d = (pa[i] || 0) - (pb[i] || 0);
+    if (d) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+
+const validVersion = (v) => typeof v === 'string' && VERSION_RE.test(v);
+
+/**
+ * The repository's vendored kit, from pmos/KIT-VERSION. build-kit.sh writes `kernel-source:` and create-pmos appends an
+ * `installed-via: create-pmos@<v>` block on each vendor and update, so the LAST installed-via is the version in use.
+ */
+function readKit(root) {
+  let text;
+  try { text = fs.readFileSync(path.join(String(root || ''), 'pmos', 'KIT-VERSION'), 'utf8'); }
+  catch { return { present: false }; }
+  const last = (key) => {
+    let v = null;
+    for (const line of text.split(/\r?\n/)) {
+      const i = line.indexOf(':');
+      if (i > 0 && line.slice(0, i).trim() === key) v = line.slice(i + 1).trim();
+    }
+    return v;
+  };
+  const via = last('installed-via');
+  const m = via ? /create-pmos@(\S+)/.exec(via) : null;
+  return {
+    present: true,
+    version: m && validVersion(m[1]) ? m[1] : null,
+    kernelSource: last('kernel-source'),
+    installed: last('installed'),
+    mode: last('install-mode'),
+  };
+}
+
+/** True when the app runs from a PMOS checkout (workspace/ beside a .git): there `git pull` updates it, not npm. */
+function fromCheckout(appDir) {
+  try { return fs.existsSync(path.join(String(appDir), '..', '.git')); } catch { return false; }
+}
+
+function status({ root, appVersion, appDir }) {
+  return { app: { version: appVersion || null, fromCheckout: fromCheckout(appDir) }, kit: readKit(root) };
+}
+
+function compare(st, latestVersion) {
+  if (!validVersion(latestVersion)) return { appBehind: false, kitBehind: false };
+  const app = st && st.app && st.app.version;
+  const kit = st && st.kit && st.kit.present ? st.kit.version : null;
+  return {
+    appBehind: !!app && cmpVer(app, latestVersion) < 0,
+    // A kit with no installed-via line (vendored by hand from a checkout) has no version to compare: offer the update.
+    kitBehind: !!(st && st.kit && st.kit.present) && (!kit || cmpVer(kit, latestVersion) < 0),
+  };
+}
+
+const tail = (s) => String(s || '').trim().split(/\r?\n/).slice(-OUTPUT_LINES).join('\n');
+
+/** execFile as a promise that never rejects. */
+function run(exec, cmd, args, opts) {
+  return new Promise((resolve) => {
+    exec(cmd, args, { encoding: 'utf8', windowsHide: true, shell: IS_WIN, ...opts }, (err, stdout, stderr) => {
+      resolve({ err: err || null, stdout: String(stdout || ''), stderr: String(stderr || '') });
+    });
+  });
+}
+
+function why(r, what) {
+  if (!r.err) return null;
+  if (r.err.code === 'ENOENT') return `${what} could not run: the command was not found on this computer's PATH`;
+  if (r.err.killed) return `${what} took too long and was stopped`;
+  const said = tail(r.stderr).split('\n').filter(Boolean).pop();
+  return `${what} did not finish${said ? ': ' + said : ''}`;
+}
+
+async function latest({ exec = cp.execFile } = {}) {
+  const r = await run(exec, NPM, ['view', PKG_NAME, 'version', '--json'], { timeout: CHECK_TIMEOUT_MS });
+  const bad = why(r, 'The check');
+  if (bad) return { ok: false, error: bad };
+  let v = r.stdout.trim();
+  try { const j = JSON.parse(v); if (typeof j === 'string') v = j; } catch { /* plain text */ }
+  if (!validVersion(v)) return { ok: false, error: 'The check did not return a version number' };
+  return { ok: true, version: v };
+}
+
+async function updateKit(root, { version, exec = cp.execFile } = {}) {
+  if (!validVersion(version)) return { ok: false, error: 'Check for updates first' };
+  if (!readKit(root).present) return { ok: false, error: 'This repository has no PMOS kit folder (pmos/KIT-VERSION)' };
+  const r = await run(exec, NPX, ['-y', `${PKG_NAME}@${version}`, '--update', String(root)], { timeout: UPDATE_TIMEOUT_MS, cwd: String(root) });
+  const output = tail(r.stdout + (r.stderr ? '\n' + r.stderr : ''));
+  const bad = why(r, 'The kit update');
+  if (bad) return { ok: false, error: bad, output };
+  return { ok: true, output, kit: readKit(root) };
+}
+
+/**
+ * Start the app reinstall and return at once. The child is detached from this server, because create-pmos stops this
+ * server before it reinstalls, and it starts the new one after. Its output goes to `logFile`.
+ */
+function upgradeApp(root, { version, logFile, spawn = cp.spawn } = {}) {
+  if (!validVersion(version)) return { ok: false, error: 'Check for updates first' };
+  let fd;
+  try {
+    fs.mkdirSync(path.dirname(logFile), { recursive: true });
+    fd = fs.openSync(logFile, 'w');
+    fs.writeSync(fd, `${new Date().toISOString()} ${NPX} -y ${PKG_NAME}@${version} workspace --reinstall ${root}\n`);
+  } catch (e) { return { ok: false, error: `Could not write the log file: ${e.message}` }; }
+  try {
+    const child = spawn(NPX, ['-y', `${PKG_NAME}@${version}`, 'workspace', '--reinstall', String(root)],
+      { cwd: String(root), detached: true, stdio: ['ignore', fd, fd], windowsHide: true, shell: IS_WIN });
+    if (child && typeof child.on === 'function') child.on('error', () => { /* reported in the log by npx, or the page times out */ });
+    if (child && typeof child.unref === 'function') child.unref();
+    return { ok: true, log: logFile };
+  } catch (e) {
+    return { ok: false, error: `The workspace update could not start: ${e.message}` };
+  } finally {
+    try { fs.closeSync(fd); } catch { /* the child holds its own copy */ }
+  }
+}
+
+module.exports = { PKG_NAME, cmpVer, validVersion, readKit, fromCheckout, status, compare, latest, updateKit, upgradeApp };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/components.css

@@ -2245,7 +2245,7 @@
   margin: 12px 16px 0;
   color: var(--muted-foreground);
 }
-/* Settings: one column of five sections. */
+/* Settings: one column of seven sections. */
 .fr-set {
   display: flex;
   flex-direction: column;
@@ -2299,6 +2299,22 @@
 .fr-set__add {
   padding: 12px 0;
 }
+.fr-set__error {
+  color: var(--destructive);
+}
+.fr-set__output {
+  margin: 0;
+  max-height: 200px;
+  overflow: auto;
+  padding: 8px;
+  border: 1px solid var(--border);
+  background: var(--muted);
+  color: var(--foreground);
+  font-family: var(--mono);
+  font-size: 11px;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
 @media (max-width: 760px) {
   .fr-detail,
   .fr-dock {

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

@@ -1,6 +1,6 @@
 /* pm/dest-settings.js — the Settings destination, the frame's ⚙ (pm-os-absorb Run 3, slice 3A; PRD R9).
  *
- * Settings holds settings only, in six sections and in this order:
+ * Settings holds settings only, in seven sections and in this order:
  *   Repositories       every registered repository as a row (open it to make it current; ⋯ for more), and Add repository,
  *                      which draws the existing add-repository flow (view-addrepo.js) in place
  *   Profiles           one row that opens the Claude profiles in the detail
@@ -8,6 +8,10 @@
  *   Validate consent   the current repository's consent switch (GET and POST /api/validate/repo)
  *   Online             the Online switch and its five settings (GET and POST /api/online; workspace-online-mode, D89)
  *   Theme              Dark or Light
+ *   Updates            the workspace app's version and the current repository's kit version; Check for updates asks the
+ *                      npm registry for the latest create-pmos (POST /api/kit/check, the PM's press only), and Update the
+ *                      kit / Update the workspace run what `npx create-pmos@latest --update` and `pmos upgrade` run
+ *                      (workspace-kit-update). The workspace update restarts the server, so the page waits and reloads.
  * The work itself (what needs you, initiatives, items, reports) is never here.
  *
  * The mount contract (registry.js): mountDestination(host, ctx) is called on every render with the same host. The page
@@ -23,10 +27,13 @@ import { repoTuples, activeProduct, renameRepo, removeRepo } from './panel-repos
 import { repoRow } from './fixture.js';
 import { sessionDefaults, setSessionDefaults } from './dock.js';
 import { COPY } from './frame-copy.js';
+import { askConfirm } from './dialogs.js';
 
 const P = COPY.page;
 const roots = new WeakMap();      // host -> { root, sig }
 const consentByWs = new Map();    // ws -> { on: boolean | null, error, at, pending }
+const kitByWs = new Map();        // ws -> { st: GET /api/kit/status body | null, at, pending }
+const upd = { phase: null, latest: null, compare: null, message: '', error: '', output: '' };   // the Updates section
 const online = { data: null, error: null, note: null, at: 0, pending: false };   // GET /api/online, and the last refusal
 let addOpen = false;
 let addMod = null;
@@ -76,7 +83,7 @@ const section = (id, title, kids, action) => el('section', { class: 'fr-set__sec
   el('div', { class: 'fr-set__head' }, el('h2', { class: 'fr-set__title' }, title), action || null),
   kids);
 
-/* ── the six sections ───────────────────────────────────────────────────────────────────────────────────────────── */
+/* ── the seven sections ────────────────────────────────────────────────────────────────────────────────────────── */
 
 function reposSection(scope) {
   const tuples = repoTuples();
@@ -227,6 +234,100 @@ function themeSection() {
   })]);
 }
 
+function readKitStatus(ws, force) {
+  if (!ws || FIXTURE) return;
+  const have = kitByWs.get(ws);
+  if (!force && have && (have.pending || Date.now() - have.at < 30000)) return;
+  const entry = { st: have ? have.st : null, at: Date.now(), pending: true };
+  kitByWs.set(ws, entry);
+  pmGet('/api/kit/status?ws=' + encodeURIComponent(ws)).then((j) => {
+    entry.pending = false; entry.at = Date.now();
+    if (j && j.ok !== false) entry.st = j;
+    setState({});
+  });
+}
+
+const say = (fields) => { Object.assign(upd, fields); setState({}); };
+
+async function checkUpdates(ws) {
+  say({ phase: 'check', message: '', error: '', output: '' });
+  const j = await pmPost('/api/kit/check', { ws });
+  if (j && j.ok !== false) {
+    kitByWs.set(ws, { st: j, at: Date.now() });
+    say({ phase: null, latest: j.latest, compare: { appBehind: !!j.appBehind, kitBehind: !!j.kitBehind } });
+  } else say({ phase: null, error: (j && j.error) || P.updateFailed });
+}
+
+async function updateKit(ws) {
+  say({ phase: 'kit', message: '', error: '', output: '' });
+  const j = await pmPost('/api/kit/update', { ws, version: upd.latest });
+  if (j && j.ok !== false) {
+    kitByWs.set(ws, { st: j, at: Date.now() });
+    say({ phase: null, compare: { ...(upd.compare || {}), kitBehind: false }, message: P.updateKitDone((j.kit && j.kit.version) || upd.latest), output: j.output || '' });
+  } else say({ phase: null, error: (j && j.error) || P.updateFailed, output: (j && j.output) || '' });
+}
+
+const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** Wait for the server to come back after the app update: reload on a new version, or say what happened. */
+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) { say({ phase: null, error: P.updateAppSame(j.version, log) }); return; }
+  }
+  say({ phase: null, error: P.updateAppLost(log) });
+}
+
+async function updateApp(ws, from) {
+  const yes = await askConfirm({ title: P.updateAppTitle, body: P.updateAppBody(from || '?', upd.latest), confirmLabel: P.updateApp });
+  if (!yes) return;
+  say({ phase: 'app', message: P.updateAppBusy, error: '', output: '' });
+  const j = await pmPost('/api/kit/upgrade-app', { ws, version: upd.latest });
+  if (!j || j.ok === false) { say({ phase: null, message: '', error: (j && j.error) || P.updateFailed }); return; }
+  waitForRestart(j.from || from, j.log || '');
+}
+
+function updatesSection(scope) {
+  const repo = scope === 'all' ? null : activeProduct();
+  const ws = wsOfRepo(repo) || wsOfRepo(activeProduct());
+  readKitStatus(ws);
+  const st = (ws && kitByWs.get(ws) && kitByWs.get(ws).st) || null;
+  const app = st && st.app ? st.app : {};
+  const kit = st && st.kit ? st.kit : null;
+  const busy = !!upd.phase;
+  const cmp = upd.compare || {};
+  const kids = [];
+  const appLine = el('div', { class: 'fr-set__line' }, el('span', { 'data-fr': 'app-version' }, P.updatesApp(app.version)),
+    cmp.appBehind && !app.fromCheckout ? button({
+      label: P.updateApp, variant: 'primary', size: 'sm', disabled: busy, attrs: { 'data-fr': 'update-app' },
+      onClick: () => updateApp(ws, app.version),
+    }) : null);
+  kids.push(appLine);
+  if (cmp.appBehind && app.fromCheckout) kids.push(el('p', { class: 'fr-set__note', 'data-fr': 'app-checkout' }, P.updatesCheckout));
+  const kitText = scope === 'all' || !ws ? P.updatesNoRepo : !kit ? '' : kit.present ? P.updatesKit(kit.version) : P.updatesNoKit;
+  kids.push(el('div', { class: 'fr-set__line' }, el('span', { 'data-fr': 'kit-version' }, kitText),
+    cmp.kitBehind && kit && kit.present ? button({
+      label: P.updateKit, variant: 'primary', size: 'sm', disabled: busy, attrs: { 'data-fr': 'update-kit' },
+      onClick: () => updateKit(ws),
+    }) : null));
+  const line = upd.phase === 'check' ? P.updatesChecking : upd.phase === 'kit' ? P.updateKitBusy
+    : upd.message ? upd.message : upd.latest ? (cmp.appBehind || cmp.kitBehind ? P.updatesLatest(upd.latest) : P.updatesCurrent(upd.latest)) : P.updatesNever;
+  kids.push(el('p', { class: 'fr-set__note', role: 'status', 'aria-live': 'polite', 'data-fr': 'update-state' }, line));
+  if (upd.error) kids.push(el('p', { class: 'fr-set__note fr-set__error', role: 'alert', 'data-fr': 'update-error' }, upd.error));
+  if (upd.output) kids.push(el('pre', { class: 'fr-set__output', 'data-fr': 'update-output' }, upd.output));
+  kids.push(el('p', { class: 'fr-set__note' }, P.updatesNote));
+  const check = button({
+    label: P.updatesCheck, variant: 'outline', size: 'sm', icon: 'refresh-cw', disabled: busy || !ws,
+    attrs: { 'data-fr': 'check-updates' }, onClick: () => checkUpdates(ws),
+  });
+  return section('updates', P.updates, kids, check);
+}
+
 /* ── mount ────────────────────────────────────────────────────────────────────────────────────────────────────────── */
 
 function signature(scope) {
@@ -234,7 +335,9 @@ function signature(scope) {
   const addKeys = addOpen ? Object.keys(state).filter((k) => /^add[A-Z]/.test(k)).sort().map((k) => [k, state[k]]) : null;
   let add = '';
   try { add = JSON.stringify(addKeys); } catch { add = String(Date.now()); }
-  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), ws, consentByWs.get(ws) || null, addOpen, !!addMod, online.data, online.error, online.note]) + add;
+  const kit = ws ? kitByWs.get(ws) : null;
+  return JSON.stringify([repoTuples(), activeProduct(), scope, state.theme, sessionDefaults(), ws, consentByWs.get(ws) || null, addOpen, !!addMod, online.data, online.error, online.note,
+    kit ? kit.st : null, upd]) + add;
 }
 
 /** True while the PM is typing in the page or a menu of it is open: a rebuild then would take the focus away. */
@@ -262,6 +365,7 @@ export function mountDestination(host, ctx) {
     validateSection(scope),
     onlineSection(),
     themeSection(),
+    updatesSection(scope),
   ]);
 }
 

package/workspace/public/pm/frame-copy.js

@@ -170,6 +170,28 @@ export const COPY = {
     onlineEnv: (host) => `Online at https://${host}/, set by PMOS_PUBLIC_HOST when the workspace started. It signs in with the token. Restart the workspace without PMOS_PUBLIC_HOST to use this switch.`,
     onlineRemote: 'Only the computer that runs the workspace can change this.',
     onlineUnread: 'The Online settings did not load.',
+    updates: 'Updates',
+    updatesCheck: 'Check for updates',
+    updatesChecking: 'Checking for updates…',
+    updatesApp: (v) => 'Workspace app: ' + (v || 'version not known'),
+    updatesKit: (v) => 'Kit in this repository: ' + (v || 'version not recorded'),
+    updatesNoKit: 'This repository has no PMOS kit folder (pmos/), so it has no kit to update.',
+    updatesNoRepo: 'Choose a repository to see its kit.',
+    updatesNever: 'Press Check for updates to compare with the latest published version.',
+    updatesLatest: (v) => 'Latest published version: ' + v + '.',
+    updatesCurrent: (v) => 'Up to date. The latest published version is ' + v + '.',
+    updatesCheckout: 'This workspace runs from a PMOS checkout. Update it with git pull.',
+    updatesNote: 'Updating the kit changes only its own files (skills, scripts, templates and guides). Your records in state/, planning/ and okf/product/ do not change.',
+    updateKit: 'Update the kit',
+    updateKitBusy: 'Updating the kit…',
+    updateKitDone: (v) => 'The kit is now ' + v + '. The changed files are under pmos/, and Sync sends them with your other records.',
+    updateApp: 'Update the workspace',
+    updateAppTitle: 'Update the workspace?',
+    updateAppBody: (from, to) => 'The workspace stops, installs ' + to + ' in place of ' + from + ', and starts again. This takes about a minute. Sessions keep running in tmux.\n\nThis page reloads when the new version starts.',
+    updateAppBusy: 'Updating the workspace. This page reloads when the new version starts.',
+    updateAppSame: (v, log) => 'The workspace started again on ' + v + ', so the update did not finish. The update log is ' + log + '.',
+    updateAppLost: (log) => 'The workspace did not come back on this address. Type pmos in a terminal to open it. The update log is ' + log + '.',
+    updateFailed: 'The update did not finish.',
   },
 };
 

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

@@ -112,6 +112,7 @@ const modelLib = require('./lib/models');               // tier routing — one
 const memoryLib = require('./lib/memory');             // curated repository memory — one ledger code path, shared with the agents' CLI (D72)
 const audit = require('./lib/audit');                 // the workflow audit — the sweep the agents' CLI runs, read-only here (D77)
 const syncLib = require('./lib/sync');                 // press-only fetch / integrate / commit records / push (D70)
+const kitUpdate = require('./lib/kit-update.js');       // workspace-kit-update: press-only check and update of the kit and the app
 const gitInfo = require('./lib/git-info');             // read-mostly branch awareness + select/create at session start
 const startPolicy = require('./lib/start-policy');     // ONE stated rule for where a session starts (repo-first R1/R3)
 const treeShare = require('./lib/tree-share');         // who shares a working tree, and who is DECLARED to be driving it
@@ -1868,6 +1869,7 @@ function readLedger(w, basename) {
 // D70 — the lifecycle ledger: the latest line for an initiative wins; `active` reopens. The same rule
 // as scripts/workflow-state.js#readLifecycle (a parity case in workspace/test.js keeps them in step).
 const syncing = new Set();   // repositories with a sync in flight — one at a time
+let kitBusy = null;          // workspace-kit-update: the one kit or app update in flight ('kit' | 'app'), or null
 // D70 as amended 2026-10-06: the same Sync, run without the press at startup and when work sits unpushed and quiet.
 // Every rule it must pass is in lib/auto-sync.js; a scratch server (its own PMOS_STATE_DIR) does not auto-sync.
 const autoSync = require('./lib/auto-sync').createAutoSync({
@@ -3705,7 +3707,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) {
@@ -3724,6 +3727,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);
@@ -3731,6 +3748,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');
@@ -3744,7 +3768,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';
@@ -3795,6 +3819,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;
@@ -6922,6 +6947,50 @@ async function handleRequest(req, res) {
       return json(res, { ws: w.id, name: w.name, ...out });
     } finally { syncing.delete(w.root); }
   }
+  /* ── workspace-kit-update: Settings › Updates. GET reads versions from disk only. Each POST is the PM's press, and is
+   *    the only way the workspace reaches the npm registry (lib/kit-update.js; no-network.test.js holds that). ── */
+  if (p === '/api/kit/status' && req.method === 'GET') {
+    const w = getWs(url.searchParams.get('ws'));
+    if (!w) return json(res, { ok: false, error: 'no workspace' }, 400);
+    return json(res, { ok: true, ws: w.id, name: w.name, busy: kitBusy, ...kitUpdate.status({ root: w.root, appVersion: APP_VERSION, appDir: __dirname }) });
+  }
+  if ((p === '/api/kit/check' || p === '/api/kit/update' || p === '/api/kit/upgrade-app') && req.method === 'POST') {
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const g = pmGuard.requirePagePress(req, body);
+    if (!g.ok) return json(res, { ok: false, error: g.error }, g.status);
+    // A named workspace only: getWs falls back to the home repository, and an update must never land on a repository
+    // the page did not show.
+    const w = body.ws ? workspaces.get(String(body.ws)) : null;
+    if (!w) return json(res, { ok: false, error: 'no such workspace' }, 400);
+    const st = () => kitUpdate.status({ root: w.root, appVersion: APP_VERSION, appDir: __dirname });
+    if (p === '/api/kit/check') {
+      const r = await kitUpdate.latest();
+      const now = st();
+      if (!r.ok) return json(res, { ok: false, error: r.error, ws: w.id, ...now }, 502);
+      return json(res, { ok: true, ws: w.id, ...now, latest: r.version, ...kitUpdate.compare(now, r.version) });
+    }
+    if (kitBusy) return json(res, { ok: false, error: kitBusy === 'app' ? 'The workspace is already updating' : 'A kit update is already running' }, 409);
+    if (p === '/api/kit/update') {
+      kitBusy = 'kit';
+      try {
+        const r = await kitUpdate.updateKit(w.root, { version: body.version });
+        boardCache.invalidate(w.root);
+        return json(res, { ws: w.id, ...r, ...st() }, r.ok ? 200 : 502);
+      } finally { kitBusy = null; }
+    }
+    // The app update stops this server and starts a new one. It is refused from a phone: the new server starts on
+    // loopback only, so the phone that asked would lose the page. It is refused from a checkout, which git updates.
+    if (!remoteAccess.isLoopbackAddr(req.socket.remoteAddress) || remoteAccess.isProxied(req.headers, BIND.publicHost)) {
+      return json(res, { ok: false, error: 'Update the workspace from the computer it runs on' }, 403);
+    }
+    if (st().app.fromCheckout) return json(res, { ok: false, error: 'This workspace runs from a PMOS checkout. Update it with git pull' }, 409);
+    const r = kitUpdate.upgradeApp(w.root, { version: body.version, logFile: path.join(STATE, 'app-update.log') });
+    if (!r.ok) return json(res, { ok: false, error: r.error }, 400);
+    kitBusy = 'app';
+    return json(res, { ok: true, ws: w.id, from: APP_VERSION, to: body.version, log: r.log });
+  }
   /* ── next-step actions: prepare is read-only; go starts exactly what was shown; review records the PM's word ── */
   if (p === '/api/next-step/prepare' && req.method === 'POST') {
     let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
@@ -7436,6 +7505,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;
@@ -7606,7 +7684,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); }
@@ -7615,8 +7693,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 };

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:

package/workspace/test-lists/workspace-kit-update.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "workspace-kit-update: Settings › Updates — the check and the kit and app updates (lib/kit-update.js, the /api/kit routes).",
+  "modules": ["kit-update.test.js"],
+  "seconds": { "kit-update.test.js": 6 }
+}