create-pmos 0.130.0 → 0.132.0

package/workspace/lib/routes-pm-items.js

@@ -1,13 +1,29 @@
 'use strict';
-/* routes-pm-items.js — the PM's own work items and jobs to be done (planning-flows run 1 and 2, UI slice).
+/* routes-pm-items.js — the PM's own work items and jobs to be done (planning-flows run 1 and 2, UI slice; the
+ * console3 Work page: lib/pm-items.js workPlacement, lib/work-focus.js).
  *
- *   GET  /api/pm-items                     → { ok, today, lists: { waiting, today, week, triage, later }, jobs, items }
+ *   GET  /api/pm-items                     → { ok, today, lists: { waiting, today, week, triage, later }, jobs, items,
+ *                                              work: { inbox, today, upcoming, waiting, someday }  open items, placed once here
+ *                                              review, review_days: 7        open items untouched 7 days, most stale first
+ *                                              focus: { suggestions, accepted }   at most 3 suggestions: { key, title, why, item_ids, job }
+ *                                              counts: { inbox, today, upcoming, waiting, someday, review } }
  *   POST /api/pm-items/add    { line }     → { ok, item }            one line: the parser (lib/pm-items.js) reads the parts
- *   POST /api/pm-items/edit   { id, fields }→ { ok, item }            fields: title, due, priority, waiting_on, job
+ *   POST /api/pm-items/edit   { id, fields }→ { ok, item }            fields: title, due, priority, waiting_on, job,
+ *                                              defer, flagged, resolves, kind, person, evidence, outcome
  *   POST /api/pm-items/remove { id }       → { ok, undo_ms }         deleted (created here) or dropped (imported)
  *   POST /api/pm-items/undo   { id }       → { ok, item } | 409      restores the last removal inside the 8 s window
- *   POST /api/pm-items/done   { id }       → { ok }                  folds to item.done + done_at;  /reopen undoes it
+ *   POST /api/pm-items/done   { id, outcome? } → { ok }              folds to item.done + done_at (+ outcome, one line);  /reopen undoes it
  *   POST /api/pm-items/park   { id }       → { ok }                  parked: true, placed in Later;  /unpark clears it
+ *   POST /api/pm-items/flag   { id, flagged }       → { ok }         flagged: boolean; a flagged item is in Today
+ *   POST /api/pm-items/defer  { id, until|null }    → { ok }         defer: not before that date (null clears); clears parked
+ *   POST /api/pm-items/someday { id }               → { ok }         parked: true, placed in Someday
+ *   POST /api/pm-items/waiting { id, on|null }      → { ok }         waiting_on and waiting_since (null clears); clears parked
+ *   POST /api/pm-items/notyet { id, when }          → { ok }         when: later-today | tomorrow | next-week; adds 1 to not_yet_count;
+ *                                              tomorrow and next-week set defer (next Monday), later-today sets nudge_at (now + 3 h)
+ *   POST /api/pm-items/keep   { id }                → { ok }         the Review pass kept it: event 'kept', touched_at moves
+ *   POST /api/pm-items/focus/accept  { key, title, why, item_ids, job? } → { ok }   today's Focus (focus.jsonl)
+ *   POST /api/pm-items/focus/dismiss { key }        → { ok }         not suggested again today
+ *   POST /api/pm-items/focus/clear   { key }        → { ok }         forget the accept or the dismissal
  *   POST /api/pm-items/move   { id, list } → { ok }                  list_override, one of the five lists
  *   POST /api/pm-items/steps/add  { id, text, who? } → { ok, step }  outward steps are forced to agent-drafts
  *   POST /api/pm-items/steps/who  { step_id, who }   → { ok, who }
@@ -16,7 +32,7 @@
  *   POST /api/pm-jobs/edit    { id, fields }→ { ok, job }            fields: when, want, so
  *   POST /api/pm-jobs/delete  { id, reassign_to? } → { ok, reassigned }   items move to reassign_to, or to none
  *
- * STATE. Two append-only files under <runtime>/pm-items/: items.jsonl and jobs.jsonl. Every write is one appended line
+ * STATE. Append-only files under <runtime>/pm-items/: items.jsonl, jobs.jsonl, steps.jsonl and focus.jsonl. Every write is one appended line
  * through pm-items.appendEvent, the single writer, and the GET folds the whole file again. Nothing is read from Jira.
  *
  * WHO WRITES. Every POST passes pm-guard requirePagePress: the page only, with the Origin and nonce checks. An agent
@@ -28,9 +44,12 @@ const crypto = require('crypto');
 const guard = require('./pm-guard.js');
 const pmItems = require('./pm-items.js');
 const jobs = require('./jobs-to-be-done.js');
+const workFocus = require('./work-focus.js');
 const steps = require('./item-steps.js');
 
-const FIELDS = ['title', 'due', 'priority', 'waiting_on', 'job'];
+const FIELDS = ['title', 'due', 'priority', 'waiting_on', 'job', 'defer', 'flagged', 'resolves', 'kind', 'person', 'evidence', 'outcome'];
+const STRING_OR_NULL = ['resolves', 'person', 'evidence', 'outcome'];
+const NOT_YET = ['later-today', 'tomorrow', 'next-week'];
 const JOB_FIELDS = ['when', 'want', 'so'];
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -38,17 +57,40 @@ const dirOf = (ctx) => path.join(ctx.runtimeDir, 'pm-items');
 const itemsFile = (ctx) => path.join(dirOf(ctx), 'items.jsonl');
 const stepsFile = (ctx) => path.join(dirOf(ctx), 'steps.jsonl');
 const jobsFile = (ctx) => path.join(dirOf(ctx), 'jobs.jsonl');
+const focusFile = (ctx) => path.join(dirOf(ctx), 'focus.jsonl');
 const newId = (prefix) => `${prefix}-${crypto.randomBytes(6).toString('hex')}`;
 
 // The current view, folded from the files. `now` decides placement, so tests can pin the day.
-function view(itemLines, jobLines, now, stepLines = []) {
+// The titles of the team tasks (plan items) that own items advance, so the page can say "Advances: <title>". Best effort: no workspace, no map.
+function resolvesTitles(items, ctx, url) {
+  const ids = [...new Set((items || []).map((i) => i.resolves).filter(Boolean))];
+  if (!ids.length || typeof ctx.getWs !== 'function') return {};
+  try {
+    const w = ctx.getWs(String(url.searchParams.get('ws') || ''));
+    if (!w || !w.root) return {};
+    const fold = require('./plan-items.js').readFold(w.root);
+    const out = {};
+    for (const id of ids) if (fold.items[id] && fold.items[id].title) out[id] = fold.items[id].title;
+    return out;
+  } catch { return {}; }
+}
+
+function view(itemLines, jobLines, now, stepLines = [], focusLines = []) {
   const today = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
   const byItem = steps.foldSteps(stepLines).byItem;
   const items = pmItems.fold(itemLines).map((i) => ({ ...i, steps: byItem[i.id] || [] }));
   const currentJobs = jobs.foldJobs(jobLines).map((j) => ({ ...j, ...jobs.progress(j.id, items) }));
   const lists = Object.fromEntries(pmItems.LISTS.map((l) => [l, []]));
   for (const it of items) lists[pmItems.placement(it, today)].push(it);
-  return { ok: true, today: today.toISOString().slice(0, 10), lists, jobs: currentJobs, items };
+  const todayIso = today.toISOString().slice(0, 10);
+  const work = Object.fromEntries(pmItems.WORK_LISTS.map((l) => [l, []]));
+  for (const it of items) if (!it.done) work[pmItems.workPlacement(it, today)].push(it);
+  for (const l of pmItems.WORK_LISTS) work[l] = pmItems.sortWorkList(l, work[l], today);
+  const review = pmItems.reviewQueue(items, now);
+  const state = workFocus.foldFocus(focusLines, todayIso);
+  const focus = { suggestions: workFocus.focusSuggestions(work.today, currentJobs, state, todayIso), accepted: state.accepted };
+  const counts = { ...Object.fromEntries(pmItems.WORK_LISTS.map((l) => [l, work[l].length])), review: review.length };
+  return { ok: true, today: todayIso, lists, jobs: currentJobs, items, work, review, review_days: pmItems.REVIEW_DAYS, focus, counts };
 }
 
 // Each operation returns { status, body, events } and writes nothing itself; the caller appends `events`.
@@ -59,6 +101,12 @@ function checkFields(fields, allowed) {
   }
   if ('due' in fields && fields.due !== null && !DATE_RE.test(String(fields.due))) return 'due must be YYYY-MM-DD or null';
   if ('priority' in fields && fields.priority !== null && !/^P[1-3]$/.test(String(fields.priority))) return 'priority must be P1, P2, P3 or null';
+  if ('defer' in fields && fields.defer !== null && !DATE_RE.test(String(fields.defer))) return 'defer must be YYYY-MM-DD or null';
+  if ('flagged' in fields && typeof fields.flagged !== 'boolean') return 'flagged must be true or false';
+  if ('kind' in fields && fields.kind !== null && fields.kind !== 'offline') return 'kind must be offline or null';
+  for (const k of STRING_OR_NULL) {
+    if (k in fields && fields[k] !== null && typeof fields[k] !== 'string') return `${k} must be a string or null`;
+  }
   return null;
 }
 
@@ -98,7 +146,11 @@ function flagItem(body, itemLines, events) {
   if (!item) return noItem;
   return { status: 200, body: { ok: true }, events: typeof events === 'function' ? events(item) : events };
 }
-const doneItem = (b, l) => flagItem(b, l, [{ event: 'done', id: b.id }]);
+function doneItem(b, l) {
+  if (b.outcome !== undefined && b.outcome !== null && typeof b.outcome !== 'string') return { status: 400, body: { ok: false, error: 'outcome must be a string' } };
+  const outcome = typeof b.outcome === 'string' && b.outcome.trim() ? { outcome: b.outcome.trim() } : {};
+  return flagItem(b, l, [{ event: 'done', id: b.id, ...outcome }]);
+}
 const reopenItem = (b, l) => flagItem(b, l, [{ event: 'reopened', id: b.id }]);
 const parkItem = (b, l) => flagItem(b, l, [{ event: 'edited', id: b.id, fields: { parked: true, list_override: null } }]);
 const unparkItem = (b, l) => flagItem(b, l, [{ event: 'edited', id: b.id, fields: { parked: false } }]);
@@ -107,6 +159,53 @@ function moveItem(b, l) {
   return flagItem(b, l, [{ event: 'edited', id: b.id, fields: { list_override: b.list, parked: false } }]);
 }
 
+// Work page routes. A legacy list_override would beat the new placement, so the routes that place an item clear it.
+const bad = (error) => ({ status: 400, body: { ok: false, error } });
+function flagRoute(b, l) {
+  if (typeof b.flagged !== 'boolean') return bad('flagged must be true or false');
+  return flagItem(b, l, [{ event: 'edited', id: b.id, fields: { flagged: b.flagged } }]);
+}
+function deferItem(b, l) {
+  if (b.until !== null && !DATE_RE.test(String(b.until))) return bad('until must be YYYY-MM-DD or null');
+  return flagItem(b, l, [{ event: 'edited', id: b.id, fields: { defer: b.until, parked: false, list_override: null } }]);
+}
+const somedayItem = (b, l) => flagItem(b, l, [{ event: 'edited', id: b.id, fields: { parked: true, list_override: null } }]);
+function waitingItem(b, l, now) {
+  const on = typeof b.on === 'string' ? b.on.trim() : b.on;
+  if (on !== null && (typeof on !== 'string' || !on)) return bad('on must be a name or null');
+  return flagItem(b, l, [{ event: 'edited', id: b.id, fields: { waiting_on: on, waiting_since: on ? now.toISOString() : null, parked: false, list_override: null } }]);
+}
+// "Not yet": tomorrow and next Monday are dates (defer); later today only counts and nudges 3 hours on.
+// Dates follow the server's UTC day, as the placement does.
+function notYetItem(b, l, now) {
+  if (!NOT_YET.includes(b.when)) return bad('when must be one of ' + NOT_YET.join(', '));
+  return flagItem(b, l, (item) => {
+    const fields = { not_yet_count: (item.not_yet_count || 0) + 1 };
+    const day = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()));
+    const plus = (n) => new Date(day.getTime() + n * 86400000).toISOString().slice(0, 10);
+    if (b.when === 'later-today') fields.nudge_at = new Date(now.getTime() + 3 * 3600000).toISOString();
+    else {
+      fields.defer = b.when === 'tomorrow' ? plus(1) : plus(((1 - day.getUTCDay() + 7) % 7) || 7);
+      fields.nudge_at = null;
+      fields.list_override = null;
+    }
+    return [{ event: 'edited', id: b.id, fields }];
+  });
+}
+const keepItem = (b, l) => flagItem(b, l, [{ event: 'kept', id: b.id }]);
+
+// Focus events go to focus.jsonl. The day comes from the server date, never from the page.
+function focusEvent(kind, b, now) {
+  if (typeof b.key !== 'string' || !b.key) return bad('key is required');
+  const day = now.toISOString().slice(0, 10);
+  if (kind !== 'accepted') return { status: 200, body: { ok: true }, events: [{ event: kind, key: b.key, day }] };
+  if (typeof b.title !== 'string' || !b.title.trim()) return bad('title is required');
+  if (typeof b.why !== 'string') return bad('why must be a string');
+  if (!Array.isArray(b.item_ids) || b.item_ids.some((x) => typeof x !== 'string')) return bad('item_ids must be a list of item ids');
+  if (b.job !== undefined && b.job !== null && typeof b.job !== 'string') return bad('job must be a string or null');
+  return { status: 200, body: { ok: true }, events: [{ event: 'accepted', key: b.key, title: b.title.trim(), why: b.why, item_ids: b.item_ids, job: b.job || null, day }] };
+}
+
 function addStepRoute(b, itemLines) {
   if (!findItem(itemLines, b.id)) return noItem;
   const id = newId('step');
@@ -172,6 +271,15 @@ const ROUTES = {
   'POST /api/pm-items/park': (b, ctx) => ({ ...parkItem(b, ctx.itemLines), file: 'items' }),
   'POST /api/pm-items/unpark': (b, ctx) => ({ ...unparkItem(b, ctx.itemLines), file: 'items' }),
   'POST /api/pm-items/move': (b, ctx) => ({ ...moveItem(b, ctx.itemLines), file: 'items' }),
+  'POST /api/pm-items/flag': (b, ctx) => ({ ...flagRoute(b, ctx.itemLines), file: 'items' }),
+  'POST /api/pm-items/defer': (b, ctx) => ({ ...deferItem(b, ctx.itemLines), file: 'items' }),
+  'POST /api/pm-items/someday': (b, ctx) => ({ ...somedayItem(b, ctx.itemLines), file: 'items' }),
+  'POST /api/pm-items/waiting': (b, ctx) => ({ ...waitingItem(b, ctx.itemLines, ctx.now || new Date()), file: 'items' }),
+  'POST /api/pm-items/notyet': (b, ctx) => ({ ...notYetItem(b, ctx.itemLines, ctx.now || new Date()), file: 'items' }),
+  'POST /api/pm-items/keep': (b, ctx) => ({ ...keepItem(b, ctx.itemLines), file: 'items' }),
+  'POST /api/pm-items/focus/accept': (b, ctx) => ({ ...focusEvent('accepted', b, ctx.now || new Date()), file: 'focus' }),
+  'POST /api/pm-items/focus/dismiss': (b, ctx) => ({ ...focusEvent('dismissed', b, ctx.now || new Date()), file: 'focus' }),
+  'POST /api/pm-items/focus/clear': (b, ctx) => ({ ...focusEvent('cleared', b, ctx.now || new Date()), file: 'focus' }),
   'POST /api/pm-items/steps/add': (b, ctx) => ({ ...addStepRoute(b, ctx.itemLines), file: 'steps' }),
   'POST /api/pm-items/steps/who': (b, ctx) => ({ ...stepWho(b, ctx.stepLines), file: 'steps' }),
   'POST /api/pm-items/steps/plan': (b, ctx) => ({ ...planSteps(b, ctx.itemLines), file: 'steps' }),
@@ -181,17 +289,19 @@ const ROUTES = {
 };
 
 function prepare(ctx, now = new Date()) {
-  return { itemLines: pmItems.readLines(itemsFile(ctx)), jobLines: pmItems.readLines(jobsFile(ctx)), stepLines: pmItems.readLines(stepsFile(ctx)), now };
+  return { itemLines: pmItems.readLines(itemsFile(ctx)), jobLines: pmItems.readLines(jobsFile(ctx)), stepLines: pmItems.readLines(stepsFile(ctx)), focusLines: pmItems.readLines(focusFile(ctx)), now };
 }
 
 module.exports = {
   prefixes: ['/api/pm-items', '/api/pm-jobs'],
-  view, doneItem, reopenItem, parkItem, unparkItem, moveItem, addStepRoute, stepWho, planSteps, addItem, editItem, removeItem, undoItem, addJob, editJob, deleteJob, checkFields, ROUTES, prepare,
+  view, resolvesTitles, flagRoute, deferItem, somedayItem, waitingItem, notYetItem, keepItem, focusEvent, doneItem, reopenItem, parkItem, unparkItem, moveItem, addStepRoute, stepWho, planSteps, addItem, editItem, removeItem, undoItem, addJob, editJob, deleteJob, checkFields, ROUTES, prepare,
   handle: async (req, res, url, ctx) => {
     const p = url.pathname;
     if (p === '/api/pm-items' && req.method === 'GET') {
       const c = prepare(ctx);
-      ctx.json(res, view(c.itemLines, c.jobLines, c.now, c.stepLines));
+      const v = view(c.itemLines, c.jobLines, c.now, c.stepLines, c.focusLines);
+      v.resolves_titles = resolvesTitles(v.items, ctx, url);
+      ctx.json(res, v);
       return true;
     }
     const key = `${req.method} ${p}`;
@@ -207,7 +317,7 @@ module.exports = {
       for (const ev of r.events) {
         const which = ev._file || r.file;
         const { _file, ...line } = ev;
-        pmItems.appendEvent(which === 'jobs' ? jobsFile(ctx) : which === 'steps' ? stepsFile(ctx) : itemsFile(ctx), line, c.now);
+        pmItems.appendEvent(which === 'jobs' ? jobsFile(ctx) : which === 'steps' ? stepsFile(ctx) : which === 'focus' ? focusFile(ctx) : itemsFile(ctx), line, c.now);
       }
     }
     ctx.json(res, r.body, r.status);

package/workspace/lib/routes-sources.js

@@ -0,0 +1,64 @@
+'use strict';
+/* routes-sources.js — how old each source of a workspace is, and Refresh now (workspace-data-freshness R6, R7).
+ *
+ *   GET  /api/sources?ws=<id>                → { ok, ws, version, sources: [row] }   lib/freshness.js sources()
+ *   POST /api/sources/refresh { ws, source } → { ok, source, started: 'rebuild'|'session', session? }
+ *   POST /api/sources/watch   { ws, on }     → { ok, watch }   the change detector on or off for this repository
+ *
+ * Both POSTs pass pm-guard requirePagePress: the PM's press from the page. An agent session cannot start a refresh or
+ * switch the detector off. A refresh of `repository` or `initiatives` rebuilds the facts in a child process; a refresh of
+ * an external source starts that source's skill as a session in the workspace, with the PM's own connections. The server
+ * itself calls nothing outside this machine.
+ */
+const guard = require('./pm-guard.js');
+const freshness = require('./freshness.js');
+
+function wsOf(ctx, id) {
+  const w = ctx.getWs(id || '');
+  return w && (!id || w.id === id) ? w : null;
+}
+const repoStateDir = (ctx, w) => { try { return ctx.stateDirFor ? ctx.stateDirFor(w) : null; } catch { return null; } };
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const F = ctx.freshness;
+  if (!F) return false;
+  if (p === '/api/sources') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    const w = wsOf(ctx, url.searchParams.get('ws'));
+    if (!w) { ctx.json(res, { ok: false, error: 'no such workspace' }, 404); return true; }
+    const sources = F.sources({ id: w.id, root: w.root, repoStateDir: repoStateDir(ctx, w) });
+    ctx.json(res, { ok: true, ws: w.id, version: F.versions()[w.id] || 0, sources });
+    return true;
+  }
+  if (p !== '/api/sources/refresh' && p !== '/api/sources/watch') return false;
+  if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
+  const got = await ctx.readJson(req);
+  if (!got.ok) { ctx.json(res, { ok: false, error: 'the body is not JSON' }, 400); return true; }
+  const body = got.body || {};
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
+  const w = wsOf(ctx, typeof body.ws === 'string' ? body.ws : '');
+  if (!w) { ctx.json(res, { ok: false, error: 'no such workspace' }, 404); return true; }
+
+  if (p === '/api/sources/watch') {
+    if (typeof body.on !== 'boolean') { ctx.json(res, { ok: false, error: 'on must be true or false' }, 400); return true; }
+    if (!F.setEnabled(w.root, body.on)) { ctx.json(res, { ok: false, error: 'the setting could not be saved' }, 500); return true; }
+    ctx.json(res, { ok: true, watch: F.enabled(w.root) });
+    return true;
+  }
+
+  const src = freshness.SOURCES.find((s) => s.id === body.source);
+  if (!src) { ctx.json(res, { ok: false, error: 'source must be one of ' + freshness.SOURCES.map((s) => s.id).join(', ') }, 400); return true; }
+  if (!src.skill) {
+    ctx.factsRefresh(w.root);
+    ctx.json(res, { ok: true, source: src.id, started: 'rebuild' });
+    return true;
+  }
+  const r = ctx.startSkill(w.id, src.skill, `${src.label} · refresh`);
+  if (!r.ok) { ctx.json(res, { ok: false, error: r.error }, r.status || 500); return true; }
+  ctx.json(res, { ok: true, source: src.id, started: 'session', session: r.session });
+  return true;
+}
+
+module.exports = { prefixes: ['/api/sources'], handle };

package/workspace/lib/work-focus.js

@@ -0,0 +1,106 @@
+'use strict';
+/* work-focus.js — Focus on the Work page: up to three jobs PMOS suggests for today (console3 PRD R4).
+ *
+ * Rules first, no model call. Pure functions; the route layer reads and writes focus.jsonl.
+ *
+ * focusSuggestions(workToday, jobs, state, todayIso)
+ *   Groups the Today items by their job (an item with no job is its own group, key 'item:<id>'; a job group's key
+ *   is 'job:<jobId>'), scores each group, and returns the best three as { key, title, why, item_ids, job }.
+ *   Score per item: overdue 3 per day (at most 9), due today 2, flagged 2, P1 2, offline 1. A group scores the
+ *   sum of its items. A key the PM accepted or dismissed today is not suggested again.
+ *
+ * foldFocus(lines, todayIso)
+ *   The focus.jsonl events 'accepted', 'dismissed' and 'cleared' carry `day` (YYYY-MM-DD, set by the route from the
+ *   server date). Only today's events count, so Focus starts empty each day. Returns { accepted, dismissed }.
+ */
+const MAX_SUGGESTIONS = 3;
+const DAY_MS = 86400000;
+
+const dayNumber = (isoDay) => Math.floor(Date.parse(`${isoDay}T00:00:00Z`) / DAY_MS);
+
+function parts(item, todayIso) {
+  const overdueDays = item.due && item.due < todayIso ? dayNumber(todayIso) - dayNumber(item.due) : 0;
+  return {
+    overdueDays,
+    dueToday: item.due === todayIso,
+    flagged: item.flagged === true,
+    p1: item.priority === 'P1',
+    offline: item.kind === 'offline',
+  };
+}
+
+function itemScore(p) {
+  return Math.min(p.overdueDays * 3, 9) + (p.dueToday ? 2 : 0) + (p.flagged ? 2 : 0) + (p.p1 ? 2 : 0) + (p.offline ? 1 : 0);
+}
+
+// Plain words, no dashes: "2 items overdue, 1 flagged".
+function whyText(list) {
+  const n = (f) => list.filter(f).length;
+  const overdue = n((p) => p.overdueDays > 0);
+  const bits = [];
+  if (overdue) bits.push(`${overdue} ${overdue === 1 ? 'item' : 'items'} overdue`);
+  if (n((p) => p.dueToday)) bits.push(`${n((p) => p.dueToday)} due today`);
+  if (n((p) => p.flagged)) bits.push(`${n((p) => p.flagged)} flagged`);
+  if (n((p) => p.p1)) bits.push(`${n((p) => p.p1)} at P1`);
+  if (n((p) => p.offline)) bits.push(`${n((p) => p.offline)} outside PMOS`);
+  return bits.length ? bits.join(', ') : 'Planned for today';
+}
+
+function jobTitle(job) {
+  const t = job && (job.want || job.when || job.so);
+  return t ? String(t).trim() : 'A standing job';
+}
+
+function focusSuggestions(workToday, jobs, state, todayIso) {
+  const blocked = new Set([...(state && state.accepted ? state.accepted.map((a) => a.key) : []), ...(state && state.dismissed ? state.dismissed : [])]);
+  const jobById = new Map((jobs || []).map((j) => [j.id, j]));
+  const groups = new Map();
+  for (const item of workToday || []) {
+    const job = item.job && jobById.has(item.job) ? item.job : null;
+    const key = job ? `job:${job}` : `item:${item.id}`;
+    if (!groups.has(key)) groups.set(key, { key, job, members: [] });
+    const p = parts(item, todayIso);
+    groups.get(key).members.push({ item, p, score: itemScore(p) });
+  }
+  const out = [];
+  for (const g of groups.values()) {
+    if (blocked.has(g.key)) continue;
+    g.members.sort((a, b) => b.score - a.score);
+    out.push({
+      key: g.key,
+      score: g.members.reduce((sum, m) => sum + m.score, 0),
+      earliest: g.members.map((m) => m.item.due || '9999').sort()[0],
+      suggestion: {
+        key: g.key,
+        title: g.job ? jobTitle(jobById.get(g.job)) : g.members[0].item.title,
+        why: whyText(g.members.map((m) => m.p)),
+        item_ids: g.members.map((m) => m.item.id),
+        job: g.job,
+      },
+    });
+  }
+  const cmp = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+  out.sort((a, b) => b.score - a.score || cmp(a.earliest, b.earliest) || cmp(a.key, b.key));
+  return out.slice(0, MAX_SUGGESTIONS).map((o) => o.suggestion);
+}
+
+function foldFocus(lines, todayIso) {
+  const accepted = new Map();
+  const dismissed = new Set();
+  for (const ev of lines || []) {
+    if (!ev || !ev.key || ev.day !== todayIso) continue;
+    if (ev.event === 'accepted') {
+      dismissed.delete(ev.key);
+      accepted.set(ev.key, { key: ev.key, title: ev.title, why: ev.why, item_ids: ev.item_ids || [], job: ev.job || null });
+    } else if (ev.event === 'dismissed') {
+      accepted.delete(ev.key);
+      dismissed.add(ev.key);
+    } else if (ev.event === 'cleared') {
+      accepted.delete(ev.key);
+      dismissed.delete(ev.key);
+    }
+  }
+  return { accepted: [...accepted.values()], dismissed };
+}
+
+module.exports = { MAX_SUGGESTIONS, focusSuggestions, foldFocus };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.130.0",
+  "version": "0.132.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.130.0",
+      "version": "0.132.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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