create-pmos 0.73.0 → 0.75.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.73.0",
+  "version": "0.75.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@a8b70bb
 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:33:59Z"}
 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:33:59Z"}
 status: stable
 ---
 

package/payload/scripts/workflow-state.js

@@ -1396,6 +1396,21 @@ function duplicatesArchive(root, L) {
   return path.relative(root, path.join(path.dirname(L.initiatives), 'archive', 'duplicates')).split(path.sep).join('/') + '/';
 }
 function scanRepository(root, L) { return scanDetail(root, L).index; }
+/** The kinds the PM confirmed (S11): `<state>/document-kinds.jsonl`, the latest line for a path. A kind is a role, or `none`. */
+const DOCUMENT_KINDS = ['brief', 'draft', 'review', 'handoff', 'none'];
+function documentKinds(L) {
+  const out = new Map();
+  let text = '';
+  try { text = fs.readFileSync(path.join(path.dirname(L.initiatives), 'document-kinds.jsonl'), 'utf8'); } catch { return out; }
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const o = JSON.parse(line);
+      if (o && typeof o.path === 'string' && DOCUMENT_KINDS.includes(o.kind)) out.set(o.path, o.kind);
+    } catch { /* a torn line is skipped */ }
+  }
+  return out;
+}
 /** The scan's index, and how many initiatives each found document belongs to (`owners`, for the tidy). */
 function scanDetail(root, L) {
   const key = path.resolve(root);
@@ -1403,6 +1418,8 @@ function scanDetail(root, L) {
   if (hit && Date.now() - hit.at < SCAN_TTL_MS) return hit;
   const index = new Map();
   const owners = new Map();
+  const owned = [];     // every document tied to an initiative, with or without a role (the Jev check reads them, S11)
+  const kinds = documentKinds(L);
   const keys = recordKeys(L);
   const idSet = new Set(keys.map((k) => k.id));
   const recDir = path.relative(root, L.initiatives).split(path.sep).join('/') + '/';
@@ -1421,10 +1438,13 @@ function scanDetail(root, L) {
     }
     const owner = documentOwners(rel, fm, idSet, keys);
     if (!owner.ids.length) continue;
-    const role = documentRole(rel, fm.type, owner.key);
-    if (!role) continue;
     // git's index still lists a tracked file that was moved or deleted and not yet staged
     if (!SCAN_TEXT.test(rel) && !fs.existsSync(path.join(root, rel))) continue;
+    const local = documentRole(rel, fm.type, owner.key);
+    const kind = kinds.get(rel) || null;   // a kind the PM confirmed outranks the name (S11)
+    const role = kind ? (kind === 'none' ? null : kind) : local;
+    owned.push({ path: rel, ids: owner.ids, role, local, kind, title: fm.title ? String(fm.title) : null });
+    if (!role) continue;
     owners.set(rel, owner.ids.length);
     for (const id of owner.ids) {
       if (!index.has(id)) index.set(id, { brief: [], draft: [], review: [], handoff: [] });
@@ -1432,7 +1452,7 @@ function scanDetail(root, L) {
     }
   }
   for (const v of index.values()) for (const k of Object.keys(v)) v[k].sort();
-  const out = { at: Date.now(), index, owners };
+  const out = { at: Date.now(), index, owners, owned };
   _scanCache.set(key, out);
   return out;
 }
@@ -1442,6 +1462,27 @@ function documentChangedAt(root, rel) {
   if (t > 0) return t;
   try { return Math.floor(fs.statSync(path.join(root, rel)).mtimeMs / 1000); } catch { return 0; }
 }
+/**
+ * Every document the scan ties to an initiative, for the Jev check (S11): { ok, profile, kinds, documents: [{ path, ids,
+ * role, local, kind, title, text }] }. `local` is the role the name gives, `kind` the one the PM confirmed, `role` the one
+ * the scan uses, and `text` says whether the file is Markdown or text (only those can be read by Jev). Nothing is written.
+ */
+function documentCandidates(root, opts) {
+  const L = layout(root);
+  const profile = profileOf(root);
+  const kinds = path.relative(root, path.join(path.dirname(L.initiatives), 'document-kinds.jsonl')).split(path.sep).join('/');
+  if (profile !== 'pm-artifacts') return { ok: true, profile, kinds, documents: [] };
+  if (opts && opts.fresh) forgetDocumentScan(root);
+  const { owned } = scanDetail(root, L);
+  const titles = {};
+  try {
+    for (const f of fs.readdirSync(L.initiatives)) {
+      if (!f.endsWith('.md') || /^(README|index|log)\.md$/i.test(f)) continue;
+      titles[f.slice(0, -3)] = String((readFrontmatter(path.join(L.initiatives, f)) || {}).title || f.slice(0, -3));
+    }
+  } catch { /* no records */ }
+  return { ok: true, profile, kinds, titles, documents: owned.map((d) => ({ ...d, text: SCAN_TEXT.test(d.path), changed: documentChangedAt(root, d.path) })) };
+}
 /**
  * The duplicates the tidy offers (S10): for each initiative, each role with more than one document. The group keeps the
  * file the record names, else the most recently changed, else the shortest path. A document that belongs to more than one
@@ -1920,7 +1961,7 @@ module.exports = {
   historyRange,
   ENFORCED_FROM,
   lanesFor, laneNames,
-  forgetDocumentScan, documentDuplicates,
+  forgetDocumentScan, documentDuplicates, documentCandidates, DOCUMENT_KINDS,
 };
 
 /*

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:33:59Z"}
 status: stable
 ---
 

package/workspace/guide/initiatives-screen.md

@@ -48,6 +48,16 @@ Select another file to keep a different one. Clear a group's check box to leave
 
 Press **Scan without tidying** to scan with every document in place. Press **Cancel** or Escape to do neither. The tidy writes no initiative record.
 
+### Check documents with Jev
+
+A file name, a folder or a `type:` line can give a document the wrong kind. When Jev is set up for the repository, **Scan repository** first asks Jev to read each document that is tied to an initiative and say what it is: a problem brief, a PRD, an evaluation, a handoff, or none of these. Jev is set up when three things are true: a TypeSafe key is saved, validation is on for the repository, and the switch that lets Jev categorize documents is on.
+
+1. The **Check documents with Jev** sheet says how many documents Jev reads and how many requests that sends. Nothing is sent before you press **Check with Jev**. Jev gets each document's title, headings and opening only. It never gets the path or the whole file. A document in an excluded folder, or one that may contain a secret, is not sent. A document Jev read before, and that did not change, is not sent again.
+2. The next sheet lists each document that Jev reads as a different kind, with how sure Jev is. A kind that Jev is unsure of is not listed. Clear a check box to keep the kind the scan gives now. Then the sheet lists the duplicates by Jev's kinds, and in each group it selects the version Jev picks as the most complete and current. The file the record names is still kept first.
+3. Press the confirm button. Each changed kind is one line in `pmos/state/document-kinds.jsonl`, and the scan uses that kind from now on. A document set to "none of these" leaves the scan. Then the duplicates move to the archive as in [Tidy duplicate documents](#tidy-duplicate-documents), and the scan runs. Its toast says how many kinds changed and how many documents moved.
+
+Press **Scan without Jev** to use the file names only. When Jev is not set up, the scan toast says which part is missing, and the tidy sheet uses the file names.
+
 ## The Roadmap
 
 The Roadmap has three columns: Now, Next and Later. Each column is a ranked list of cards. The line at the top reads, for example, "Now · 5 KR · 3 health". It counts the initiatives in Now by what they serve: a key result (KR) or a health budget. When the rules set an advisory cap for Now, the line shows it. The cap only advises. It never stops a move.

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 };