create-pmos 0.73.0 → 0.74.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@a99e09f
+kernel-source: pmos@fb515e5
 assembled: 2026-10-07
 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-07T05:41:12Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T07:25:37Z"}
 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-07T05:41:12Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T07:25:37Z"}
 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-07T05:41:12Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T07:25:37Z"}
 status: stable
 ---
 

package/workspace/guide/today.md

@@ -82,12 +82,33 @@ Each job has one of three kinds.
 
 | Kind | Who does it | What you do |
 |---|---|---|
-| you | Only you. | Do it. Nothing runs for it. |
+| you | Only you. | Do it, then mark it. See [Jobs you do and meetings you prepare for](#jobs-you-do-and-meetings-you-prepare-for). |
 | approve | An agent prepares one draft. | Read the draft. Press **Approve** to let the one outward step happen, or **Revise** with a note. |
 | auto | An agent does it, and nothing leaves the computer. | Read the result. Press **Revise** if it is wrong. |
 
 A draft that waits for you shows its summary, its text and the link of the place it is for. **Approve** sends only that text, to that place. **Revise** takes a note of at most 500 characters and asks for a new draft. You can revise a job 3 times. A fourth revise is refused, so do the job yourself or drop it. A failed job shows its reason and **Retry**.
 
+### Jobs you do and meetings you prepare for
+
+A job that only you can do starts with a verb, such as **Reply**, **Review** or **Sign off**, and one sentence that says what to do. Under the sentence are who asked, why it is for today, and the steps. Check each step when you finish it. The first button opens the place where you do the job, for example **Reply in Slack**. **Have the agent draft it** gives the job to an agent. The draft then waits for your approval, as for any approve job.
+
+A job card holds what you need to do the job without opening another file. **The conversation** shows the last messages, up to 4. A step that reads a source shows what the source says, in a few lines, under the step. **What the sources say** shows the other sources. **Open the source** opens the source itself when you want more.
+
+When the job is a reply or a review, you can finish it in the card. Write your answer in the box, or press a suggestion to start from it. For a review, choose **Approve** or **Ask for changes**. Then press **Send to …**. An agent posts exactly your text, as you, to the place the button names. Nothing else is sent, and nothing is sent before you press. The job then shows **Sending**, and **Sent** when it is posted. If the send fails, the job shows the reason and **Retry**, which sends the same text again.
+
+A meeting that needs prep is a row of **Needs you**, with the verb **Prepare**. Its detail shows the prep, how many steps are ready, the free time before the meeting, and the steps before it. A step that reads a source shows what the source says under it. A step that asks for your view, such as **Write your recommendation**, has a box for your note. The note is saved when you leave the box. It stays with the meeting on this computer and is not sent. A step that the brief already marked done stays checked.
+
+When you finish or put off a job or a meeting, mark it:
+
+| Press | What it does |
+|---|---|
+| **Mark done** (a meeting: **Mark ready**) | Moves it to **Done today**. |
+| **Snooze** (a meeting: **Remind me**) | Moves it to **Snoozed** until a time later today. At that time it comes back to **Needs you**. |
+| **Waiting on…** | Puts a job on hold. Write who or what you wait on, and when to ask again today. It shows in **Waiting on others** until that time. |
+| **Not mine** (a meeting: **Skip prep**) | Takes it off **Needs you**, with a reason. |
+
+Each press shows **Undo**. **Bring it back now** or **Reopen** puts a marked item back in **Needs you**. A mark lasts for the day. A mark does not send anything and does not change the source. Only **Send to …** sends, and only your text. **Snoozed**, **Waiting on others** and **Done today** are folded. Press a group to open it.
+
 The page also shows which sources were read and how many items each gave, and the next daytime check. **Check now** starts a check at once.
 
 ## What waits for you

package/workspace/lib/brief.js

@@ -41,6 +41,8 @@ const EFFORTS = ['minutes', 'an-hour', 'half-day', 'day'];
 const KINDS = ['you', 'approve', 'auto'];
 const DIGEST_SOURCES = ['slack', 'jira', 'confluence'];
 const STEP_WHEN = ['before', 'during', 'after'];
+// The verb of an item the PM acts on (initiative today-act-prepare, PRD A2): the chip Your day shows first.
+const VERBS = ['reply', 'review', 'decide', 'sign-off', 'read', 'do'];
 const WORTH_ASKING = 0.5;
 const MAX_ITEMS = 30;
 const MAX_EVENTS = 20;
@@ -95,6 +97,10 @@ function eventExtras(e, at, sources) {
     const err = optText(e[k], n, `${at}: ${k}`); if (err) return { error: err };
     if (typeof e[k] === 'string' && e[k].trim()) f[k] = clip(e[k], n);
   }
+  // The sources the PM reads to prepare, each in a few lines, so no other file needs opening (PRD X2).
+  const refs = refList(e.refs, at);
+  if (refs.error) return refs;
+  if (refs.refs.length) f.refs = refs.refs;
   if (e.steps !== undefined && e.steps !== null) {
     if (typeof e.steps !== 'object' || Array.isArray(e.steps)) return { error: `${at}: steps must be {before, during, after}` };
     for (const k of Object.keys(e.steps)) if (!STEP_WHEN.includes(k)) return { error: `${at}: steps has "${k}" — only ${STEP_WHEN.join(', ')}` };
@@ -112,7 +118,10 @@ function eventExtras(e, at, sources) {
         if (tooLong(st.t, 140)) return { error: `${sa}: t is over 140 characters` };
         if (!OWNERS.includes(st.who)) return { error: `${sa}: who must be one of ${OWNERS.join(', ')}` };
         if (st.done !== undefined && typeof st.done !== 'boolean') return { error: `${sa}: done must be true or false` };
-        steps[k].push({ t: clip(st.t, 140), who: st.who, done: st.done === true });
+        if (st.ref !== undefined && st.ref !== null && !(Number.isInteger(st.ref) && st.ref >= 0 && st.ref < refs.refs.length)) return { error: `${sa}: ref must name one of the refs` };
+        if (st.note !== undefined && typeof st.note !== 'boolean') return { error: `${sa}: note must be true or false` };
+        if (st.note && (k !== 'before' || st.who !== 'pm')) return { error: `${sa}: note is for a step the PM does before the meeting` };
+        steps[k].push({ t: clip(st.t, 140), who: st.who, done: st.done === true, ...(Number.isInteger(st.ref) ? { ref: st.ref } : {}), ...(st.note ? { note: true } : {}) });
       }
     }
     f.steps = steps;
@@ -177,9 +186,86 @@ function itemExtras(x, at) {
   if (!KINDS.includes(kind)) return { error: `${at}: kind must be one of ${KINDS.join(', ')}` };
   if (x.owner === 'pm' && kind !== 'you') return { error: `${at}: an item the PM owns has kind "you" — "${kind}" is for an item the agent owns` };
   f.kind = kind;
+  // What the PM does, said once (PRD A2): a verb, one sentence, a due time and at most 4 steps. All optional.
+  if (x.verb !== undefined && x.verb !== null) {
+    if (!VERBS.includes(x.verb)) return { error: `${at}: verb must be one of ${VERBS.join(', ')}` };
+    f.verb = x.verb;
+  }
+  const terr = optText(x.todo, 200, `${at}: todo`);
+  if (terr) return { error: terr };
+  if (typeof x.todo === 'string' && x.todo.trim()) f.todo = clip(x.todo, 200);
+  // The context the PM reads in the card, so no other file needs opening (PRD X1, X2), and where the PM's own answer goes
+  // (PRD F1). All optional.
+  const ctx = cardContext(x, at);
+  if (ctx.error) return { error: ctx.error };
+  Object.assign(f, ctx.fields);
+  if (x.due !== undefined && x.due !== null) {
+    if (typeof x.due !== 'string' || Number.isNaN(Date.parse(x.due))) return { error: `${at}: due must be a date and time` };
+    f.due = x.due;
+  }
+  const st = stepList(x.steps, 4, f.refs ? f.refs.length : 0, at);
+  if (st.error) return { error: st.error };
+  if (st.steps.length) f.steps = st.steps;
   return { fields: f };
 }
 
+/* The messages of the conversation (at most 4) and the sources it points to, each read in a few lines (at most 3). */
+function cardContext(x, at) {
+  const f = {};
+  if (x.thread !== undefined && x.thread !== null) {
+    if (!Array.isArray(x.thread) || x.thread.length > 4) return { error: `${at}: thread must be a list of at most 4 messages` };
+    const thread = [];
+    for (const [i, m] of x.thread.entries()) {
+      const w = `${at}: thread message ${i + 1}`;
+      if (!m || typeof m !== 'object' || typeof m.text !== 'string' || !m.text.trim()) return { error: `${w} needs text` };
+      const e = optText(m.text, 280, `${w} text`) || optText(m.who, 80, `${w} who`) || optText(m.at, 20, `${w} at`);
+      if (e) return { error: e };
+      thread.push({ who: m.who ? clip(m.who, 80) : null, at: m.at ? clip(m.at, 20) : null, text: clip(m.text, 280) });
+    }
+    if (thread.length) f.thread = thread;
+  }
+  const refs = refList(x.refs, at);
+  if (refs.error) return refs;
+  if (refs.refs.length) f.refs = refs.refs;
+  if (x.send !== undefined && x.send !== null) {
+    const sd = x.send;
+    if (typeof sd !== 'object' || Array.isArray(sd)) return { error: `${at}: send must be {to, suggest}` };
+    const e = optText(sd.to, 120, `${at}: send.to`) || optLines(sd.suggest, 3, 280, `${at}: send.suggest`);
+    if (e) return { error: e };
+    if (sd.review !== undefined && typeof sd.review !== 'boolean') return { error: `${at}: send.review must be true or false` };
+    f.send = { to: sd.to ? clip(sd.to, 120) : null, suggest: lines(sd.suggest, 280), ...(sd.review ? { review: true } : {}) };
+  }
+  return { fields: f };
+}
+function refList(v, at) {
+  if (v === undefined || v === null) return { refs: [] };
+  if (!Array.isArray(v) || v.length > 3) return { error: `${at}: refs must be a list of at most 3 sources` };
+  const refs = [];
+  for (const [i, r] of v.entries()) {
+    const w = `${at}: ref ${i + 1}`;
+    if (!r || typeof r !== 'object' || typeof r.label !== 'string' || !r.label.trim()) return { error: `${w} needs a label` };
+    const e = optText(r.label, 120, `${w} label`) || optText(r.source, 20, `${w} source`) || optLink(r.link, `${w} link`) || optLines(r.lines, 5, 200, `${w} lines`);
+    if (e) return { error: e };
+    if (!Array.isArray(r.lines) || !r.lines.length) return { error: `${w} needs lines: what the source says, in your words` };
+    refs.push({ label: clip(r.label, 120), source: r.source ? clip(r.source, 20) : null, link: r.link || null, lines: lines(r.lines, 200) });
+  }
+  return { refs };
+}
+/* Steps of an item: text, or {t, ref} where ref is the index of the source the step reads. */
+function stepList(v, max, nRefs, at) {
+  if (v === undefined || v === null) return { steps: [] };
+  if (!Array.isArray(v) || v.length > max) return { error: `${at}: steps must be a list of at most ${max}` };
+  const steps = [];
+  for (const [i, s] of v.entries()) {
+    const o = typeof s === 'string' ? { t: s } : s;
+    if (!o || typeof o !== 'object' || typeof o.t !== 'string' || !o.t.trim()) return { error: `${at}: step ${i + 1} must be text` };
+    if (tooLong(o.t, 140)) return { error: `${at}: step ${i + 1} is over 140 characters` };
+    if (o.ref !== undefined && o.ref !== null && !(Number.isInteger(o.ref) && o.ref >= 0 && o.ref < nRefs)) return { error: `${at}: step ${i + 1}: ref must name one of the refs` };
+    steps.push(Number.isInteger(o.ref) ? { t: clip(o.t, 140), ref: o.ref } : { t: clip(o.t, 140) });
+  }
+  return { steps };
+}
+
 /* The fixed order of items: higher confidence first, then PM-owned before agent-owned, then by title. */
 function sortItems(items) {
   return items.sort((a, b) => b.confidence - a.confidence || (a.owner === b.owner ? 0 : a.owner === 'pm' ? -1 : 1) || a.title.localeCompare(b.title));
@@ -419,5 +505,5 @@ function rereadBrief(stored, incoming) {
     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,
+module.exports = { VERBS, SOURCES, ITEM_SOURCES, SOURCE_STATES, OWNERS, EFFORTS, KINDS, DIGEST_SOURCES, WORTH_ASKING, MAX_ITEMS, MAX_EVENTS, MAX_DIGESTS, MAX_PLACES,
   isUrl, validateBrief, mergeBrief, rereadBrief, greeting, localDate };

package/workspace/lib/day-marks.js

@@ -0,0 +1,163 @@
+'use strict';
+/* day-marks.js — the PM's marks on today's items and meetings (initiative `today-act-prepare`, PRD M1 to M6).
+ *
+ * A brief item the PM owns, or a meeting with prep, used to stay in Needs you all day: nothing the PM did changed it.
+ * A mark is what the PM did with it: done (a meeting: ready), snoozed until a time, waiting on someone until a time, or
+ * dismissed with a reason (not mine, or skip prep). A mark also holds the steps the PM checked, by their text.
+ *
+ * PURE: no I/O and no clock of its own. The server reads goals/<date>.marks.json, passes it with `now` and the ids of
+ * today's brief, and writes what `edit` returns. A refused edit returns the reason and the caller writes nothing.
+ *
+ *   emptyMarks(date)                       → { date, marks: {} }
+ *   readMarks(raw, date)                   → a checked record, or an empty one when `raw` is not one for `date`
+ *   edit(rec, op, { now, known })          → { ok:true, rec, mark, prev } | { ok:false, error }
+ *        op: { action: 'done' | 'reopen', id }
+ *            | { action: 'snooze', id, until }            until: a time later today
+ *            | { action: 'hold', id, on, until }          on: who or what (1 to 80 characters), until: a time later today
+ *            | { action: 'dismiss', id, why }             why: no-action | someone-else | done-elsewhere (an item)
+ *                                                               nothing | elsewhere (a meeting)
+ *            | { action: 'step', id, step, done }         step: the step's text, done: true | false
+ *            | { action: 'note', id, text }               the PM's own note, written in the card (at most 1000
+ *                                                               characters; empty clears it). It stays on this machine.
+ *            | { action: 'restore', id, mark }            mark: a `prev` an earlier edit returned, or null (Undo)
+ *        known: Map of today's ids → 'item' | 'event'. An id not in it is refused.
+ *   effective(rec, now)                    → { id: mark } with a snooze or hold whose time has passed read as open
+ *
+ * A mark lasts for its day: brief item ids are per day (lib/brief.js), so a snooze or a hold ends at midnight.
+ */
+
+const STATES = ['done', 'snoozed', 'waiting', 'dismissed'];
+const ACTIONS = ['done', 'reopen', 'snooze', 'hold', 'dismiss', 'step', 'note', 'restore'];
+const KINDS = ['item', 'event'];
+const REASONS = { item: ['no-action', 'someone-else', 'done-elsewhere'], event: ['nothing', 'elsewhere'] };
+const ID_RE = /^[0-9a-f]{12}$/;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const MAX_IDS = 400;
+const MAX_STEPS = 12;
+const MAX_STEP = 140;
+const MAX_ON = 80;
+const MAX_NOTE = 1000;
+
+const clip = (s, n) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, n);
+const pad = (n) => String(n).padStart(2, '0');
+const localDate = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+const iso = (ms) => new Date(ms).toISOString();
+
+const emptyMarks = (date) => ({ date, marks: {} });
+
+/** One mark read from disk or from an Undo, checked. Returns the clean mark, or null when it is not one. */
+function cleanMark(m, date) {
+  if (!m || typeof m !== 'object' || Array.isArray(m) || !KINDS.includes(m.kind)) return null;
+  const state = m.state === null || m.state === undefined ? null : m.state;
+  if (state !== null && !STATES.includes(state)) return null;
+  const out = { kind: m.kind, state, at: typeof m.at === 'string' ? m.at : null };
+  if (state === 'snoozed' || state === 'waiting') {
+    const t = Date.parse(m.until);
+    if (!Number.isFinite(t) || localDate(t) !== date) return null;
+    out.until = iso(t);
+  }
+  if (state === 'waiting') { const on = clip(m.on, MAX_ON); if (!on) return null; out.on = on; }
+  if (state === 'dismissed') { if (!REASONS[m.kind].includes(m.why)) return null; out.why = m.why; }
+  const steps = Array.isArray(m.steps) ? [...new Set(m.steps.map((s) => clip(s, MAX_STEP)).filter(Boolean))].slice(0, MAX_STEPS) : [];
+  if (steps.length) out.steps = steps;
+  if (typeof m.note === 'string' && m.note.trim()) out.note = m.note.trim().slice(0, MAX_NOTE);
+  return out;
+}
+
+/** A marks record read from disk, checked. Anything that is not one for `date` reads as an empty record. */
+function readMarks(raw, date) {
+  if (!raw || typeof raw !== 'object' || raw.date !== date || !raw.marks || typeof raw.marks !== 'object') return emptyMarks(date);
+  const marks = {};
+  for (const [id, m] of Object.entries(raw.marks).slice(0, MAX_IDS)) {
+    if (!ID_RE.test(id)) continue;
+    const c = cleanMark(m, date);
+    if (c) marks[id] = c;
+  }
+  return { date, marks };
+}
+
+/** A time later today, or the reason it is not one. */
+function laterToday(v, now, date) {
+  const t = typeof v === 'number' ? v : Date.parse(v);
+  if (!Number.isFinite(t)) return { error: 'until must be a date and time' };
+  if (t <= now) return { error: 'until must be later than now' };
+  if (localDate(t) !== date) return { error: 'until must be today: a mark ends with the day' };
+  return { at: t };
+}
+
+function edit(rec, op, { now = Date.now(), known } = {}) {
+  if (!rec || !DATE_RE.test(String(rec.date)) || !rec.marks || typeof rec.marks !== 'object') return { ok: false, error: 'no marks record to edit' };
+  if (!op || typeof op !== 'object' || !ACTIONS.includes(op.action)) return { ok: false, error: `action must be one of ${ACTIONS.join(', ')}` };
+  const id = String(op.id || '');
+  if (!ID_RE.test(id)) return { ok: false, error: 'id must be the id of an item or a meeting of today\'s brief' };
+  const kind = known && typeof known.get === 'function' ? known.get(id) : null;
+  if (!KINDS.includes(kind)) return { ok: false, error: 'no item or meeting with that id in today\'s brief' };
+  if (localDate(now) !== rec.date) return { ok: false, error: `the marks are for ${rec.date}, and today is ${localDate(now)}` };
+  const marks = { ...rec.marks };
+  const prev = marks[id] ? JSON.parse(JSON.stringify(marks[id])) : null;
+  const cur = prev ? { ...prev } : { kind, state: null, at: null };
+  cur.kind = kind;
+  const at = iso(now);
+  const setState = (state, extra) => {
+    delete cur.until; delete cur.on; delete cur.why;
+    Object.assign(cur, { state, at }, extra || {});
+  };
+
+  if (op.action === 'restore') {
+    if (op.mark === null || op.mark === undefined) { delete marks[id]; return { ok: true, rec: { date: rec.date, marks }, mark: null, prev }; }
+    const c = cleanMark({ ...op.mark, kind }, rec.date);
+    if (!c) return { ok: false, error: 'mark is not a mark of this item' };
+    marks[id] = c;
+    return { ok: true, rec: { date: rec.date, marks }, mark: c, prev };
+  }
+  if (op.action === 'step') {
+    const step = clip(op.step, MAX_STEP);
+    if (!step) return { ok: false, error: 'step must be the text of a step' };
+    if (typeof op.done !== 'boolean') return { ok: false, error: 'done must be true or false' };
+    const steps = new Set(cur.steps || []);
+    if (op.done) steps.add(step); else steps.delete(step);
+    if (steps.size > MAX_STEPS) return { ok: false, error: `at most ${MAX_STEPS} steps are kept for one item` };
+    if (steps.size) cur.steps = [...steps]; else delete cur.steps;
+  } else if (op.action === 'note') {
+    if (typeof op.text !== 'string') return { ok: false, error: 'text must be the note' };
+    if (op.text.trim().length > MAX_NOTE) return { ok: false, error: `the note is over ${MAX_NOTE} characters` };
+    if (op.text.trim()) cur.note = op.text.trim(); else delete cur.note;
+  } else if (op.action === 'done') {
+    if (cur.state === 'done') return { ok: false, error: kind === 'event' ? 'that meeting is already marked ready' : 'that item is already done' };
+    setState('done');
+  } else if (op.action === 'reopen') {
+    if (cur.state === null) return { ok: false, error: 'that item is already open' };
+    setState(null);
+  } else if (op.action === 'snooze') {
+    const t = laterToday(op.until, now, rec.date);
+    if (t.error) return { ok: false, error: t.error };
+    setState('snoozed', { until: iso(t.at) });
+  } else if (op.action === 'hold') {
+    if (kind !== 'item') return { ok: false, error: 'a meeting is not put on hold: snooze it, or skip prep' };
+    const on = clip(op.on, MAX_ON);
+    if (!on) return { ok: false, error: `on must say who or what you wait on, in 1 to ${MAX_ON} characters` };
+    if (typeof op.on === 'string' && op.on.trim().length > MAX_ON) return { ok: false, error: `on is over ${MAX_ON} characters` };
+    const t = laterToday(op.until, now, rec.date);
+    if (t.error) return { ok: false, error: t.error };
+    setState('waiting', { on, until: iso(t.at) });
+  } else if (op.action === 'dismiss') {
+    if (!REASONS[kind].includes(op.why)) return { ok: false, error: `why must be one of ${REASONS[kind].join(', ')}` };
+    setState('dismissed', { why: op.why });
+  }
+  if (!marks[id] && Object.keys(marks).length >= MAX_IDS) return { ok: false, error: `at most ${MAX_IDS} marks a day` };
+  const clean = cleanMark(cur, rec.date);
+  if (clean.state === null && !clean.steps && !clean.note) delete marks[id]; else marks[id] = clean;
+  return { ok: true, rec: { date: rec.date, marks }, mark: marks[id] || null, prev };
+}
+
+/** The marks as the page shows them now: a snooze or a hold whose time has passed is open again, with `back: true`. */
+function effective(rec, now = Date.now()) {
+  const out = {};
+  for (const [id, m] of Object.entries((rec && rec.marks) || {})) {
+    const passed = (m.state === 'snoozed' || m.state === 'waiting') && Date.parse(m.until) <= now;
+    out[id] = passed ? { ...m, state: null, back: true, was: m.state } : { ...m };
+  }
+  return out;
+}
+
+module.exports = { STATES, ACTIONS, REASONS, MAX_ON, MAX_STEPS, MAX_NOTE, emptyMarks, readMarks, edit, effective };

package/workspace/lib/day-run.js

@@ -15,6 +15,7 @@
  *   newRun(date, now) · readRun(raw, date)
  *   addTasks(run, brief)                       agent priorities (kind approve|auto) → waiting tasks
  *   addBriefed(run, spec)                      one task the PM briefed in My work (initiative my-work, PRD R5)
+ *   addSend(run, spec, now)                    the PM's own text, written in the card, to post as written (today-act-prepare)
  *   toStart(run, limit)                        the tasks to start now, each with its mode (do | revise | send)
  *   started · deliver · decide · sent · fail · sessionEnded · sessionStalled
  *   stage(run, brief)                          reading | working | review | done
@@ -113,7 +114,8 @@ function addTasks(run, brief) {
 }
 
 /**
- * One task the PM briefed in My work: kind approve, with the PM's instruction and the item's context card on it, so the
+ * One task the PM briefed in My work, or a job of Your day the PM gave to the agent (`item_id`, initiative
+ * today-act-prepare, PRD C2): kind approve, with the PM's instruction and the item's context card on it, so the
  * day-task session reads the instruction as the ask (PRD R5, R6). `spec` is lib/my-work.js taskSpec. A run opened only
  * for this (no Prepare my day yet) is marked `opened_by: 'my-work'`, so it does not read as a morning read that failed.
  */
@@ -124,12 +126,43 @@ function addBriefed(run, spec) {
   if (!text(s.instruction)) return { ok: false, error: 'a briefed task needs the PM\'s instruction' };
   if (findTask(run, s.id)) return { ok: false, error: `task ${s.id} is already in today's run` };
   const next = clone(run);
-  next.tasks.push({ id: s.id, item_id: null, title: text(s.title).slice(0, 250) || s.id, kind: 'approve', source: s.source || 'my-work', link: isUrl(s.link) ? s.link : null,
+  next.tasks.push({ id: s.id, item_id: /^[0-9a-f]{12}$/.test(String(s.item_id || '')) ? s.item_id : null, title: text(s.title).slice(0, 250) || s.id, kind: 'approve', source: s.source || 'my-work', link: isUrl(s.link) ? s.link : null,
     goal: null, my_work: s.my_work || null, brief_at: s.brief_at || null, instruction: text(s.instruction), context: s.context && typeof s.context === 'object' ? clone(s.context) : null,
     status: 'waiting', session_id: null, started_at: null, attempts: 0, revisions: [], draft: null, decided: null, error: null });
   return { ok: true, run: next, added: s.id };
 }
 
+/**
+ * The PM's own text, written in a Your day card, to post as written (initiative today-act-prepare, PRD F1 to F3). The press
+ * IS the approval: the task goes straight to `sending` with the PM's text as its draft (`by: 'pm'`), and one send session
+ * does that one outward step. A task already in the run for the item (the agent's draft) takes the PM's text instead.
+ * `spec`: { id, item_id, title, source, link, to, text, verdict? }.
+ */
+function addSend(run, spec, now) {
+  if (!run) return { ok: false, error: 'no day run today' };
+  const s = spec && typeof spec === 'object' ? spec : {};
+  if (!TASK_RE.test(String(s.id || ''))) return { ok: false, error: 'a task needs an id like t-0123456789ab' };
+  const body = typeof s.text === 'string' ? s.text.trim() : '';
+  if (!body) return { ok: false, error: 'write the text to send' };
+  if (body.length > 4000) return { ok: false, error: 'the text is over 4000 characters' };
+  const to = text(s.to).slice(0, 120) || 'the place it came from';
+  const what = s.verdict === 'approve' ? 'review, approving' : s.verdict === 'changes' ? 'review, asking for changes' : 'reply';
+  const at = iso(now);
+  const draft = { summary: `The PM's own ${what}: post it as written to ${to}`.slice(0, 240), body, link: isUrl(s.link) ? s.link : null, at, by: 'pm' };
+  const next = clone(run);
+  const t = findTask(next, s.id);
+  if (t) {
+    if (['working', 'sending', 'sent'].includes(t.status)) return { ok: false, error: `task ${s.id} is ${t.status} — wait for it, or open its session` };
+    keepSession(t);
+    Object.assign(t, { kind: 'approve', status: 'sending', draft, decided: { action: 'approve', at, by: 'pm' }, error: null, started_at: null });
+    return { ok: true, run: next, task: s.id };
+  }
+  next.tasks.push({ id: s.id, item_id: /^[0-9a-f]{12}$/.test(String(s.item_id || '')) ? s.item_id : null, title: text(s.title).slice(0, 250) || s.id, kind: 'approve',
+    source: s.source || 'today', link: isUrl(s.link) ? s.link : null, goal: null, instruction: `Post the PM's own text exactly as written to ${to}. Change nothing.`,
+    status: 'sending', session_id: null, started_at: null, attempts: 0, revisions: [], draft, decided: { action: 'approve', at, by: 'pm' }, error: null });
+  return { ok: true, run: next, task: s.id };
+}
+
 /**
  * The tasks to start now, oldest first, so that the sessions running (working, and sending with a session) stay at
  * most `limit`. An approved task waiting for its send session comes first: the PM is waiting on it.
@@ -208,7 +241,8 @@ function decide(run, taskId, op, now) {
     }
     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 };
+    // the PM's own text is sent again as it is: a retry never asks an agent to draft over it
+    t.status = t.draft && t.draft.by === 'pm' ? 'sending' : '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;
   });
@@ -350,5 +384,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, addBriefed, toStart, started, deliver, decide, sent, fail, sessionEnded, sessionStalled, stage, intervalMin,
+  newRun, readRun, findTask, modeOf, addTasks, addBriefed, addSend, 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.73.0",
+  "version": "0.74.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

@@ -3346,6 +3346,40 @@
 .td-day__draftbox { display: grid; gap: 4px; }
 .td-day__draft { margin: 0; max-height: 220px; overflow: auto; padding: 8px 10px; white-space: pre-wrap; font: 12px/1.5 var(--mono); background: var(--muted); color: var(--foreground); }
 .td-day__revise { display: grid; gap: 6px; }
+/* act and prepare (initiative today-act-prepare): a verb first, one sentence, the steps, one button that fits, the marks */
+.td-day__verb { display: inline-block; min-width: 58px; padding: 2px 5px; border: 1px solid currentColor; font: 600 10px/1.3 var(--mono); letter-spacing: 0.05em; text-transform: uppercase; text-align: center; color: var(--foreground); white-space: nowrap; }
+.td-day__verb[data-verb="decide"], .td-day__verb[data-verb="prepare"] { color: var(--warning); }
+.td-day__acth { margin: 0; font-size: 16px; font-weight: 600; line-height: 1.3; text-wrap: balance; }
+.td-day__todo { margin: 0; padding: 7px 10px; border-left: 3px solid var(--foreground); background: var(--muted); font-size: 14px; line-height: 1.45; color: var(--foreground); }
+.td-day__steps2 { list-style: none; margin: 0; padding: 0; display: grid; gap: 4px; }
+.td-day__step2 { display: flex; align-items: center; justify-content: space-between; gap: 8px; padding: 5px 8px; border: 1px solid var(--border); background: var(--background); }
+.td-day__step2[data-done="true"] .td-day__steprow { text-decoration: line-through; color: var(--muted-foreground); }
+.td-day__marks { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; padding-top: 8px; border-top: 1px solid var(--border); }
+.td-day__grow { flex: 1 1 0; }
+.td-day__mark { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 10px; padding: 6px 10px; border: 1px solid var(--border); background: var(--muted); font-size: 14px; }
+.td-day__mark[data-day-mark-state="done"] { border-color: var(--foreground); }
+.td-day__ready { display: flex; flex-wrap: wrap; align-items: center; gap: 6px 12px; font-size: 12px; }
+.td-day__prep { display: grid; gap: 8px; padding: 10px 12px; border: 1px solid var(--border); background: var(--background); }
+.td-day__fold { border-top: 1px solid var(--border); padding-top: 6px; }
+.td-day__fold > summary { cursor: pointer; font-size: 12px; color: var(--muted-foreground); }
+.td-day__fold[open] > summary { margin-bottom: 6px; }
+.td-day__fold > summary:focus-visible, .td-day__fold[open] > summary:focus-visible, .td-day__ref > summary:focus-visible { outline: 2px solid color-mix(in oklab, var(--ring) 50%, var(--foreground)); outline-offset: 2px; }
+@media (pointer: coarse) { .td-day__fold > summary, .td-day__fold[open] > summary, .td-day__ref > summary { min-height: 44px; } }
+.td-day__fold-head { justify-self: start; }
+.td-day__steprow { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
+.td-day__step2:has(.td-day__ref), .td-day__step2:has(.td-day__notebox) { flex-direction: column; align-items: stretch; }
+.td-day__ref { display: grid; gap: 4px; padding: 6px 8px; background: var(--muted); font-size: 14px; }
+.td-day__ref > summary { display: flex; justify-content: space-between; gap: 8px; cursor: pointer; font-weight: 600; color: var(--foreground); }
+.td-day__reflines { margin: 0; padding-left: 18px; display: grid; gap: 2px; color: var(--foreground); line-height: 1.45; }
+.td-day__thread { display: grid; gap: 6px; }
+.td-day__msg { display: grid; gap: 2px; padding: 6px 10px; border-left: 2px solid var(--border); }
+.td-day__msg p { margin: 0; font-size: 14px; line-height: 1.45; color: var(--foreground); }
+.td-day__msg--last { border-left-color: var(--foreground); }
+.td-day__compose { display: grid; gap: 6px; padding: 8px 10px; border: 1px solid var(--border); background: var(--background); }
+.td-day__chipsrow { display: flex; flex-wrap: wrap; align-items: center; gap: 4px; }
+.td-day__notebox { display: grid; gap: 4px; }
+.td-day__a--primary { background: var(--primary); color: var(--primary-foreground); border-color: var(--primary); }
+@media (hover: hover) { .td-day__a--primary:hover { color: var(--primary-foreground); opacity: 0.9; } }
 .td-day__log { font-size: 12px; color: var(--muted-foreground); }
 .td-day__ch { display: grid; grid-template-columns: minmax(0, 1fr) auto; align-items: center; gap: 8px; font-size: 14px; color: var(--foreground); }
 .td-day__slist { display: grid; }

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

@@ -159,7 +159,7 @@ export const COPY = {
     all: 'All',
     status2: {
       waiting: 'waiting', working: 'agent working', review: 'approve', reviewAuto: 'check it', sending: 'sending', sent: 'sent',
-      done: 'done', failed: 'failed', you: 'your act', notStarted: 'not started', handled: 'handled', replyNeeded: 'reply needed',
+      done: 'done', failed: 'failed', notStarted: 'not started', handled: 'handled', replyNeeded: 'reply needed',
     },
     newItem: 'new',
     pill: { prepare: 'prepare', ready: 'ready', ended: 'ended', notes: 'notes', goal: (n) => `goal ${n}` },
@@ -189,8 +189,6 @@ export const COPY = {
     prep: 'Prepare',
     phases: { before: 'Before', during: 'During', after: 'After' },
     who: { pm: 'you', agent: 'agent' },
-    needPrep: 'You need to prepare',
-    nothingToPrep: 'Nothing to prepare',
     initiative: 'Initiative',
     suggested: (why) => `Suggested. ${why}`,
     openInitiative: 'Open the initiative',
@@ -235,7 +233,6 @@ export const COPY = {
     waitingNote: 'The agent has not started this job yet. At most 5 sessions run at once.',
     workingNote: 'An agent session is doing this job now.',
     sendingNote: 'You said yes to this draft. An agent session is sending it now.',
-    youNote: 'Only you can do this one. The link opens the conversation.',
     autoNote: 'The agent did this alone. Nothing went outside this machine.',
     notTask: 'The agent starts this job when you press Prepare my day.',
     related: 'Related',
@@ -351,6 +348,87 @@ export const COPY = {
       today: 'Today',
     },
   },
+  /** The items the PM acts on and the meetings the PM prepares for (initiative today-act-prepare, PRD A1 to D4). A verb
+   *  first, one sentence of what to do, then the steps, one button that fits the first open step, and the marks. */
+  act: {
+    verb: { reply: 'Reply', review: 'Review', decide: 'Decide', 'sign-off': 'Sign off', read: 'Read', do: 'Do', prepare: 'Prepare', approve: 'Approve' },
+    groups: { later: 'Snoozed', waiting: 'Waiting on others', done: 'Done today' },
+    by: (at) => `by ${at}`,
+    at: (at) => `at ${at}`,
+    left: (min) => (min <= 0 ? 'now' : min < 60 ? `in ${min} min` : `in ${Math.floor(min / 60)} h ${min % 60} min`),
+    back: (at) => `back ${at}`,
+    check: (at) => `ask ${at}`,
+    chip: { done: 'done', ready: 'ready', dismissed: 'not mine', skipped: 'no prep', today: 'today' },
+    from: (who, where) => (who && where ? `${who} in ${where}` : who || where || ''),
+    howTitle: (d, n) => `How to do it · ${d} of ${n}`,
+    beforeTitle: (at) => `Before ${at}`,
+    more: 'More context',
+    moreMeeting: (during, after) => `In the meeting (${during}) · After (${after})`,
+    readOnly: 'Read only. Nothing is sent before you press a button that says so.',
+    open: { slack: 'Reply in Slack ↗', jira: 'Open in Jira ↗', confluence: 'Open in Confluence ↗', github: 'Open on GitHub ↗', figma: 'Open in Figma ↗',
+      mail: 'Open the mail ↗', drive: 'Open in Google Drive ↗', calendar: 'Open the event ↗', wispr: 'Open the notes ↗', website: 'Open the page ↗' },
+    openLink: 'Open the link ↗',
+    startStep: (t) => `Start: ${t}`,
+    askAgentStep: 'Ask the agent',
+    draft: 'Have the agent draft it',
+    drafting: 'The agent is drafting. The draft shows here, and nothing is sent before you approve it.',
+    draftStarted: 'The agent is drafting it. Approve or revise the draft when it is ready.',
+    done: 'Mark done',
+    ready: 'Mark ready',
+    snooze: 'Snooze',
+    remind: 'Remind me',
+    hold: 'Waiting on…',
+    notMine: 'Not mine',
+    skip: 'Skip prep',
+    snoozeTo: { hour: 'In 1 hour', later: 'Later today, 16:00', due: 'Before it is due', end: 'End of the day, 17:30', m30: '30 min before it', m15: '15 min before it' },
+    holdWho: 'Who or what you wait on',
+    holdHint: 'For example: Raj, or the cost model',
+    holdWhen: 'Ask again',
+    holdWhenOpts: { h2: 'In 2 hours', end: 'At 17:30' },
+    holdGo: 'Put on hold',
+    holdNeed: 'Say who or what you wait on, in 1 to 80 characters.',
+    why: { 'no-action': 'No action needed', 'someone-else': 'Someone else handles it', 'done-elsewhere': 'It is already done', nothing: 'Nothing to prepare', elsewhere: 'I prepare elsewhere' },
+    did: {
+      done: (t) => `Done: ${t}.`, ready: (t) => `Ready: ${t}.`, snooze: (at) => `Snoozed. It comes back at ${at}.`,
+      hold: (who, at) => `Waiting on ${who}. Today asks you again at ${at}.`, dismiss: (why) => `${why}. Taken off Needs you.`, reopen: 'Back in Needs you.',
+    },
+    undo: 'Undo',
+    undone: 'Put back as it was.',
+    state: {
+      snoozed: (at) => `Snoozed. It comes back to Needs you at ${at}.`,
+      waiting: (who, at) => `On hold: waiting on ${who}. Today asks you again at ${at}.`,
+      done: (at) => `Done at ${at}.`, ready: (at) => `Ready at ${at}.`,
+      dismissed: (why) => `Not on your list: ${why}.`,
+      back: 'Back from snooze or hold: the time you set has come.',
+    },
+    bringBack: 'Bring it back now',
+    reopen: 'Reopen',
+    readiness: (d, n) => `${d} of ${n} ready`,
+    fit: { ok: 'Your prep is done.', time: (left, free) => `${left} ${left === 1 ? 'step' : 'steps'} left, ${free} min free before it.`,
+      short: (left, free) => `${left} ${left === 1 ? 'step' : 'steps'} left and ${free} min free. Give a step to the agent, or snooze.` },
+    noSteps: 'No steps were given. The sentence above says what to do.',
+    stepFailed: (why) => `The step was not saved: ${why}`,
+    // the context and the answer in the card (PRD X1, X2, F1 to F3)
+    threadTitle: 'The conversation',
+    refsTitle: 'What the sources say',
+    refRead: 'Read: ',
+    refOpen: 'Open the source ↗',
+    compose: { reply: 'Your reply', review: 'Your review', decide: 'Your answer', 'sign-off': 'Your sign-off' },
+    composeHint: 'Write it here, or start from a suggestion.',
+    startFrom: 'Start from:',
+    verdictLabel: 'Your verdict',
+    verdict: { approve: 'Approve', changes: 'Ask for changes' },
+    sendTo: (to) => `Send to ${to}`,
+    postReview: (to) => `Post the review to ${to}`,
+    sendNote: 'When you press, the agent posts exactly this text, as you, to that place. Nothing else is sent.',
+    sendNeed: 'Write the text to send first.',
+    verdictNeed: 'Choose Approve or Ask for changes first.',
+    sendStarted: (to) => `Sending to ${to}. The job shows Sent when it is posted.`,
+    noteTitle: 'Your note',
+    noteHint: 'Write it here. It is saved when you leave the box.',
+    noteStays: 'Saved with the meeting on this machine. Nothing is sent.',
+    noteSaved: 'Note saved.',
+  },
   /** The Acceptance Gate card (D12): the PM's own act on a run. */
   accept: {
     review: 'Review',