create-pmos 0.65.0 → 0.65.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.65.0",
+  "version": "0.65.2",
   "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@bcf4a86
+kernel-source: pmos@cc06cf0
 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:08:29Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T01:20:37Z"}
 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:08:29Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T01:20:37Z"}
 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:08:29Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T01:20:37Z"}
 status: stable
 ---
 

package/workspace/guide/docs.md

@@ -1,6 +1,6 @@
 ---
 type: Guide
-title: "Docs: is each document the same as its Google Docs and Confluence copy, and which version to use"
+title: "Docs: every repository file by category, the files each one links to, and whether each copy in Google Docs or Confluence is the same"
 timestamp: 2026-10-06
 ---
 
@@ -8,15 +8,65 @@ timestamp: 2026-10-06
 
 Open Docs from the top bar, from ⌘K (**Docs**), or press `g d`.
 
-Docs lists every document in the repository that has a copy in Google Docs or Confluence. For each copy, it shows whether the repository version (PMOS) or the copy is newer. You can then use one version over the other, one copy at a time.
+Docs lists every markdown file in the repository by category. For each file, it shows the files that it links to and the files that link to it. For each document that has a copy in Google Docs or Confluence, it shows whether the repository version (PMOS) or the copy is newer. You can then use one version over the other, one copy at a time.
 
 Nothing syncs by itself. A copy changes only when you press a button for that copy.
 
 ## The list
 
-The copies are grouped by initiative. Copies of files that no initiative owns are under **Other**.
+Docs has three views:
 
-**Needs you** shows the copies that are not the same. **All** shows every copy.
+- **Needs you** shows the copies that are not the same.
+- **With a copy** shows every copy.
+- **All files** shows every markdown file in the repository.
+
+The copies are grouped by category.
+
+## Categories
+
+The category of a file comes from its folder, then from its frontmatter `type`. You do not tag a file.
+
+| Category | Files |
+|---|---|
+| Specs | `planning/prd/`, or `type: PRD` |
+| Initiatives | `planning/initiatives/` |
+| Decisions | the ADR folder, `DECISIONS.md`, `pm-decisions.md` |
+| Research & plans | the other `planning/` folders |
+| Explainers | `planning/explainers/` |
+| Evals | `planning/evals/`, or `type: Rubric` |
+| Knowledge | the other `okf/` folders |
+| Guides & rules | all other files |
+| Prototypes | `prototype/` |
+
+## All files
+
+**All files** opens with one line for each category: its name, its number of files, and "N need you" when a copy in it is not the same. Press a category to open it. It shows its first 20 files: the files with a copy first, then the newest. Press **Show all** to see the rest.
+
+A file with no copy is one line: its title, the short name of its initiative (or its path when no initiative owns it), and the date of its last edit. **Add copy** shows when you point at the line, and always on a touch screen.
+
+## The links of a file
+
+Press a file in **All files** to see its links:
+
+- on the left, the files that link to it;
+- in the middle, the file;
+- on the right, the files that it links to.
+
+Each side shows at most 7 files. A dashed line is a decision that the file cites. Press a file in the graph to put it in the middle. Press **Back** to go back. **Open file** opens the file in the reader.
+
+**List all N links** lists every link in both directions, grouped by kind.
+
+A link counts only when a file writes it:
+
+- a markdown link to another file;
+- a path in the frontmatter, such as `prd_path`;
+- the `initiative_id` of the file;
+- the anchor (`parent_kr`);
+- a decision number, such as D65.
+
+PMOS does not guess a link from similar words. `pmos kg neighbors <path>` shows the same links in the terminal.
+
+On a phone the graph is not shown. The list is shown.
 
 Each copy is one line:
 
@@ -49,7 +99,8 @@ Click a line to see its details:
 - the copy: its address and its last edit;
 - a **Use … version** button for each side;
 - the first difference that the compare found, when it found one;
-- **Compare again** and **Stop tracking this copy**.
+- **Compare again** and **Stop tracking this copy**;
+- the links of the file, as in **All files**.
 
 **Stop tracking this copy** removes the link. The copy is not deleted. Press **Undo** in the message to link it again.
 
@@ -72,7 +123,9 @@ A compare runs only when you press it. There is no schedule. An edit to a reposi
 
 ## Add a copy
 
-Type in **Find a document**. The search finds every markdown file in the repository by its title or path, also files that have no copy. A file with no copy shows **No copy** and **Add copy**.
+Type in the search box. The search finds every markdown file in the repository by its title, its path or the name of its initiative, also files that have no copy. The results are grouped by category, and the match is marked. Press Esc to clear the search.
+
+Press **Add copy** on a file with no copy.
 
 Press **Add copy**, paste the address of the Google Doc or Confluence page, and press Enter. A document can have one Google Doc and one Confluence page.
 

package/workspace/guide/initiatives-screen.md

@@ -76,6 +76,14 @@ The Files tab lists every file that belongs to the initiative, in three groups:
 - **Linked documents.** The documents the library joins to the initiative: a document that declares its `initiative_id`, a document the record names, a file name that starts with the id.
 - **Changed for it in git.** The files that the commits for this initiative changed and that still exist. These are its own branch, trunk commits that name the id, and merged changes that carried its documents. The file opens read-only.
 
+**List · Graph** at the top of the tab changes the view. **List** shows the groups above. **Graph** shows the files of the initiative as a network:
+
+- a filled dot is a markdown file of the initiative: a file that the record names, or a linked document. Its label is its role, such as PRD, Rubric or Explainer;
+- a hollow dot is a file outside the initiative that one of its files links to, or that links to one of its files. A decision shows its number, such as D65;
+- a line is a link that a file writes. A dashed line is a decision that a file cites.
+
+The graph shows at most 14 outside files, the most-linked first. The legend says how many are left out. Press a dot to mark its lines and to see its title, its path and **Open file**. The same files and links always give the same picture. On a phone the list is shown.
+
 ### A breakdown read from the spec
 
 When nobody has planned items for an initiative, the Breakdown tab shows the items of its spec above the empty Breakdown: the user stories, or the entries of the Requirements section of the PRD that the record names. Each item shows the state of the whole initiative: **Done** after you accept it, **Built** when its build is on the trunk, and **Todo** before that. These items are read-only and nothing is written. To track an item, add it to the Breakdown. The card and the row show the same count, for example "0 of 8 · from board-delivery-truth-prd.md".

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/doc-library.js

@@ -0,0 +1,131 @@
+'use strict';
+/* doc-library.js — every tracked markdown file of a workspace, by category, with its initiative and the links between the
+ * files (initiative docs-library-graph, PRD R-L1 to R-L5).
+ *
+ * The links are the knowledge graph's (lib/kg.js through kg-cli `graphFor`): a markdown link, a path in the header, the
+ * initiative, the anchor, a decision number. Nothing is inferred from wording. A category is derived from where a file
+ * lives, then from its frontmatter type; it is never written into a file. The result is kept in memory per repository
+ * state (git HEAD plus the uncommitted markdown files), and the kg cache stays in the runtime state directory. Nothing
+ * here writes into the repository or reads the network.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const kgCli = require('./kg-cli');
+
+/* [key, name] in display order */
+const CATEGORIES = [
+  ['spec', 'Specs'], ['ini', 'Initiatives'], ['dec', 'Decisions'], ['res', 'Research & plans'], ['exp', 'Explainers'],
+  ['eval', 'Evals'], ['know', 'Knowledge'], ['guide', 'Guides & rules'], ['proto', 'Prototypes'],
+];
+/* the link kinds, in the order the client numbers them */
+const KINDS = ['link', 'header', 'initiative', 'anchor', 'cites'];
+
+const BY_TYPE = { prd: 'spec', initiative: 'ini', adr: 'dec', decision: 'dec', rubric: 'eval', eval: 'eval', verdict: 'eval', explainer: 'exp' };
+
+/** The category of one file: where it lives first, then its frontmatter type, then Guides & rules. */
+function categoryOf(rel, type) {
+  const p = String(rel || '');
+  if (/^prototype\//.test(p)) return 'proto';
+  if (/(^|\/)planning\/initiatives\//.test(p)) return 'ini';
+  if (/(^|\/)planning\/prd\//.test(p)) return 'spec';
+  if (/(^|\/)planning\/evals\//.test(p)) return 'eval';
+  if (/(^|\/)planning\/explainers\//.test(p)) return 'exp';
+  if (/^okf\/products\/[^/]+\/adr\//.test(p) || /^(DECISIONS|pm-decisions)\.md$/.test(p) || /(^|\/)planning\/decisions-/.test(p)) return 'dec';
+  if (/(^|\/)planning\//.test(p)) return 'res';
+  if (/^okf\//.test(p)) return 'know';
+  const t = String(type || '').trim().toLowerCase();
+  return BY_TYPE[t] || 'guide';
+}
+
+/** A short name for an initiative title: no "PRD:" prefix, the part before the first dash or colon, at most 44 characters. */
+function shortTitle(title) {
+  let t = String(title || '').trim();
+  t = t.replace(/^(PRD|Initiative|Chore|Spike|Prototype Brief|Discovery|Incident|Content brief|Feature)\s*(?:[:—–]|\s-\s)\s*/i, '');
+  t = t.split(/\s[—–]\s|:\s|\.\s/)[0].trim();
+  if (t.length > 44) { const cut = t.slice(0, 43); t = (cut.includes(' ') ? cut.replace(/\s+\S*$/, '') : cut) + '…'; }
+  return t ? t[0].toUpperCase() + t.slice(1) : '';
+}
+
+/** The kind of one kg edge, or null for a kind the library does not show. */
+function kindOf(e) {
+  if (e.type === 'link') return 'link';
+  if (e.type === 'initiative') return 'initiative';
+  if (e.type === 'anchor') return 'anchor';
+  if (e.type === 'cites') return e.typed ? 'header' : 'cites';
+  if (e.type === 'frontmatter' || e.type === 'supersedes' || e.type === 'amended_by') return 'header';
+  return null;
+}
+
+const git = (cwd, args) => execFileSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 256 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+
+/** path → YYYY-MM-DD of its last commit (one git log; merge commits are skipped, their changes are in their parents). */
+function commitDates(root) {
+  const out = new Map();
+  let text = '';
+  try { text = git(root, ['log', '--format=%x01%cs', '--name-only', '--', '*.md']); } catch { return out; }
+  let day = null;
+  for (const line of text.split('\n')) {
+    if (line.startsWith('\x01')) { day = line.slice(1); continue; }
+    if (line && day && !out.has(line)) out.set(line, day);
+  }
+  return out;
+}
+
+/** The uncommitted markdown files: their date is the file's own. */
+function dirtyPaths(root) {
+  try {
+    return new Set(git(root, ['status', '--porcelain', '-z', '--untracked-files=no']).split('\0').filter(Boolean)
+      .map((l) => l.slice(3)).filter((p) => /\.md$/.test(p)));
+  } catch { return new Set(); }
+}
+
+const cache = new Map();   // root -> { key, value }
+
+/**
+ * The library of one repository.
+ *   owners: () => Map path → { id, title } — the library's own attribution (server.js initiativeIndex), real initiatives
+ *   only. It is called only when the repository state changed, because the index reads every planning file.
+ * Returns { ok, files: [{path,title,category,date,initiative}], initiatives: {id: {title, short}}, kinds, edges: [[from, to, kind]], categories }.
+ * `from` and `to` index `files`; `kind` indexes `kinds`.
+ */
+function library(root, { stateDir, owners = () => new Map() } = {}) {
+  let key;
+  try { key = kgCli.cacheKey(root); } catch (e) { return { ok: false, error: 'this workspace is not a git repository, so there are no tracked files to list' }; }
+  const hit = cache.get(root);
+  if (hit && hit.key === key) return hit.value;
+  const { graph, unreadable } = kgCli.graphFor(root, stateDir ? { stateDir } : {});
+  let own = new Map();
+  try { own = owners() || new Map(); } catch { /* no attribution: every file has no initiative */ }
+  const dates = commitDates(root);
+  const dirty = dirtyPaths(root);
+  const dayOf = (rel) => {
+    if (!dirty.has(rel) && dates.has(rel)) return dates.get(rel);
+    try { return fs.statSync(path.join(root, rel)).mtime.toISOString().slice(0, 10); } catch { return dates.get(rel) || null; }
+  };
+  // An initiative is named by its record's title (planning/initiatives/<id>.md), else by the index's title for it.
+  const titleOf = new Map(graph.nodes.map((n) => [n.id, n.title]));
+  const named = (o) => String(titleOf.get(`planning/initiatives/${o.id}.md`) || o.title || o.id);
+  const initiatives = {};
+  const files = graph.nodes.map((n) => {
+    const o = own.get(n.id) || null;
+    if (o && !initiatives[o.id]) initiatives[o.id] = { title: named(o), short: shortTitle(named(o)) };
+    return { path: n.id, title: String(n.title || n.id), category: categoryOf(n.id, n.type), date: dayOf(n.id), initiative: o ? o.id : null };
+  });
+  const index = new Map(files.map((f, i) => [f.path, i]));
+  const seen = new Set();
+  const edges = [];
+  for (const e of graph.edges) {
+    const k = kindOf(e);
+    if (!k || e.from === e.to || !index.has(e.from) || !index.has(e.to)) continue;
+    const a = index.get(e.from); const b = index.get(e.to); const ki = KINDS.indexOf(k);
+    const id = a + '|' + b + '|' + ki;
+    if (seen.has(id)) continue;
+    seen.add(id); edges.push([a, b, ki]);
+  }
+  const value = { ok: true, key, files, initiatives, kinds: KINDS, edges, categories: CATEGORIES.map(([k, name]) => ({ key: k, name })), unreadable: unreadable || [] };
+  cache.set(root, { key, value });
+  return value;
+}
+
+module.exports = { CATEGORIES, KINDS, categoryOf, shortTitle, kindOf, library, commitDates };

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.0",
+  "version": "0.65.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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