create-pmos 0.48.0 → 0.49.0

package/workspace/lib/jev-categorize.js

@@ -17,6 +17,10 @@
  * WHAT A RESULT IS. Advisory (D40), basis `jev`, shown in words. The ticket options are summed into one `ticket` first;
  * a top category under 0.6, or within 0.1 of the next, is `undetermined` with the two leading options named (C6).
  *
+ * WHAT THE PAGE SEES. Each pass records the outcome of every undetermined file it looked at: categorized, unsure,
+ * unreadable, failed (with the service's reason), withheld, excluded, or not asked because the pass paused. The record holds
+ * paths and outcomes, never a snippet or the key, and keeps at most MAX_FILES files.
+ *
  * WHAT IT NEVER DOES. It writes nothing into the repository. Its state (confirmation, pause, cache) lives in the per-user
  * cache directory the caller passes. Two rejected keys or three failed asks in a row pause the repository until resumed.
  */
@@ -38,6 +42,7 @@ const UNREACHABLE_LIMIT = 3;
 const UNSURE_BELOW = 0.6;
 const UNSURE_GAP = 0.1;
 const UNREADABLE_LIMIT = 3;
+const MAX_FILES = 500;
 const sha = (s) => crypto.createHash('sha1').update(s).digest('hex');
 
 /* The Choice options. A ticket is three options, so one question decides the category and the ticket kind. */
@@ -183,7 +188,7 @@ async function locked(cacheDir, busy, fn) {
   try { return await fn(); } finally { dropLock(cacheDir); }
 }
 
-const emptyState = () => ({ confirmed: false, confirmed_at: null, paused: null, rejected: 0, unreachable: 0, unreadable: 0, last: null });
+const emptyState = () => ({ confirmed: false, confirmed_at: null, paused: null, rejected: 0, unreachable: 0, unreadable: 0, last: null, results: null });
 function readState(cacheDir) {
   const s = readJson(stateFile(cacheDir), null);
   return s && typeof s === 'object' ? { ...emptyState(), ...s } : emptyState();
@@ -199,7 +204,7 @@ function writeCache(cacheDir, c) {
 /** What the page may know about the bridge for one repository. */
 function status(cacheDir) {
   const s = readState(cacheDir);
-  return { confirmed: s.confirmed, confirmed_at: s.confirmed_at, paused: s.paused, last: s.last };
+  return { confirmed: s.confirmed, confirmed_at: s.confirmed_at, paused: s.paused, last: s.last, results: s.results || null };
 }
 /** The PM's press: lift a pause and forget the failure counts. */
 function resume(cacheDir) {
@@ -218,14 +223,14 @@ function lookup(cache, doc) {
 
 /** Triage the candidates: excluded, withheld by the secret scan, answered from the cache, or to ask. Pure; sends nothing. */
 function triage(cands, { exclude = [], cache }) {
-  const out = { ask: [], cached: 0, withheld: [], excluded: 0 };
+  const out = { ask: [], cached: 0, withheld: [], excluded: 0, cachedItems: [], excludedRels: [] };
   for (const d of cands) {
-    if (settings.isExcluded(exclude, d.rel)) { out.excluded++; continue; }
+    if (settings.isExcluded(exclude, d.rel)) { out.excluded++; out.excludedRels.push(d.rel); continue; }
     const snip = snippetFor(d);
     const rules = scanner.scan(snip);
     if (rules.length) { out.withheld.push({ doc: d.rel, rules }); continue; }
     const ck = keyFor(snip);
-    if (cache[ck]) out.cached++; else out.ask.push({ rel: d.rel, snip, ck });
+    if (cache[ck]) { out.cached++; out.cachedItems.push({ rel: d.rel, ck }); } else out.ask.push({ rel: d.rel, snip, ck });
   }
   return out;
 }
@@ -233,15 +238,15 @@ function triage(cands, { exclude = [], cache }) {
 /* ── asking ────────────────────────────────────────────────────────────────────────────────────── */
 async function askAll({ items, key, ask, askOpts, state, cache, now }) {
   let failed = 0, unreadable = 0, sent = 0, decided = 0, unsure = 0, lastError = null;
-  const asked = new Set();
+  const outcomes = new Map();                                            // ck → what happened to that snippet
   for (const it of items) {
     if (state.paused) break;
-    if (asked.has(it.ck)) continue;                                      // two files with one snippet: one request
-    asked.add(it.ck);
+    if (outcomes.has(it.ck)) continue;                                   // two files with one snippet: one request
     const req = requestFor(it.snip);
     const res = await ask({ key, state: req.state, questions: req.questions, ...askOpts });
     if (!res.ok) {
       failed++; lastError = res.reason;
+      outcomes.set(it.ck, { outcome: 'failed', reason: String(res.reason || 'the request failed') });
       if (res.status === 401) { state.rejected++; state.unreachable = 0; } else { state.unreachable++; state.rejected = 0; }
       if (state.rejected >= REJECTED_LIMIT) state.paused = { reason: 'The service rejected the key twice, so categorizing with Jev is paused.', at: new Date(now).toISOString() };
       else if (state.unreachable >= UNREACHABLE_LIMIT) state.paused = { reason: 'The service could not be reached three times in a row, so categorizing with Jev is paused.', at: new Date(now).toISOString() };
@@ -253,16 +258,43 @@ async function askAll({ items, key, ask, askOpts, state, cache, now }) {
       // Cached as a marker, so no later pass sends the same snippet again; three in a row pause the repository, because
       // that is what a changed answer format looks like.
       unreadable++; state.unreadable = (state.unreadable || 0) + 1;
+      outcomes.set(it.ck, { outcome: 'unreadable' });
       cache[it.ck] = { probs: null, unreadable: true, model: res.model || null, at: new Date(now).toISOString() };
       if (state.unreadable >= UNREADABLE_LIMIT) state.paused = { reason: 'Jev\'s answers could not be read three times in a row, so categorizing with Jev is paused.', at: new Date(now).toISOString() };
       continue;
     }
     state.unreadable = 0;
     cache[it.ck] = { probs, model: res.model || null, at: new Date(now).toISOString() };
-    if (decide(probs).decided) decided++; else unsure++;
+    const d = decide(probs);
+    if (d.decided) decided++; else unsure++;
+    outcomes.set(it.ck, outcomeOf(d));
+  }
+  return { failed, unreadable, sent, decided, unsure, lastError, outcomes };
+}
+
+/* ── what happened to each file ────────────────────────────────────────────────────────────────── */
+function outcomeOf(d) {
+  if (!d) return { outcome: 'unreadable' };
+  if (!d.decided) return { outcome: 'unsure', leading: d.leading.map((x) => x.category), sentence: sentenceFor(d) };
+  return { outcome: 'categorized', category: d.category, ticket_kind: d.ticket_kind, sentence: sentenceFor(d) };
+}
+/** One entry per undetermined file the pass looked at, in path order. Paths and outcomes only, never a snippet. Pure. */
+function fileResults(t, outcomes, cache, paused) {
+  const files = [];
+  for (const it of t.ask) {
+    const o = outcomes.get(it.ck);
+    files.push({ doc: it.rel, ...(o || { outcome: 'not-asked', reason: paused ? paused.reason : 'the pass stopped before this file' }) });
+  }
+  for (const it of t.cachedItems) {
+    const hit = cache[it.ck];
+    files.push({ doc: it.rel, ...(hit && hit.probs ? outcomeOf(decide(hit.probs)) : { outcome: 'unreadable' }), cached: true });
   }
-  return { failed, unreadable, sent, decided, unsure, lastError };
+  for (const w of t.withheld) files.push({ doc: w.doc, outcome: 'withheld', rules: w.rules });
+  for (const rel of t.excludedRels) files.push({ doc: rel, outcome: 'excluded' });
+  files.sort((a, b) => a.doc.localeCompare(b.doc));
+  return { total: files.length, files: files.slice(0, MAX_FILES) };
 }
+const recordFiles = (state, t, r, cache, now, kind) => { state.results = { at: new Date(now).toISOString(), kind, ...fileResults(t, r.outcomes, cache, state.paused) }; };
 
 const summarize = (extra) => ({ at: new Date().toISOString(), sent: 0, cached: 0, withheld: [], excluded: 0, failed: 0, decided: 0, unsure: 0, ...extra });
 const gatesFor = (key, flags) => gates({ key: typesafe.validKey(key), consent: !!(flags && flags.consent), categorize: !!(flags && flags.categorize) });
@@ -302,9 +334,10 @@ async function confirmedPass({ docs, named, cacheDir, key, exclude = [], expectR
   }
   const r = await askAll({ items: t.ask, key, ask, askOpts, state, cache, now });
   state.confirmed = true; state.confirmed_at = state.confirmed_at || new Date(now).toISOString();
+  recordFiles(state, t, r, cache, now, 'confirmed');
   state.last = summarize({ confirmed: true, sent: r.sent, cached: t.cached, withheld: t.withheld.slice(0, MAX_LISTED), withheld_count: t.withheld.length, excluded: t.excluded, failed: r.failed, unreadable: r.unreadable, decided: r.decided, unsure: r.unsure, error: r.lastError, paused: state.paused });
   writeCache(cacheDir, cache); writeState(cacheDir, state);
-  return { ok: true, sent: r.sent, cached: t.cached, withheld: t.withheld.length, excluded: t.excluded, failed: r.failed, unreadable: r.unreadable, decided: r.decided, unsure: r.unsure, paused: state.paused };
+  return { ok: true, sent: r.sent, cached: t.cached, withheld: t.withheld.length, excluded: t.excluded, failed: r.failed, unreadable: r.unreadable, decided: r.decided, unsure: r.unsure, paused: state.paused, results: state.results };
 }
 
 /**
@@ -330,6 +363,7 @@ async function autoPass({ docs, named, cacheDir, key, exclude = [], ask = typesa
     return { ok: true, skipped: 'needs-confirmation', requests: unique, sent: 0 };
   }
   const r = await askAll({ items: t.ask, key, ask, askOpts, state, cache, now });
+  recordFiles(state, t, r, cache, now, 'automatic');
   state.last = summarize({ sent: r.sent, cached: t.cached, withheld: t.withheld.slice(0, MAX_LISTED), withheld_count: t.withheld.length, excluded: t.excluded, failed: r.failed, unreadable: r.unreadable, decided: r.decided, unsure: r.unsure, error: r.lastError, paused: state.paused });
   writeCache(cacheDir, cache); writeState(cacheDir, state);
   return { ok: true, sent: r.sent, cached: t.cached, failed: r.failed, decided: r.decided, unsure: r.unsure, paused: state.paused };
@@ -394,6 +428,6 @@ async function measuredPass({ rows, cacheDir, key, exclude = [], expectRequests,
 
 module.exports = {
   plan, runConfirmed, runAuto, measurePlan, measure, status, resume, lookup, readCache, gates, gateSentence, candidates, snippetFor, requestFor,
-  readAnswer, decide, sentenceFor, wordsFor, keyFor, triage,
-  OPTIONS, SNIPPET_MAX, AUTO_LIMIT, REJECTED_LIMIT, UNREACHABLE_LIMIT, UNREADABLE_LIMIT, UNSURE_BELOW, UNSURE_GAP,
+  readAnswer, decide, sentenceFor, wordsFor, keyFor, triage, fileResults,
+  OPTIONS, MAX_FILES, SNIPPET_MAX, AUTO_LIMIT, REJECTED_LIMIT, UNREACHABLE_LIMIT, UNREADABLE_LIMIT, UNSURE_BELOW, UNSURE_GAP,
 };

package/workspace/lib/jev-live.js

@@ -0,0 +1,37 @@
+'use strict';
+/* jev-live.js — the one bridge from the Live notes view to Jev (D85, jev-live-notes Run 7).
+ *
+ * It hands lib/live-notes.js a sender that calls lib/typesafe.js, and only when all three gates hold: a saved key, D79 consent
+ * for the repository, and the per-repository switch "live notes may use Jev" (default off, kept in the runtime directory).
+ * The engine decides what goes out (one cleaned point and the shortlist) and never sends a withheld point or a point from a
+ * private session; this module adds no text of its own. With any gate shut it hands back no sender, and the local word
+ * match answers.
+ */
+const typesafe = require('./typesafe');
+const live = require('./live-notes');
+
+/** The gates, from what the server knows. `key` is the saved key or null; it is never logged or returned. */
+function gatesFor(key, flags) {
+  return live.gates({ key: typesafe.validKey(key), consent: !!(flags && flags.consent), live: !!(flags && flags.live) });
+}
+
+/* A meeting does not wait: a point Jev cannot answer quickly gets the local guess instead (one retry, ten seconds). */
+const LIVE_ASK = { timeoutMs: 10000, retries: 1, backoffMs: 400 };
+
+/** { ask, gates, askOpts }: `ask` is a sender for the engine, or null when a gate is shut. */
+function senderFor(key, flags, askOpts = {}) {
+  const g = gatesFor(key, flags);
+  if (!g.open) return { ask: null, gates: g, askOpts: {} };
+  return { ask: (a) => typesafe.ask(a), gates: g, askOpts: { ...LIVE_ASK, ...askOpts } };
+}
+
+const SENT = 'Jev checks each point. Only the cleaned sentence and the titles, intents and open questions of the shortlisted initiatives are sent to TypeSafe. Speaker names, withheld points and private meetings are never sent.';
+const LOCAL = 'Proposals here are a local word match. Nothing leaves this machine.';
+
+/** What the view needs to explain the switch. `present` is whether a key is saved (a boolean, never the key). */
+function infoFor(present, flags) {
+  const g = live.gates({ key: !!present, consent: !!(flags && flags.consent), live: !!(flags && flags.live) });
+  return { switch: !!(flags && flags.live), open: g.open, missing: g.missing, sentence: g.open ? null : live.gateSentence(g.missing), note: g.open ? SENT : LOCAL };
+}
+
+module.exports = { gatesFor, senderFor, infoFor };

package/workspace/lib/jev-route.js

@@ -126,4 +126,14 @@ function modelFromPolicy(root) {
   return loaded.ok && loaded.policy.router && typeof loaded.policy.router.jev_model === 'string' ? loaded.policy.router.jev_model : null;
 }
 
-module.exports = { gates, gateSentence, classify, routePrompt, modelFromPolicy, QUESTIONS };
+/* A prompt routed from a terminal waits for its answer before it runs, so Jev gets one short try:
+ * no retries, and a few seconds. A miss falls back to the keyword route, which never moves the model. */
+const INTERACTIVE = Object.freeze({ timeoutMs: 2500, retries: 0 });
+
+/** The loopback address the workspace puts in each terminal's environment (PMOS_ROUTE_URL). */
+function routeUrl(port) {
+  const n = Number(port);
+  return Number.isInteger(n) && n > 0 && n < 65536 ? `http://127.0.0.1:${n}/api/model/route` : null;
+}
+
+module.exports = { gates, gateSentence, classify, routePrompt, modelFromPolicy, routeUrl, INTERACTIVE, QUESTIONS };

package/workspace/lib/live-notes.js

@@ -12,6 +12,8 @@
  *     Jev" switch — and no sender is injected, the same prompt asks the PM's own agent session to make the two choices
  *     with the Typesafe skill (the route `judgment.js` already uses) and to mark each answer `"by":"jev"`. The
  *     workspace sends nothing itself; no new server egress, so D79 is not amended.
+ *   local (Run 6): the cockpit's live-notes view. A word match made here, banded no higher than "possible" and flagged
+ *     `local-guess`, so the PM has something to confirm the moment a point arrives. No model, no Jev, no request.
  *   jev: the same three gates, through the `ask` function a caller injects. This file requires no network module,
  *     and no command injects one: a server-side send of live talk needs a decision that amends D79.
  *
@@ -194,6 +196,27 @@ function attachQuestions(root, items, exclude) {
 const terms = (s) => new Set(String(s).toLowerCase().match(/[a-z][a-z0-9-]{3,}/g)?.filter((w) => !STOP.has(w)) || []);
 const overlap = (a, b) => { let n = 0; for (const t of a) if (b.has(t)) n++; return n; };
 
+/* ── Run 6: a local word match, for the view. No model and no Jev, so it is never claimed above "possible". ─────── */
+const LOCAL_MIN = 2;     // shared words before a local guess names an initiative or an open question
+function localProposal(text, items) {
+  const t = terms(text);
+  let best = null; let second = 0;
+  for (const i of items) {
+    const n = overlap(t, terms([i.title, i.intent, ...(i.questions || [])].join(' ')));
+    if (!best || n > best.n) { second = best ? best.n : 0; best = { i, n }; } else if (n > second) second = n;
+  }
+  const flags = ['local-guess'];
+  const none = { initiative: 'none', initiative_band: 'unlikely', relation: 'none', relation_band: 'unlikely', in_scope: null, scope_band: null,
+    confidence: 'unconfirmed', answers_question: null, flags, judged_by: 'local', shared_words: best ? best.n : 0 };
+  if (!best || best.n < LOCAL_MIN) return none;
+  if (best.n === second) flags.push('local-tie');
+  const q = pickQuestions([best.i], text)[0];
+  const answers = q && q.score >= LOCAL_MIN ? { initiative: best.i.id, n: q.n, text: q.text.slice(0, 200), band: 'possible' } : null;
+  // the relation is left for the PM unless an open question is named: a word match cannot tell "validates" from "contradicts"
+  return { ...none, initiative: best.i.id, initiative_band: 'possible', relation: answers ? 'answers' : null, relation_band: answers ? 'possible' : null,
+    answers_question: answers };
+}
+
 /** Deterministic shuffle: Jev leans toward the first option, so the order changes with the pass. */
 function shuffled(arr, seed) {
   return arr.map((x, i) => [sha(seed + '|' + i + '|' + (x.id || x)), x]).sort((a, b) => (a[0] < b[0] ? -1 : 1)).map((p) => p[1]);
@@ -222,7 +245,7 @@ function requestFor(segment, items, pass = 0) {
     confirmed: { type: 'noul', instructions: 'The speaker states this as decided or agreed, not as an idea, a question or an opinion.' },
   };
   asked.forEach((q, k) => { questions['answers_' + (k + 1)] = { type: 'noul', instructions: `The talking point answers this open question: "${q.text}"` }; });
-  const state = 'TALKING POINT:\n' + (segment.speaker ? segment.speaker + ': ' : '') + segment.text;
+  const state = 'TALKING POINT:\n' + segment.text;   // D85: a speaker's name is never sent
   return { state, questions, asked };
 }
 
@@ -470,7 +493,7 @@ function readLedger(file) {
  * @param {object} [a.askOpts]
  * @param {Map|null} [a.agentAnswers]
  */
-function openSession({ root, runtimeDir, session = null, key = null, flags = {}, exclude = [], anchor = null, ask = null, askOpts = {}, agentAnswers = null, now = Date.now() }) {
+function openSession({ root, runtimeDir, session = null, key = null, flags = {}, exclude = [], anchor = null, ask = null, askOpts = {}, agentAnswers = null, local = false, now = Date.now() }) {
   if (session && !SAFE_ID.test(session)) throw new Error('a session id is letters, digits, dots, dashes and underscores');
   const id = session || newSessionId(now);
   const P = sessionPaths({ root, runtimeDir, session: id });
@@ -481,8 +504,11 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
   const state = st0 || { started: nowISO(now), rejected: 0, unreachable: 0, paused: null, n: 0, candidates: {}, closed: false };
   if (readLedger(P.ledger).some((r) => r.row === 'close')) state.closed = true;
   const g = gates({ key: !!key, consent: !!flags.consent, live: !!flags.live });
-  const jevPath = g.open && typeof ask === 'function';
-  const route = jevPath ? 'jev' : g.open ? 'jev-agent' : 'agent-only';
+  const isPrivate = readLedger(P.ledger).some((r) => r.row === 'private');
+  const jevPath = g.open && typeof ask === 'function' && !isPrivate;   // D85: nothing from a private session is ever sent
+  const route = jevPath ? 'jev' : local ? 'local' : g.open ? 'jev-agent' : 'agent-only';
+  // a resumed session keeps the anchor it started with, so its shortlist (and what a decision may name) does not change
+  if (anchor == null) { const first = readLedger(P.ledger).find((r) => r.row === 'session'); if (first && first.anchor) anchor = first.anchor; }
   const loaded = loadInitiatives(root);
   const sl = shortlist(loaded.open, { anchor });
   const items = sl.ok ? attachQuestions(root, sl.list, exclude) : [];
@@ -501,8 +527,9 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
   }
   const failure = (res, at) => {
     if (res.status === 401) { state.rejected++; state.unreachable = 0; } else { state.unreachable++; state.rejected = 0; }
-    if (state.rejected >= REJECTED_LIMIT) state.paused = { reason: 'The service rejected the key twice, so Jev is paused for this session. The agent-only path continues.', at: nowISO(at) };
-    else if (state.unreachable >= UNREACHABLE_LIMIT) state.paused = { reason: 'The service could not be reached three times in a row, so Jev is paused for this session. The agent-only path continues.', at: nowISO(at) };
+    const goesOn = local ? 'The local word match continues.' : 'The agent-only path continues.';
+    if (state.rejected >= REJECTED_LIMIT) state.paused = { reason: 'The service rejected the key twice, so Jev is paused for this session. ' + goesOn, at: nowISO(at) };
+    else if (state.unreachable >= UNREACHABLE_LIMIT) state.paused = { reason: 'The service could not be reached three times in a row, so Jev is paused for this session. ' + goesOn, at: nowISO(at) };
     if (state.paused) append({ row: 'pause', at, reason: state.paused.reason });
   };
 
@@ -534,7 +561,7 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
       fs.appendFileSync(P.transcript, usable.map((s) => JSON.stringify(s)).join('\n') + '\n');
     }
     const useJev = jevPath && !state.paused;
-    result.path = useJev ? 'jev' : route === 'jev-agent' ? 'jev-agent' : 'agent-only';
+    result.path = useJev ? 'jev' : local ? 'local' : route === 'jev-agent' ? route : 'agent-only';
     const pendingSegs = [];
     for (const s of usable) {
       const pointer = { kind: 'live', source: s.source, id: s.id, at: s.at, speaker: s.speaker };
@@ -542,7 +569,16 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
       if (useJev && !state.paused) {
         by = 'jev';
         let { req, res } = await ask1(s, 0);
-        if (!res.ok) { result.failed++; failure(res, Date.now()); pendingSegs.push(s); continue; }
+        if (!res.ok) {
+          result.failed++; failure(res, Date.now());
+          if (!local) { pendingSegs.push(s); continue; }
+          // the view never leaves a point blank: the local word match answers, and the card says Jev was not reached
+          prop = localProposal(s.text, items); prop.flags.push('jev-not-reached'); by = 'local';
+        }
+        if (prop) {
+          const row = { row: 'segment', at: s.at, segment: s.id, hash: sha(s.text), pointer, quote: quoteOf(s.text), path: 'local', model: null, ...prop, status: 'proposed' };
+          append(row); result.rows.push(row); continue;
+        }
         state.rejected = 0; state.unreachable = 0;
         let m = mapJev(res.answers, req, ids);
         model = res.model || null;
@@ -556,14 +592,20 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
             model = again.res.model || model;
           } else { result.failed++; failure(again.res, Date.now()); }
         }
+        if (!m && local) {
+          prop = localProposal(s.text, items); prop.flags.push('jev-unreadable');
+          const row = { row: 'segment', at: s.at, segment: s.id, hash: sha(s.text), pointer, quote: quoteOf(s.text), path: 'local', model, ...prop, status: 'proposed' };
+          append(row); result.rows.push(row); continue;
+        }
         if (!m) { append({ row: 'unreadable', at: s.at, segment: s.id, pointer }); result.rows.push({ segment: s.id, status: 'unreadable' }); continue; }
         prop = proposalFrom(m, { flags: [], inconsistent });
       } else {
         const a = (opts.agentAnswers || agentAnswers || new Map()).get(s.id);
-        if (!a) { pendingSegs.push(s); continue; }
-        prop = proposalFromAgent(a);
+        if (a) prop = proposalFromAgent(a);
+        else if (local) { prop = localProposal(s.text, items); by = 'local'; }
+        else { pendingSegs.push(s); continue; }
       }
-      const row = { row: 'segment', at: s.at, segment: s.id, hash: sha(s.text), pointer, quote: quoteOf(s.text), path: by === 'jev' ? 'jev' : 'agent-only', model, ...prop, status: 'proposed' };
+      const row = { row: 'segment', at: s.at, segment: s.id, hash: sha(s.text), pointer, quote: quoteOf(s.text), path: by === 'jev' ? 'jev' : by === 'local' ? 'local' : 'agent-only', model, ...prop, status: 'proposed' };
       append(row);
       result.rows.push(row);
     }
@@ -676,7 +718,7 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
   }
 
   /** The PM's accept, change or reject. Appended; never overwrites a proposal. */
-  function decide({ segment, action, initiative = null, relation = null, by = 'pm' }) {
+  function decide({ segment, action, initiative = null, relation = null, question = null, by = 'pm' }) {
     if (!['accept', 'change', 'reject'].includes(action)) throw new Error('action is accept, change or reject');
     const prop = readLedger(P.ledger).filter((r) => r.row === 'segment' && r.segment === segment).pop();
     if (!prop) throw new Error('no such segment in this session: ' + segment);
@@ -684,10 +726,25 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
     if (action === 'change') {
       if (initiative && initiative !== 'none' && !ids.includes(initiative)) throw new Error('that initiative is not in the shortlist');
       if (relation && !RELATIONS.includes(relation)) throw new Error('relation is one of: ' + RELATIONS.join(', '));
-      if (!initiative && !relation) throw new Error('a change names an initiative, a relation, or both');
+      if (!initiative && !relation && question == null) throw new Error('a change names an initiative, a relation, or both');
     }
-    const row = { row: 'decision', segment, action, by, proposed_by: prop.path === 'jev' || prop.path === 'jev-agent' ? 'jev' : 'agent', was: { initiative: prop.initiative, relation: prop.relation },
-      now: action === 'change' ? { initiative: initiative || prop.initiative, relation: relation || prop.relation } : null, overridden: action !== 'accept' };
+    const finalIni = action === 'change' ? (initiative || prop.initiative) : prop.initiative;
+    const finalRel = action === 'change' ? (finalIni === 'none' ? 'none' : (relation || prop.relation)) : prop.relation;
+    if (action === 'accept' && finalIni && finalIni !== 'none' && !finalRel) throw new Error('pick how the point relates to the initiative before confirming it');
+    if (action === 'change' && finalIni !== 'none' && !finalRel) throw new Error('pick how the point relates to the initiative');
+    // "answers" holds only with a named open question of the chosen initiative (N4)
+    let answered = null;
+    if (action !== 'reject' && finalRel === 'answers') {
+      const item = items.find((i) => i.id === finalIni);
+      const qs = (item && item.questions) || [];
+      const n = question != null ? Number(question) : (prop.answers_question && prop.answers_question.initiative === finalIni ? prop.answers_question.n : null);
+      if (!Number.isInteger(n) || n < 1 || n > qs.length) throw new Error(qs.length ? 'name which open question of ' + finalIni + ' it answers' : finalIni + ' has no open questions, so the point cannot answer one');
+      answered = { n, text: qs[n - 1].slice(0, 200) };
+    }
+    const changed = action === 'change' && (finalIni !== prop.initiative || finalRel !== prop.relation || (answered && (!prop.answers_question || prop.answers_question.n !== answered.n)));
+    const proposedBy = prop.path === 'jev' || prop.path === 'jev-agent' ? 'jev' : prop.path === 'local' ? 'local' : 'agent';
+    const row = { row: 'decision', segment, action: action === 'change' && !changed ? 'accept' : action, by, proposed_by: proposedBy, was: { initiative: prop.initiative, relation: prop.relation },
+      now: changed ? { initiative: finalIni, relation: finalRel, ...(answered ? { answers_question: answered } : {}) } : null, overridden: action === 'reject' || changed };
     append(row);
     return row;
   }
@@ -713,7 +770,7 @@ function openSession({ root, runtimeDir, session = null, key = null, flags = {},
     return { note: note.rel, transcript: 'kept until ' + nowISO(at + retentionDays * 86400000) };
   }
 
-  return { id, paths: P, items, shortlistError: sl.ok ? null : sl.error, path: route, gates: g, add, answer, plan, addContext, addDrafts, decide, close, ledger: () => readLedger(P.ledger), state: () => ({ ...state }) };
+  return { id, paths: P, items, shortlistError: sl.ok ? null : sl.error, anchor, path: route, private: isPrivate, gates: g, add, answer, plan, addContext, addDrafts, decide, close, ledger: () => readLedger(P.ledger), state: () => ({ ...state }) };
 }
 
 /** Delete transcripts whose retention has passed. */
@@ -757,21 +814,27 @@ function writeNote({ root, session, at, items, decisions, ctx = new Map(), draft
   const word = { contradicts: 'contradicts', answers: 'answers an open question of', validates: 'validates', clarifies: 'clarifies', extends: 'extends' };
   const line = (r) => {
     const dec = decisions.get(r.segment);
-    const where = r.initiative && r.initiative !== 'none' ? `${word[r.relation] || r.relation} \`${r.initiative}\` (${r.relation_band})` : 'matches no initiative';
+    const where = r.initiative && r.initiative !== 'none' ? `${r.relation ? word[r.relation] || r.relation : 'is about'} \`${r.initiative}\` (${r.relation_band || r.initiative_band})` : 'matches no initiative';
     const tail = dec ? ` — PM: ${dec.action}${dec.now ? ' → ' + [dec.now.initiative, dec.now.relation].filter(Boolean).join(' / ') : ''}` : '';
     const c = ctx.get(r.segment);
     const more = c ? `\n  - context (${c.tier}; ${c.settled ? 'the initiative\'s text settles it' : 'the initiative\'s text does not settle it'}): ${c.note} [${c.cites.map((x) => x.path).join(', ')}]` : '';
     return `- "${r.quote}" — ${where}; ${r.confidence}${r.in_scope === false ? '; outside scope' : ''}; pointer: live · ${r.pointer.source} · ${r.pointer.id} · ${r.at}${tail}${more}`;
   };
-  const answered = items.filter((r) => r.status === 'proposed');
+  // the PM's decision wins: a changed point is filed as changed, a rejected one is counted and left out
+  const rejected = items.filter((r) => r.status === 'proposed' && decisions.get(r.segment) && decisions.get(r.segment).action === 'reject').length;
+  const answered = items.filter((r) => r.status === 'proposed').map((r) => {
+    const d = decisions.get(r.segment);
+    if (d && d.action === 'reject') return null;
+    return d && d.now ? { ...r, initiative: d.now.initiative, relation: d.now.relation, answers_question: d.now.answers_question || r.answers_question, relation_band: 'confirmed by the PM' } : r;
+  }).filter(Boolean);
   const body = [];
   body.push(`## Live notes ${hm} (session ${session})`, '');
   body.push(`Proposals only: nothing here is a decision. Path: ${pathName}.${paused ? ' ' + paused.reason : ''}`, '');
-  body.push('### New or changed requirements', ...(answered.filter((r) => ['extends', 'clarifies', 'none'].includes(r.relation)).map(line) || []), '');
+  body.push('### New or changed requirements', ...(answered.filter((r) => ['extends', 'clarifies', 'none', null, undefined].includes(r.relation)).map(line) || []), '');
   body.push('### Validations and contradictions', ...answered.filter((r) => ['validates', 'contradicts'].includes(r.relation)).sort((a, b) => (a.relation === 'contradicts' ? -1 : 1) - (b.relation === 'contradicts' ? -1 : 1)).map(line), '');
   body.push('### Open questions', ...answered.filter((r) => r.relation === 'answers').map((r) => line(r) + (r.answers_question ? `; answers: ${r.answers_question.text}` : '')),
     ...candidates.map((c) => { const d = drafts.get(c.candidate); return `- Possible new initiative (${c.segments.length} points about: ${c.topic_terms.join(', ')}); prior-rejection check found ${c.prior_rejection_check.found}.${d ? ` Draft: "${d.title}" (${d.lane} lane; prior-rejection check on the title found ${d.prior_rejection_check.found}). A proposal; the PM presses through pmos-router to create it.` : ''}`; }), '');
-  body.push('### Sources reached and not reached', `- live conversation: ${items.length} point(s) proposed, ${items.filter((r) => r.status === 'pending').length} still unanswered, ${withheld} withheld (secret-shaped or private-marked, not read further).`, '');
+  body.push('### Sources reached and not reached', `- live conversation: ${items.length} point(s) proposed, ${items.filter((r) => r.status === 'pending').length} still unanswered, ${rejected} rejected by the PM, ${withheld} withheld (secret-shaped or private-marked, not read further).`, '');
   fs.mkdirSync(dir, { recursive: true });
   let exists = false;
   try { const ls = fs.lstatSync(file); if (ls.isSymbolicLink() || ls.nlink > 1) throw new Error('the requirements note is a link, so nothing was written'); exists = true; } catch (e) { if (e.code !== 'ENOENT') throw e; }
@@ -828,6 +891,7 @@ function rank(rows) {
     paused: paused ? { reason: paused.reason, at: paused.at } : null,
     path: (rows.find((r) => r.row === 'session') || {}).path || null,
     closed: rows.some((r) => r.row === 'close'),
+    private: rows.some((r) => r.row === 'private'),
     counts: { points: segs.size, pending: sections.pending.length },
   };
 }
@@ -848,26 +912,107 @@ function sessionsOf(root) {
 }
 const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,60}$/;
 /** GET: the sessions, or one session ranked. Reads only; writes nothing. */
-function apiList({ root, session = null }) {
+function apiList({ root, session = null, exclude = [] }) {
   if (!root) return { ok: false, status: 400, error: 'no repository' };
   if (!session) return { ok: true, sessions: sessionsOf(root), note: 'Proposals only. Nothing here is a decision.' };
   if (!SESSION_RE.test(session)) return { ok: false, status: 400, error: 'that is not a session id' };
   const file = path.join(stateDirIn(root), 'live-notes', session + '.jsonl');
   if (!fs.existsSync(file)) return { ok: false, status: 404, error: 'no such session in this repository' };
-  return { ok: true, session, ranked: rank(readLedger(file)), note: 'Proposals only. Nothing here is a decision.' };
+  const rows = readLedger(file);
+  const first = rows.find((r) => r.row === 'session') || {};
+  const sl = shortlist(loadInitiatives(root).open, { anchor: first.anchor || null });
+  const list = sl.ok ? attachQuestions(root, sl.list, exclude).map((i) => ({ id: i.id, title: i.title, questions: i.questions || [] })) : [];
+  return { ok: true, session, anchor: first.anchor || null, ranked: rank(rows), shortlist: list, note: 'Proposals only. Nothing here is a decision.' };
 }
 /** POST: append the PM's accept, change or reject. Nothing else is written. */
-function apiDecide({ root, runtimeDir, session, segment, action, initiative = null, relation = null, exclude = [] }) {
+function apiDecide({ root, runtimeDir, session, segment, action, initiative = null, relation = null, question = null, exclude = [] }) {
   if (!root) return { ok: false, status: 400, error: 'no repository' };
   if (!SESSION_RE.test(String(session || ''))) return { ok: false, status: 400, error: 'that is not a session id' };
   if (!fs.existsSync(path.join(stateDirIn(root), 'live-notes', session + '.jsonl'))) return { ok: false, status: 404, error: 'no such session in this repository' };
   try {
     const s = openSession({ root, runtimeDir, session, key: null, flags: {}, exclude, ask: null });
-    const row = s.decide({ segment, action, initiative, relation, by: 'pm' });
+    const row = s.decide({ segment, action, initiative, relation, question, by: 'pm' });
     return { ok: true, decision: row };
   } catch (e) { return { ok: false, status: 400, error: String((e && e.message) || e) }; }
 }
 
+/* ── Run 6: clean up a recognised phrase before it becomes a point. Local and deterministic: no model. ─────────────── */
+const FILLERS = /\b(?:um+|uh+|uhm+|er+m*|hmm+|mm+)\b[,.]?\s*/gi;
+function cleanPhrase(raw) {
+  let t = String(raw == null ? '' : raw).replace(/\s+/g, ' ').trim();
+  t = t.replace(FILLERS, '').replace(/\s+/g, ' ').trim();
+  // an immediate repeat ("the the", "we we will") is a stumble, not meaning
+  t = t.replace(/\b(\w+)(?:\s+\1\b)+/gi, '$1');
+  t = t.replace(/\s+([,.;:?!])/g, '$1').replace(/^[,.;:\s]+/, '');
+  if (!t) return '';
+  t = t[0].toUpperCase() + t.slice(1);
+  if (!/[.?!]$/.test(t)) t += '.';
+  return t;
+}
+
+/* ── Run 6: the view's three writes. Each opens the session on the local path: the server never sends anything. ───── */
+const ledgerOf = (root, session) => path.join(stateDirIn(root), 'live-notes', session + '.jsonl');
+const shortlistOf = (s) => s.items.map((i) => ({ id: i.id, title: i.title, questions: i.questions || [] }));
+/** Anchors with their open-initiative counts, for narrowing a shortlist that is past the Choice cap. */
+function anchorsOf(root) {
+  const counts = {};
+  for (const i of loadInitiatives(root).open) if (i.anchor) counts[i.anchor] = (counts[i.anchor] || 0) + 1;
+  return Object.entries(counts).sort((a, b) => b[1] - a[1] || (a[0] < b[0] ? -1 : 1)).map(([anchor, open]) => ({ anchor, open }));
+}
+/** POST: start a session, or resume one. Returns its shortlist so the view can offer only those initiatives. */
+function apiOpen({ root, runtimeDir, session = null, anchor = null, exclude = [] }) {
+  if (!root) return { ok: false, status: 400, error: 'no repository' };
+  if (session && !SESSION_RE.test(String(session))) return { ok: false, status: 400, error: 'that is not a session id' };
+  if (anchor != null && (typeof anchor !== 'string' || !/^[\w:.-]{1,80}$/.test(anchor))) return { ok: false, status: 400, error: 'that is not an anchor' };
+  // with no anchor, a shortlist past the cap is refused BEFORE any ledger is written, and the anchors are offered
+  if (!session && !anchor) { const sl = shortlist(loadInitiatives(root).open); if (!sl.ok) return { ok: false, status: 409, error: sl.error, anchors: anchorsOf(root) }; }
+  if (session && !fs.existsSync(ledgerOf(root, session))) return { ok: false, status: 404, error: 'no such session in this repository' };
+  try {
+    const s = openSession({ root, runtimeDir, session, key: null, flags: {}, exclude, anchor, ask: null, local: true });
+    if (s.shortlistError) return { ok: false, status: 409, error: s.shortlistError, anchors: anchorsOf(root) };
+    return { ok: true, session: s.id, path: s.path, anchor: s.anchor, closed: s.state().closed, shortlist: shortlistOf(s), note: 'Proposals here are a local word match. Nothing leaves this machine.' };
+  } catch (e) { return { ok: false, status: 400, error: String((e && e.message) || e) }; }
+}
+/** POST: add talking points (one per line) to an open session. Each gets a local proposal at once. */
+async function apiAdd({ root, runtimeDir, session, text, source = 'typed', exclude = [], key = null, flags = {}, ask = null, askOpts = {} }) {
+  const spoken = source === 'speech';
+  if (!root) return { ok: false, status: 400, error: 'no repository' };
+  if (!SESSION_RE.test(String(session || ''))) return { ok: false, status: 400, error: 'that is not a session id' };
+  if (!fs.existsSync(ledgerOf(root, session))) return { ok: false, status: 404, error: 'no such session in this repository' };
+  const lines = String(text == null ? '' : text).split(/\r?\n/).map((l) => (spoken ? cleanPhrase(l) : l.trim())).filter((l) => l && (!spoken || l.length >= MIN_SEGMENT_CHARS));
+  if (!lines.length) return { ok: false, status: 400, error: 'type a talking point first' };
+  if (lines.length > 200 || String(text).length > 40000) return { ok: false, status: 413, error: 'that is too much at once: add at most 200 lines' };
+  try {
+    const s = openSession({ root, runtimeDir, session, key, flags, exclude, ask, askOpts, local: true });
+    if (s.state().closed) return { ok: false, status: 409, error: 'this session is closed' };
+    const r = await s.add(lines, { source: SAFE_ID.test(source) ? source : 'typed' });
+    if (r.error) return { ok: false, status: 409, error: r.error };
+    return { ok: true, added: r.rows.map((x) => x.segment), cleaned: spoken ? lines : undefined, withheld: r.withheld, path: r.path, failed: r.failed, paused: r.paused || null, ranked: rank(s.ledger()) };
+  } catch (e) { return { ok: false, status: 400, error: String((e && e.message) || e) }; }
+}
+/** POST: mark a session private. The view stops listening; Run 7 never sends a point from a private session. */
+function apiMarkPrivate({ root, session }) {
+  if (!root) return { ok: false, status: 400, error: 'no repository' };
+  if (!SESSION_RE.test(String(session || ''))) return { ok: false, status: 400, error: 'that is not a session id' };
+  const file = ledgerOf(root, session);
+  if (!fs.existsSync(file)) return { ok: false, status: 404, error: 'no such session in this repository' };
+  const rows = readLedger(file);
+  if (rows.some((r) => r.row === 'private')) return { ok: true, already: true };
+  createSinkGuard({ sink: file, what: 'live-notes' }).appendLine(file, { row: 'private', session, at: nowISO(Date.now()), by: 'pm' });
+  return { ok: true };
+}
+/** POST: close a session: the day's note gets its section and the raw transcript goes (or is dated to go). */
+function apiClose({ root, runtimeDir, session, retentionDays = 0, exclude = [] }) {
+  if (!root) return { ok: false, status: 400, error: 'no repository' };
+  if (!SESSION_RE.test(String(session || ''))) return { ok: false, status: 400, error: 'that is not a session id' };
+  if (!fs.existsSync(ledgerOf(root, session))) return { ok: false, status: 404, error: 'no such session in this repository' };
+  try {
+    const s = openSession({ root, runtimeDir, session, key: null, flags: {}, exclude, ask: null, local: true });
+    const r = s.close({ retentionDays });
+    return r.already ? { ok: true, already: true } : { ok: true, note: r.note, transcript: r.transcript };
+  } catch (e) { return { ok: false, status: 400, error: String((e && e.message) || e) }; }
+}
+
 /* ── the override rate (N13): the first measure, never an accuracy claim ─────────────────────────── */
 function overrideRate(rows) {
   const by = {};
@@ -876,7 +1021,7 @@ function overrideRate(rows) {
   const dec = new Map();
   for (const r of rows) if (r.row === 'decision') dec.set(r.segment, r);
   for (const [id, s] of seg) {
-    const p = s.path === 'jev' || s.path === 'jev-agent' ? s.path : 'agent-only';
+    const p = ['jev', 'jev-agent', 'local'].includes(s.path) ? s.path : 'agent-only';
     by[p] = by[p] || { proposed: 0, decided: 0, overridden: 0 };
     by[p].proposed++;
     const d = dec.get(id);
@@ -886,5 +1031,5 @@ function overrideRate(rows) {
   return by;
 }
 
-module.exports = { rank, sessionsOf, apiList, apiDecide, segmentsFromTranscript, contextPlan, parseContext, parseDrafts, checkCite, LANES, openSession, purgeExpired, getSwitch, setSwitch, gates, gateSentence, band, shortlist, loadInitiatives, openQuestionsOf, requestFor,
+module.exports = { rank, sessionsOf, apiList, apiDecide, apiOpen, apiAdd, apiClose, apiMarkPrivate, cleanPhrase, anchorsOf, localProposal, LOCAL_MIN, segmentsFromTranscript, contextPlan, parseContext, parseDrafts, checkCite, LANES, openSession, purgeExpired, getSwitch, setSwitch, gates, gateSentence, band, shortlist, loadInitiatives, openQuestionsOf, requestFor,
   mapJev, parseAgentAnswers, agentPrompt, normalizeSegments, overrideRate, readLedger, sessionPaths, stateDirIn, isExcluded, RELATIONS, MAX_CHOICE, REJECTED_LIMIT, UNREACHABLE_LIMIT };

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.48.0",
+  "version": "0.49.0",
   "private": true,
   "description": "PMOS Terminal Workspace — local companion hosting real PTYs beside the library and gates (D62)",
   "license": "MIT",
@@ -16,7 +16,7 @@
     "test:parity:four-panel": "node design-parity.js --states",
     "test:all": "npm test && npm run test:panels && npm run test:ui && npm run test:parity && npm run test:offline",
     "doctor": "node doctor.js",
-    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js && node pm-r15-test.js && node pm-r16-test.js && node pm-r17-test.js && node pm-r16-test.js && node pm-r18-test.js && node pm-r19-test.js && node pm-r20-test.js && node pm-r21-test.js && node pm-r22-test.js && node pm-r23-test.js && node pm-r24-test.js && node pm-r25-test.js && node pm-r26-test.js && node pm-doc-category-test.js && node pm-r27-test.js && node pm-r28-test.js && node pm-r29-today-test.js && node pm-r29-portfolio-test.js && node pm-r29-knowledge-test.js && node pm-r29-memory-test.js && node pm-r29-skills-scheduled-test.js && node pm-r29-validate-guide-test.js && node pm-r29-reports-addrepo-test.js && node pm-r29-filespad-test.js && node pm-r29-newsession-alignment-test.js",
+    "test:panels": "node pm-shell-test.js && node pm-repos-test.js && node pm-initiatives-test.js && node pm-detail-test.js && node pm-tabs-test.js && node pm-term-test.js && node pm-modes-test.js && node pm-r1-test.js && node pm-r2-test.js && node pm-r3-test.js && node pm-r4-test.js && node pm-r5-test.js && node pm-r6-test.js && node pm-r7-test.js && node pm-r8-test.js && node pm-r9-test.js && node pm-r10-test.js && node pm-r11-test.js && node pm-r12-test.js && node pm-r13-test.js && node pm-r14-test.js && node pm-r15-test.js && node pm-r16-test.js && node pm-r17-test.js && node pm-r16-test.js && node pm-r18-test.js && node pm-r19-test.js && node pm-r20-test.js && node pm-r21-test.js && node pm-r22-test.js && node pm-r23-test.js && node pm-r24-test.js && node pm-r25-test.js && node pm-r26-test.js && node pm-doc-category-test.js && node pm-r27-test.js && node pm-r28-test.js && node pm-r29-today-test.js && node pm-r29-portfolio-test.js && node pm-r29-knowledge-test.js && node pm-r29-memory-test.js && node pm-r29-skills-scheduled-test.js && node pm-r29-validate-guide-test.js && node pm-r29-reports-addrepo-test.js && node pm-r29-filespad-test.js && node pm-r29-newsession-alignment-test.js && node pm-live-notes-test.js && node pm-r30-test.js",
     "test:offline": "node offline-tarball.test.js"
   },
   "engines": {