create-pmos 0.130.0 → 0.132.0

package/workspace/public/pm/work-place.js

@@ -0,0 +1,58 @@
+/* pm/work-place.js — the Work page's placement rule, as the client needs it (initiative console3-work-page, PRD R2, R5, R7).
+ *
+ * The SERVER places every item (lib/pm-items.js workPlacement) and answers GET /api/pm-items with `work`, `review` and `counts`.
+ * The client never copies an item from one view to another. It uses this copy of the rule for two things only:
+ *   1. the capture line's preview chip, which says where a new line lands before it is saved;
+ *   2. demo mode (/c3.html?demo=1), where nothing reaches the server, so the fixture and the in-memory overlay are placed here.
+ * The rule, in order: parked is Someday; waiting on someone is Waiting; a "not before" (defer) date after today is Upcoming;
+ * flagged is Today; due today or earlier is Today; a later due date is Upcoming; no date is Inbox. Dates are YYYY-MM-DD strings.
+ * Pure: no DOM, no fetch. */
+
+export const VIEWS = Object.freeze(['inbox', 'today', 'upcoming', 'waiting', 'someday']);
+export const REVIEW_DAYS = 7;
+
+const day = (s) => (s ? String(s).slice(0, 10) : '');
+export function addIso(s, n) { const d = new Date(day(s) + 'T00:00:00Z'); d.setUTCDate(d.getUTCDate() + n); return d.toISOString().slice(0, 10); }
+export function daysBetween(a, b) { return Math.round((Date.parse(day(b) + 'T00:00:00Z') - Date.parse(day(a) + 'T00:00:00Z')) / 86400000); }
+
+/** The view an open item belongs in. */
+export function workPlace(item, today) {
+  const i = item || {};
+  if (i.parked) return 'someday';
+  if (i.waiting_on) return 'waiting';
+  if (i.defer && day(i.defer) > today) return 'upcoming';
+  if (i.flagged) return 'today';
+  if (i.due && day(i.due) <= today) return 'today';
+  if (i.due) return 'upcoming';
+  return 'inbox';
+}
+
+/** The day an Upcoming item arrives: its "not before" date when that is still ahead, else its due date. */
+export function arrives(item, today) { return item.defer && day(item.defer) > today ? day(item.defer) : day(item.due); }
+
+/** The days since the item was last touched (any event), from touched_at, else created_at. */
+export function untouchedDays(item, today) { const t = day(item.touched_at || item.created_at); return t ? daysBetween(t, today) : 0; }
+
+const byStr = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+/** Each view in the order the PRD's contract gives: Today overdue first, then flagged, then by due; Upcoming by arrival; Inbox newest first. */
+export function sortView(view, list, today) {
+  const l = list.slice();
+  if (view === 'today') {
+    const rank = (i) => (i.due && day(i.due) < today ? 0 : i.flagged ? 1 : 2);
+    l.sort((a, b) => rank(a) - rank(b) || byStr(day(a.due) || '9999', day(b.due) || '9999') || byStr(String(a.time || ''), String(b.time || '')));
+  } else if (view === 'upcoming') l.sort((a, b) => byStr(arrives(a, today), arrives(b, today)));
+  else if (view === 'inbox') l.sort((a, b) => byStr(String(b.created_at || ''), String(a.created_at || '')));
+  return l;
+}
+
+/** { work, review, counts } for a set of items (done ones are left out), as the server's answer has them. */
+export function buildWork(items, today, reviewDays = REVIEW_DAYS) {
+  const work = Object.fromEntries(VIEWS.map((v) => [v, []]));
+  const open = (items || []).filter((i) => i && !i.done);
+  open.forEach((i) => work[workPlace(i, today)].push(i));
+  VIEWS.forEach((v) => { work[v] = sortView(v, work[v], today); });
+  const review = open.filter((i) => ['inbox', 'someday', 'waiting'].includes(workPlace(i, today)) && untouchedDays(i, today) >= reviewDays)
+    .sort((a, b) => untouchedDays(b, today) - untouchedDays(a, today));
+  const counts = { ...Object.fromEntries(VIEWS.map((v) => [v, work[v].length])), review: review.length };
+  return { work, review, counts };
+}

package/workspace/server.js

@@ -1942,6 +1942,21 @@ const autoSync = require('./lib/auto-sync').createAutoSync({
   onDone: (root) => boardCache.invalidate(root),
   label: `${os.hostname()} (auto-sync)`,
 });
+// workspace-data-freshness (R2 to R4): the facts cache is kept in the runtime state folder, and ONE change detector per
+// workspace starts the board and facts rebuilds when the repository changes, so nothing is re-read on a clock. The board
+// keeps its last value while it rebuilds (stale while revalidate): dropping it would show a blank Board on every change.
+const factsAsync = require('./lib/facts-async.js');
+factsAsync.configure({ stateDir: STATE });
+const freshness = require('./lib/freshness.js').create({
+  stateDir: STATE,
+  workspaces: () => [...workspaces.values()],
+  schedules: () => readSchedules(),
+  factsStatus: (root) => factsAsync.status(root),
+  onChange: (w) => { boardCache.board(w.root, { refreshNow: true }); factsAsync.refresh(w.root); },
+  pollMs: Math.max(250, Number(process.env.PMOS_FRESH_POLL_MS) || 10000),
+  stableMs: Math.max(0, Number(process.env.PMOS_FRESH_STABLE_MS) || 3000),
+});
+if (!REQUIRED_AS_LIBRARY) freshness.start();
 const STOPPED_STATES = ['closed', 'on-hold', 'cancelled'];
 function readLifecycle(w) {
   const latest = new Map();
@@ -2362,6 +2377,12 @@ const SEED_SETS = {
   // jira-wbs (J14): the agent step that reads the status of every pushed Jira ticket into each initiative's snapshot,
   // read-only. Daily at 06:30, so the morning brief (06:45) and every report read a status at most a day old.
   jira: [{ name: 'Jira status check', skill: 'jira-sync', cadence: 'daily', time: '06:30' }],
+  // workspace-data-freshness (R8): the read-only calendar pull, before the morning brief (06:45) and again at midday, so
+  // Briefing and Calendar never work from yesterday's events.
+  calendar: [
+    { name: 'Calendar pull (morning)', skill: 'calendar-sync', cadence: 'daily', time: '06:30' },
+    { name: 'Calendar pull (midday)', skill: 'calendar-sync', cadence: 'daily', time: '12:30' },
+  ],
 };
 function readSchedules() {
   try { const a = JSON.parse(fs.readFileSync(schedFile(), 'utf8')); return Array.isArray(a) ? a : []; } catch { return []; }
@@ -4065,6 +4086,18 @@ function myWorkRead(wsId) {
   if (!s || s.state === 'exited') return { ok: false, status: 500, error: (s && s.note) || 'the read session could not start' };
   return { ok: true, session: s.id };
 }
+/** Refresh now (workspace-data-freshness R7): start skill `skillId` in a session of repository `wsId`, as myWorkRead does. */
+function startSkillSession(wsId, skillId, name) {
+  const w = getWs(wsId);
+  if (!w) return { ok: false, status: 400, error: 'no workspace' };
+  const task = taskById(skillId, w.root);
+  if (!task || task.kind !== 'agent' || !task.prompt) return { ok: false, status: 409, error: `the ${skillId} skill is not installed for this repository` };
+  const prompt = skillStore.retargetFiling(task.prompt, filingContract(w));
+  const s = spawnSession({ name, agent: task.agent || 'claude', ws: w.id, origin: 'source-refresh', initialInput: prompt + '\r',
+    modelAsk: { scheduleTier: null, skillTier: task.tier || null, skill: task.skill } });
+  if (!s || s.state === 'exited') return { ok: false, status: 500, error: (s && s.note) || 'the refresh session could not start' };
+  return { ok: true, session: s.id };
+}
 /* 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
@@ -6457,7 +6490,9 @@ async function handleRequest(req, res) {
   // `ledgers` (pm-os-absorb Run 1) — the plan-items signature of every registered workspace, so an open Breakdown
   // knows to refetch: `items` is one stat per workspace; `evidence` is computed only for the ids in ?ledgers=
   // (at most 4). Computed on this request and never stored (D33).
-  if (p === '/api/sessions') return json(res, { sessions: sessionList(), version: APP_VERSION,
+  // `data_versions` (workspace-data-freshness R4): a number per workspace that moves when its files change, so a page
+  // refetches only then.
+  if (p === '/api/sessions') return json(res, { sessions: sessionList(), version: APP_VERSION, data_versions: freshness.versions(),
     ledgers: planItems.ledgerSigs([...workspaces.values()].map((w) => ({ id: w.id, root: w.root })), url.searchParams.get('ledgers')) });
   if (p === '/api/git/branches') {
     // Read-only branch awareness for a workspace. A non-repo returns {ok:false} (never a fake
@@ -8654,7 +8689,9 @@ async function handleRequest(req, res) {
   if (await routeModules.dispatch(req, res, url, { json, readBody, getWs, invalidateNeedsAgg, boardCache, consoleState, stateDirFor, sessionList, initiativeIndex,
     runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession,
     // initiative my-work: every registered repository, the day runs, and the two presses that start sessions
-    workspaceList: () => [...workspaces.values()], readDayRun, myWorkBrief, myWorkRead })) return;
+    workspaceList: () => [...workspaces.values()], readDayRun, myWorkBrief, myWorkRead,
+    // workspace-data-freshness: the source table, the facts rebuild and Refresh now's skill sessions
+    freshness, factsRefresh: (root) => factsAsync.refresh(root, { force: true }), startSkill: startSkillSession })) return;
   res.writeHead(404); res.end('not found');
 }
 

package/workspace/skills/calendar-sync.skill

@@ -0,0 +1,30 @@
+---
+name: calendar-sync
+label: "Calendar pull"
+description: "Read, read-only, the PM's calendar events for today and the next 14 days, and hand them to PMOS so Briefing and Calendar work from today's events. It writes nothing to the calendar."
+run: agent
+agent: claude
+output:
+  - Imported
+  - Not reached
+  - Needs you
+---
+
+/calendar-sync — bring the PM's calendar up to date in PMOS. You read the calendar with the PM's own calendar connection. PMOS saves what you read and shows it on Briefing and Calendar. You change nothing in the calendar.
+
+Rules that always hold:
+1. READ-ONLY on the calendar. Use only the tools that list or read events. Never create, edit, move, accept, decline, delete or respond to an event, and never send an invitation or a message.
+2. THE ONLY WRITE is `pmos calendar import --from <file> --sensitivity <label>`, once, at the end. Never edit a repository file. Never commit.
+3. LIGHT ON CONTENT. For each event, give only its id, title, start, end, the attendees' display names and, when you can tell, the initiative id it is for. Never copy a description, a meeting link, a dial-in number, an attachment, an email address or a token.
+4. SENSITIVITY. Use `internal` unless the PM said otherwise. Leave out any event marked private, personal, confidential or HR, and count it.
+5. TEMPORARY FILES OUTSIDE THE REPOSITORY. Write the events file in this session's scratch folder, and delete it after the import.
+6. NOTHING INVENTED. If the calendar cannot be reached, list it under "Not reached" and import nothing: an empty import is not a calendar with no meetings.
+
+Procedure:
+1. List the PM's events from the start of today to the end of the 14th day after today, from the primary calendar. Fetch every page. Skip an event the PM declined.
+2. Write the events as JSON in the scratch folder, for example `<scratch>/calendar.json`, as a list with one object per event:
+   `{"id", "title", "start", "end", "attendees": ["Display Name", …], "initiative": "<initiative id or null>"}`
+   `start` and `end` are ISO times with the offset, for example `2026-10-12T09:00:00+07:00`. An all-day event has the date only.
+3. Run `pmos calendar import --from <scratch>/calendar.json --sensitivity internal`. If it refuses the file, fix what it names and run it once more.
+4. Delete the scratch file.
+5. Report in four short lists: Imported (the count, and the first and last day), Left out (the count of private events), Not reached, and Needs you (only when something blocked the pull).

package/workspace/test-files.json

@@ -25,6 +25,7 @@
     "pm-items.test.js",
     "jobs-to-be-done.test.js",
     "pm-items-routes.test.js",
+    "work-focus.test.js",
     "brief-page.test.js",
     "item-steps.test.js",
     "status-facts-panel.test.js",
@@ -147,6 +148,7 @@
     "pm-items.test.js": 1,
     "jobs-to-be-done.test.js": 1,
     "pm-items-routes.test.js": 1,
+    "work-focus.test.js": 1,
     "brief-page.test.js": 1,
     "pm-brief-page-test.js": 30,
     "item-steps.test.js": 1,

package/workspace/test-lists/calendar-layers.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "calendar-layers: GET /api/calendar-views layers, free blocks and event context (initiative calendar-time-page, R2 to R5, R8).",
+  "modules": ["calendar-layers.test.js"],
+  "seconds": { "calendar-layers.test.js": 2 }
+}

package/workspace/test-lists/calendar-time-page.json

@@ -0,0 +1,5 @@
+{
+  "_comment": "Initiative calendar-time-page: the console3 Calendar tab as a page about time (layers, meeting context, free time). Demo fixture /c3.html?demo=1.",
+  "panels": ["pm-calendar-page-test.js"],
+  "seconds": { "pm-calendar-page-test.js": 40 }
+}

package/workspace/test-lists/console3-work-page.json

@@ -0,0 +1,9 @@
+{
+  "_comment": "Initiative console3-work-page: the Work page browser suite.",
+  "panels": [
+    "c3-work-test.js"
+  ],
+  "seconds": {
+    "c3-work-test.js": 30
+  }
+}

package/workspace/test-lists/workspace-data-freshness.json

@@ -0,0 +1,6 @@
+{
+  "_comment": "workspace-data-freshness: the shared commit range, the change-keyed facts cache, the change detector and data version, the source table and Refresh now, the worker-thread folds, and pmos calendar.",
+  "modules": ["data-freshness.test.js"],
+  "panels": [],
+  "seconds": { "data-freshness.test.js": 25 }
+}

package/workspace/public/pm/c3-demo-work2.js

@@ -1,13 +0,0 @@
-/* pm/c3-demo-work2.js — demo-only fixtures of the Work tab's Jobs card (/c3.html?demo=1). Sets window.__c3work2, which pm-work-view.js reads in demo mode only.
- * jobAll: for each job, the items the mockup lists in its case file under "All N items, across every list" (console3.html c3jall, line 4653),
- * grouped by list in the order triage, today, week, waiting, later, done. Each group is [list label, [titles], struck-through?]. The titles are the
- * mockup's own S.items (line 1070); the demo list data holds a few more items under job 1, so the count shown here is the mockup's. */
-window.__c3work2 = {
-  jobAll: {
-    j1: [['Triage', ['Assign owners to 2 unowned workshop actions', 'Approve pricing-page copy before handoff', 'Confirm the growth assumption in the Q4 forecast']],
-      ['Today', ['Cut Checkout v2 to 3 core flows to hold 24 Oct?']], ['Waiting', ['Payments sandbox keys', 'Annual-plan label']], ['Done', ['Send revised PRD to Dara'], true]],
-    j2: [['Triage', ['Confirm the 1 Oct numbers before the 10:30 update']]],
-    j3: [['Triage', ['Review the 13:00 interview guide', 'Pick interview slots with 3 customers', 'Accept the 15 Oct interview invite']], ['Week', ['Share returns insights with sales']]],
-    j4: [['Week', ['Confirm the SSO date to Marta']]],
-  },
-};