create-pmos 0.59.0 → 0.59.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.59.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@e9f1bd9
+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-06T13:15:52Z"}
+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-06T13:15:52Z"}
+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-06T13:15:52Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T13:37:09Z"}
 status: stable
 ---
 

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.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.59.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/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

@@ -3707,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) {
@@ -3726,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);
@@ -3733,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');
@@ -3746,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';
@@ -3797,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;
@@ -7482,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;
@@ -7652,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); }
@@ -7661,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: