create-pmos 0.163.0 → 0.165.0

package/workspace/lib/routes-meeting-focus.js

@@ -0,0 +1,291 @@
+'use strict';
+/* routes-meeting-focus.js — the Meeting focus page's server side (initiative c3-meeting-focus; lib/route-modules.js).
+ *
+ *   GET  /api/meeting-focus?event=<id>&date=YYYY-MM-DD[&ws=]
+ *        → { ok, now_ms, event, brief, note, topics, current, runs, tail, captured, gist, chips, notes, asks, companion }
+ *        The meeting (the calendar read for that day), its brief (lib/calendar-layers.js briefOf), the note linked to it, the last
+ *        minutes of that note's transcript with who said them, the decisions, actions and questions so far, and the companion's state.
+ *        An unknown meeting is a 404. The read also starts the companion when lib/meeting-focus.js shouldRun says it may: the note
+ *        records, new lines arrived, 40 s passed, no run is under way, PMOS_FOCUS_AGENT is not off. The run is fire and forget.
+ *   POST /api/meeting-focus/topic { event | note, date?, action: 'set'|'add'|'park', topic }   page press; the PM's correction, appended to the state
+ *   POST /api/meeting-focus/ask   { event, note?, date?, question }                            page press; one headless read-only run with the PM's question
+ *   GET  /api/meeting-focus/ask?id=  → { ok, id, state: working | answered | failed, error? }   the answer itself comes back as a note in GET /api/meeting-focus
+ *
+ * The companion runs as origin `focus-companion:<key>` (lib/headless.js 'ask': Read, Glob and Grep only). It sends nothing to anyone and
+ * writes nothing: its answer is parsed here and appended to <runtimeDir>/focus/<note id or event id>.jsonl. Handlers are pure over
+ * (req, body, ctx): ctx = { runtimeDir, spawnSession, w, readEvents?, briefFor?, env?, now? }, so a test needs no server.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const guard = require('./pm-guard.js');
+const headless = require('./headless.js');
+const notes = require('./notes.js');
+const F = require('./meeting-focus.js');
+
+const fail = (status, error, extra) => ({ status, body: { ok: false, error, ...(extra || {}) } });
+const dirOf = (runtimeDir) => path.join(runtimeDir, 'focus');
+const KEY_BAD = /[^A-Za-z0-9_@.-]/g;
+const keyOf = (id) => String(id == null ? '' : id).replace(KEY_BAD, '_').slice(0, 80);
+const baseId = (id) => String(id || '').split('@')[0];
+const pad = (n) => String(n).padStart(2, '0');
+const localDay = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+const DAY = /^\d{4}-\d{2}-\d{2}$/;
+
+function readLines(file) {
+  let raw; try { raw = fs.readFileSync(file, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const l of raw.split('\n')) { if (!l.trim()) continue; try { out.push(JSON.parse(l)); } catch { /* a torn line */ } }
+  return out;
+}
+function append(runtimeDir, name, row) {
+  fs.mkdirSync(dirOf(runtimeDir), { recursive: true });
+  fs.appendFileSync(path.join(dirOf(runtimeDir), name), JSON.stringify(row) + '\n');
+}
+/** The state of a meeting: the lines of its note's file and of its event's file (a topic set before the note existed), in order. */
+function linesOf(runtimeDir, keys) {
+  const all = [];
+  for (const k of [...new Set(keys.filter(Boolean))]) all.push(...readLines(path.join(dirOf(runtimeDir), k + '.jsonl')));
+  return all.map((l, i) => [l, i]).sort((a, b) => (Number(a[0].at) || 0) - (Number(b[0].at) || 0) || a[1] - b[1]).map((x) => x[0]);
+}
+
+/* ── the meeting, its note and its brief ──────────────────────────────────────────────────────────────────────────── */
+
+function findEvent(events, id, date, by) {
+  if (!id && by && by.at) {   // a meeting without a stored id: its start and title name it
+    const hit = (events || []).filter((e) => e && e.id && e.at === String(by.at) && (!by.title || e.title === String(by.title)));
+    return hit[0] || null;
+  }
+  const rows = (events || []).filter((e) => e && e.id && (String(e.id) === id || baseId(e.id) === baseId(id)));
+  const onDay = rows.filter((e) => !date || String(e.at || '').slice(0, 10) === date);
+  return onDay.find((e) => String(e.id) === id) || onDay[0] || null;
+}
+function noteFor(runtimeDir, ev, noteId) {
+  if (noteId) { const r = notes.read(runtimeDir, String(noteId)); return r.ok ? r.note : null; }
+  const hit = notes.findByEvent(runtimeDir, { event_id: String(ev.id), start: ev.at, title: ev.title }) || notes.findByEvent(runtimeDir, { event_id: baseId(ev.id), start: ev.at, title: ev.title });
+  if (!hit) return null;
+  const r = notes.read(runtimeDir, hit.id);
+  return r.ok ? r.note : null;
+}
+
+const briefCache = new Map();   // runtimeDir|event|date → { at, brief }
+const BRIEF_MS = 60000;
+/** The brief of one meeting, as the Calendar card reads it (briefOf). Kept for a minute: the page asks every few seconds. */
+async function realBrief(ctx, ev, date) {
+  const key = ctx.runtimeDir + '|' + ev.id + '|' + date;
+  const hit = briefCache.get(key);
+  if (hit && Date.now() - hit.at < BRIEF_MS) return hit.brief;
+  let brief = null;
+  try {
+    const root = ctx.w && ctx.w.root ? path.resolve(ctx.w.root) : null;
+    const layers = require('./calendar-layers.js');
+    const views = require('./routes-calendar-views.js');
+    let inis = [];
+    if (root) { try { const facts = await require('./facts-async.js').readFactsAsync(root); inis = ((facts && facts.inis) || []).filter((i) => i && i.id).map((i) => ({ id: i.id, title: i.title || i.id, status: null })); } catch { inis = []; } }
+    const src = root ? views.readers(root, ctx.runtimeDir).readContextSources() : { notes: [], planItems: [], ownItems: [] };
+    const mine = (src.notes || []).filter((n) => n.meeting && (n.meeting.event_id === ev.id || n.meeting.event_id === baseId(ev.id)));
+    let links = null; try { links = require('./calendar-links.js').read(ctx.runtimeDir); } catch { links = null; }
+    let boards = null; try { boards = require('./routes-boards.js').meetingBoards(ctx); } catch { boards = null; }
+    brief = layers.briefOf(ev, mine, src, { today: localDay(Date.now()), inis, links, boards }).brief || null;
+  } catch { brief = null; }
+  briefCache.set(key, { at: Date.now(), brief });
+  return brief;
+}
+
+const kindOk = () => headless.kindFor({ agent: 'claude', origin: 'focus-companion:x' }) === 'ask';
+const spawnable = (ctx) => typeof ctx.spawnSession === 'function' && kindOk();
+
+/* ── the companion run ────────────────────────────────────────────────────────────────────────────────────────────── */
+
+function settleRun(ctx, key, done, now) {
+  const at = typeof now === 'function' ? now() : Date.now();
+  const res = done && done.result;
+  if (done && done.stopped) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The run was stopped before it answered.' });
+  if (done && done.timedOut) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion took too long and was stopped.' });
+  if (!res || !res.ok || res.isError) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion did not answer (' + ((done && done.note) || 'no result') + ').' });
+  const parsed = F.parseCompanion(res.text);
+  // a malformed answer is dropped, not shown
+  if (!parsed) return append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at, error: 'The companion answered in a form PMOS could not read, so nothing was shown.' });
+  return append(ctx.runtimeDir, key + '.jsonl', F.outLine(parsed, at));
+}
+
+function inputFor(ctx, ev, brief, note, state, topics, question) {
+  const now = ctx.nowMs;
+  const names = new Map(state.topics.map((t) => [t.id, t.text]));
+  return { event: ev, brief: brief || {}, topics: state.topics.length ? state.topics : topics, current: state.current ? names.get(state.current) : null,
+    tail: note ? F.tailOf(note, { now }) : [], earlier: state.notes, question: question || null, now };
+}
+
+function startRun(ctx, key, ev, brief, note, state, topics, now) {
+  const origin = 'focus-companion:' + key;
+  const lines = note ? (note.transcript || []).length : 0;
+  append(ctx.runtimeDir, key + '.jsonl', { k: 'run', at: now, lines });
+  const prompt = F.companionPrompt(inputFor({ ...ctx, nowMs: now }, ev, brief, note, state, topics, null));
+  let s = null;
+  try {
+    s = ctx.spawnSession({ name: 'focus: companion', agent: 'claude', ws: ctx.w ? ctx.w.id : undefined, origin, initialInput: prompt,
+      onDone: (done) => settleRun(ctx, key, done, ctx.now) });
+  } catch (e) { s = null; }
+  if (!s || s.state === 'exited') append(ctx.runtimeDir, key + '.jsonl', { k: 'fail', at: now, error: 'The companion could not start: ' + ((s && s.note) || 'no session') + '.' });
+}
+
+/* ── GET /api/meeting-focus ───────────────────────────────────────────────────────────────────────────────────────── */
+
+async function read(q, ctx) {
+  const id = String((q && q.event) || '');
+  const by = q && q.at ? { at: String(q.at).slice(0, 40), title: String(q.title || '').slice(0, 200) } : null;
+  if ((!id && !by) || id.length > 120) return fail(400, 'event is required');
+  const date = q && q.date ? String(q.date) : '';
+  if (date && !DAY.test(date)) return fail(400, 'date must be YYYY-MM-DD');
+  const nowMs = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  let events = [];
+  try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir, { now: nowMs }); } catch { events = []; }
+  const ev = findEvent(events, id, date, by);
+  if (!ev) return fail(404, 'no such meeting on the calendar');
+  const day = date || String(ev.at || '').slice(0, 10);
+  const brief = typeof ctx.briefFor === 'function' ? await ctx.briefFor(ev, day) : await realBrief(ctx, ev, day);
+  const note = noteFor(ctx.runtimeDir, ev, q && q.note);
+  const startMs = Date.parse(ev.at);
+  const topics = F.topicsFrom(ev, brief);
+  const keys = [keyOf(ev.id), note ? keyOf(note.id) : null];
+  const key = note ? keyOf(note.id) : keyOf(ev.id);
+  const state = F.foldState(linesOf(ctx.runtimeDir, keys), { topics, startMs: Number.isFinite(startMs) ? startMs : null, nowMs });
+  const env = ctx.env || process.env;
+  const call = F.shouldRun(nowMs, state, note ? { state: note.state, lines: (note.transcript || []).length } : null, { env, timeoutMs: headless.timeoutMs(env) });
+  let started = false;
+  if (call.run && spawnable(ctx)) { startRun(ctx, key, ev, brief, note, state, topics, nowMs); started = true; }
+  const fresh = started ? F.foldState(linesOf(ctx.runtimeDir, keys), { topics, startMs: Number.isFinite(startMs) ? startMs : null, nowMs }) : state;
+  const links = [];
+  const seen = new Set();
+  for (const l of [...(Array.isArray(ev.links) ? ev.links : []), ...((brief && brief.links) || []), ...(((brief && brief.refs) || []).filter((r) => r.link).map((r) => ({ label: r.label, url: r.link })))]) {
+    const url = l && typeof l.url === 'string' && /^https?:\/\//i.test(l.url) ? l.url : ''; if (!url || seen.has(url)) continue;
+    seen.add(url); links.push({ label: F.str(l.label, 120) || url, url });
+  }
+  const sessions = note && Array.isArray(note.sessions) && note.sessions.length ? note.sessions : [];
+  return { status: 200, body: {
+    ok: true, now_ms: nowMs, date: day,
+    event: { id: ev.id, title: ev.title, at: ev.at, end: ev.end, attendees: [].concat(ev.attendees || ev.people || []).map((p) => (p && typeof p === 'object' ? p.name || p.id : p)).filter(Boolean).map(String),
+      initiative: ev.initiative || null, purpose: ev.purpose || (brief && brief.purpose) || null, links },
+    brief: brief || null,
+    note: note ? { id: note.id, title: note.title || ev.title, state: note.state, recorded_from: note.recorded_from || null, lines: (note.transcript || []).length, sessions } : null,
+    topics: fresh.topics, current: fresh.current, runs: fresh.runs,
+    tail: note ? F.tailOf(note, { now: nowMs }) : [], captured: F.capturedFrom(note),
+    gist: fresh.gist, chips: fresh.chips, notes: fresh.notes, asks: fresh.asks,
+    companion: { on: !F.off(env) && kindOk() && typeof ctx.spawnSession === 'function', running: !!fresh.pending, started, reason: call.reason, last_run_at: fresh.last_run_at || null, error: fresh.error },
+  } };
+}
+
+/* ── POST /api/meeting-focus/topic ────────────────────────────────────────────────────────────────────────────────── */
+
+async function topic(req, body, ctx) {
+  const g = guard.requirePagePress(req, body); if (!g.ok) return fail(g.status, g.error);
+  const action = String(body.action || '');
+  if (!['set', 'add', 'park'].includes(action)) return fail(400, 'action must be set, add or park');
+  const text = F.str(body.topic, 120);
+  if (!text) return fail(400, 'Name the topic.');
+  const key = await keyFromBody(body, ctx); if (key.error) return key.error;
+  const now = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  append(ctx.runtimeDir, key.key + '.jsonl', F.moveLine(action, text, now));
+  return { status: 200, body: { ok: true, key: key.key } };
+}
+/** The state file a body names: its note, else its event. */
+async function keyFromBody(body, ctx) {
+  if (body.note) {
+    const r = notes.read(ctx.runtimeDir, String(body.note));
+    if (!r.ok) return { error: fail(404, 'no such note') };
+    return { key: keyOf(r.note.id), note: r.note };
+  }
+  if (!body.event) return { error: fail(400, 'event or note is required') };
+  let events = [];
+  try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir); } catch { events = []; }
+  const ev = findEvent(events, String(body.event), body.date && DAY.test(String(body.date)) ? String(body.date) : '');
+  if (!ev) return { error: fail(404, 'no such meeting on the calendar') };
+  const note = noteFor(ctx.runtimeDir, ev, null);
+  return { key: note ? keyOf(note.id) : keyOf(ev.id), note, ev };
+}
+
+/* ── Ask PMOS quietly ─────────────────────────────────────────────────────────────────────────────────────────────── */
+
+const asksFile = 'asks.jsonl';
+const asksOf = (runtimeDir) => { const by = new Map(); for (const e of readLines(path.join(dirOf(runtimeDir), asksFile))) by.set(e.id, { ...(by.get(e.id) || {}), ...e }); return by; };
+
+/** What a private question's run answered → a note on the stream, or a failure the page shows. Exported so a test can settle without a process. */
+function settleAsk(ctx, a, done, nowFn) {
+  const at = typeof nowFn === 'function' ? nowFn() : Date.now();
+  const end = (row) => { append(ctx.runtimeDir, asksFile, { id: a.id, at, ...row }); return row; };
+  const bad = (error) => { append(ctx.runtimeDir, a.key + '.jsonl', { k: 'fail', id: a.id, at, error }); return end({ event: 'failed', state: 'failed', error }); };
+  if (done && done.stopped) return bad('The run was stopped before it answered.');
+  if (done && done.timedOut) return bad('The agent took too long and was stopped. Ask again with a shorter question.');
+  const res = done && done.result;
+  if (!res || !res.ok || res.isError) return bad('The agent did not answer (' + ((done && done.note) || 'no result') + ').');
+  let list = (F.parseCompanion(res.text) || { notes: [] }).notes;
+  // a plain-text answer is one Answer note; an answer that looks like broken JSON is dropped
+  if (!list.length && !/[{}]/.test(String(res.text || '')) && String(res.text || '').trim()) list = [{ cat: 'Answer', heard: '', body: F.str(res.text, 700), why: '', src: 'PMOS', show: 'now' }];
+  if (!list.length) return bad('The agent answered in a form PMOS could not read, so nothing was shown.');
+  const out = list.map((n) => ({ ...n, show: 'now', heard: n.heard || a.question }));
+  append(ctx.runtimeDir, a.key + '.jsonl', { k: 'answer', id: a.id, at, notes: out });
+  return end({ event: 'answered', state: 'answered' });
+}
+
+async function ask(req, body, ctx) {
+  const g = guard.requirePagePress(req, body); if (!g.ok) return fail(g.status, g.error);
+  const question = F.str(body.question, 1000);
+  if (!question) return fail(400, 'Type your question.');
+  if (typeof ctx.spawnSession !== 'function') return fail(409, 'this workspace cannot start sessions');
+  if (!kindOk()) return fail(409, 'Background runs are switched off here (PMOS_HEADLESS=off), so PMOS cannot answer from this page.');
+  const k = await keyFromBody({ ...body, note: body.note }, ctx); if (k.error) return k.error;
+  const nowMs = typeof ctx.now === 'function' ? ctx.now() : Date.now();
+  let ev = k.ev;
+  if (!ev) {
+    let events = [];
+    try { events = typeof ctx.readEvents === 'function' ? ctx.readEvents() : require('./calendar-events.js').readAll(ctx.runtimeDir); } catch { events = []; }
+    ev = body.event ? findEvent(events, String(body.event), '') : null;
+    if (!ev && k.note && k.note.meeting) ev = { id: k.note.meeting.event_id || k.note.id, title: k.note.meeting.title || k.note.title, at: k.note.meeting.start, end: k.note.meeting.end };
+  }
+  if (!ev) return fail(404, 'no such meeting on the calendar');
+  const day = String(ev.at || '').slice(0, 10);
+  const brief = typeof ctx.briefFor === 'function' ? await ctx.briefFor(ev, day) : await realBrief(ctx, ev, day);
+  const topics = F.topicsFrom(ev, brief);
+  const keys = [keyOf(ev.id), k.note ? keyOf(k.note.id) : null];
+  const startMs = Date.parse(ev.at);
+  const state = F.foldState(linesOf(ctx.runtimeDir, keys), { topics, startMs: Number.isFinite(startMs) ? startMs : null, nowMs });
+  const a = { id: 'fa-' + crypto.randomBytes(6).toString('hex'), key: k.key, question };
+  const origin = 'focus-companion:' + k.key;
+  const prompt = F.companionPrompt(inputFor({ ...ctx, nowMs }, ev, brief, k.note, state, topics, question));
+  const s = ctx.spawnSession({ name: 'focus: ask', agent: 'claude', ws: ctx.w ? ctx.w.id : undefined, origin, initialInput: prompt, onDone: (done) => settleAsk(ctx, a, done, ctx.now) });
+  if (!s || s.state === 'exited') return fail(409, 'The agent could not start: ' + ((s && s.note) || 'no session'));
+  append(ctx.runtimeDir, k.key + '.jsonl', { k: 'ask', id: a.id, at: nowMs, question });
+  append(ctx.runtimeDir, asksFile, { event: 'asked', id: a.id, key: k.key, question, state: 'working', session: s.id, at: nowMs });
+  return { status: 200, body: { ok: true, id: a.id, state: 'working', session: s.id } };
+}
+
+function askState(q, ctx, now = typeof ctx.now === 'function' ? ctx.now() : Date.now()) {
+  const a = asksOf(ctx.runtimeDir).get(String((q && q.id) || ''));
+  if (!a) return fail(404, 'no such question');
+  const out = { ok: true, id: a.id, state: a.state, session: a.session || null };
+  if (a.state === 'failed') out.error = a.error;
+  if (a.state === 'working' && now - Number(a.at || 0) > headless.timeoutMs() + 120000) { out.state = 'failed'; out.error = 'The run ended without an answer. Ask again.'; }
+  return { status: 200, body: out };
+}
+
+const respond = (ctx, res, r) => { ctx.json(res, r.body, r.status); return true; };
+
+module.exports = {
+  prefixes: ['/api/meeting-focus'],
+  read, topic, ask, askState, settleAsk, settleRun, findEvent, keyOf,
+  handle: async (req, res, url, ctx) => {
+    const p = url.pathname;
+    const wsId = url.searchParams.get('ws');
+    const w = ctx.getWs ? ctx.getWs(wsId) : null;
+    const base = { runtimeDir: ctx.runtimeDir, spawnSession: ctx.spawnSession, w, getWs: ctx.getWs, json: ctx.json };
+    if (req.method === 'GET' && p === '/api/meeting-focus') return respond(ctx, res, await read(Object.fromEntries(url.searchParams), base));
+    if (req.method === 'GET' && p === '/api/meeting-focus/ask') return respond(ctx, res, askState(Object.fromEntries(url.searchParams), base));
+    const fn = req.method === 'POST' && { '/api/meeting-focus/topic': topic, '/api/meeting-focus/ask': ask }[p];
+    if (!fn) return false;
+    const got = await ctx.readJson(req);
+    if (!got.ok) return respond(ctx, res, fail(400, 'invalid JSON body'));
+    const body = got.body || {};
+    const bw = body.ws && ctx.getWs ? ctx.getWs(body.ws) : w;
+    return respond(ctx, res, await fn(req, body, { ...base, w: bw }));
+  },
+};

package/workspace/lib/typesafe-settings.js

@@ -9,10 +9,16 @@
  * returns the key. `getKey()` is for the server's validation path only; no route returns its value.
  * `TYPESAFE_API_KEY` in the environment is read as a fallback, ONCE, at server start (`adoptEnv`), which
  * then deletes the variable from the process environment. Nothing the server spawns afterwards can see it.
+ *
+ * LOCAL FALLBACK (D95). The same file keeps `local: { backend, port }`: the System One server the PM runs on this
+ * machine (Winnow or Laya). Every read hands it to lib/typesafe.js (`configureLocal`). With no key saved, `getKey`
+ * returns `typesafe.LOCAL_KEY` so the bridges' key gate opens and their questions go to loopback; `status` says
+ * `source: 'local'`. With a key saved, the local server is only asked when TypeSafe fails.
  */
 const fs = require('fs');
 const path = require('path');
-const { validKey } = require('./typesafe');
+const typesafe = require('./typesafe');
+const { validKey } = typesafe;
 
 const FILE = 'typesafe.json';
 const ENV_NAME = 'TYPESAFE_API_KEY';
@@ -23,13 +29,20 @@ function file(stateDir) { return path.join(stateDir, FILE); }
 function read(stateDir) {
   try {
     const st = fs.lstatSync(file(stateDir));
-    if (!st.isFile()) return { key: null, repos: {} };
+    if (!st.isFile()) return { key: null, repos: {}, local: localFrom(null) };
     const o = JSON.parse(fs.readFileSync(file(stateDir), 'utf8'));
     return {
       key: typeof o.key === 'string' ? o.key : null,
       repos: o && typeof o.repos === 'object' && o.repos && !Array.isArray(o.repos) ? o.repos : {},
+      local: localFrom(o && o.local),
     };
-  } catch { return { key: null, repos: {} }; }
+  } catch { return { key: null, repos: {}, local: localFrom(null) }; }
+}
+
+/* The saved local server, checked, and handed to the TypeSafe module so the process follows the file. */
+function localFrom(l) {
+  const t = typesafe.configureLocal(l && typeof l === 'object' ? { backend: l.backend, port: l.port } : null);
+  return t ? { backend: t.backend, port: t.port } : null;
 }
 
 function write(stateDir, data) {
@@ -59,30 +72,50 @@ function adoptEnv(env) {
 }
 function envKey(env) { return adopted || (env && validKey(env[ENV_NAME]) ? env[ENV_NAME] : null); }
 
-/** The key for the server's own use, or null. File first, then the environment. */
+/** The key for the server's own use, or null. File first, then the environment, then the local server's handle. */
 function getKey(stateDir, env = null) {
-  const f = read(stateDir).key;
-  if (validKey(f)) return f;
-  return envKey(env);
+  const cur = read(stateDir);
+  if (validKey(cur.key)) return cur.key;
+  return envKey(env) || (cur.local ? typesafe.LOCAL_KEY : null);
 }
 
-/** What the browser may know: present or not, and from where. Never the value, never its length. */
+/** What the browser may know: present or not, and from where. Never the value, never its length.
+ *  `local` is the fallback server (backend and port; neither is a secret). */
 function status(stateDir, env = null) {
-  if (validKey(read(stateDir).key)) return { present: true, source: 'settings' };
-  if (envKey(env)) return { present: true, source: 'environment' };
-  return { present: false, source: null };
+  const cur = read(stateDir);
+  const local = cur.local ? { backend: cur.local.backend, name: typesafe.BACKENDS[cur.local.backend].name, port: cur.local.port } : null;
+  if (validKey(cur.key)) return { present: true, source: 'settings', local };
+  if (envKey(env)) return { present: true, source: 'environment', local };
+  if (local) return { present: true, source: 'local', local };
+  return { present: false, source: null, local: null };
+}
+
+/** Save or clear the local fallback server. `backend` is 'winnow' or 'laya'; `port` defaults to that server's own. */
+function setLocal(stateDir, { backend, port } = {}) {
+  const cur = read(stateDir);
+  if (backend == null || backend === '' || backend === 'off') {
+    const out = write(stateDir, { key: cur.key, repos: cur.repos, local: null });
+    if (out.ok) typesafe.configureLocal(null);
+    return out;
+  }
+  if (!typesafe.validBackend(backend)) return { ok: false, error: 'choose Winnow or Laya' };
+  const p = port == null || port === '' ? typesafe.BACKENDS[backend].port : Number(port);
+  if (!typesafe.validPort(p)) return { ok: false, error: 'the port must be a whole number from 1024 to 65535' };
+  const out = write(stateDir, { key: cur.key, repos: cur.repos, local: { backend, port: p } });
+  if (out.ok) typesafe.configureLocal({ backend, port: p });
+  return out;
 }
 
 function setKey(stateDir, key) {
   const k = typeof key === 'string' ? key.trim() : '';
   if (!validKey(k)) return { ok: false, error: 'that does not look like a key — it must be 8 to 512 characters with no spaces' };
   const cur = read(stateDir);
-  return write(stateDir, { key: k, repos: cur.repos });
+  return write(stateDir, { key: k, repos: cur.repos, local: cur.local });
 }
 
 function clearKey(stateDir) {
   const cur = read(stateDir);
-  return write(stateDir, { key: null, repos: cur.repos });
+  return write(stateDir, { key: null, repos: cur.repos, local: cur.local });
 }
 
 /** Consent and exclusions for one repository root. Consent defaults to off. */
@@ -115,7 +148,7 @@ function setRepo(stateDir, root, { consent, exclude, watch, jev, categorize, rou
     ? exclude.map((x) => String(x).trim().replace(/^\/+/, '')).filter((x) => x && !x.includes('..') && x.length <= 200).slice(0, MAX_EXCLUDES)
     : prev.exclude;
   const repos = { ...cur.repos, [root]: { consent: typeof consent === 'boolean' ? consent : prev.consent, exclude: ex, watch: typeof watch === 'boolean' ? watch : prev.watch, jev: typeof jev === 'boolean' ? jev : prev.jev, categorize: typeof categorize === 'boolean' ? categorize : prev.categorize, route: typeof route === 'boolean' ? route : prev.route, status_read: typeof statusRead === 'boolean' ? statusRead : prev.status_read } };
-  return write(stateDir, { key: cur.key, repos });
+  return write(stateDir, { key: cur.key, repos, local: cur.local });
 }
 
 /** Does `rel` fall under an exclusion? An entry is a path prefix, or a `*` pattern matched on the path. */
@@ -130,4 +163,4 @@ function isExcluded(exclude, rel) {
   });
 }
 
-module.exports = { adoptEnv, status, getKey, setKey, clearKey, getRepo, setRepo, isExcluded, ENV_NAME, FILE };
+module.exports = { adoptEnv, status, getKey, setKey, clearKey, setLocal, getRepo, setRepo, isExcluded, ENV_NAME, FILE };

package/workspace/lib/typesafe.js

@@ -17,6 +17,17 @@
  *   Noul    "high means yes"; the single `noul` number is P(yes). There is no separate confidence.
  *   Score   levels 0..N-1; `score` is the probability-weighted mean; `confidence` is reported.
  *   Choice  one option plus a distribution.
+ *
+ * LOCAL FALLBACK (D95). When the PM has no TypeSafe key, or Jev cannot answer, the same questions may go to a
+ * System One server the PM runs on this machine: Winnow (winnow-inference, port 8091) or Laya (laya-serve, port
+ * 8000). Both speak Jev's `POST /v1/systemone`. The host is LOOPBACK, fixed in source like the TypeSafe host; only
+ * the port is a setting. A local request carries no key and no model name, and nothing leaves the machine.
+ *   - `configureLocal({ backend, port })` turns the fallback on for this process; `configureLocal(null)` turns it off.
+ *     lib/typesafe-settings.js calls it from what the PM saved.
+ *   - `LOCAL_KEY` is the handle the key store returns when only the local server is set. It is not a secret and
+ *     it is never sent to TypeSafe: `ask` routes it to loopback before the TypeSafe branch.
+ *   - With a real key, a TypeSafe failure (unreachable, 401, 429, 5xx) is asked again locally when the fallback is
+ *     on. The result says `fallback: true` and names the local backend.
  */
 const https = require('https');
 const http = require('http');
@@ -28,6 +39,14 @@ const MAX_STATE_CHARS = 60000;       // a conservative cap; the documentation st
 const MAX_RESPONSE_BYTES = 1 << 20;  // 1 MiB — an answer set is small; anything larger is not one
 const MAX_QUESTIONS = 16;
 
+const LOCAL_HOST = '127.0.0.1';      // loopback only — the local fallback never reaches another machine (D95)
+const LOCAL_KEY = 'local-systemone';  // the key store's handle for "no TypeSafe key, the local server answers"
+const BACKENDS = {
+  winnow: { name: 'Winnow', port: 8091, start: 'python3 scripts/serve.py   (in a winnow-inference checkout)' },
+  laya: { name: 'Laya', port: 8000, start: 'pip install "laya[serve]" && laya-serve' },
+};
+const LOCAL_ASK = { timeoutMs: 15000, retries: 1, backoffMs: 400 };  // a floor: a laptop model can be slower than the hosted one
+
 /* A seam for tests, gated like the sink's. It lets a suite point this module at a loopback stub; it
  * is unreachable in a production process, so no setting can redirect the key to another host. */
 let endpointForTests = null;
@@ -42,6 +61,19 @@ function endpoint() {
   return endpointForTests || { protocol: 'https:', hostname: HOST, port: 443 };
 }
 
+function validPort(p) { const n = Number(p); return Number.isInteger(n) && n >= 1024 && n <= 65535; }
+function validBackend(b) { return typeof b === 'string' && Object.prototype.hasOwnProperty.call(BACKENDS, b); }
+
+/* The local fallback for this process, or null. Set from the PM's saved choice; never from a request body. */
+let local = null;
+function configureLocal(cfg) {
+  if (!cfg || !validBackend(cfg.backend)) { local = null; return null; }
+  const port = cfg.port == null || cfg.port === '' ? BACKENDS[cfg.backend].port : Number(cfg.port);
+  local = validPort(port) ? { backend: cfg.backend, port } : null;
+  return local;
+}
+function localTarget() { return local ? { ...local, name: BACKENDS[local.backend].name } : null; }
+
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const retryable = (status) => status === 429 || status === 529 || (status >= 500 && status < 600);
 
@@ -49,8 +81,7 @@ function validKey(key) {
   return typeof key === 'string' && key.length >= 8 && key.length <= 512 && !/[\s\u0000-\u001f\u007f]/.test(key);
 }
 
-function once({ key, body, timeoutMs }) {
-  const ep = endpoint();
+function once({ key, body, timeoutMs, ep = endpoint() }) {
   const mod = ep.protocol === 'http:' ? http : https;
   const payload = Buffer.from(body, 'utf8');
   return new Promise((resolve) => {
@@ -60,7 +91,7 @@ function once({ key, body, timeoutMs }) {
       protocol: ep.protocol, hostname: ep.hostname, port: ep.port, path: PATH, method: 'POST',
       headers: {
         'Content-Type': 'application/json', 'Content-Length': payload.length,
-        Authorization: 'Bearer ' + key, 'User-Agent': 'pmos-workspace',
+        ...(key ? { Authorization: 'Bearer ' + key } : {}), 'User-Agent': 'pmos-workspace',
       },
       timeout: timeoutMs,
     }, (res) => {
@@ -104,16 +135,10 @@ function once({ key, body, timeoutMs }) {
  * @returns {Promise<{ok:true, model, answers, usage}|{ok:false, reason, status?, requested:boolean}>}
  *   `requested` says whether a request left this process, so a caller can tell a refusal from a failure.
  */
-async function ask({ key, state, questions, model = DEFAULT_MODEL, timeoutMs = 30000, retries = 2, backoffMs = 600 } = {}) {
-  if (!validKey(key)) return { ok: false, requested: false, reason: 'no TypeSafe key is set' };
-  if (typeof state !== 'string' || !state.trim()) return { ok: false, requested: false, reason: 'there is no text to judge' };
-  if (state.length > MAX_STATE_CHARS) return { ok: false, requested: false, reason: `the text is longer than ${MAX_STATE_CHARS} characters` };
-  const names = questions && typeof questions === 'object' ? Object.keys(questions) : [];
-  if (!names.length || names.length > MAX_QUESTIONS) return { ok: false, requested: false, reason: `between 1 and ${MAX_QUESTIONS} questions are required` };
-  const body = JSON.stringify({ state, model, questions });
+async function send({ key, body, ep, timeoutMs, retries, backoffMs }) {
   let last = null;
   for (let attempt = 0; attempt <= retries; attempt++) {
-    last = await once({ key, body, timeoutMs });
+    last = await once({ key, body, timeoutMs, ep });
     if (last.ok) return { ...last, requested: true };
     if (!(last.status === 0 || retryable(last.status)) || attempt === retries) break;
     await sleep(backoffMs * Math.pow(2, attempt));
@@ -121,4 +146,40 @@ async function ask({ key, state, questions, model = DEFAULT_MODEL, timeoutMs = 3
   return { ok: false, requested: true, status: last.status, reason: last.reason };
 }
 
-module.exports = { ask, validKey, HOST, PATH, DEFAULT_MODEL, MAX_STATE_CHARS, MAX_QUESTIONS, __setEndpointForTests };
+/* A local server may leave out an answer's `type`; the bridges read it, so it is filled from the question. */
+function withTypes(answers, questions) {
+  const out = {};
+  for (const [n, a] of Object.entries(answers || {})) {
+    out[n] = a && typeof a === 'object' && a.type == null && questions[n] ? { ...a, type: questions[n].type } : a;
+  }
+  return out;
+}
+
+/* Ask the PM's local System One server. No key and no model name go with it: each server answers with its own model. */
+async function askLocal({ state, questions, timeoutMs, retries, backoffMs }) {
+  const t = localTarget();
+  if (!t) return { ok: false, requested: false, reason: 'no local model is set' };
+  const r = await send({ key: null, body: JSON.stringify({ state, questions }), ep: { protocol: 'http:', hostname: LOCAL_HOST, port: t.port },
+    timeoutMs: Math.max(timeoutMs || 0, LOCAL_ASK.timeoutMs), retries: Math.min(retries == null ? LOCAL_ASK.retries : retries, LOCAL_ASK.retries), backoffMs: backoffMs || LOCAL_ASK.backoffMs });
+  if (!r.ok) return { ...r, local: t.backend, reason: `${t.name} on this machine: ` + r.reason.replace(/^the service/, 'the server') };
+  return { ...r, answers: withTypes(r.answers, questions), model: r.model || t.backend, local: t.backend };
+}
+
+/* When the hosted answer fails this way, the local server is asked instead (D95). A malformed request (422) is not. */
+const failsOver = (r) => r.requested && (r.status === 0 || r.status === 401 || retryable(r.status));
+
+async function ask({ key, state, questions, model = DEFAULT_MODEL, timeoutMs = 30000, retries = 2, backoffMs = 600 } = {}) {
+  if (!validKey(key)) return { ok: false, requested: false, reason: 'no TypeSafe key is set' };
+  if (typeof state !== 'string' || !state.trim()) return { ok: false, requested: false, reason: 'there is no text to judge' };
+  if (state.length > MAX_STATE_CHARS) return { ok: false, requested: false, reason: `the text is longer than ${MAX_STATE_CHARS} characters` };
+  const names = questions && typeof questions === 'object' ? Object.keys(questions) : [];
+  if (!names.length || names.length > MAX_QUESTIONS) return { ok: false, requested: false, reason: `between 1 and ${MAX_QUESTIONS} questions are required` };
+  // The local handle never reaches TypeSafe: it is routed to loopback here, before the hosted branch.
+  if (key === LOCAL_KEY) return askLocal({ state, questions, timeoutMs, retries, backoffMs });
+  const r = await send({ key, body: JSON.stringify({ state, model, questions }), ep: endpoint(), timeoutMs, retries, backoffMs });
+  if (r.ok || !local || !failsOver(r)) return r;
+  const l = await askLocal({ state, questions, timeoutMs, retries, backoffMs });
+  return l.ok ? { ...l, fallback: true, hosted_reason: r.reason } : { ...r, reason: r.reason + '; ' + l.reason };
+}
+
+module.exports = { ask, validKey, configureLocal, localTarget, validPort, validBackend, HOST, PATH, DEFAULT_MODEL, MAX_STATE_CHARS, MAX_QUESTIONS, LOCAL_HOST, LOCAL_KEY, BACKENDS, __setEndpointForTests };

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.163.0",
+  "version": "0.165.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.163.0",
+      "version": "0.165.0",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/workspace/package.json

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

package/workspace/public/pm/c3-calendar.js

@@ -568,6 +568,11 @@ function detail(ui) {
     el('p', { class: 'dim cal3-note' }, 'Select a meeting to see what came out of it or what to prepare. Select a dated marker to see its date and open its home.')]);
 }
 
+/** The Meeting focus page (initiative c3-meeting-focus): one calm full-screen page for a meeting that is today. It loads when pressed. */
+const focusBtn = (e, date) => button({ label: [c3ic('target', 'sm'), 'Focus'], variant: 'primary', size: 'sm',
+  attrs: { 'data-cal3': 'focus', title: 'Open the meeting focus page: the clock, the topics, the material and PMOS beside the conversation' },
+  onClick: () => { import('./c3-focus.js').then((m) => m.openFocus({ event: e, date })).catch(() => toast({ text: 'The focus page could not load.', tone: 'error' })); } });
+
 function meetingDetail(ui, hit) {
   const { M, h } = ui; const e = hit.e;
   const s = h.timeOf(e.at); const f = s === null ? null : h.endH(e);
@@ -595,7 +600,8 @@ function meetingDetail(ui, hit) {
   const iniStatus = b && b.initiative && b.initiative.id === iniId ? b.initiative.status : (((ui.d.gantt || []).find((g) => g.id === iniId) || {}).status || null);
   const sources = b && b.sources && b.sources.length ? 'Put together from ' + listWords(b.sources) + '. Each line opens its source. ' : '';
   return [
-    el('div', { class: 'cal3-dt' }, el('h3', null, c3ic('cal'), 'Meeting'), el('span', { class: 'tag' + (past ? '' : ' cal3-up') }, past ? 'past' : 'upcoming'), closeBtn(ui)),
+    el('div', { class: 'cal3-dt' }, el('h3', null, c3ic('cal'), 'Meeting'), el('span', { class: 'tag' + (past ? '' : ' cal3-up') }, past ? 'past' : 'upcoming'),
+      !past && s !== null && hit.date === ui.d.today ? focusBtn(e, hit.date) : null, closeBtn(ui)),
     el('b', { class: 'cal3-title' }, e.title || e.id),
     el('div', { class: 'dim mono cal3-when' }, h.dayLabel(hit.date) + (s === null ? ', all day' : ' · ' + h.hhmm(s) + ' to ' + h.hhmm(f))),
     el('div', { class: 'chips2', 'data-cal3': 'meeting-chips' }, homeChip('Calendar'), ...peopleOf(e).map((n) => el('span', { class: 'tag', 'data-cal3': 'person' }, n)),