create-pmos 0.53.0 → 0.53.1

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,

package/workspace/lib/launcher-cli.js

@@ -0,0 +1,207 @@
+'use strict';
+/* launcher-cli.js — `pmos launcher on|off|status`: start the workspace without a terminal (initiative workspace-launcher).
+ *
+ *   pmos launcher on [<path>] [--no-login]   write a PMOS app (and, unless --no-login, a login item) for one repository
+ *   pmos launcher off                        remove what `on` wrote, and nothing else
+ *   pmos launcher status                     say what is installed and whether it still points at a real node and repo
+ *
+ * The app and the login item are two more callers of `pmos up <repo>`; nothing here starts a server itself. The app
+ * opens the browser. The login item passes --no-open, so a login starts the server and opens nothing.
+ *
+ *   macOS  ~/Applications/PMOS.app                         Spotlight, Launchpad, drag it to the Dock
+ *          ~/Library/LaunchAgents/com.pmos.workspace.plist  runs at login (RunAtLoad), once
+ *   Linux  $XDG_DATA_HOME/applications/pmos.desktop        the app menu
+ *          $XDG_CONFIG_HOME/autostart/pmos-workspace.desktop
+ *
+ * A file started by the desktop has no shell profile, so the PATH of the terminal that ran `on` is written into the
+ * script; that is how `claude`, `git` and `tmux` resolve. It never starts remote (tailnet) mode and writes no token.
+ * `off` deletes a file only when it carries MARK, so a file of the same name that the PM wrote is left alone.
+ * Native Windows is refused: the workspace needs WSL there for a real PTY (doctor.js says the same).
+ *
+ * plan() is pure: every input is injected, so each platform's files are assertable from any machine.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const stateRoot = require('./state-root');
+
+const COMMANDS = { launcher: ['on', 'off', 'status'] };
+const MARK = 'pmos-launcher: written by `pmos launcher on`';
+const LABEL = 'com.pmos.workspace';
+const USAGE = [
+  'usage: pmos launcher on|off|status — start the workspace without a terminal',
+  '  pmos launcher on [<path>] [--no-login]   a PMOS app for this repository, and a login item that starts the server',
+  '  pmos launcher off                        remove the app and the login item',
+  '  pmos launcher status                     what is installed, and for which repository',
+];
+
+// POSIX shell single quotes: nothing inside is special except the quote itself.
+const shq = (s) => `'${String(s).replace(/'/g, `'\\''`)}'`;
+// XML text and attribute values in a plist.
+const xml = (s) => String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+// A .desktop Exec argument: double-quoted, with the four characters the spec reserves escaped.
+const deq = (s) => `"${String(s).replace(/[\\"`$]/g, (c) => '\\' + c)}"`;
+
+function script({ node, bin, repo, pathEnv, log }) {
+  return [
+    '#!/bin/sh',
+    `# ${MARK} (workspace/lib/launcher-cli.js). \`pmos launcher off\` removes it.`,
+    '# It runs `pmos up` on one repository with the PATH the terminal had at setup. Arguments pass through (--no-open).',
+    `PATH=${shq(pathEnv)}; export PATH`,
+    `exec ${shq(node)} ${shq(bin)} up ${shq(repo)} "$@" >>${shq(log)} 2>&1`,
+    '',
+  ].join('\n');
+}
+
+function plist(dict) {
+  const v = (x) => Array.isArray(x) ? `<array>${x.map((s) => `<string>${xml(s)}</string>`).join('')}</array>`
+    : typeof x === 'boolean' ? (x ? '<true/>' : '<false/>') : `<string>${xml(x)}</string>`;
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    `<!-- ${MARK} (workspace/lib/launcher-cli.js). \`pmos launcher off\` removes it. -->`,
+    '<plist version="1.0">',
+    '<dict>',
+    ...Object.entries(dict).map(([k, x]) => `  <key>${xml(k)}</key>${v(x)}`),
+    '</dict>',
+    '</plist>',
+    '',
+  ].join('\n');
+}
+
+function desktop(entries) {
+  return [`# ${MARK} (workspace/lib/launcher-cli.js). \`pmos launcher off\` removes it.`, '[Desktop Entry]',
+    ...Object.entries(entries).map(([k, x]) => `${k}=${x}`), ''].join('\n');
+}
+
+/**
+ * The files `on` writes, for one platform. Pure.
+ *   → { files: [{ role: 'app'|'login', path, content, mode }], app, login }   or   { refused: '<reason>' }
+ * `login: false` leaves the login item out.
+ */
+function plan({ platform, home, env = {}, node, bin, repo, login = true }) {
+  if (platform === 'win32') return { refused: 'native Windows needs WSL for a real PTY. Run `pmos launcher on` inside WSL.' };
+  if (platform !== 'darwin' && platform !== 'linux') return { refused: `no launcher is made for ${platform}. Start the workspace with \`pmos\`.` };
+  const log = path.join(stateRoot.defaultRoot({ env, platform, home }), 'launcher.log');
+  const body = script({ node, bin, repo, pathEnv: env.PATH || '/usr/bin:/bin', log });
+  const files = [];
+  if (platform === 'darwin') {
+    const appDir = path.join(home, 'Applications', 'PMOS.app');
+    const exe = path.join(appDir, 'Contents', 'MacOS', 'pmos-launch');
+    files.push({ role: 'app', path: exe, content: body, mode: 0o755 });
+    files.push({ role: 'app', path: path.join(appDir, 'Contents', 'Info.plist'), mode: 0o644, content: plist({
+      CFBundleName: 'PMOS', CFBundleDisplayName: 'PMOS', CFBundleIdentifier: 'com.pmos.launcher',
+      CFBundleExecutable: 'pmos-launch', CFBundlePackageType: 'APPL', CFBundleVersion: '1',
+      // No Dock icon: the script hands off to the browser and exits within seconds.
+      LSUIElement: true,
+    }) });
+    const agent = path.join(home, 'Library', 'LaunchAgents', `${LABEL}.plist`);
+    if (login) files.push({ role: 'login', path: agent, mode: 0o644, content: plist({
+      Label: LABEL, ProgramArguments: ['/bin/sh', exe, '--no-open'], RunAtLoad: true,
+      // `pmos up` detaches the server and exits; launchd must not reap the group it leaves behind.
+      AbandonProcessGroup: true,
+    }) });
+    return { files, app: appDir, login: login ? agent : null, removable: [appDir, agent] };
+  }
+  const data = env.XDG_DATA_HOME && path.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path.join(home, '.local', 'share');
+  const conf = env.XDG_CONFIG_HOME && path.isAbsolute(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path.join(home, '.config');
+  const exe = path.join(data, 'pmos', 'pmos-launch.sh');
+  const app = path.join(data, 'applications', 'pmos.desktop');
+  const auto = path.join(conf, 'autostart', 'pmos-workspace.desktop');
+  files.push({ role: 'app', path: exe, content: body, mode: 0o755 });
+  files.push({ role: 'app', path: app, mode: 0o644, content: desktop({
+    Type: 'Application', Name: 'PMOS', Comment: 'Open the PMOS workspace', Exec: `/bin/sh ${deq(exe)}`,
+    Terminal: 'false', Categories: 'Development;' }) });
+  if (login) files.push({ role: 'login', path: auto, mode: 0o644, content: desktop({
+    Type: 'Application', Name: 'PMOS workspace', Comment: 'Start the PMOS workspace server at login',
+    Exec: `/bin/sh ${deq(exe)} --no-open`, Terminal: 'false', NoDisplay: 'true', 'X-GNOME-Autostart-enabled': 'true' }) });
+  return { files, app, login: login ? auto : null, removable: [exe, app, auto] };
+}
+
+const marked = (f) => { try { return fs.readFileSync(f, 'utf8').includes(MARK); } catch { return false; } };
+// The file under a removable path that carries the mark: the bundle's script for a .app, else the path itself.
+const markFile = (p) => p.endsWith('.app') ? path.join(p, 'Contents', 'MacOS', 'pmos-launch') : p;
+
+function repoRootOf(dir) {
+  const r = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd: dir, encoding: 'utf8' });
+  return r.status === 0 ? String(r.stdout).trim() : dir;
+}
+
+// What the installed script points at: the repository and whether node and pmos.js still exist.
+function readTarget(exe) {
+  let src = '';
+  try { src = fs.readFileSync(exe, 'utf8'); } catch { return null; }
+  const m = src.match(/^exec '((?:[^']|'\\'')*)' '((?:[^']|'\\'')*)' up '((?:[^']|'\\'')*)'/m);
+  if (!m) return null;
+  const un = (s) => s.replace(/'\\''/g, "'");
+  return { node: un(m[1]), bin: un(m[2]), repo: un(m[3]) };
+}
+
+function run(argv, { say = console.log, platform = process.platform, home = os.homedir(), env = process.env,
+  node = process.execPath, bin = path.join(__dirname, '..', 'bin', 'pmos.js'), cwd = process.cwd() } = {}) {
+  const pos = argv.slice(1).filter((a) => !a.startsWith('--'));
+  const flags = new Set(argv.slice(1).filter((a) => a.startsWith('--')).map((a) => a.slice(2)));
+  const unknown = [...flags].filter((f) => f !== 'no-login' && f !== 'help');
+  if (unknown.length) { say(`✗ unknown option --${unknown[0]}`); for (const l of USAGE) say(l); return 2; }
+  const sub = pos[0];
+  if (!sub || flags.has('help') || sub === 'help') { for (const l of USAGE) say(l); return sub ? 0 : 2; }
+  if (!COMMANDS.launcher.includes(sub)) { say(`✗ pmos launcher ${sub} is not a command`); for (const l of USAGE) say(l); return 2; }
+
+  if (sub === 'on') {
+    const dir = pos[1] ? path.resolve(cwd, pos[1]) : cwd;
+    if (!fs.existsSync(dir)) { say(`✗ ${dir} does not exist`); return 1; }
+    const repo = repoRootOf(dir);
+    const p = plan({ platform, home, env, node, bin, repo, login: !flags.has('no-login') });
+    if (p.refused) { say(`✗ ${p.refused}`); return 1; }
+    // Never write over a file of the same name that the launcher did not write.
+    const foreign = p.files.filter((f) => fs.existsSync(f.path) && !marked(f.path));
+    if (foreign.length) { say(`✗ not written: ${foreign.map((f) => f.path).join(', ')} exists and was not written by pmos launcher`); return 1; }
+    for (const f of p.files) {
+      fs.mkdirSync(path.dirname(f.path), { recursive: true });
+      fs.writeFileSync(f.path, f.content, { mode: f.mode });
+      fs.chmodSync(f.path, f.mode);
+    }
+    say(`✓ PMOS app for ${repo}`);
+    say(`  ${p.app}`);
+    say(platform === 'darwin' ? '  Open it from Spotlight or Launchpad, or drag it to the Dock.' : '  Open it from the app menu.');
+    if (p.login) {
+      say('✓ login item: the workspace server starts when you log in, without a browser window');
+      say(`  ${p.login}`);
+    } else say('  no login item (--no-login): the server starts when you open the app');
+    say('  The app opens the browser on the running workspace and starts the server when none runs.');
+    say('  If you move or upgrade node, run `pmos launcher on` again.');
+    return 0;
+  }
+
+  const p = plan({ platform, home, env, node, bin, repo: cwd });
+  if (p.refused) { say(`✗ ${p.refused}`); return 1; }
+
+  if (sub === 'off') {
+    let removed = 0;
+    for (const r of p.removable) {
+      if (!fs.existsSync(r)) continue;
+      if (!marked(markFile(r))) { say(`· left ${r}: it was not written by pmos launcher`); continue; }
+      fs.rmSync(r, { recursive: true, force: true });
+      say(`✓ removed ${r}`);
+      removed++;
+    }
+    if (!removed) say('○ nothing to remove: no launcher is installed');
+    return 0;
+  }
+
+  // status
+  const exe = p.files.find((f) => f.role === 'app' && f.mode === 0o755).path;
+  const t = marked(exe) ? readTarget(exe) : null;
+  const loginPath = p.removable.find((r) => r.endsWith('.plist') || r.endsWith('pmos-workspace.desktop'));
+  const login = fs.existsSync(loginPath) && marked(loginPath);
+  if (!t) { say('○ no PMOS app is installed (pmos launcher on)'); if (login) say(`· a login item is installed without the app: ${loginPath}`); return 1; }
+  say(`✓ PMOS app — ${p.app}`);
+  say(`  repository: ${t.repo}${fs.existsSync(t.repo) ? '' : '  ✗ not found'}`);
+  say(`  node: ${t.node}${fs.existsSync(t.node) ? '' : '  ✗ not found — run `pmos launcher on` again'}`);
+  say(`  pmos: ${t.bin}${fs.existsSync(t.bin) ? '' : '  ✗ not found — run `pmos launcher on` again'}`);
+  say(login ? `✓ login item — ${loginPath}` : '○ no login item: the server starts when you open the app');
+  return [t.repo, t.node, t.bin].every((x) => fs.existsSync(x)) ? 0 : 1;
+}
+
+module.exports = { run, plan, readTarget, COMMANDS, USAGE, MARK };

package/workspace/lib/plan-tree.js

@@ -110,7 +110,20 @@ function profileAndLane(root, initiative) {
   // An unknown or missing lane is the profile's strictest, exactly as workflow-state.js computes `effLane`.
   const fallback = profile === 'pm-artifacts' ? 'prd' : 'feature';
   const lane = declared && defs[declared] ? declared : fallback;
-  return { profile, lane, defs, record: file };
+  return { profile, lane, defs, record: file, group: viewGroup(defs, declared) };
+}
+
+/**
+ * Whether an initiative is a work card or a document in the planning views (D86 point 4), from its DECLARED lane.
+ *
+ * Only a record that declares a document lane is a document. A missing or unknown lane is work: the fallback above
+ * picks the strictest ladder for the gate, and in a pm-artifacts repository that fallback is `prd`, a document lane.
+ * Grouping by the fallback hid every record written before lanes were declared (0.53.0: most of a kit repository's
+ * initiatives were missing from Initiatives, Board and Reports).
+ */
+function viewGroup(defs, declared) {
+  const d = String(declared || '').trim();
+  return d && defs && defs[d] && defs[d].group ? defs[d].group : 'work';
 }
 
 const cap = (s) => (s && /^[a-z]/.test(s) ? s[0].toUpperCase() + s.slice(1) : s);
@@ -363,5 +376,5 @@ function layout({ root, initiative, fold, ladder, now }) {
 
 module.exports = {
   STAGE_GROUPS, STEP_NOUN, OWED_ACTOR, OPEN, DONE_WINDOW_MS, INIT_RE, NOT_MERGED_LABEL, withFactory,
-  mainTree, recordPath, profileAndLane, stagesFor, stageIdsFor, resolveStage, owedFor, nounFor, byLabel, progressLabel, layout, historyText,
+  mainTree, recordPath, profileAndLane, viewGroup, stagesFor, stageIdsFor, resolveStage, owedFor, nounFor, byLabel, progressLabel, layout, historyText,
 };

package/workspace/lib/pmos-verbs.js

@@ -34,6 +34,9 @@ const VERBS = Object.freeze({
     help: 'pmos verify-work — mark work items integrated from the default branch (local refs only)' }),
   report: Object.freeze({ module: 'report-cli.js', run: 5, guide: 'reports.md',
     help: 'pmos report draft|issue|list … — draft and issue reports (pmos report help)' }),
+  // Not a pm-os-absorb verb (run: null): the workspace-launcher initiative added it through the same table.
+  launcher: Object.freeze({ module: 'launcher-cli.js', run: null, guide: 'launcher.md',
+    help: 'pmos launcher on|off|status — a PMOS app and a login item, so the workspace starts without a terminal' }),
 });
 
 const has = (verb) => typeof verb === 'string' && Object.prototype.hasOwnProperty.call(VERBS, verb);

package/workspace/lib/proactive-cli.js

@@ -13,6 +13,7 @@
  *   pmos proactive brief [show]
  *   pmos proactive brief submit --file PATH
  *   pmos proactive brief schedule [--repo PATH]
+ *   pmos proactive goals [list] | add TEXT [--initiative ID] | done N | drop N | reopen N | remove N | plan [--repo PATH]
  *   pmos proactive prepare plan --initiative ID [--repo PATH]
  *   pmos proactive prepare queue --initiative ID --item ITEM --sha HASH [--repo PATH]
  *   pmos proactive prepare status | cancel ID | run
@@ -23,8 +24,8 @@ const path = require('path');
 const { execFileSync } = require('child_process');
 const { parseArgs } = require('./schedule-cli');
 
-const COMMANDS = { proactive: ['today', 'scan', 'settings', 'feedback', 'brief', 'prepare', 'learn'] };
-const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'jira', 'confluence'];
+const COMMANDS = { proactive: ['today', 'scan', 'settings', 'feedback', 'brief', 'goals', 'prepare', 'learn'] };
+const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'slack', 'jira', 'confluence'];
 const onOff = (v, what) => (v === 'on' || v === 'true' ? true : v === 'off' || v === 'false' ? false : { err: `${what} takes on or off` });
 
 async function run(argv, { call, say, cwd = process.cwd() }) {
@@ -189,6 +190,61 @@ async function run(argv, { call, say, cwd = process.cwd() }) {
     for (const l of r.lessons.filter((x) => x.status === 'proposed' || x.status === 'approved')) say(`${l.id}  ${l.status}  ${l.text}`);
     return 0;
   }
+  if (verb === 'goals') {
+    const sub = pos[0] || 'list';
+    const usage = 'usage: pmos proactive goals [list] | add TEXT [--initiative ID] | done N | drop N | reopen N | remove N | plan [--repo PATH]';
+    const wsOfRepo = async () => {
+      let root; try { root = execFileSync('git', ['rev-parse', '--show-toplevel'], { cwd: flags.repo ? path.resolve(cwd, flags.repo) : cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return null; }
+      const wl = await call('GET', '/api/workspaces');
+      const hit = ((wl && wl.workspaces) || []).find((w) => path.resolve(w.root) === path.resolve(root));
+      return hit ? hit.id : null;
+    };
+    const get = async () => { const ws = await wsOfRepo(); return call('GET', '/api/proactive/goals' + (ws ? '?ws=' + encodeURIComponent(ws) : '')); };
+    if (sub === 'add') {
+      const text = pos.slice(1).join(' ');
+      if (!text.trim()) return fail(usage);
+      const r = await call('POST', '/api/proactive/goals', { action: 'add', text, ...(flags.initiative ? { initiative_id: flags.initiative } : {}) });
+      if (!r || r.ok === false) return fail(`refused — ${(r && r.error) || 'the server did not answer'}. Nothing changed.`);
+      say(`added goal ${r.day.goals.length}: ${r.goal.text}${r.goal.initiative_id ? ' · ' + r.goal.initiative_id : ''}`);
+      return 0;
+    }
+    if (['done', 'drop', 'reopen', 'remove'].includes(sub)) {
+      const t = await get();
+      if (!t || t.ok === false) return fail((t && t.error) || 'the server did not answer');
+      const ref = pos[1];
+      const g = /^\d+$/.test(String(ref)) ? t.plan.goals[Number(ref) - 1] : t.plan.goals.find((x) => x.id === ref);
+      if (!g) return fail(`no goal ${ref || ''} today — ${usage}`);
+      const r = await call('POST', '/api/proactive/goals', { action: sub, id: g.id });
+      if (!r || r.ok === false) return fail(`refused — ${(r && r.error) || 'the server did not answer'}. Nothing changed.`);
+      say(`${sub === 'remove' ? 'removed' : sub === 'reopen' ? 'reopened' : sub === 'drop' ? 'dropped' : 'done'}: ${g.text}`);
+      return 0;
+    }
+    if (sub === 'plan') {
+      const ws = await wsOfRepo();
+      if (!ws) return fail('this is not inside a registered workspace — open it with pmos first, or use --repo PATH');
+      const r = await call('POST', '/api/proactive/goals/plan', { ws });
+      if (!r || r.ok === false) return fail(`not started — ${(r && r.error) || 'the server did not answer'}`);
+      say(`${r.seeded ? `scheduled the morning brief daily at ${r.schedule.time}, and ` : ''}started a morning-brief session to plan ${r.goals} goal(s). The plan shows when it submits the brief.`);
+      return 0;
+    }
+    if (sub !== 'list') return fail(usage);
+    const t = await get();
+    if (!t || t.ok === false) return fail((t && t.error) || 'the server did not answer');
+    const pl = t.plan;
+    if (!pl.goals.length) say(`No goals for ${t.today}. Add one with: pmos proactive goals add "…"`);
+    pl.goals.forEach((g, i) => {
+      say(`${i + 1}. ${g.id} [${g.coverage}] ${g.text}${g.initiative_id ? ' · ' + g.initiative_id : ''}`);
+      for (const e of g.context) say(`     ${e.start}  ${e.title}`);
+      for (const st of g.steps) say(`     ${st.owner === 'pm' ? 'you  ' : 'agent'}  ${st.title}  (${st.source}${st.mention ? ', mention' : ''}${st.prepare ? ', can prepare' : ''})`);
+    });
+    if (pl.also.length) { say('Also on your plate:'); for (const st of pl.also) say(`   ${st.owner === 'pm' ? 'you  ' : 'agent'}  ${st.title}  (${st.source})`); }
+    if (pl.brief && !pl.brief.fresh) say(`The brief is for ${pl.brief.date}, not today: it is not used. Run: pmos proactive goals plan`);
+    if (!pl.brief) say('No brief yet, so the plan uses only what Today derived. Run: pmos proactive goals plan');
+    if (pl.time) say(`Free until ${pl.time.until}: ${pl.time.free_minutes} min${pl.time.next ? ` · next: ${pl.time.next.title} at ${pl.time.next.start}` : ''}`);
+    if (pl.not_read.length) say('not read: ' + pl.not_read.map((x) => `${x.source} (${x.state})`).join(', '));
+    if (t.cards_error) say('! Today could not be read: ' + t.cards_error);
+    return 0;
+  }
   if (verb === 'brief') {
     const sub = pos[0] || 'show';
     if (sub === 'submit') {

package/workspace/lib/proactive.js

@@ -29,9 +29,9 @@ const DISMISS_MS = 7 * DAY;
 const BASE = { needs: 100, returned: 100, review: 80, schedule: 60, stalled: 40 };
 const OWNER = { needs: 'pm', returned: 'pm', review: 'pm', schedule: 'pm', stalled: 'agent' };
 
-const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'jira', 'confluence'];
+const BRIEF_SOURCES = ['calendar', 'wispr', 'mail', 'slack', 'jira', 'confluence'];
 // Mail is off by default: a brief reads titles and metadata of the other sources, and the PM turns mail on.
-const BRIEF_DEFAULT = Object.freeze({ calendar: true, wispr: true, mail: false, jira: true, confluence: true });
+const BRIEF_DEFAULT = Object.freeze({ calendar: true, wispr: true, mail: false, slack: true, jira: true, confluence: true });
 const DEFAULTS = Object.freeze({ name: '', briefSources: BRIEF_DEFAULT, briefScoring: false, backgroundPrepare: false, enabled: true, triggers: Object.freeze(Object.fromEntries(TRIGGERS.map((t) => [t, true]))), stalledDays: 5, quiet: null, pauseLearning: false });
 
 const idOf = (key) => crypto.createHash('sha1').update(String(key)).digest('hex').slice(0, 12);