create-pmos 0.65.1 → 0.65.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.65.1",
+  "version": "0.65.3",
   "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@5f54d4e
+kernel-source: pmos@bc7453c
 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-07T00:49:12Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T01:27:56Z"}
 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-07T00:49:12Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T01:27:56Z"}
 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-07T00:49:12Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T01:27:56Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -119,7 +119,7 @@ Every row has a visible ⋯ button. Every control is at least 44 pixels high. No
 
 You can have the same session open on your phone and your computer. A session has one size, so the screen you type in or tap last sets it. The other screen keeps showing the session and takes the size back as soon as you type in it.
 
-On an iPhone or an iPad, the terminal gets smaller when the keyboard opens, so the agent's prompt stays above the keyboard. Tapping the terminal does not zoom the page, and dragging at its top or bottom does not pull or reload the page. A swipe from the left edge of the screen is Safari's Back gesture and leaves the workspace. To avoid that, add the workspace to your Home Screen and open it from there.
+On an iPhone or an iPad, the terminal gets smaller when the keyboard opens, so the agent's prompt stays above the keyboard. Tapping the terminal does not zoom the page, and dragging at its top or bottom does not pull or reload the page. Swipe up or down on the terminal to scroll it, also inside Claude Code or any other program that uses the mouse. A swipe from the left edge of the screen is Safari's Back gesture and leaves the workspace. To avoid that, add the workspace to your Home Screen and open it from there.
 
 ## The older layout
 

package/workspace/guide/today.md

@@ -30,7 +30,7 @@ An agent job can stop with its session still open, for example when the agent as
 
 Each job session is named "Job ·" and the first words of the job, so the session list stays short.
 
-The Agenda month is at the top of the left column. **Agent results** comes under it, counts the jobs and lists each finished one with its draft summary or the reason it failed. Your goals for today come under Agent results. The day is open when you go to Agenda, also before you press **Prepare my day**. 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.
+The Agenda month is at the top of the left column. **Agent results** comes under it, counts the jobs and lists each finished one with its draft summary or the reason it failed. Your goals for today come under Agent results. The day is open when you go to Agenda, also before you press **Prepare my day**. The other things that wait for you, such as outcome checks, report drafts and sessions, are jobs too. Each one is a row of **Needs you** in the jobs. Press it to see its card, with its own buttons (for example **Draft now**), in the detail column. When the day is folded, they show as cards under it.
 
 ### The Agenda month
 
@@ -50,7 +50,9 @@ Each day of the month answers three questions:
 
 The switch above the month shows one answer at a time: **Overview** (all three), **Full** (the time in meetings), **Key** (the meeting that matters), **Prep** (how ready you are) or **Free** (the free blocks of 90 minutes or more).
 
-The memory of a meeting says what kind of meeting it is (one-to-one, onboarding or group), how many times it was held, how many are to come, and why it matters. **Before this meeting** lists the prep. **Last time** is folded: open it to read the notes and what stayed open.
+The memory of a meeting says what kind of meeting it is (one-to-one, onboarding or group), how many times it was held, how many are to come, and why it matters.
+
+To mark a meeting yourself, open it. Press **Mark as key** to make this time a key meeting, or **Key every time** for every time it happens. On a meeting that is key already, press **Not key** or **Never key**. Your mark is used before what the calendar says. Press **Remove my mark** to go back to what the calendar says. The marks are kept in `calendar-marks.json` in the state folder. **Before this meeting** lists the prep. **Last time** is folded: open it to read the notes and what stayed open.
 
 The month comes from the calendar memory. The morning-brief session reads your calendar 90 days back and 31 days ahead the first time, and from today to 31 days ahead after that, and sends it with the brief. The workspace keeps 100 days back and 45 days ahead, in `calendar-memory.json` in the state folder. Nothing on the Agenda writes to your calendar. To see what the memory holds, run `pmos proactive calendar`.
 
@@ -66,7 +68,13 @@ To tie an item to a repository:
 1. For a goal, open it and pick a **Repository**. A goal you add while Today shows one repository belongs to that repository.
 2. For a Slack channel, Jira project or Confluence space, open **Sources**, open the service, and pick a repository next to the place.
 
-A job takes the repository of its goal. A job with no goal takes the repository of the place it came from. A job with neither belongs to no repository.
+A job takes the repository of its goal. A job with no goal takes the repository of the initiative it names, then of the place it came from. A goal tied to an initiative takes that initiative's repository when you pick none. A job with none of these belongs to no repository.
+
+When **Repository** hides a goal of another repository, the goals say how many it hides. Press **Show all repositories** to see them.
+
+A job's agent session runs in the folder of the job's repository, so it can read that repository's files. A job with no repository runs in the repository where you pressed **Prepare my day**.
+
+Your goals stay until you mark them done or drop them. A new day starts with the goals that were still open on the last day you had goals.
 
 Each job has one of three kinds.
 

package/workspace/lib/calendar-memory.js

@@ -5,7 +5,8 @@
  *   mergeMemory(stored, memory, { now })         → { ok, memory }   the stored file with the submitted window replaced
  *   seriesKey(e) · normTitle(title)              → the key that joins the occurrences of one meeting
  *   kindOf(e) · isImportant(e)                   → 'one' | 'onboard' | 'group' · true | false
- *   agendaMonth({ memory, brief, month, now })   → the month the Agenda draws: weeks, days with their three answers, series
+ *   agendaMonth({ memory, brief, month, marks, now }) → the month the Agenda draws: weeks, days with their three answers, series
+ *   readMarks(raw) · setMark(marks, { title, start, scope, on }) · markOf(marks, e) → the PM's key-meeting marks
  *
  * The morning-brief session reads the calendar wide (90 days back, 31 ahead) and submits it with the brief. The workspace
  * checks it here and keeps it in one file. Every answer the month gives is derived here, with no model and no I/O:
@@ -62,6 +63,51 @@ function isImportant(e) {
   return !!e && (e.role === 'present' || e.role === 'decide' || e.external === true || e.exec === true || (typeof e.attendees === 'number' && e.attendees >= 8));
 }
 
+/* ── the PM's own marks ───────────────────────────────────────────────────────────────────────────────────────────
+ * The PM can mark a meeting as key, or as not key, over what isImportant derives: this one time, or every time it
+ * happens. A mark is keyed by the title (normTitle), and a time mark also by the start minute, so it holds whether the
+ * meeting comes from the calendar memory or from today's brief. */
+const MAX_MARKS = 500;
+const seriesMark = (title) => 't:' + normTitle(title);
+const timeMark = (title, start) => { const t = Date.parse(start); return Number.isFinite(t) ? seriesMark(title) + '@' + new Date(t).toISOString().slice(0, 16) : null; };
+const emptyMarks = () => ({ one: {}, series: {} });
+
+/** The marks file, checked: anything else reads as no marks. */
+function readMarks(raw) {
+  const out = emptyMarks();
+  if (!raw || typeof raw !== 'object') return out;
+  for (const k of ['one', 'series']) {
+    const m = raw[k] && typeof raw[k] === 'object' && !Array.isArray(raw[k]) ? raw[k] : {};
+    for (const [key, v] of Object.entries(m).slice(0, MAX_MARKS)) if (typeof v === 'boolean' && key.length <= 300 && key.startsWith('t:')) out[k][key] = v;
+  }
+  return out;
+}
+
+/** One mark set or cleared. `scope` 'one' (this time) or 'series' (every time); `on` true (key), false (not key) or null
+ *  (clear, back to what the calendar says). A mark for every time also clears this time's mark. */
+function setMark(marks, { title, start, scope, on } = {}) {
+  if (!str(title, 300)) return { ok: false, error: 'a mark needs the meeting title' };
+  if (!['one', 'series'].includes(scope)) return { ok: false, error: "scope must be 'one' or 'series'" };
+  if (!(on === true || on === false || on === null)) return { ok: false, error: 'on must be true, false or null' };
+  const key = scope === 'one' ? timeMark(title, start) : seriesMark(title);
+  if (!key || key === 't:') return { ok: false, error: 'a mark needs a title with letters and, for one time, its start' };
+  const next = readMarks(marks);
+  if (on === null) delete next[scope][key]; else next[scope][key] = on;
+  if (scope === 'series') { const t = timeMark(title, start); if (t) delete next.one[t]; }
+  if (Object.keys(next[scope]).length > MAX_MARKS) return { ok: false, error: 'too many marks — clear some first' };
+  return { ok: true, marks: next };
+}
+
+/** The PM's mark of a meeting: { on, scope } or null when there is none. A time mark wins over an every-time mark. */
+function markOf(marks, e) {
+  if (!marks || !e) return null;
+  const t = timeMark(e.title, e.start);
+  if (t && marks.one && typeof marks.one[t] === 'boolean') return { on: marks.one[t], scope: 'one' };
+  const s = seriesMark(e.title);
+  if (marks.series && typeof marks.series[s] === 'boolean') return { on: marks.series[s], scope: 'series' };
+  return null;
+}
+
 /* ── the check ─────────────────────────────────────────────────────────────────────────────────────────────────── */
 
 function validateMemory(raw, { now = Date.now() } = {}) {
@@ -166,14 +212,16 @@ function fromBrief(e) {
  * The month the Agenda draws. `month` is YYYY-MM (default: this month). Weeks run Monday to Sunday. Each day of the month
  * carries its events and the three answers; `series` describes every series that has an event in the month.
  */
-function agendaMonth({ memory, brief, month, now = Date.now() } = {}) {
+function agendaMonth({ memory, brief, month, marks = null, now = Date.now() } = {}) {
   const today = localDate(now);
   const ym = typeof month === 'string' && /^\d{4}-\d{2}$/.test(month) ? month : today.slice(0, 7);
   const all = ((memory && memory.events) || []).map((e) => ({ ...e, src: 'memory' }));
   // today's events come from the brief of today when there is one; memory events of today are then left out
   const b = brief && brief.date === today && Array.isArray(brief.calendar) ? brief.calendar.map(fromBrief) : null;
+  // key: the PM's mark when there is one, else what the calendar says (isImportant)
+  const impOf = (e) => { const auto = isImportant(e); const mk = markOf(marks, e); return { imp: mk ? mk.on : auto, auto, mark: mk ? mk.scope : null }; };
   const events = (b ? [...all.filter((e) => localDate(Date.parse(e.start)) !== today), ...b] : all)
-    .map((e) => { const s = Date.parse(e.start); const f = Date.parse(e.end); return { ...e, s, f, date: localDate(s), from: minuteOfDay(s), to: f - s >= DAY_MS ? DAY_END : (localDate(f) === localDate(s) ? minuteOfDay(f) : DAY_END), key: seriesKey(e), kind: kindOf(e), imp: isImportant(e) }; })
+    .map((e) => { const s = Date.parse(e.start); const f = Date.parse(e.end); return { ...e, s, f, date: localDate(s), from: minuteOfDay(s), to: f - s >= DAY_MS ? DAY_END : (localDate(f) === localDate(s) ? minuteOfDay(f) : DAY_END), key: seriesKey(e), kind: kindOf(e), ...impOf(e) }; })
     .sort((x, y) => x.s - y.s);
 
   // series over everything remembered, so "held 12 of 13" and "the last time" see beyond the month
@@ -227,7 +275,7 @@ function agendaMonth({ memory, brief, month, now = Date.now() } = {}) {
       if (lv === 'risk' || (lv === 'warn' && level !== 'risk') || (lv === 'ok' && !level)) level = lv;
       const x = series.get(e.key);
       return { id: e.id, src: e.src, title: e.title, start: e.start, end: e.end, time: `${pad(Math.floor(e.from / 60))}:${pad(e.from % 60)}`, minutes: Math.round((e.f - e.s) / 60000),
-        kind: e.kind, imp: e.imp, key: e.key, repeats: x.count > 1, routine: routine(e), ended, prep: p ? e.prep : null, prep_done: p ? pd : null, ready: lv,
+        kind: e.kind, imp: e.imp, auto: e.auto, mark: e.mark, key: e.key, repeats: x.count > 1, routine: routine(e), ended, prep: p ? e.prep : null, prep_done: p ? pd : null, ready: lv,
         notes: e.notes || null, open: e.open || null, role: e.role || null, external: e.external === true, attendees: typeof e.attendees === 'number' ? e.attendees : null, with: e.with || null };
     });
     if (need && done >= need) level = 'ok';
@@ -253,6 +301,6 @@ function agendaMonth({ memory, brief, month, now = Date.now() } = {}) {
 }
 
 module.exports = {
-  validateMemory, mergeMemory, agendaMonth, seriesKey, normTitle, kindOf, isImportant, dayLoad,
+  validateMemory, mergeMemory, agendaMonth, seriesKey, normTitle, kindOf, isImportant, dayLoad, readMarks, setMark, markOf,
   MAX_EVENTS, MAX_SPAN_DAYS, KEEP_BACK_DAYS, KEEP_AHEAD_DAYS, FREE_BLOCK, PER_STEP,
 };

package/workspace/lib/goals.js

@@ -11,12 +11,15 @@
  *            | { action: 'tag', id, repo }   (repo: a workspace id, or null for none)
  *   readDay(raw, date)                     → a checked day record, or an empty day when `raw` is not one
  *   planDay({ day, brief, cards, now, endOfDay }) → the plan Today and `pmos proactive goals` show
- *   itemRepos({ day, brief, placeRepos })   → { itemId: repo } for the brief items that have a repository
+ *   itemRepos({ day, brief, placeRepos, iniRepos }) → { itemId: repo } for the brief items that have a repository
+ *   goalRepos({ day, iniRepos })            → { goalId: repo } for the untagged goals whose initiative names one
+ *   carryOver(prev, date)                   → a new day holding the goals still open on `prev`
  *
  * ONE DAY, REPOSITORY TAGS. The day is the PM's, not a repository's: every repository shows the same goals, brief and
  * jobs. A goal can carry a repository (`repo`, a workspace id), and so can a channel, project or space (the settings'
  * `placeRepos`). An item takes the repository of the open goal it is under; failing that, of the place it came from
- * (its `where`). An item with neither is personal and shows under every repository.
+ * (its `where`). An initiative held by one repository tags the items that name it, and the goals tied to it. An item
+ * with none of these is personal and shows under every repository.
  *
  * THE JOIN IS CHECKABLE. A brief item or calendar event belongs to a goal when it names the goal's id (the morning-brief
  * session sets it). Failing that, an item or Today card belongs to the first open goal tied to the same initiative. There
@@ -56,6 +59,13 @@ function readDay(raw, date) {
   return { date, goals };
 }
 
+/** A new day starts with the goals still open on the last day that had any: a goal is the PM's until it is done or
+ *  dropped, not until midnight. `prev` is that day's record (readDay); a day with its own file never takes these. */
+function carryOver(prev, date) {
+  if (!prev || !Array.isArray(prev.goals) || !prev.date || prev.date >= date) return emptyDay(date);
+  return { date, goals: prev.goals.filter((g) => g.status === 'open').slice(0, MAX_GOALS).map((g) => ({ ...g, closed_at: null })) };
+}
+
 /** One edit of the day's goals. A refused edit returns the reason and the caller writes nothing. */
 function edit(day, op, { now = Date.now() } = {}) {
   if (!day || !DATE_RE.test(String(day.date)) || !Array.isArray(day.goals)) return { ok: false, error: 'no day record to edit' };
@@ -205,8 +215,9 @@ function planDay({ day, brief = null, cards = [], now = Date.now(), endOfDay = E
 const placeKey = (s) => { const t = String(s || '').trim().toLowerCase().replace(/^#/, ''); const k = /^([a-z][a-z0-9]*)-\d+$/.exec(t); return k ? k[1] : t; };
 const placeNameKeys = (n) => { const t = String(n || '').trim().toLowerCase().replace(/^#/, ''); return [t, t.split(/[\s·:|]+/)[0]].filter(Boolean); };
 
-/** { itemId: repo } for today's brief items: the repository of the open goal an item is under, else of its place. */
-function itemRepos({ day, brief, placeRepos = {} } = {}) {
+/** { itemId: repo } for today's brief items: the repository of the open goal an item is under, else of the initiative
+ *  it names (`iniRepos`: { initiativeId: repo }, only the ids one repository holds), else of its place. */
+function itemRepos({ day, brief, placeRepos = {}, iniRepos = {} } = {}) {
   const out = {};
   if (!brief || !day || brief.date !== day.date) return out;
   const open = (day.goals || []).filter((g) => g.status === 'open');
@@ -214,7 +225,8 @@ function itemRepos({ day, brief, placeRepos = {} } = {}) {
   const byIni = (ini) => (ini ? open.find((g) => g.initiative_id === ini) || null : null);
   for (const x of [...(brief.priorities || []), ...(brief.worth_asking || [])]) {
     const g = (x.goal && byId.get(x.goal)) || byIni(x.initiative_id);
-    let r = g ? repoOrNull(g.repo) : null;
+    let r = g ? repoOrNull(g.repo) || (g.initiative_id ? repoOrNull(iniRepos[g.initiative_id]) : null) : null;
+    if (!r && x.initiative_id) r = repoOrNull(iniRepos[x.initiative_id]);
     if (!r && x.where) {
       const want = placeKey(x.where);
       for (const [name, repo] of Object.entries(placeRepos[x.source] || {})) if (placeNameKeys(name).includes(want) && repoOrNull(repo)) { r = repo; break; }
@@ -224,4 +236,11 @@ function itemRepos({ day, brief, placeRepos = {} } = {}) {
   return out;
 }
 
-module.exports = { MAX_GOALS, MAX_TEXT, STATUSES, ACTIONS, GOAL_ID_RE, START_OF_DAY, END_OF_DAY, emptyDay, readDay, edit, freeTime, planDay, itemRepos };
+/** { goalId: repo } for the goals with no repository of their own whose initiative one repository holds. */
+function goalRepos({ day, iniRepos = {} } = {}) {
+  const out = {};
+  for (const g of (day && day.goals) || []) if (!g.repo && g.initiative_id && repoOrNull(iniRepos[g.initiative_id])) out[g.id] = iniRepos[g.initiative_id];
+  return out;
+}
+
+module.exports = { MAX_GOALS, MAX_TEXT, STATUSES, ACTIONS, GOAL_ID_RE, START_OF_DAY, END_OF_DAY, emptyDay, readDay, carryOver, edit, freeTime, planDay, itemRepos, goalRepos };

package/workspace/package-lock.json

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

package/workspace/package.json

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

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

@@ -143,14 +143,14 @@ function build(ctx0) {
   const dayWs = dayRepo ? wsOf(dayRepo) : null;
   const prep = onPhone && !(window.pmDeck && window.pmDeck.phoneView('today') === 'day') ? prepCard(dayWs) : null;
   if (prep) { prep.setAttribute('role', 'listitem'); const none = list.querySelector('[data-today="empty"]'); if (none) none.setAttribute('data-today-id', 'empty'); list.prepend(prep); }   // the empty note stays, as the deck's last card
-  // the open day takes the list into its left column ("Also waiting for you"), so Today shows one layout; a folded day
-  // leaves it below, as before
-  const owed = { list, more, count: n };
+  // the open day takes the cards into its jobs (rows of Needs you; a pressed row shows its card), so Today shows one layout; a folded day
+  // leaves it below, as before. A phone does not draw the day, so its deck keeps every card
+  const owed = onPhone ? null : { list, more, count: n };
   // one day for every repository: the day is the same everywhere; the Show switch narrows it to the repository Today
   // was opened from (`here`) or shows all of it
   const here = sc.repo ? wsOf(sc.repo) : null;
   const day = daySection({ ws: dayWs, setState: ctx0.setState || setState, openIni: dayRepo ? (id) => openInitiative(dayRepo, id) : null, owed, here, all: sc.all });
-  const inDay = !!(day && day.contains(list));
+  const inDay = !!(day && owed && owed.taken);
   return { children: inDay ? [head, day, health] : [head, day, health, list, more], sig: JSON.stringify([sc.all, sc.repo, n, ready, expanded, banner, onPhone, prep ? prep.outerHTML : null]) + daySig(dayWs) + nodes.map((x) => x.outerHTML).join('') };
 }
 

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

@@ -915,9 +915,78 @@ function buildReal(tab) {
     rec.ro = new ResizeObserver(() => refitVisible());
     try { rec.ro.observe(host); } catch { /* ignore */ }
   }
+  touchScroll(rec);
   return rec;
 }
 
+/* ── a swipe scrolls ───────────────────────────────────────────────────────────────────────────
+ * xterm scrolls on a touch drag only while no program has asked for the mouse. A program that has
+ * (Claude Code, tmux, an editor) gets nothing from a swipe, because xterm ignores touch then and a
+ * touch is not a wheel. On an iPhone or iPad a swipe was therefore dead in exactly the sessions
+ * that matter. A vertical drag on the pane is turned into wheel events instead, and xterm does with
+ * them what it does with a mouse wheel: it scrolls its own scrollback, or it reports the wheel to
+ * the program that asked for the mouse, or it sends arrow keys in a full-screen program that did
+ * not. The finger's speed carries on for a moment after it lifts, as a native scroll does. A tap
+ * is left alone, so it still focuses the terminal and raises the keyboard. */
+const TOUCH_SLOP = 6;          // px a finger moves before a touch is a swipe rather than a tap
+const MOMENTUM_DECAY = 0.95;   // the carried speed kept per frame after the finger lifts
+
+function touchScroll(rec) {
+  const { host, term } = rec;
+  let t = null;        // the swipe in progress: { x, y, lastY, lastT, v, swiping }
+  let glide = 0;       // the momentum frame, if one is queued
+
+  const wheel = (dy, x, y) => {
+    const target = (term.element && term.element.querySelector('.xterm-screen')) || term.element;
+    if (!target || !dy) return;
+    target.dispatchEvent(new WheelEvent('wheel', {
+      deltaY: dy, deltaMode: 0, clientX: x, clientY: y, bubbles: true, cancelable: true,
+    }));
+  };
+  const stopGlide = () => { if (glide) { cancelAnimationFrame(glide); glide = 0; } };
+
+  host.addEventListener('touchstart', (e) => {
+    stopGlide();
+    if (e.touches.length !== 1) { t = null; return; }
+    const p = e.touches[0];
+    t = { x: p.clientX, y: p.clientY, lastY: p.clientY, lastT: e.timeStamp, v: 0, swiping: false };
+  }, { capture: true, passive: true });
+
+  host.addEventListener('touchmove', (e) => {
+    if (!t || e.touches.length !== 1) return;
+    const p = e.touches[0];
+    if (!t.swiping) {
+      const dx = p.clientX - t.x, dy = p.clientY - t.y;
+      if (Math.abs(dy) < TOUCH_SLOP || Math.abs(dy) < Math.abs(dx)) return;
+      t.swiping = true;
+    }
+    // Ours from here: xterm's own touch handling and the page's scroll do not also see it.
+    e.preventDefault();
+    e.stopPropagation();
+    const dy = t.lastY - p.clientY;   // finger up = content up = wheel down
+    const dt = Math.max(1, e.timeStamp - t.lastT);
+    t.v = 0.8 * (dy / dt) + 0.2 * t.v;
+    t.lastY = p.clientY; t.lastT = e.timeStamp;
+    wheel(dy, p.clientX, p.clientY);
+  }, { capture: true, passive: false });
+
+  const end = () => {
+    if (!t || !t.swiping) { t = null; return; }
+    let v = t.v * 16;                  // px per frame
+    const x = t.x, y = t.lastY;
+    t = null;
+    const step = () => {
+      v *= MOMENTUM_DECAY;
+      if (Math.abs(v) < 0.5) { glide = 0; return; }
+      wheel(v, x, y);
+      glide = requestAnimationFrame(step);
+    };
+    if (Math.abs(v) >= 0.5) glide = requestAnimationFrame(step);
+  };
+  host.addEventListener('touchend', end, { capture: true, passive: true });
+  host.addEventListener('touchcancel', end, { capture: true, passive: true });
+}
+
 /* ── the exported surface ──────────────────────────────────────────────────────────────────── */
 
 /**

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

@@ -10,13 +10,14 @@
  * One read feeds it: GET /api/proactive/agenda?month=YYYY-MM. The server derives every answer (how full, the key
  * meeting, readiness, no notes); this file only draws them. A day cell is a button: it picks that day. A week number
  * picks the week. The lens switch says which answer the cells show; the agenda under the month always shows them all.
- * Nothing here writes: the calendar memory changes only through the morning-brief session's brief.
+ * The calendar memory changes only through the morning-brief session's brief. The one write here is the PM's key-meeting
+ * mark (POST /api/proactive/agenda/mark): this time or every time, key or not key, over what the calendar says.
  */
 
 import { peopleLinks } from './people-link.js';
 import { el } from './dom.js';
-import { button, iconButton, badge, tabs } from './primitives.js';
-import { pmGet } from './http.js';
+import { button, iconButton, badge, tabs, toast } from './primitives.js';
+import { pmGet, pmPost } from './http.js';
 import { COPY } from './today-copy.js';
 
 const A = COPY.day.ag;
@@ -74,10 +75,12 @@ function current() {
   return c;
 }
 
+// a short hash of the days, so a change that keeps the length (a key mark set or cleared) still redraws
+const hash = (t) => { let h = 0; for (let i = 0; i < t.length; i++) h = (h * 31 + t.charCodeAt(i)) | 0; return h; };
 export function agendaSig() {
   const c = ag.month ? cache.get(ag.month) : cache.get('now');
   return JSON.stringify([ag, c ? [c.error, c.data && c.data.now ? String(c.data.now).slice(0, 16) : null, c.data && Object.keys(c.data.days || {}).length, c.data && c.data.memory] : null])
-    + (c && c.data ? JSON.stringify(c.data.days).length : 0);
+    + (c && c.data ? hash(JSON.stringify(c.data.days)) : 0);
 }
 
 /* ── finding a meeting across the months read ─────────────────────────────────────────────────────────────────── */
@@ -270,6 +273,26 @@ function whyLines(e) {
   return out;
 }
 
+async function setMark(e, scope, on) {
+  const r = await pmPost('/api/proactive/agenda/mark', { title: e.title, start: e.start, scope, on });
+  if (!r || r.ok === false) { toast({ text: A.key.failed((r && r.error) || 'the workspace did not answer'), tone: 'destructive' }); return; }
+  for (const k of [...cache.keys()]) loadMonth(k === 'now' ? undefined : k);
+}
+
+/** The key-meeting line of a meeting: what the PM marked, and the presses that change it. */
+function keyBlock(e) {
+  const K = A.key;
+  const b = (label, scope, on, id) => button({ label, variant: 'outline', size: 'sm', attrs: { 'data-ag-mark': id }, onClick: () => setMark(e, scope, on) });
+  const presses = e.mark ? [b(K.clear, e.mark, null, 'clear')]
+    : e.imp ? [b(K.unmark, 'one', false, 'not-one'), e.repeats ? b(K.unmarkAll, 'series', false, 'not-series') : null]
+      : [b(K.mark, 'one', true, 'one'), e.repeats ? b(K.markAll, 'series', true, 'series') : null];
+  const said = e.mark ? K[(e.imp ? 'marked' : 'not') + e.mark] : null;
+  return el('div', { class: 'td-day__phase', 'data-ag': 'key', 'data-ag-key': e.imp ? 'true' : 'false' },
+    e.imp ? el('h4', null, A.star + ' ' + K.title) : null,
+    said ? el('p', { class: 'td-day__note' }, said) : null,
+    el('div', { class: 'td-day__acts' }, ...presses));
+}
+
 /** The series of a meeting: how often it met, what is to come, and the last time, folded. Null when unknown. */
 export function memoryBlock(id) {
   const f = findEvent(id);
@@ -280,7 +303,8 @@ export function memoryBlock(id) {
   return el('div', { class: 'td-day__notes', 'data-ag': 'memory' },
     el('h4', null, A.means),
     el('p', null, A.kindWord[f.e.kind] + '. ' + (s.count > 1 ? A.series(s.past, s.coming) : A.once)),
-    ...whyLines(f.e).map((t) => el('p', null, t)),
+    ...(f.e.mark ? [] : whyLines(f.e)).map((t) => el('p', null, t)),
+    keyBlock(f.e),
     last ? el('details', { class: 'td-ag__last', 'data-ag': 'last' }, el('summary', null, A.lastTime(dayLabel(last.date))),
       last.notes ? el('p', null, last.notes) : el('p', { class: 'td-day__note' }, A.noLast),
       last.open && last.open.length ? el('ul', { class: 'td-day__chk' }, ...last.open.map((x) => el('li', null, x))) : null) : null);

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

@@ -136,16 +136,17 @@ export const COPY = {
     unreached: 'The workspace did not answer.',
     refused: (why) => `Nothing changed. ${why}`,
     oldServer: 'This workspace server has no day run yet. Only your goals show.',
-    panels: { summary: 'Agent results', calendar: 'Calendar', agenda: 'Agenda', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', waiting: 'Also waiting for you', detail: 'Detail' },
+    panels: { summary: 'Agent results', calendar: 'Calendar', agenda: 'Agenda', jobs: 'Jobs', goals: 'Goals for today', mentions: 'Mentions since yesterday', detail: 'Detail' },
     summary: (c) => [c.review ? `${c.review} ${c.review === 1 ? 'draft waits' : 'drafts wait'} for you` : null, c.done ? `${c.done} done` : null,
       c.working ? `${c.working} working` : null, c.failed ? `${c.failed} failed` : null].filter(Boolean).join(' · ') || 'No agent job yet.',
     summaryAll: (n) => `All ${n} agent ${n === 1 ? 'job has' : 'jobs have'} a result.`,
-    waitingHint: 'Outcome checks, reports and sessions from your repositories, outside today\'s jobs.',
     // one day for every repository: a goal or a place can carry a repository; the Show switch narrows the day to it
     repo: { label: 'Repository', none: 'No repository',
       goalHint: 'Its jobs show under this repository. With no repository, the goal is yours and shows under every repository.',
       placeHint: 'Repository: its mentions and jobs show under that repository. With none, they show under every repository.',
-      only: (name) => `Showing ${name} and your items with no repository. The calendar always shows.` },
+      only: (name) => `Showing ${name} and your items with no repository. The calendar always shows.`,
+      hiddenGoals: (n) => `${n} ${n === 1 ? 'goal belongs' : 'goals belong'} to another repository.`,
+      showAll: 'Show all repositories' },
     now: (at) => `now ${at}`,
     noCalendar: 'No events read for today.',
     noJobs: 'No jobs yet. Press Prepare my day. Each job shows here; select one to see what it needs.',
@@ -329,6 +330,13 @@ export const COPY = {
       kindWord: { one: 'One-to-one', onboard: 'Onboarding', group: 'Group meeting' },
       why: { present: 'You present.', decide: 'You decide.', external: 'People from outside the company join.', exec: 'Leadership joins.', many: (n) => `${n} people join.`, routine: 'It repeats, and nothing in it is for you.' },
       means: 'What it means',
+      key: {
+        title: 'Key meeting',
+        markedone: 'You marked this time as key.', markedseries: 'You marked it as key every time.',
+        notone: 'You marked this time as not key.', notseries: 'You marked it as not key every time.',
+        mark: 'Mark as key', markAll: 'Key every time', unmark: 'Not key', unmarkAll: 'Never key', clear: 'Remove my mark',
+        failed: (why) => `The mark was not saved: ${why}`,
+      },
       before: 'Before this meeting',
       prepLine: (done, need) => `${done} of ${need} prep steps done.`,
       readyNote: { ok: 'Your prep is done.', warn: 'Some prep is left, and there is time for it.', risk: 'The free time before it is short for the prep left.' },

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

@@ -142,7 +142,9 @@ function model(d, view) {
   const today = d && d.today;
   const brief = d && d.brief && (!today || d.brief.date === today) ? d.brief : null;
   const plan = (d && d.plan) || null;
-  const goals = plan ? plan.goals || [] : [];
+  // a goal with no repository of its own takes the one its initiative is in (goal_repos, from the server)
+  const goalRepos = (d && d.goal_repos) || {};
+  const goals = (plan ? plan.goals || [] : []).map((g) => (g.repo || !goalRepos[g.id] ? g : { ...g, repo: goalRepos[g.id] }));
   const goalNo = new Map(goals.map((g, i) => [g.id, i + 1]));
   const run = (d && d.run) || null;
   const tasks = run && Array.isArray(run.tasks) ? run.tasks : [];
@@ -178,7 +180,7 @@ function model(d, view) {
   const shownIds = new Set(shownJobs.map((j) => j.task && j.task.id).filter(Boolean));
   const shownTasks = narrow ? tasks.filter((t) => shownIds.has(t.id)) : tasks;
   return {
-    d, brief, plan, goals: goals.filter((g) => inView(g.repo)), allGoals: goals, goalNo, run, tasks: shownTasks, jobs: shownJobs, events, now, settings, scopes, level,
+    d, brief, plan, goals: goals.filter((g) => inView(g.repo)), allGoals: goals, hiddenGoals: goals.filter((g) => !inView(g.repo)).length, goalNo, run, tasks: shownTasks, jobs: shownJobs, events, now, settings, scopes, level,
     digests: digests.filter((g) => inView(g.repo)), places, placeRepo, repos, repoName, here: v.here || null, narrow,
     stage: run ? (d.stage || deriveStage(run, brief)) : null,
     mentions: shownJobs.filter((j) => j.item && j.item.mention),
@@ -419,13 +421,31 @@ function jobRow(ctx, j) {
     dot: j.isNew && !seen.has(j.id) ? el('span', { class: 'td-day__newdot', 'data-day': 'new', role: 'img', 'aria-label': D.newItem }) : null });
 }
 
+/* What the repositories owe the PM outside today's jobs (outcome checks, report drafts, sessions) are jobs too: each one is a
+ * row of Needs you, and pressing it shows its card, with the card's own buttons, in the detail column. The Agenda has no
+ * separate section for them. */
+function owedItems(owed) {
+  if (!owed || !owed.list) return [];
+  return [...owed.list.children].filter((n) => n.getAttribute && n.getAttribute('data-today-id')).map((n) => {
+    const cause = n.querySelector('[data-today-cause]');
+    const ev = n.querySelector('.td-card__evidence');
+    const text = ((cause || n).textContent || '').trim().replace(/\s+/g, ' ');
+    return { id: n.getAttribute('data-today-id'), node: n, title: text, meta: ev ? ev.textContent.trim().replace(/\s+/g, ' ') : '' };
+  });
+}
+
+function owedRow(ctx, o) {
+  return rowBtn(ctx, 'owed', o.id, { lead: '·', title: o.title, meta: o.meta, trail: pill(D.status2.you, 'warn') });
+}
+
 function jobsPanel(ctx) {
   const { m } = ctx;
-  if (!m.jobs.length) return panel('jobs', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noJobs, { 'data-day': 'no-jobs' }));
-  const groups = ['needs', 'working', 'done', 'worth'].map((g) => [g, m.jobs.filter((j) => j.group === g)]).filter(([, l]) => l.length);
-  return panel('jobs', D.jobsCount(m.needs, m.done), ...groups.map(([g, l]) => el('div', { class: 'td-day__group', 'data-day-group': g },
-    el('div', { class: 'td-day__gh' }, D.groups[g], pill(String(l.length), '')),
-    el('ul', { class: 'td-day__rows' }, ...l.map((j) => jobRow(ctx, j))))));
+  const owed = ctx.owed;
+  if (!m.jobs.length && !owed.length) return panel('jobs', null, note(m.run && m.stage === 'reading' ? D.readingJobs : D.noJobs, { 'data-day': 'no-jobs' }));
+  const groups = ['needs', 'working', 'done', 'worth'].map((g) => [g, m.jobs.filter((j) => j.group === g)]).filter(([g, l]) => l.length || (g === 'needs' && owed.length));
+  return panel('jobs', D.jobsCount(m.needs + owed.length, m.done), ...groups.map(([g, l]) => el('div', { class: 'td-day__group', 'data-day-group': g },
+    el('div', { class: 'td-day__gh' }, D.groups[g], pill(String(l.length + (g === 'needs' ? owed.length : 0)), '')),
+    el('ul', { class: 'td-day__rows', 'data-day-list': 'jobs-' + g }, ...l.map((j) => jobRow(ctx, j)), ...(g === 'needs' ? owed.map((o) => owedRow(ctx, o)) : [])))));
 }
 
 /* The coordinator's view of the run: what every agent job came back with, in one place. The server runs the jobs as one
@@ -455,14 +475,12 @@ function summaryPanel(ctx) {
 
 /* What waits for the PM outside today's jobs (the Today cards: outcome checks, reports, sessions). Today hands its list
  * in, so the cards keep their own controls and the open day shows one layout. */
-function waitingPanel(owed) {
-  if (!owed || !owed.list) return null;
-  return panel('waiting', owed.count ? String(owed.count) : null, note(D.waitingHint), owed.list, owed.more || null);
-}
-
 function goalsPanel(ctx) {
   const { m } = ctx;
-  return panel('goals', D.goalsCount(m.allGoals.filter((g) => g.status === 'open').length, m.maxGoals), goalRows(ctx), goalAdd(ctx));
+  // a goal of another repository is not lost: the panel says how many the Show switch hides, with the way to them
+  const hidden = m.hiddenGoals ? el('p', { class: 'td-day__note', 'data-day': 'goals-hidden' }, D.repo.hiddenGoals(m.hiddenGoals) + ' ',
+    button({ label: D.repo.showAll, variant: 'ghost', size: 'sm', attrs: { 'data-day': 'show-all' }, onClick: () => ctx.showAll() })) : null;
+  return panel('goals', D.goalsCount(m.allGoals.filter((g) => g.status === 'open').length, m.maxGoals), goalRows(ctx), hidden, goalAdd(ctx));
 }
 
 function mentionStatus(j) {
@@ -778,9 +796,10 @@ function sourcesDetail(ctx) {
   return [dhead(D.kind.settings, D.sources), note(D.sourcesIntro), box, el('div', { class: 'td-day__slist' }, ...rows)];
 }
 
-function defaultSel(m) {
+function defaultSel(m, owed) {
   const j = m.jobs.find((x) => x.group === 'needs');
   if (j) return { type: 'job', id: j.id };
+  if (owed && owed.length) return { type: 'owed', id: owed[0].id };
   const e = m.events.find((x) => !x.ended);
   if (e) return { type: 'event', id: e.id };
   return { type: 'step', id: String(Math.max(0, Math.min(3, stepIndex(m.stage)))) };
@@ -799,10 +818,11 @@ function detail(ctx) {
     if (s.type === 'step') return stepDetail(ctx, Math.max(0, Math.min(3, Number(s.id) || 0)));
     if (s.type === 'sources') return sourcesDetail(ctx);
     if (s.type === 'meeting') return meetingDetail(ctx, s.id, { dhead });
+    if (s.type === 'owed') { const o = ctx.owed.find((x) => x.id === s.id); if (o) o.node.hidden = false; return o ? [dhead(D.groups.needs), el('div', { class: 'td-day__owed', 'data-day': 'owed' }, o.node)] : null; }
     return null;
   };
   kids = find(sel);
-  if (!kids) { sel = defaultSel(m); kids = find(sel); }
+  if (!kids) { sel = defaultSel(m, ctx.owed); kids = find(sel); }
   return el('aside', { class: 'td-day__detail', 'aria-label': D.panels.detail, 'data-day': 'detail', 'data-day-detail': sel.type, 'data-day-detail-id': sel.id }, kids);
 }
 
@@ -847,9 +867,13 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
   const sel = ui.sel;
   const ctx = {
     ws, m, sel, openIni, reload: () => load(ws), rerender: () => rerender(), select, repoPicker,
-    cur: (type, id) => { const s = sel || defaultSel(m); return s.type === type && s.id === String(id) ? 'true' : 'false'; },
+    showAll: () => { if (setState) setState({ todayScope: 'all' }); },
+    cur: (type, id) => { const s = sel || defaultSel(m, ctx.owed); return s.type === type && s.id === String(id) ? 'true' : 'false'; },
+    owed: owedItems(owed),
   };
-  ctx.sel = sel || defaultSel(m);
+  ctx.sel = sel || defaultSel(m, ctx.owed);
+  // the open day takes what the repositories owe into its jobs: dest-today draws no second list under it
+  if (owed) owed.taken = true;
   if (ui.scroll) {
     ui.scroll = false;
     // on a narrow screen the detail is under the list: bring it into view once it is on the page
@@ -866,7 +890,7 @@ export function daySection({ ws, setState, openIni, owed, here, all } = {}) {
     c.error ? el('p', { class: 'td-day__run td-day__run--failed', role: 'status', 'data-day': 'error' }, D.refused(c.error)) : null,
     m.d && m.d.legacy ? note(D.oldServer) : null,
     el('div', { class: 'td-day__cols' },
-      el('div', { class: 'td-day__left' }, agenda(ctx), summaryPanel(ctx), goalsPanel(ctx), jobsPanel(ctx), mentionsPanel(ctx), waitingPanel(owed)),
+      el('div', { class: 'td-day__left' }, agenda(ctx), summaryPanel(ctx), goalsPanel(ctx), jobsPanel(ctx), mentionsPanel(ctx)),
       detail(ctx)));
 }
 

package/workspace/server.js

@@ -3772,8 +3772,8 @@ function stallQuietTasks(run, now) {
   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);
+function daySkillPrompt(run, skillId, wsId) {
+  const w = getWs(wsId || run.ws);
   const task = taskById(skillId, w ? w.root : null);
   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)) };
@@ -3785,9 +3785,22 @@ function jobSessionName(title) {
   const cut = t.slice(0, 28); const sp = cut.lastIndexOf(' ');
   return 'Job · ' + (sp > 12 ? cut.slice(0, sp) : cut).replace(/[\s,.;:·—-]+$/, '') + '…';
 }
+/** The repository a job belongs to (its item's tag: its goal's, its initiative's or its place's repository), when that
+ *  repository is registered and has the day-task skill; else null and the job runs where Prepare my day was pressed. */
+function taskWsId(run, t) {
+  try {
+    const brief = briefOfDay(run.date);
+    if (!brief || !t.item_id) return null;
+    const st = proSettings();
+    const r = goalsLib.itemRepos({ day: readGoalsDay(run.date), brief, placeRepos: st.placeRepos || {}, iniRepos: iniRepos() })[t.item_id];
+    const w = r && r !== run.ws ? getWs(r) : null;
+    return w && !daySkillPrompt(run, 'day-task', w.id).error ? w.id : null;
+  } catch { return null; }
+}
 /** 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');
+  // a job runs in its own repository's folder, so it reads that repository's files and records (one day, many repositories)
+  const sk = daySkillPrompt(run, 'day-task', taskWsId(run, t));
   let s = null;
   const line = `This run: /day-task ${t.id} ${t.mode} — read the task first with: pmos proactive day show ${t.id}`;
   // The session that did the task's last step is used again while it is open: it has the skill and the task in its
@@ -3862,6 +3875,15 @@ function dayTick() {
 // ── end of the today day run helpers ─────────────────────────────────────────────────────────────────────────────
 /* The calendar the Agenda remembers (G23): one file beside the briefs, written only by the brief route. */
 const CAL_MEMORY = () => path.join(STATE, 'calendar-memory.json');
+// the PM's key-meeting marks (lib/calendar-memory.js setMark): a small file beside the calendar memory, written only by
+// POST /api/proactive/agenda/mark
+const CAL_MARKS = () => path.join(path.dirname(CAL_MEMORY()), 'calendar-marks.json');
+function readCalMarks() {
+  try { return calMemLib.readMarks(JSON.parse(fs.readFileSync(CAL_MARKS(), 'utf8'))); } catch { return calMemLib.readMarks(null); }
+}
+function writeCalMarks(m) {
+  try { const f = CAL_MARKS(); fs.mkdirSync(path.dirname(f), { recursive: true }); const tmp = `${f}.${process.pid}.tmp`; fs.writeFileSync(tmp, JSON.stringify(m) + '\n'); fs.renameSync(tmp, f); return true; } catch { return false; }
+}
 function readCalMemory() {
   try { return JSON.parse(fs.readFileSync(CAL_MEMORY(), 'utf8')); } catch { return null; }
 }
@@ -3935,7 +3957,30 @@ const goalsCardsMemo = new Map();   // ws -> { at, cards, error }: GET /api/proa
 function readGoalsDay(date) {
   let raw = null;
   try { raw = JSON.parse(fs.readFileSync(path.join(GOALS_DIR(), date + '.json'), 'utf8')); } catch { /* none yet */ }
-  return goalsLib.readDay(raw, date);
+  if (raw) return goalsLib.readDay(raw, date);
+  // a day with no file of its own yet starts with the goals still open on the last day that had a file (lib/goals.js
+  // carryOver); the first edit of the day writes them into the day's own file
+  let prev = null;
+  try {
+    const last = fs.readdirSync(GOALS_DIR()).map((f) => /^(\d{4}-\d{2}-\d{2})\.json$/.exec(f)).filter((m) => m && m[1] < date).map((m) => m[1]).sort().pop();
+    if (last) prev = goalsLib.readDay(JSON.parse(fs.readFileSync(path.join(GOALS_DIR(), last + '.json'), 'utf8')), last);
+  } catch { /* no earlier day */ }
+  return goalsLib.carryOver(prev, date);
+}
+/** { initiativeId: workspace id } for the initiatives exactly one registered repository holds, read at most every 30 s.
+ *  An item or goal naming one of them belongs to that repository (lib/goals.js itemRepos, goalRepos). */
+let iniReposMemo = null;
+function iniRepos(now = Date.now()) {
+  if (iniReposMemo && now - iniReposMemo.at < 30000) return iniReposMemo.map;
+  const map = {}; const twice = new Set();
+  try {
+    for (const r of portfolio().rows) {
+      if (twice.has(r.id)) continue;
+      if (map[r.id] && map[r.id] !== r.ws) { delete map[r.id]; twice.add(r.id); } else map[r.id] = r.ws;
+    }
+  } catch { /* no tags this read */ }
+  iniReposMemo = { at: now, map };
+  return map;
 }
 function latestBrief() {
   try {
@@ -7676,7 +7721,8 @@ async function handleRequest(req, res) {
       settings: { briefSources: st.briefSources, scopes: st.scopes, placeRepos: st.placeRepos, dayCheck: st.dayCheck, websites: st.websites }, sources,
       // one day for every repository: the repositories it can be narrowed to, and the repository of each tagged item
       repos: [...workspaces.values()].map((x) => ({ id: x.id, name: x.name || path.basename(x.root) })),
-      item_repos: goalsLib.itemRepos({ day: readGoalsDay(date), brief, placeRepos: st.placeRepos || {} }),
+      item_repos: goalsLib.itemRepos({ day: readGoalsDay(date), brief, placeRepos: st.placeRepos || {}, iniRepos: iniRepos(now) }),
+      goal_repos: goalsLib.goalRepos({ day: readGoalsDay(date), iniRepos: iniRepos(now) }),
       check: { every: st.dayCheck.every, last: run ? run.checks.last : null, next: due.next, running: !!(run && run.checks.session_id), log: run ? run.checks.log : [] } });
   }
   /* The Agenda month (G25 to G27): read-only. The calendar memory and today's brief, joined by lib/calendar-memory.js. */
@@ -7684,7 +7730,15 @@ async function handleRequest(req, res) {
     const now = Date.now();
     const month = url.searchParams.get('month') || undefined;
     if (month !== undefined && !/^\d{4}-\d{2}$/.test(month)) return json(res, { ok: false, error: 'month must be YYYY-MM' }, 400);
-    return json(res, calMemLib.agendaMonth({ memory: readCalMemory(), brief: briefOfDay(briefLib.localDate(now)), month, now }));
+    return json(res, calMemLib.agendaMonth({ memory: readCalMemory(), brief: briefOfDay(briefLib.localDate(now)), month, marks: readCalMarks(), now }));
+  }
+  /* A key-meeting mark: the PM's press in a meeting's detail. { title, start, scope: 'one'|'series', on: true|false|null }. */
+  if (p === '/api/proactive/agenda/mark' && req.method === 'POST') {
+    let body = {}; try { body = JSON.parse((await readBody(req)) || '{}'); } catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const r = calMemLib.setMark(readCalMarks(), { title: body.title, start: body.start, scope: body.scope, on: body.on === undefined ? null : body.on });
+    if (!r.ok) return json(res, { ok: false, error: r.error }, 400);
+    if (!writeCalMarks(r.marks)) return json(res, { ok: false, error: 'could not save — nothing changed' }, 500);
+    return json(res, { ok: true });
   }
   if (p.startsWith('/api/proactive/day/') && req.method === 'POST') {
     const verb = p.slice('/api/proactive/day/'.length);