create-pmos 0.53.0 → 0.53.2

package/workspace/guide/layout.md

@@ -16,7 +16,8 @@ The top bar has these parts, from left to right:
 - **Repository ▾** names the current repository. Press it to choose another repository, or **All repositories** to see the work of every repository at once. All repositories replaces the old Portfolio mode.
 - **Today, Initiatives, Board and Reports** are the four places. Press one to show it. The Today count shows how many items need you.
 - **Search or capture ⌘K** opens the command palette. Type to find an initiative, a repository, an open tab or a command.
-- **Sync** shows only when the current repository is not in sync with its remote. Press it to fetch, bring in the work of the other machine, record your changes and push. When the repository is in sync, Sync is not shown.
+- **Sync** shows only when the current repository is not in sync with its remote. Press it to fetch, bring in the work of the other machine, record your changes and push. If the repository has not fetched in the last 10 minutes, Sync also shows, because a push from another machine is not visible until a fetch. When the repository fetched recently and is in sync, Sync is not shown. If Sync stops, the message names the step that stopped.
+- **Sync on its own.** If you forget to press Sync, the workspace syncs for you. It syncs each repository once when the workspace starts. It also syncs a repository that has records not yet pushed when no record changed for 5 minutes. In a document repository it syncs every changed file on any branch. In a code repository it syncs only on the default branch (for example `main`), and only when every commit not yet pushed changes records and no code. If you close the tab while records are not yet pushed, the browser asks you first. To turn automatic sync off, start the workspace with `PMOS_AUTO_SYNC=0`.
 - **Settings** opens the settings of the workspace.
 
 Each place is drawn when its run is built. Until then the place says which run brings it, for example "Board arrives in Run 4."
@@ -41,6 +42,9 @@ The dock holds your terminals, documents, conversations, skills and web pages. I
 - The dock never opens by itself. A tab that opens while the dock is a rail waits in the dock until you open it.
 - **＋ Session** in the dock starts a new session. Its menu also has **Session with options** and one item for each skill of the repository. A skill opens in its own tab in the dock.
 - The Web button in the dock opens a web page in a tab.
+- To make the dock wider or narrower, drag its left edge. With the edge focused, the left and right arrow keys change the width in steps. Double-click the edge to go back to the default width. The width is kept in this browser.
+- **Focus** in the dock gives the dock the whole window. The place and the detail are hidden, and the dock stays full width on every place. Press **Exit focus**, or ⌘⇧J (Ctrl-Shift-J), to show the place again. Folding the dock also ends Focus.
+- **▲ scratchpad** in the bar under the tabs opens the scratchpad. The pad keeps one note for each terminal session, and one for the repository when no terminal is in front. **Send to terminal** types the note into the session in front.
 
 Folding the dock, or going to another place, does not touch your terminals.
 
@@ -63,6 +67,7 @@ The workspace is neutral. A primary button is the text colour on the page colour
 | g t, g i, g b, g r | Show Today, Initiatives, Board or Reports. |
 | ⌘K (Ctrl-K) | Open or close the command palette. |
 | ⌘J (Ctrl-J) | Open or fold the dock. |
+| ⌘⇧J (Ctrl-Shift-J) | Focus: give the dock the whole window, or show the place again. |
 | j, k | Move down or up the rows of the place. |
 | Enter | Open the row that has the focus. |
 | Space | Tick the row. Space never opens a row. On another button of the row, for example ⋯, Space presses that button. |
@@ -77,7 +82,7 @@ A key that you type in a field, or in a terminal, goes to the field or the termi
 
 A phone shows one panel at a time. The tabs at the bottom are **Today, Initiatives, Board, Reports and Agent**. Agent shows the dock, with your terminals. Search or capture ⌘K is pinned at the top of Today.
 
-The bar at the top has Back (when you are deeper than a tab), Repository, the name of the screen, ⌘K, Sync (only when the repository is not in sync) and Settings. Settings opens over the current tab. Back returns to the tab.
+The bar at the top has Back (when you are deeper than a tab), Repository, the name of the screen, ⌘K, Sync (when the repository is not in sync, or has not fetched in the last 10 minutes) and Settings. Settings opens over the current tab. Back returns to the tab.
 
 Every row has a visible ⋯ button. Every control is at least 44 pixels high. Nothing works only when you hover.
 

package/workspace/guide/proactive-engine.md

@@ -1,20 +1,35 @@
 ---
 type: Guide
 title: "Guide: Today and the proactive engine"
-description: "What the Today item shows, how the morning brief is made, and how the workspace works out what is waiting for you."
-timestamp: 2026-10-04
+description: "What the Today item shows, how your goals for the day are prepared, how the morning brief is made, and how the workspace works out what is waiting for you."
+timestamp: 2026-10-06
 ---
 
 # Guide: Today and the proactive engine
 
 The today item shows what is waiting for you now. The workspace works it out by itself from the records of your repositories. You do not ask for it.
 
+## Goals for today
+
+At the top of Today you can list what you want done today. A goal is one line of text, and it can name an initiative.
+
+- Open **Goals for today** and type a goal. Press Enter to add it. A day has at most 7 goals, each at most 140 characters.
+- Press **Done**, **Drop**, **Reopen** or **Remove** on a goal. A goal is open, done or dropped.
+- Press **Prepare my day**. The workspace makes the daily 06:45 morning-brief schedule if this repository has none, and runs it now. The session reads your goals, your calendar, and the mentions of you in Slack, Jira and Confluence. It ties each meeting, mention and step that moves a goal to that goal.
+- Each goal shows its steps: yours first, then the agent's. A step comes from the brief, or from a Today card on the goal's initiative. A goal with no step says so. The session does not invent a step.
+- A step is under a goal only when the brief names the goal, or when the step and the goal name the same initiative. The workspace never matches words.
+- An agent step that names an initiative has **Prepare**. It shows the step, the branch and the prompt, the same as background preparation. **Queue it** approves that exact prompt. Background preparation must be on in the settings. Otherwise the queue says so and nothing is queued.
+- What fits no goal is listed under **Also on your plate**, and items the session is less than 0.5 sure about under **Worth asking**.
+- Today also says how much free time you have until 18:00, the event coming up, and which sources were not read.
+- If the brief is for another day, it is not used. Only the Today cards are shown under the goals.
+- The goals are stored in the workspace state folder on this computer, one file for each day (`goals/<date>.json`). They are not committed.
+
 ## The morning brief
 
 The top of Today is the morning brief: a greeting, the day's calendar, the priorities and a list of things worth asking about. The brief is not computed by the workspace. A skill called morning-brief runs in an agent session. The session reads the sources, and then submits one brief with `pmos proactive brief submit`. The workspace server only checks the brief and stores it. It makes no model call and reaches no calendar or mailbox.
 
 - Press **schedule the morning brief** in Today to make a daily schedule at 06:45. The schedule is an ordinary scheduled task, so it runs only while the workspace server runs. A sleeping computer gets no brief. A schedule that is made after its time of day for the first time runs within a minute, so pressing the button at 10:00 starts one brief session straight away.
-- Each source is a setting: calendar, wispr, mail, jira and confluence. Mail is off by default and the skill reads only subjects and senders, never bodies. A source that is off cannot be reported as read.
+- Each source is a setting: calendar, wispr, mail, slack, jira and confluence. Mail is off by default and the skill reads only subjects and senders, never bodies. Slack is on by default. In Slack, Jira and Confluence the skill reads the mentions of you: where, who, and a one-line summary. It never copies a message. A source that is off cannot be reported as read.
 - The brief names the day it is for. If that is not today, Today says it is out of date.
 - An item the session is less than 0.5 sure about is shown under worth asking, not as a priority. The workspace sets that bucket from the confidence. The session cannot choose it.
 - The order is fixed: higher confidence first, then your items before the agent's, then by title.
@@ -85,7 +100,7 @@ A verdict never changes a status, a lifecycle record or an acceptance. It is rec
 |---|---|
 | engine on | Off stops automatic scans. The scan now button still works. |
 | watch: needs, returned, review, schedule, stalled | Turn one trigger off. |
-| brief sources | One switch for each of calendar, wispr, mail, jira and confluence. |
+| brief sources | One switch for each of calendar, wispr, mail, slack, jira and confluence. |
 | background prepare | Off by default. On lets the workspace start a session for a plan you approved. |
 | typed scoring | Off by default. On lets the skill send titles and metadata to the Typesafe service. |
 | name | Used in the greeting. |
@@ -102,6 +117,7 @@ Text that you type in a setting (the name, the stalled days, the quiet hours) or
 - `pmos proactive today` lists the items.
 - `pmos proactive scan` scans now.
 - `pmos proactive settings` shows the settings. Add `--enabled`, `--trigger NAME=on|off`, `--stalled-days`, `--quiet HH:MM-HH:MM|none`, `--pause-learning`, `--background-prepare on|off`, `--brief-source NAME=on|off`, `--brief-scoring on|off` or `--name` to change one.
+- `pmos proactive goals` lists today's goals with their steps. `pmos proactive goals add TEXT [--initiative ID]` adds one. `done N`, `drop N`, `reopen N` and `remove N` change the Nth goal. `pmos proactive goals plan` does the same as **Prepare my day**.
 - `pmos proactive brief` shows today's brief. `pmos proactive brief submit --file PATH` submits one. `pmos proactive brief schedule` makes the 06:45 schedule for the current repository.
 - `pmos proactive prepare` shows the queue. `pmos proactive prepare plan --initiative ID` shows a plan and its hash. `pmos proactive prepare queue --initiative ID --item ITEM --sha HASH` approves it. `pmos proactive prepare cancel ID` cancels an entry. `pmos proactive prepare run` looks at the queue now.
 - `pmos proactive learn` shows the rollup, the weights, the narrowed triggers and the lessons. `pmos proactive learn run` takes the weekly review now. `pmos proactive learn lessons` lists the approved lessons. `pmos proactive learn approve ID`, `reject ID` and `retire ID` decide a lesson. `pmos proactive learn restore TRIGGER` brings back a narrowed trigger. `pmos proactive learn reset` makes it ignore earlier feedback.
@@ -110,7 +126,7 @@ Text that you type in a setting (the name, the stalled days, the quiet hours) or
 ## Limits
 
 - It runs only while the workspace server runs. It does not catch up for time the server was off. A sleeping computer gets no scan.
-- The items from the records come from this computer. The workspace itself does not read your mail or your calendar. Only the morning-brief session does, and only the sources you switched on.
+- The items from the records come from this computer. The workspace itself does not read your mail, your calendar, Slack, Jira or Confluence. Only the morning-brief session does, and only the sources you switched on.
 - It does not start a session, push, send, post, accept or merge. It only shows items and records your feedback, and learns from it as described above. The one exception is background preparation, which starts a session only for a plan you approved, as described above.
 - An unreadable repository is listed as not read. An empty list is not proof that nothing waits there.
 - The records stay in the workspace state folder on this computer. They are not committed.

package/workspace/guide/report-slides.md

@@ -0,0 +1,28 @@
+---
+type: Guide
+title: "Report slides: present and print a report"
+description: "How the Reports page shows a report as the PM-OS biweekly slides, how to present and print them, and how your notes become the words on the slides."
+timestamp: 2026-10-06
+---
+
+# Report slides
+
+The Reports page shows a report as slides, in the PM-OS biweekly format: the roadmap snapshot, the initiative list, one slide for each initiative, and the release notes. **Present** shows them full screen. Use the arrow keys or swipe to move, and press Escape to close. **Print / PDF** prints one slide on each page.
+
+The script writes the data of the slides at the end of the draft, in one `<!-- pmos:slides v1 … -->` block. Do not edit that block. Your words on the slides come from the notes:
+
+- The note of an initiative is the note box on its slide. Start it with "Warning:" or "Info:" to set the type of the box. Write each point on its own line that starts with "- ". The box shows four points.
+- The `report.changelog` note is the release notes. Only you write it; the agent leaves it empty. Write one entry for each release. Put a blank line after the title, after the sentence, and between entries:
+
+```
+Launch · Sign-in: Email codes for every title
+
+Readers can sign in with a one-time code.
+
+- Added: Code entry screen
+- Changed: The login page offers codes first
+```
+
+The type is Launch, Improvement, Fix, Security, Deprecation or Beta. To give an entry its own date, add it after the title, for example `(2026-10-02)`. When the note is empty, the slide says that no release notes are logged.
+
+A draft from before the slides has no slides block. Press **Redraft** to add it. Your notes stay as you wrote them.

package/workspace/guide/reports.md

@@ -43,6 +43,8 @@ Your note. Start it with "Warning:" when the block needs attention.
 
 The headline note is `report.headline`. The asks are in the `report.asks` note, one ask on each line, each line starting with "- ". Write prose only between the markers. Do not type numbers: the script writes them.
 
+The Reports page shows a report as slides. [Report slides](report-slides.md) tells how your notes become the words on the slides.
+
 When you draft a slot again, every note stays as you wrote it, next to its initiative. The order of the blocks can change. A note for an initiative that is no longer in the window moves to "Notes kept from an earlier draft".
 
 ## The commands

package/workspace/lib/auto-sync.js

@@ -0,0 +1,83 @@
+'use strict';
+/* auto-sync — Sync without the press, for the PM who forgot to press it (D70 as amended 2026-10-06).
+ *
+ * The press (POST /api/sync) stays. This module runs the SAME lib/sync.js#sync, with every safety it has (no force,
+ * a conflict aborts the rebase whole, records only), at two moments and no others:
+ *   startup  once per repository when the server starts: brings in what another machine pushed.
+ *   idle     on the server's tick: a repository with work not yet pushed, quiet for QUIET_MS, is synced.
+ * Before either, a repository must pass every rule below. A rule that cannot be read is a no.
+ *   - auto-sync is on for this server (see enabledFor);
+ *   - the branch has an upstream;
+ *   - in a CODE repository only (profile product-code, D68): the branch is the remote's default branch, and every commit
+ *     not yet pushed touches record paths only, so a feature branch and code are never auto-pushed. A DOCUMENT
+ *     repository (profile pm-artifacts) holds only the PM's documents: any branch, every file;
+ *   - no record file changed in the last QUIET_MS: a document being written is left alone;
+ *   - no sync is running for the repository, and the last auto-sync did not fail within RETRY_MS.
+ */
+const syncLib = require('./sync');
+
+const QUIET_MS = 5 * 60 * 1000;
+const RETRY_MS = 30 * 60 * 1000;
+
+// On for a real server start. A server given its own state directory (every suite does, through test-run.js) is a
+// scratch server and does not auto-sync unless asked. PMOS_AUTO_SYNC=0 turns it off; =1 turns it on.
+function enabledFor(env = process.env) {
+  const v = String(env.PMOS_AUTO_SYNC || '').trim();
+  if (v === '0') return false;
+  if (v === '1') return true;
+  return !String(env.PMOS_STATE_DIR || '').trim();
+}
+
+// Why `root` may not auto-sync now, or null when it may. `moment` is 'startup' or 'idle'.
+async function blocker(root, moment, { now = Date.now(), lastFail = 0 } = {}) {
+  if (lastFail && now - lastFail < RETRY_MS) return 'the last auto-sync failed; it waits before trying again';
+  const st = await syncLib.status(root);
+  if (!st.ok) return st.error || 'not a git repository';
+  if (!st.upstream) return 'no upstream';
+  if (st.state === 'mid-operation') return 'a merge, rebase or cherry-pick is in progress';
+  const docs = syncLib.profileOf(root) === 'pm-artifacts';
+  const remote = st.upstream.split('/')[0];
+  const def = docs ? null : await syncLib.defaultBranchOf(root, remote);
+  if (!docs && (!def || st.branch !== def)) return `'${st.branch}' is not the default branch of ${remote}`;
+  if (st.ahead && !docs) {
+    const paths = await syncLib.unpushedPaths(root, st.upstream);
+    if (!paths) return 'the unpushed commits cannot be read';
+    const code = paths.filter((p) => !syncLib.isRecord(p));
+    if (code.length) return `unpushed commits change files that are not records (${code[0]}${code.length > 1 ? ', …' : ''})`;
+  }
+  if (moment === 'idle') {
+    if (!st.dirty_records && !st.ahead) return 'nothing to send';
+    const newest = await syncLib.newestDirtyRecordMs(root);
+    if (newest && now - newest < QUIET_MS) return 'a record changed in the last few minutes';
+  }
+  return null;
+}
+
+/* createAutoSync({ roots, busy, onDone, env }) → { startup(), tick(), lastOf(root) }
+ *   roots()       the repository roots the server holds
+ *   busy          a Set of roots with a sync running (shared with the press route)
+ *   onDone(root, result)   called after each auto-sync that ran (to refresh caches) */
+function createAutoSync({ roots, busy, onDone = () => {}, env = process.env, label = 'auto-sync' } = {}) {
+  const last = new Map();   // root -> { at, moment, ok, message, skipped? }
+  async function runFor(root, moment) {
+    if (!enabledFor(env) || busy.has(root)) return null;
+    const prev = last.get(root);
+    const why = await blocker(root, moment, { lastFail: prev && prev.ok === false ? prev.at : 0 });
+    if (why) return null;
+    busy.add(root);
+    try {
+      const out = await syncLib.sync(root, { label });
+      last.set(root, { at: Date.now(), moment, ok: !!out.ok, message: out.message, stopped_at: out.stopped_at || null });
+      try { onDone(root, out); } catch { /* a cache refresh is not the sync's business */ }
+      return out;
+    } finally { busy.delete(root); }
+  }
+  async function each(moment) {
+    const out = [];
+    for (const r of roots()) { try { out.push(await runFor(r, moment)); } catch { /* one repository never stops the others */ } }
+    return out;
+  }
+  return { startup: () => each('startup'), tick: () => each('idle'), lastOf: (root) => last.get(root) || null };
+}
+
+module.exports = { createAutoSync, blocker, enabledFor, QUIET_MS, RETRY_MS };

package/workspace/lib/board-fold.js

@@ -68,8 +68,8 @@ function workInitiatives(root) {
   for (const id of eng.listInitiatives(root)) {
     let pl;
     try { pl = planTree.profileAndLane(root, id); } catch { continue; }
-    const def = pl.defs && pl.defs[pl.lane];
-    if (!def || def.group !== 'work') continue;
+    if (pl.group !== 'work') continue;
+    const def = (pl.defs && pl.defs[pl.lane]) || {};
     let title = id;
     if (pl.record) {
       try { title = String((eng.parseLeadingFrontmatter(fs.readFileSync(pl.record, 'utf8')) || {}).title || '').trim() || id; } catch { title = id; }

package/workspace/lib/breakdown-export.js

@@ -18,7 +18,6 @@
 const fs = require('fs');
 const planItems = require('./plan-items.js');
 const planTree = require('./plan-tree.js');
-const rows = require('./initiative-rows.js');
 const consoleState = require('./console-state');
 
 const STATE_LABEL = { todo: 'Todo', doing: 'Doing', review: 'Review', done: 'Done' };
@@ -51,11 +50,7 @@ function exportBreakdown(root, id) {
   if (!loaded.ok) return refuse(500, loaded.error);
   let fm = {};
   try { fm = loaded.engine.parseLeadingFrontmatter(fs.readFileSync(file, 'utf8')) || {}; } catch { fm = {}; }
-  const { lane } = planTree.profileAndLane(root, id);
-  let groups;
-  try { groups = rows.workGroupOf(root); } catch { groups = {}; }
-  const declared = String(fm.lane || '').trim();
-  if (groups[Object.prototype.hasOwnProperty.call(groups, declared) ? declared : lane] !== 'work') {
+  if (planTree.profileAndLane(root, id).group !== 'work') {
     return refuse(404, `${id} is not on a work lane; a document is a file and has no breakdown to export`);
   }
   const fold = planItems.readFold(root, { now: 0 });

package/workspace/lib/brief.js

@@ -10,12 +10,16 @@
  *   greeting(now, name)                   → the one line Today opens with
  *   localDate(now)                        → YYYY-MM-DD on this machine's clock
  *
+ * Goals (initiative `today-goals`, PRD G3): an item or an event may name one of the day's goals with `goal`. With
+ * `ctx.goalIds` given, a goal that is not in that day's record is refused. An item may say it is a `mention` of the PM
+ * (Slack, Jira, Confluence, mail): a boolean, nothing more.
+ *
  * The bucket is derived: an item under WORTH_ASKING confidence is "worth asking", whatever the session said. The order is
  * fixed and stated: higher confidence first, then PM-owned before agent-owned, then by title.
  */
 const crypto = require('crypto');
 
-const SOURCES = ['calendar', 'wispr', 'mail', 'jira', 'confluence'];
+const SOURCES = ['calendar', 'wispr', 'mail', 'slack', 'jira', 'confluence'];
 const ITEM_SOURCES = [...SOURCES, 'derived'];
 const SOURCE_STATES = ['read', 'not-reached', 'off'];
 const OWNERS = ['pm', 'agent'];
@@ -24,6 +28,7 @@ const WORTH_ASKING = 0.5;
 const MAX_ITEMS = 12;
 const MAX_EVENTS = 20;
 const INI_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+const GOAL_RE = /^g-[0-9a-f]{8}$/;
 const clip = (s, n) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, n);
 
 const pad = (n) => String(n).padStart(2, '0');
@@ -40,6 +45,13 @@ const tooLong = (v, n) => typeof v === 'string' && v.trim().length > n;
 function validateBrief(raw, ctx = {}) {
   const now = ctx.now || Date.now();
   const settings = ctx.settings || {};
+  const goalIds = Array.isArray(ctx.goalIds) ? new Set(ctx.goalIds) : null;
+  const badGoal = (g, at) => {
+    if (g === undefined || g === null) return null;
+    if (typeof g !== 'string' || !GOAL_RE.test(g)) return `${at}: goal is not a goal id`;
+    if (goalIds && !goalIds.has(g)) return `${at}: goal ${g} is not one of the goals for that day`;
+    return null;
+  };
   const on = (src) => !settings.briefSources || settings.briefSources[src] !== false;
   if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return { ok: false, error: 'a brief is a JSON object' };
   const date = raw.date === undefined ? localDate(now) : raw.date;
@@ -68,7 +80,9 @@ function validateBrief(raw, ctx = {}) {
     if (typeof e.start !== 'string' || Number.isNaN(Date.parse(e.start))) return { ok: false, error: `calendar event ${i + 1}: start must be a date and time` };
     if (e.end !== undefined && (typeof e.end !== 'string' || Number.isNaN(Date.parse(e.end)))) return { ok: false, error: `calendar event ${i + 1}: end must be a date and time` };
     if (e.with !== undefined && tooLong(e.with, 120)) return { ok: false, error: `calendar event ${i + 1}: "with" is over 120 characters` };
-    calendar.push({ start: e.start, end: e.end || null, title: clip(e.title, 120), with: e.with ? clip(e.with, 120) : null });
+    const gErr = badGoal(e.goal, `calendar event ${i + 1}`);
+    if (gErr) return { ok: false, error: gErr };
+    calendar.push({ start: e.start, end: e.end || null, title: clip(e.title, 120), with: e.with ? clip(e.with, 120) : null, ...(e.goal ? { goal: e.goal } : {}) });
   }
   calendar.sort((a, b) => Date.parse(a.start) - Date.parse(b.start));
 
@@ -90,11 +104,15 @@ function validateBrief(raw, ctx = {}) {
     if (!EFFORTS.includes(x.effort)) return { ok: false, error: `${at}: effort must be one of ${EFFORTS.join(', ')}` };
     if (typeof x.confidence !== 'number' || !Number.isFinite(x.confidence) || x.confidence < 0 || x.confidence > 1) return { ok: false, error: `${at}: confidence must be a number from 0 to 1` };
     if (x.initiative_id !== undefined && x.initiative_id !== null && (typeof x.initiative_id !== 'string' || !INI_RE.test(x.initiative_id))) return { ok: false, error: `${at}: initiative_id is not an initiative id` };
+    const gErr = badGoal(x.goal, at);
+    if (gErr) return { ok: false, error: gErr };
+    if (x.mention !== undefined && typeof x.mention !== 'boolean') return { ok: false, error: `${at}: mention must be true or false` };
     const title = clip(x.title, 140);
     items.push({
       id: crypto.createHash('sha1').update(`${date}|${x.source}|${title}`).digest('hex').slice(0, 12),
       title, why_now: clip(x.why_now, 240), evidence: clip(x.evidence, 240), source: x.source, initiative_id: x.initiative_id || null,
       owner: x.owner, effort: x.effort, confidence: x.confidence, worth_asking: x.confidence < WORTH_ASKING,
+      ...(x.goal ? { goal: x.goal } : {}), ...(x.mention ? { mention: true } : {}),
     });
   }
   items.sort((a, b) => b.confidence - a.confidence || (a.owner === b.owner ? 0 : a.owner === 'pm' ? -1 : 1) || a.title.localeCompare(b.title));

package/workspace/lib/goals.js

@@ -0,0 +1,165 @@
+'use strict';
+/* goals.js — the PM's goals for the day, and the plan that joins them to what is known and what is owed (initiative
+ * `today-goals`, PRD G1 and G4).
+ *
+ * Pure: no I/O, no clock of its own, no model, no network. The server reads the goals file, the brief and the Today cards,
+ * passes them with `now`, and writes what `edit` returns.
+ *
+ *   emptyDay(date)                         → { date, goals: [] }
+ *   edit(day, op, { now })                 → { ok:true, day } | { ok:false, error }
+ *        op: { action: 'add', text, initiative_id? } | { action: 'done'|'drop'|'reopen'|'remove', id }
+ *   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
+ *
+ * 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
+ * is no word matching: a link is an id, so the PM can see why a step is under a goal. One step is under one goal only.
+ */
+const crypto = require('crypto');
+
+const MAX_GOALS = 7;
+const MAX_TEXT = 140;
+const STATUSES = ['open', 'done', 'dropped'];
+const ACTIONS = ['add', 'done', 'drop', 'reopen', 'remove'];
+const INI_RE = /^[a-z0-9][a-z0-9._-]*$/i;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const GOAL_ID_RE = /^g-[0-9a-f]{8}$/;
+const START_OF_DAY = '09:00';
+const END_OF_DAY = '18:00';
+const clip = (s, n) => String(s == null ? '' : s).replace(/\s+/g, ' ').trim().slice(0, n);
+
+const emptyDay = (date) => ({ date, goals: [] });
+
+/** A day record read from disk, checked. Anything that is not a day record for `date` reads as an empty day. */
+function readDay(raw, date) {
+  if (!raw || typeof raw !== 'object' || raw.date !== date || !Array.isArray(raw.goals)) return emptyDay(date);
+  const goals = raw.goals.filter((g) => g && typeof g === 'object' && GOAL_ID_RE.test(g.id) && typeof g.text === 'string' && g.text.trim()
+    && STATUSES.includes(g.status)).slice(0, MAX_GOALS).map((g) => ({
+    id: g.id, text: clip(g.text, MAX_TEXT), initiative_id: typeof g.initiative_id === 'string' && INI_RE.test(g.initiative_id) ? g.initiative_id : null,
+    status: g.status, added_at: typeof g.added_at === 'string' ? g.added_at : null, closed_at: typeof g.closed_at === 'string' ? g.closed_at : null,
+  }));
+  return { date, goals };
+}
+
+/** 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' };
+  if (!op || typeof op !== 'object' || !ACTIONS.includes(op.action)) return { ok: false, error: `action must be one of ${ACTIONS.join(', ')}` };
+  const at = new Date(now).toISOString();
+  const goals = day.goals.map((g) => ({ ...g }));
+  if (op.action === 'add') {
+    if (typeof op.text !== 'string' || !op.text.trim()) return { ok: false, error: 'a goal needs text' };
+    if (op.text.trim().length > MAX_TEXT) return { ok: false, error: `a goal is at most ${MAX_TEXT} characters` };
+    if (goals.length >= MAX_GOALS) return { ok: false, error: `a day has at most ${MAX_GOALS} goals. Drop or remove one first.` };
+    const ini = op.initiative_id == null || op.initiative_id === '' ? null : op.initiative_id;
+    if (ini !== null && (typeof ini !== 'string' || !INI_RE.test(ini))) return { ok: false, error: 'initiative_id is not an initiative id' };
+    const text = clip(op.text, MAX_TEXT);
+    if (goals.some((g) => g.text.toLowerCase() === text.toLowerCase())) return { ok: false, error: 'that goal is already on the list' };
+    const id = 'g-' + crypto.createHash('sha1').update(`${day.date}|${text}|${at}|${goals.length}`).digest('hex').slice(0, 8);
+    goals.push({ id, text, initiative_id: ini, status: 'open', added_at: at, closed_at: null });
+    return { ok: true, day: { date: day.date, goals }, goal: goals[goals.length - 1] };
+  }
+  const i = goals.findIndex((g) => g.id === op.id);
+  if (i < 0) return { ok: false, error: 'no goal with that id today' };
+  const g = goals[i];
+  if (op.action === 'remove') { goals.splice(i, 1); return { ok: true, day: { date: day.date, goals }, goal: g }; }
+  const to = { done: 'done', drop: 'dropped', reopen: 'open' }[op.action];
+  if (g.status === to) return { ok: false, error: `that goal is already ${to}` };
+  g.status = to; g.closed_at = to === 'open' ? null : at;
+  return { ok: true, day: { date: day.date, goals }, goal: g };
+}
+
+/* ── the plan ──────────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const minutesOf = (hhmm) => { const [h, m] = String(hhmm).split(':').map(Number); return h * 60 + m; };
+
+/** Free minutes of the working day still ahead (from `now`, or 09:00 if earlier, to 18:00 local), and the next event. */
+function freeTime(events, at, endOfDay = END_OF_DAY) {
+  const d = new Date(at);
+  const end = new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, minutesOf(endOfDay)).getTime();
+  const now = Math.max(at, new Date(d.getFullYear(), d.getMonth(), d.getDate(), 0, minutesOf(START_OF_DAY)).getTime());
+  if (now >= end) return { free_minutes: 0, until: endOfDay, next: null };
+  const spans = [];
+  for (const e of events || []) {
+    const s = Date.parse(e.start); const f = e.end ? Date.parse(e.end) : s + 30 * 60000;
+    if (!Number.isFinite(s) || !Number.isFinite(f) || f <= now || s >= end) continue;
+    spans.push([Math.max(s, now), Math.min(f, end)]);
+  }
+  spans.sort((a, b) => a[0] - b[0]);
+  let busy = 0; let cur = null;
+  for (const sp of spans) {
+    if (!cur || sp[0] > cur[1]) { if (cur) busy += cur[1] - cur[0]; cur = sp.slice(); }
+    else cur[1] = Math.max(cur[1], sp[1]);
+  }
+  if (cur) busy += cur[1] - cur[0];
+  const upcoming = (events || []).filter((e) => Date.parse(e.start) > now).sort((a, b) => Date.parse(a.start) - Date.parse(b.start))[0] || null;
+  return { free_minutes: Math.max(0, Math.round((end - now - busy) / 60000)), until: endOfDay, next: upcoming ? { start: upcoming.start, title: upcoming.title } : null };
+}
+
+const stepOrder = (a, b) => (a.owner === b.owner ? 0 : a.owner === 'pm' ? -1 : 1) || (b.confidence - a.confidence) || a.title.localeCompare(b.title);
+
+function itemStep(x) {
+  return { ref: 'brief:' + x.id, from: 'brief', source: x.source, title: x.title, why: x.why_now, evidence: x.evidence || '', owner: x.owner,
+    effort: x.effort, confidence: x.confidence, initiative_id: x.initiative_id || null, mention: !!x.mention, worth_asking: !!x.worth_asking,
+    prepare: x.owner === 'agent' && !!x.initiative_id };
+}
+function cardStep(c) {
+  return { ref: 'today:' + c.id, from: 'today', source: c.source || 'today', title: c.cause, why: c.cause, evidence: c.evidence || '', owner: 'pm',
+    effort: null, confidence: 1, initiative_id: c.initiative_id || null, kind: c.kind, act: c.act ? c.act.label : null, ws: c.ws || null, mention: false,
+    worth_asking: false, prepare: false };
+}
+
+/**
+ * The day plan.
+ *   day      the goals record for the day (readDay)
+ *   brief    the stored brief (lib/brief.js shape) or null
+ *   cards    Today cards (lib/today.js) across the workspaces read, or []
+ *   now      ms; the clock the server passes
+ * A brief for another day is not joined: it is named as out of date, and only the Today cards plan the goals.
+ */
+function planDay({ day, brief = null, cards = [], now = Date.now(), endOfDay = END_OF_DAY } = {}) {
+  const date = day && day.date;
+  const fresh = !!brief && brief.date === date;
+  const items = fresh ? [...(brief.priorities || []), ...(brief.worth_asking || [])] : [];
+  const events = fresh ? (brief.calendar || []) : [];
+  const goals = (day && day.goals ? day.goals : []).map((g) => ({ ...g, steps: [], context: [] }));
+  const open = goals.filter((g) => g.status === 'open');
+  const byId = new Map(goals.map((g) => [g.id, g]));
+  const byIni = (ini) => (ini ? open.find((g) => g.initiative_id === ini) || null : null);
+  const unplaced = { items: [], cards: [] };
+
+  for (const x of items) {
+    const g = (x.goal && byId.get(x.goal)) || byIni(x.initiative_id);
+    if (g) g.steps.push(itemStep(x)); else unplaced.items.push(x);
+  }
+  for (const c of cards || []) {
+    const g = byIni(c.initiative_id);
+    if (g) g.steps.push(cardStep(c)); else unplaced.cards.push(c);
+  }
+  for (const e of events) {
+    const g = e.goal && byId.get(e.goal);
+    if (g) g.context.push({ start: e.start, end: e.end || null, title: e.title, with: e.with || null });
+  }
+  for (const g of goals) {
+    g.steps.sort(stepOrder);
+    g.coverage = g.status === 'done' ? 'done' : g.status === 'dropped' ? 'dropped' : g.steps.length ? 'planned' : 'needs-plan';
+    g.agent_steps = g.steps.filter((s) => s.prepare).length;
+  }
+  const also = [
+    ...unplaced.items.filter((x) => !x.worth_asking).map(itemStep),
+    ...unplaced.cards.map(cardStep),
+  ].sort(stepOrder);
+  const worthAsking = unplaced.items.filter((x) => x.worth_asking).map(itemStep).sort(stepOrder);
+  const notRead = fresh ? Object.entries(brief.sources || {}).filter(([, v]) => v !== 'read').map(([k, v]) => ({ source: k, state: v })) : [];
+  const counts = { open: open.length, done: goals.filter((g) => g.status === 'done').length, planned: goals.filter((g) => g.coverage === 'planned').length,
+    needs_plan: goals.filter((g) => g.coverage === 'needs-plan').length };
+  return {
+    date, goals, also, worth_asking: worthAsking, counts,
+    brief: brief ? { date: brief.date, fresh, generated_at: brief.generated_at || null } : null,
+    not_read: notRead,
+    time: fresh ? freeTime(events, now, endOfDay) : null,
+    mentions: items.filter((x) => x.mention).length,
+  };
+}
+
+module.exports = { MAX_GOALS, MAX_TEXT, STATUSES, ACTIONS, GOAL_ID_RE, START_OF_DAY, END_OF_DAY, emptyDay, readDay, edit, freeTime, planDay };

package/workspace/lib/initiative-rows.js

@@ -60,10 +60,14 @@ const iso = (v) => {
 
 /** The engine's JSON rows → the narrowed rows, each with its lane group. */
 function narrow(root, raw) {
-  let groups = {};
-  try { groups = workGroupOf(root); } catch { groups = {}; }
+  // The group comes from the lane the record DECLARES (plan-tree.js viewGroup): the engine's `lane` is the fallback
+  // when none is declared, and in a pm-artifacts repository that fallback is the document lane `prd`.
+  const planTree = require('./plan-tree.js');
+  const groupOf = (r) => {
+    try { return planTree.profileAndLane(root, r.id).group; } catch { return 'work'; }
+  };
   return (Array.isArray(raw) ? raw : []).map((r) => (r && r.ok !== false ? {
-    ok: true, id: r.id, title: r.title || r.id, lane: r.lane, group: groups[r.lane] || null, anchor: r.anchor || null,
+    ok: true, id: r.id, title: r.title || r.id, lane: r.lane, group: groupOf(r), anchor: r.anchor || null,
     stage: r.stage || null, accepted: !!r.accepted,
     stopped: r.stopped ? { state: r.stopped.state, reason: r.stopped.reason || '', at: r.stopped.at || null } : null,
     last_activity: iso(r.last_activity), profile: r.profile || null, record: r.record || null, next: r.next || null,