create-pmos 0.61.1 → 0.63.0

package/workspace/lib/pmos-verbs.js

@@ -41,6 +41,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): docs-three-way-sync added it through the same table.
   docs: Object.freeze({ module: 'docs-cli.js', run: null, guide: 'docs.md',
     help: 'pmos docs [list|link|unlink|find] … — is each linked document the same as, ahead of or behind its Google Docs and Confluence copy, and record a sync (pmos docs help)' }),
+  // Not a pm-os-absorb verb (run: null): people-directory added it through the same table.
+  people: Object.freeze({ module: 'people-cli.js', run: null, guide: 'people.md',
+    help: 'pmos people list|show|record|settings … — the people you work with in this repository (pmos people help)' }),
   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' }),
 });

package/workspace/lib/route-modules.js

@@ -36,6 +36,7 @@ const MODULES = Object.freeze([
   'routes-timeline',      // Run 4 (4C): GET /api/timeline
   'routes-board',         // Run 4 (4D): the cross-initiative Board, Release
   'routes-reports',       // Run 5 (5C): drafts, Issue, notes
+  'routes-notes',         // meeting-notes Run 1: the Notes view (typed notes, dictation, transcripts, summaries)
 ]);
 const PM_DIR = path.join(__dirname, '..', 'public', 'pm');
 const MODULE_NAME = /^[a-z0-9][a-z0-9-]*\.js$/;

package/workspace/lib/routes-notes.js

@@ -0,0 +1,230 @@
+'use strict';
+/* routes-notes.js — the Notes view's routes (meeting-notes, Runs 1 and 2; lib/route-modules.js).
+ *
+ *   GET  /api/notes                         → { ok, notes: [row] }            newest first; a row never carries the body
+ *   GET  /api/notes/one?id=…                → { ok, note }                    imports an agent summary written since the request
+ *   POST /api/notes/new        { title? }   → { ok, note }
+ *   POST /api/notes/save       { id, title?, body? }      → { ok, updated_at }
+ *   POST /api/notes/dictate    { text }     → { ok, ops }  one dictated phrase as insert operations (lib/notes.js dictation)
+ *   POST /api/notes/record     { id, ws? }  → { ok, recorded_from }    `ws` is the repository the note's lines are checked against
+ *   POST /api/notes/transcript { id, text, source? } → { ok, added: [{ at, t, text, source, cat, index }] }
+ *   POST /api/notes/audio      { id, source, pcm, final? } → { ok, cut }   16 kHz mono 16-bit samples, base64; local Whisper (D91)
+ *   POST /api/notes/label      { id, index, cat }           → { ok, segment }   the PM's own label for a line
+ *   POST /api/notes/speaker    { id, source, name }         → { ok, speakers }
+ *   GET  /api/notes/engine?ws=…             → { ok, whisper, jev }   is Whisper set up; which Jev gates hold (booleans only)
+ *   POST /api/notes/switch     { ws, jev?, check? }         → { ok, jev }   the two D91 switches, default off
+ *   POST /api/notes/whisper-setup { ws? }   → { ok, started, session, command }   a terminal with the setup typed in, not run
+ *   POST /api/notes/private    { id, private }            → { ok, private }
+ *   POST /api/notes/summarize  { id }       → { ok, summary }   the local summary
+ *   POST /api/notes/summarize-agent { id, ws? }           → { ok, started, session, handoff, out, withheld, reason }
+ *   POST /api/notes/delete     { id }       → { ok }
+ *
+ * Notes are the PM's own and live in the per-user runtime directory (ctx.runtimeDir), never in a repository, so no route here
+ * writes into a registered workspace. Every POST goes through pm-guard `requirePagePress` (a body that is not an object or carries
+ * a writer field: 400; no Origin, a foreign Origin or a wrong nonce: 403). No route makes an outbound request of its own: the
+ * agent summary starts the PM's own agent session in the repository (ctx.spawnSession), as the skill draft does; Whisper runs
+ * on this machine (lib/notes-whisper.js); a label or a check goes to Jev only through lib/jev-notes.js, behind the D91 gates.
+ *
+ * AFTER A LINE IS ADDED (Run 2). Each new line already has its local label. Then, one note at a time and in order: Jev's label
+ * when the label gates hold; for a decision, action or statement, the closest repository passage (local, lib/notes-repo.js),
+ * and Jev's comparison when the check gates hold too. The page reads the results with GET /api/notes/one.
+ */
+const guard = require('./pm-guard.js');
+const notes = require('./notes.js');
+const whisper = require('./notes-whisper.js');
+const notesRepo = require('./notes-repo.js');
+const jevNotes = require('./jev-notes.js');
+const tsSettings = require('./typesafe-settings.js');
+
+const MAX_PCM_BYTES = 16000 * 2 * 15;       // 15 s of 16 kHz 16-bit audio in one request
+const CHECKED = new Set(['decision', 'action', 'statement']);
+
+const prefixes = ['/api/notes'];
+const POSTS = new Set(['/api/notes/new', '/api/notes/save', '/api/notes/dictate', '/api/notes/record', '/api/notes/transcript',
+  '/api/notes/private', '/api/notes/summarize', '/api/notes/summarize-agent', '/api/notes/delete', '/api/notes/audio', '/api/notes/label',
+  '/api/notes/speaker', '/api/notes/switch', '/api/notes/whisper-setup']);
+
+/* ── labels and checks, one note at a time ───────────────────────────────────────────────────── */
+const chains = new Map();      // note id → the promise of its enrichment so far
+function enrich(ctx, id, added) {
+  if (!added || !added.length) return Promise.resolve();
+  const next = (chains.get(id) || Promise.resolve()).then(() => enrichNow(ctx, id, added)).catch(() => {});
+  chains.set(id, next);
+  next.then(() => { if (chains.get(id) === next) chains.delete(id); });
+  return next;
+}
+function gatesFor(ctx, root) {
+  const dir = ctx.runtimeDir;
+  if (!root) return { root: null, exclude: [], ask: null, check: false, key: null, askOpts: {} };
+  const repo = tsSettings.getRepo(dir, root);
+  const sw = jevNotes.getSwitch(dir, root);
+  const key = tsSettings.getKey(dir);
+  const snd = jevNotes.senderFor(key, { consent: repo.consent, jev: sw.jev, check: sw.check }, typeof ctx.jevModelOpts === 'function' ? ctx.jevModelOpts(root) : {});
+  return { root, exclude: repo.exclude, ask: snd.ask, check: snd.check, key: snd.ask ? key : null, askOpts: snd.askOpts };
+}
+const stillOpen = (dir, id) => { const r = notes.read(dir, id); return r.ok && !r.note.private ? r.note : null; };
+async function enrichNow(ctx, id, added) {
+  const dir = ctx.runtimeDir;
+  const note = stillOpen(dir, id);
+  if (!note) return;
+  const w = note.ws ? ctx.getWs(note.ws) : null;
+  const g = gatesFor(ctx, w ? w.root : null);
+  for (const seg of added) {
+    let cat = seg.cat;
+    if (g.ask && stillOpen(dir, id)) {
+      const l = await jevNotes.label({ ask: g.ask, key: g.key, askOpts: g.askOpts, text: seg.text, root: g.root });
+      if (l.cat) { const u = notes.updateSegment(dir, { id, index: seg.index, text: seg.text, patch: { cat: l.cat, cat_by: 'jev' } }); if (u.ok) cat = u.segment.cat; }
+      else if (l.reason === 'failed' || l.reason === 'paused') notes.updateSegment(dir, { id, index: seg.index, text: seg.text, patch: { jev: l.reason } });
+    }
+    if (!g.root || !CHECKED.has(cat)) continue;
+    const pass = notesRepo.closest(g.root, seg.text, { exclude: g.exclude });
+    if (!pass) continue;
+    let check = { doc: pass.path, line: pass.line, verdict: 'related', by: 'local' };
+    if (g.ask && g.check && stillOpen(dir, id)) {
+      const c = await jevNotes.compare({ ask: g.ask, key: g.key, askOpts: g.askOpts, text: seg.text, passage: pass, root: g.root });
+      if (c.verdict) check = { doc: pass.path, line: pass.line, verdict: c.verdict, words: c.words || null, by: 'jev' };
+    }
+    notes.updateSegment(dir, { id, index: seg.index, text: seg.text, patch: { check } });
+  }
+}
+
+/* ── local Whisper: one transcriber for the process ───────────────────────────────────────────── */
+let transcriber = null; let transcriberDir = null;
+const audioErrors = new Map();   // note id → the last thing that went wrong, for the page
+function transcriberFor(ctx) {
+  if (transcriber && transcriberDir === ctx.runtimeDir) return transcriber;
+  transcriberDir = ctx.runtimeDir;
+  transcriber = whisper.createTranscriber({
+    runtimeDir: ctx.runtimeDir,
+    onText: async (c) => {
+      const r = notes.appendTranscript(ctx.runtimeDir, { id: c.id, text: c.text, source: c.source, t: c.t });
+      if (r.ok) { audioErrors.delete(c.id); await enrich(ctx, c.id, r.added).catch(() => {}); }
+    },
+    onError: (c) => { audioErrors.set(c.id, { at: new Date().toISOString(), error: c.error }); },
+  });
+  return transcriber;
+}
+function engineInfo(ctx, w) {
+  const d = whisper.detect(ctx.runtimeDir);
+  const out = { ready: d.ready, missing: d.missing, setup: d.setup, model_dir: d.model_dir, model_size: d.model_size };
+  if (!w) return { whisper: out, jev: null };
+  const repo = tsSettings.getRepo(ctx.runtimeDir, w.root);
+  const sw = jevNotes.getSwitch(ctx.runtimeDir, w.root);
+  const info = jevNotes.infoFor(tsSettings.status(ctx.runtimeDir).present, { consent: repo.consent, jev: sw.jev, check: sw.check });
+  return { whisper: out, jev: { ...info, paused: jevNotes.pauseStatus(w.root) } };
+}
+
+const send = (ctx, res, r) => ctx.json(res, r, r.ok ? 200 : (r.status || 400));
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const dir = ctx.runtimeDir;
+  if (!dir) { ctx.json(res, { ok: false, error: 'the notes store is not available' }, 500); return true; }
+  if (p === '/api/notes' || p === '/api/notes/one') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    if (p === '/api/notes') { send(ctx, res, notes.list(dir)); return true; }
+    const nid = url.searchParams.get('id');
+    const r = notes.read(dir, nid);
+    if (r.ok) r.audio = { pending: transcriber ? transcriber.pending() : 0, error: audioErrors.get(nid) || null };
+    send(ctx, res, r);
+    return true;
+  }
+  if (p === '/api/notes/engine') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    const wsId = url.searchParams.get('ws');
+    const w = wsId ? ctx.getWs(wsId) : null;
+    ctx.json(res, { ok: true, ...engineInfo(ctx, w && w.id === wsId ? w : null) });
+    return true;
+  }
+  if (!POSTS.has(p)) { ctx.json(res, { ok: false, error: 'no such notes route' }, 404); return true; }
+  if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
+  const parsed = await ctx.readJson(req);
+  if (!parsed.ok) { ctx.json(res, { ok: false, error: 'The body is not valid JSON.' }, 400); return true; }
+  const body = parsed.body;
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
+  const id = body && typeof body.id === 'string' ? body.id : '';
+  const done = (r) => { send(ctx, res, r); return true; };
+  if (p === '/api/notes/new') return done(notes.create(dir, { title: body.title }));
+  if (p === '/api/notes/dictate') return done(notes.dictation(body.text));
+  if (p === '/api/notes/save') return done(notes.save(dir, { id, title: body.title, body: body.body }));
+  const wsOf = () => {
+    if (body.ws == null) return { ok: true, w: null };
+    const w = typeof body.ws === 'string' ? ctx.getWs(body.ws) : null;
+    return w && w.id === body.ws ? { ok: true, w } : { ok: false };
+  };
+  if (p === '/api/notes/record') {
+    const o = wsOf();
+    if (!o.ok) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
+    return done(notes.record(dir, { id, ws: body.ws == null ? undefined : o.w.id }));
+  }
+  if (p === '/api/notes/transcript') {
+    const r = notes.appendTranscript(dir, { id, text: body.text, source: 'speech' });
+    if (r.ok) enrich(ctx, id, r.added);
+    return done(r);
+  }
+  if (p === '/api/notes/audio') {
+    const source = body.source === 'meeting' ? 'meeting' : body.source === 'mic' ? 'mic' : null;
+    if (!source) return done({ ok: false, status: 400, error: 'the source must be mic or meeting' });
+    const note = notes.read(dir, id);
+    if (!note.ok) return done(note);
+    if (note.note.private) { transcriberFor(ctx).drop(id); return done({ ok: false, status: 409, error: 'this note is marked private, so nothing more is recorded in it' }); }
+    if (!note.note.recorded_from) return done({ ok: false, status: 409, error: 'press Listen first' });
+    const b64 = typeof body.pcm === 'string' ? body.pcm : '';
+    if (b64.length > Math.ceil(MAX_PCM_BYTES / 3) * 4) return done({ ok: false, status: 413, error: 'that audio chunk is too long' });
+    const pcm = Buffer.from(b64, 'base64');
+    if (pcm.length % 2) return done({ ok: false, status: 400, error: 'the audio must be 16-bit samples' });
+    if (!whisper.detect(dir).ready) return done({ ok: false, status: 409, error: 'local transcription is not set up' });
+    const ms = (pcm.length / 2 / whisper.RATE) * 1000;
+    const t = Math.max(0, Date.now() - Date.parse(note.note.recorded_from) - ms);
+    return done(transcriberFor(ctx).push({ id, source, pcm, t, final: body.final === true }));
+  }
+  if (p === '/api/notes/label') return done(notes.setLabel(dir, { id, index: Number(body.index), cat: body.cat, drop: body.drop === true }));
+  if (p === '/api/notes/speaker') return done(notes.renameSpeaker(dir, { id, source: body.source, name: body.name }));
+  if (p === '/api/notes/switch') {
+    const o = wsOf();
+    if (!o.ok || !o.w) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
+    jevNotes.setSwitch(dir, o.w.root, { jev: typeof body.jev === 'boolean' ? body.jev : undefined, check: typeof body.check === 'boolean' ? body.check : undefined });
+    ctx.json(res, { ok: true, ...engineInfo(ctx, o.w) });
+    return true;
+  }
+  if (p === '/api/notes/whisper-setup') {
+    const o = wsOf();
+    if (!o.ok) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
+    const command = whisper.setupCommand(dir);
+    if (typeof ctx.spawnSession !== 'function') { ctx.json(res, { ok: true, started: false, command, reason: 'this workspace cannot start sessions' }); return true; }
+    // typed, not run: the PM reads the commands in their own terminal and presses Enter (D91)
+    const s = ctx.spawnSession({ name: 'notes: set up Whisper', agent: 'shell', ws: o.w ? o.w.id : undefined, origin: 'notes-whisper-setup', initialInput: command });
+    const started = !!s && s.state !== 'exited';
+    ctx.json(res, { ok: true, started, session: s ? s.id : null, command, reason: started ? '' : ((s && s.note) || 'could not start a terminal') });
+    return true;
+  }
+  if (p === '/api/notes/private') {
+    const r = notes.setPrivate(dir, { id, private: body.private });
+    if (r.ok && r.private && transcriber) transcriber.drop(id);
+    return done(r);
+  }
+  if (p === '/api/notes/summarize') return done(notes.localSummary(dir, { id }));
+  if (p === '/api/notes/delete') { if (transcriber) transcriber.drop(id); return done(notes.remove(dir, id)); }
+  // summarize-agent: the handoff file first (refused for a private note), then the PM's own agent session
+  let w = null;
+  if (body.ws != null) {
+    w = typeof body.ws === 'string' ? ctx.getWs(body.ws) : null;
+    if (!w || w.id !== body.ws) { ctx.json(res, { ok: false, error: 'This repository is not registered.' }, 404); return true; }
+  }
+  const h = notes.agentHandoff(dir, { id });
+  if (!h.ok) return done(h);
+  if (typeof ctx.spawnSession !== 'function') {
+    notes.agentStarted(dir, { id, started: false, reason: 'this workspace cannot start sessions' });
+    ctx.json(res, { ok: true, started: false, reason: 'this workspace cannot start sessions', handoff: h.handoff, out: h.out, withheld: h.withheld });
+    return true;
+  }
+  const s = ctx.spawnSession({ name: 'notes: summary', agent: 'claude', ws: w ? w.id : undefined, origin: 'notes-summary:' + id, initialInput: h.prompt + '\r' });
+  const started = !!s && s.state !== 'exited';
+  const reason = started ? '' : ((s && s.note) || 'could not start a claude session');
+  notes.agentStarted(dir, { id, session: s ? s.id : null, started, reason });
+  ctx.json(res, { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld });
+  return true;
+}
+
+module.exports = { prefixes, handle, enrich, __idle: () => Promise.all([transcriber ? transcriber.idle() : null, ...chains.values()]) };

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.61.1",
+  "version": "0.63.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

package/workspace/public/pm/app.js

@@ -406,7 +406,7 @@ function render() {
 
 const FRAME = !FIXTURE && !LEGACY_LAYOUT_FLAG;
 const FRAME_KEY = 'pmos.workspace.pm.frame';
-const FRAME_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'settings']);
+const FRAME_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'people', 'settings']);
 
 function readFrame() {
   if (!FRAME) return {};
@@ -637,7 +637,7 @@ function pressIn(r, key) {
   if (b && !b.disabled) { b.click(); return true; }
   return false;
 }
-const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs' };
+const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs', p: 'people' };
 
 function frameKey(e) {
   const mod = e.metaKey || e.ctrlKey;