create-pmos 0.63.1 → 0.64.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.63.1",
+  "version": "0.64.0",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@4cf3dc9
+kernel-source: pmos@2196dd0
 assembled: 2026-10-06
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-06T22:58:51Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T23:35:55Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-06T22:58:51Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T23:35:55Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-06T22:58:51Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T23:35:55Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -119,6 +119,8 @@ Every row has a visible ⋯ button. Every control is at least 44 pixels high. No
 
 You can have the same session open on your phone and your computer. A session has one size, so the screen you type in or tap last sets it. The other screen keeps showing the session and takes the size back as soon as you type in it.
 
+On an iPhone or an iPad, the terminal gets smaller when the keyboard opens, so the agent's prompt stays above the keyboard. Tapping the terminal does not zoom the page, and dragging at its top or bottom does not pull or reload the page. A swipe from the left edge of the screen is Safari's Back gesture and leaves the workspace. To avoid that, add the workspace to your Home Screen and open it from there.
+
 ## The older layout
 
 The address options `?layout=legacy` and `?fixture=cockpit` keep the older layouts. The rest of this page describes them. In the cockpit, the workspace has four columns: the repository rail, the list, the detail and the tabs. With `?layout=legacy` it has three columns: navigation, detail and tabs.

package/workspace/guide/people.md

@@ -12,20 +12,26 @@ People lists the people you work with in the current repository. For each person
 
 ## How people get into People
 
-The workspace does not read your mail, chat, calendar or Jira. Agent sessions that already read them with your own connectors record the people they see:
+People adds every person it finds. It reads the names the workspace already holds for the repository each time you open People:
 
-- **Gather requirements** records the author of each item it gathers.
-- **Live notes** records each named speaker.
+- **Plan items.** The owner of each item, when the owner is a person.
+- **Live notes.** Each named speaker. A session marked private is skipped.
+- **Meeting notes.** The speakers you renamed and the action owners the summary finds, in your notes for this repository. A note marked private is skipped.
+- **Calendar.** The attendees this machine remembers, but only when **Keep attendee names from the calendar** is on (see Settings below).
+
+The workspace does not read your mail, chat or Jira. Agent sessions that already read them with your own connectors record the people they see:
+
+- **Gather requirements** records the author of each item it gathers and the people an item names.
+- **Live notes** records each named speaker and each named action owner.
 - **Jira sync** records assignees and reporters by their Jira name.
-- **Morning brief** records meeting attendees, but only when **Keep attendee names from the calendar** is on (see Settings below).
+- **Morning brief** records meeting attendees, but only when calendar names are on.
 
-Each record is a sighting: a name, a handle (a mail address, a chat or Jira name, a transcript speaker, or only a name), and at most one interaction line in the agent's words with a pointer to where it came from. No message body is kept. Private, personal, confidential and HR material is skipped.
+Each record is a sighting: a name, a handle (a mail address, a chat or Jira name, a speaker, or only a name), and at most one interaction line with a pointer to where it came from. No message body is kept. Private, personal, confidential and HR material is skipped. A numbered speaker such as "Speaker 2" is not a person.
 
-A sighting does not make a person. New people wait for you in **Waiting for you** at the top of People.
+A sighting of a new handle adds the person. A sighting with the full name of a person in People joins that person. A first name alone, from a speaker or a name, joins the one person with that first name. When two people have that first name, it joins neither of them.
 
 ## Waiting for you
 
-- **A new person.** Press **Add to People** to add them, or **Ignore** to hide them. Later sightings of an ignored handle stay hidden.
 - **A possible duplicate.** When a session thinks two handles are one person, it says why. Press **Merge** to join the handle to that person, or **Keep separate** to close the question.
 - **Tones to confirm.** The count of people whose tone you have not confirmed. Open the person to confirm it.
 
@@ -39,7 +45,8 @@ Type in **Find a person** to search names, handles and initiatives. **All**, **T
 - **Tone.** The mix of tones (warm, neutral, cautious, tense) and a proposed overall tone: the most frequent tone of the latest 10 interactions. When two tones are tied, the latest one wins. Press **Confirm** to keep the proposal, **Set another** to choose a different tone, or **Change** to clear your choice. Tone describes the exchanges, not the person.
 - **Shared work.** The initiatives your interactions name, the plan items the person owns (with **Blocked** when the item is blocked), and the coming meetings that name them when calendar names are on. Nothing here is typed by hand.
 - **Notes.** Type a note and press **Add note**. Press **Remove** to remove one. Only you can add or remove a note. No command writes one.
-- **Identity and sources.** The person's handles, how many interactions each source gave, and the file the person lives in.
+- **Identity and sources.** The person's handles, how many interactions each source gave, where People found them, and the file the person lives in.
+- **Remove from People.** Takes the person out. Later sightings of their handles stay out.
 
 ## Ways in from other places
 
@@ -65,6 +72,8 @@ People keeps one append-only file, `people.jsonl`, in the repository's state dir
 - `pmos people settings` prints `calendar names: on` or `calendar names: off`. The morning brief reads it before it records attendees.
 - `pmos people help` prints the commands.
 
-The sightings file holds `{ "sightings": [...], "merges": [...] }`. A sighting is `{ "source": "gather" | "calendar" | "live" | "jira", "handle": { "kind": "mail" | "slack" | "jira" | "confluence" | "speaker" | "name", "value": "…" }, "name": "…", "role"?, "org"?, "external"?: true, "interaction"?: { "date": "YYYY-MM-DD", "kind": "Mail", "text": "one line, at most 200 characters", "pointer": "where it came from, at most 200 characters", "tone"?: "warm", "initiative"?: "<id>" } }`. A merge is `{ "a": <handle>, "b": <handle>, "why": "one line" }`.
+The sightings file holds `{ "sightings": [...], "merges": [...] }`. A sighting is `{ "source": "gather" | "calendar" | "live" | "jira" | "plan" | "notes", "handle": { "kind": "mail" | "slack" | "jira" | "confluence" | "speaker" | "name", "value": "…" }, "name": "…", "role"?, "org"?, "external"?: true, "interaction"?: { "date": "YYYY-MM-DD", "kind": "Mail", "text": "one line, at most 200 characters", "pointer": "where it came from, at most 200 characters", "tone"?: "warm", "initiative"?: "<id>" } }`. A merge is `{ "a": <handle>, "b": <handle>, "why": "one line" }`.
+
+`pmos people list` and `pmos people show` first add the plan item owners and Live notes speakers, as People does.
 
-No command adds a person, ignores or merges a handle, sets a tone or writes a note. Do those in People.
+No command removes a person, merges a handle, sets a tone or writes a note. Do those in People.

package/workspace/lib/people-cli.js

@@ -8,7 +8,9 @@
  *   pmos people settings [--json]                     whether calendar attendee names are kept
  *
  * The same module the People place reads (lib/people-store.js), so a terminal line and the page cannot disagree.
- * No command adds a person, merges, sets a tone or writes a note: those are the PM's presses in People (D90).
+ * `list` and `show` first record the names this repository's records hold (plan item owners, Live notes speakers), as
+ * the People place does. No command removes a person, merges, sets a tone or writes a note: those are the PM's presses
+ * in People (D90).
  * `record` must name who recorded: the session's PMOS_SESSION token, or `--by <profile>` outside the workspace.
  *
  * Exit codes: 0 done, 1 refused, 2 usage.
@@ -25,7 +27,7 @@ const USAGE = [
   '  pmos people show <person> [--json]          one person: interactions, tone, shared work, notes and handles',
   '  pmos people record --file <sightings.json>  (agent session) record the people a session saw',
   '  pmos people settings [--json]               whether calendar attendee names are kept (calendar names: on|off)',
-  'Nothing here adds a person, merges, sets a tone or writes a note. Do that in People.',
+  'Nothing here removes a person, merges, sets a tone or writes a note. Do that in People.',
 ];
 const BOOL = new Set(['json', 'help']);
 
@@ -64,20 +66,17 @@ async function run(argv, { say = console.log, cwd = process.cwd(), env = process
   const root = flags.root ? path.resolve(cwd, flags.root) : repoRoot(cwd);
   const fail = (error, code = 1) => { if (json) say(JSON.stringify({ ok: false, error })); else say(`✗ ${error}`); return code; };
 
+  if (sub === 'list' || sub === 'show') store.scan(root, { now });
   if (sub === 'list') {
     const v = store.view(root, { now });
     if (!v.ok) return fail(v.error);
     if (json) { say(JSON.stringify({ ok: true, people: v.people, review: v.review, settings: v.settings, counts: v.counts })); return 0; }
     const r = v.review;
-    say(`People · ${v.people.length} ${v.people.length === 1 ? 'person' : 'people'} · ${r.new.length} new · ${r.merges.length} possible duplicate${r.merges.length === 1 ? '' : 's'} · ${r.tones.length} tone${r.tones.length === 1 ? '' : 's'} to confirm`);
-    if (!v.people.length && !r.new.length) { say('Nobody yet. Agent sessions record the people they see; you add them in People.'); return 0; }
+    say(`People · ${v.people.length} ${v.people.length === 1 ? 'person' : 'people'} · ${r.merges.length} possible duplicate${r.merges.length === 1 ? '' : 's'} · ${r.tones.length} tone${r.tones.length === 1 ? '' : 's'} to confirm`);
+    if (!v.people.length) { say('Nobody yet. People adds the owners of plan items, Live notes speakers, and the people agent sessions record.'); return 0; }
     for (const p of v.people) {
       say(`${p.name}  (${p.id})  ${[p.role, p.org].filter(Boolean).join(' · ') || p.group}  · ${p.count} interaction${p.count === 1 ? '' : 's'}${p.last ? ' · last ' + p.last : ''} · ${toneWord(p.tone)}`);
     }
-    if (r.new.length) {
-      say('New, waiting for you in People:');
-      for (const f of r.new) say(`  ${f.name}  ${handleText(f.handle)}  · ${f.count} sighting${f.count === 1 ? '' : 's'} from ${f.sources.join(', ')}`);
-    }
     return 0;
   }
 

package/workspace/lib/people-store.js

@@ -8,8 +8,16 @@
  *   record(root, { by, sightings, merges, now }) → { ok, recorded, duplicates, refused[], error? }
  *   decide(root, { actor, body, now })       → { ok, row } | { ok:false, error }   one PM page press
  *   settings(root)                           → { ok, calendar_names, file }
+ *   scan(root, { now, calendar, notesDir, ws }) → { ok, recorded, found }   the names the workspace's own records hold
  *
  * Every write is an append through people.js's validators, so a refused row is never on disk. No network, no process.
+ *
+ * SCAN (the PM, 2026-10-06: "If you detect a person's name, add it to the people directory"). People no longer waits for
+ * an agent session alone. `scan` reads the names the workspace already holds and records each as a sighting by
+ * `workspace:scan`, which adds the person (people.js): plan item owners (`person:<name>`), the speakers of this
+ * repository's Live notes sessions, the renamed speakers and action owners of the PM's meeting notes for this repository,
+ * and, only while calendar names are on, the attendees this machine remembers from the calendar. A private Live notes
+ * session or a private note is skipped. A sighting already on disk is not written again, so a scan writes only what is new.
  */
 const crypto = require('crypto');
 const P = require('./people');
@@ -17,6 +25,8 @@ const fourPanel = require('./four-panel');
 const consoleState = require('./console-state');
 
 const MAX_PER_RECORD = 500;
+const fs = require('fs');
+const path = require('path');
 
 function stateDir(root) {
   const e = consoleState.loadEngine();
@@ -120,4 +130,103 @@ function decide(root, { actor, body, now = Date.now() } = {}) {
   return { ok: true, row: w.recorded, person };
 }
 
-module.exports = { view, record, decide, settings, stateDir, readRows };
+/* ── scan: the names the workspace's own records hold ─────────────────────────────────────────────────────────────── */
+// Not names: the notes' default speakers, the action owners that are not a person, and numbered speakers.
+const NOT_A_NAME = /^(you|me|meeting|mic|speech|unknown|someone|everyone|the speaker|the team|team|we|speaker\s*\d*|participant\s*\d*|guest\s*\d*)$/i;
+function personName(v) {
+  const n = String(v == null ? '' : v).replace(/\s+/g, ' ').trim().replace(/^@/, '');
+  if (n.length < 2 || n.length > 80 || !/\p{L}/u.test(n) || NOT_A_NAME.test(n)) return null;
+  return n;
+}
+const day = (v) => (typeof v === 'string' && /^\d{4}-\d{2}-\d{2}/.test(v) ? v.slice(0, 10) : null);
+const lines = (file) => { try { return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((l) => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean); } catch { return []; } };
+/** "Ana Lee, Bo Chen and kim@x.io" → ["Ana Lee", "Bo Chen", "kim@x.io"]. */
+const splitNames = (w) => String(w || '').split(/\s*(?:,|;|&|\band\b|\/)\s*/i).map((x) => x.replace(/\(.*?\)/g, '').trim()).filter(Boolean);
+
+/** The sightings the workspace's records hold for this repository. Pure apart from reading files. */
+function sightingsFrom(root, { items = [], calendar = [], calendarOn = false, notesDir = null, ws = null } = {}) {
+  const out = [];
+  const push = (source, kind, value, name, interaction) => {
+    const n = personName(name);
+    if (!n) return;
+    const s = { source, handle: { kind, value: String(value).slice(0, 120) }, name: n };
+    if (interaction && interaction.date) s.interaction = { ...interaction, text: interaction.text.slice(0, 200), pointer: interaction.pointer.slice(0, 200) };
+    out.push(s);
+  };
+  // plan item owners: the person's shared work already lists the items, so the sighting carries no interaction
+  for (const it of items || []) {
+    if (!it || it.state === 'withdrawn' || typeof it.owner !== 'string' || !it.owner.startsWith('person:')) continue;
+    const n = personName(it.owner.slice(7));
+    if (n) push('plan', 'name', n, n, null);
+  }
+  // Live notes sessions in this repository: one interaction per speaker per session
+  const lnDir = path.join(fs.existsSync(path.join(root, 'pmos', 'state')) ? path.join(root, 'pmos', 'state') : path.join(root, 'planning'), 'live-notes');
+  let files = []; try { files = fs.readdirSync(lnDir).filter((f) => f.endsWith('.jsonl')).sort(); } catch { /* no sessions */ }
+  for (const f of files) {
+    const rows = lines(path.join(lnDir, f));
+    if (rows.some((r) => r.row === 'private')) continue;
+    const session = f.replace(/\.jsonl$/, '');
+    const start = day((rows.find((r) => r.row === 'session') || {}).at) || day((rows[0] || {}).at);
+    const said = new Set();
+    for (const r of rows) {
+      const sp = r && r.pointer && personName(r.pointer.speaker);
+      if (!sp || said.has(sp.toLowerCase())) continue;
+      said.add(sp.toLowerCase());
+      push('live', 'speaker', sp, sp, { date: start || day(r.at), kind: 'Meeting', text: 'Spoke in a Live notes session', pointer: `live notes ${session}` });
+    }
+  }
+  // the PM's meeting notes for this repository: renamed speakers and the action owners the local summary reads
+  if (notesDir && ws) {
+    let nf = []; try { nf = fs.readdirSync(path.join(notesDir, 'notes')).filter((f) => f.endsWith('.json')); } catch { /* no notes */ }
+    let notesLib = null; try { notesLib = require('./notes'); } catch { /* notes unavailable */ }
+    for (const f of nf) {
+      let note = null; try { note = JSON.parse(fs.readFileSync(path.join(notesDir, 'notes', f), 'utf8')); } catch { continue; }
+      if (!note || note.private || note.ws !== ws || !note.id) continue;
+      const date = day(note.recorded_from) || day(note.created_at);
+      if (!date) continue;
+      const pointer = `note ${note.id}`;
+      for (const sp of Object.values(note.speakers || {})) push('notes', 'speaker', sp, sp, { date, kind: 'Meeting', text: 'Spoke in a meeting note', pointer });
+      if (notesLib) {
+        let actions = []; try { actions = (notesLib.summarize(note).sections || {}).actions || []; } catch { /* unreadable note */ }
+        const owners = new Set();
+        for (const a of actions) for (const o of String(a.owner || '').split(/\s+and\s+/)) { const n = personName(o); if (n) owners.add(n); }
+        for (const n of owners) push('notes', 'name', n, n, { date, kind: 'Meeting', text: 'Has an action in a meeting note', pointer });
+      }
+    }
+  }
+  // the calendar this machine remembers, only while calendar names are on (R3)
+  if (calendarOn) {
+    for (const e of calendar || []) {
+      const date = e && day(e.start);
+      if (!date || !e.with) continue;
+      for (const w of splitNames(e.with)) {
+        const mail = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(w);
+        push('calendar', mail ? 'mail' : 'name', mail ? w.toLowerCase() : w, mail ? w.split('@')[0] : w,
+          { date, kind: 'Meeting', text: e.title ? `Meeting: ${e.title}` : 'Meeting', pointer: 'calendar' });
+      }
+    }
+  }
+  return out;
+}
+
+/** Record the names the workspace's records hold. Writes only sightings not already on disk. */
+function scan(root, { now = Date.now(), calendar = [], notesDir = null, ws = null } = {}) {
+  const r = readRows(root);
+  if (!r.ok) return r;
+  const calendarOn = P.fold(r.rows).settings.calendar_names;
+  const found = sightingsFrom(root, { items: planItems(root), calendar, calendarOn, notesDir, ws });
+  const seen = new Set(r.rows.filter((x) => x && x.kind === 'sighting').map(sightKey));
+  let recorded = 0;
+  for (const s of found) {
+    const c = P.checkSighting(s);
+    if (!c.ok) continue;
+    const k = sightKey(c.row);
+    if (seen.has(k)) continue;
+    const w = fourPanel.appendDeclaration(r.dir, P.LEDGER, stamp(c.row, 'workspace:scan', now));
+    if (!w.ok) return { ok: false, error: w.error, recorded, found: found.length };
+    seen.add(k); recorded++;
+  }
+  return { ok: true, recorded, found: found.length };
+}
+
+module.exports = { view, record, decide, settings, scan, sightingsFrom, stateDir, readRows };

package/workspace/lib/people.js

@@ -4,8 +4,9 @@
  *
  *   checkSighting(s)                 → { ok, row } | { ok:false, error }   one sighting an agent session records
  *   checkMergeProposal(m)            → { ok, row } | { ok:false, error }
- *   checkDecision(body)              → { ok, row } | { ok:false, error }   one PM press (add, ignore, merge, keep-separate,
- *                                                                           edit, tone, note, note-remove, setting)
+ *   checkDecision(body)              → { ok, row } | { ok:false, error }   one PM press (add, ignore, remove, merge,
+ *                                                                           keep-separate, edit, tone, note, note-remove,
+ *                                                                           setting)
  *   fold(rows, { now, items, meetings }) → { people, review, settings, counts }
  *   handleKey(h) · slugOf(name) · toneProposal(interactions) · matchPeople(people, text)
  *   SOURCES · HANDLE_KINDS · INTERACTION_KINDS · TONES · ACTS · LEDGER
@@ -13,21 +14,24 @@
  * Pure: no file, no clock unless given, no network. lib/people-store.js reads and appends; the route, the CLI and the
  * People place all answer from fold(), so the terminal and the page cannot hold two opinions about a person.
  *
- * WHO DECIDES (D90). A sighting row is anyone's: an agent session records it through `pmos people record`. Every
- * decision row (a person added, a handle ignored or merged, a tone, a note, the calendar setting) counts only when its
- * `by` is the PM (`pm:<slug>`), which only a page press writes. A decision row with any other `by` is skipped and
- * counted in counts.skipped, so a hand-appended line cannot make an agent's choice the PM's.
+ * WHO DECIDES (D90, as amended 2026-10-06). A sighting row is anyone's: an agent session records it through
+ * `pmos people record`, and the workspace records the names its own records hold (people-store.js scan). A sighting of
+ * a handle nobody holds ADDS that person: the PM asked for every detected name to be in People, not to wait in a list.
+ * A sighting whose name is a person's full name joins that person. Every decision row (a person added or removed, a
+ * handle ignored or merged, a tone, a note, the calendar setting) counts only when its `by` is the PM (`pm:<slug>`),
+ * which only a page press writes. A decision row with any other `by` is skipped and counted in counts.skipped, so a
+ * hand-appended line cannot make an agent's choice the PM's. Remove and Ignore keep a person's handles out for good.
  *
  * CALENDAR NAMES (R3). The setting is off until the PM turns it on. While it is off, the store refuses a calendar
  * sighting, and this fold also drops the calendar sightings recorded while it was on.
  */
 
 const LEDGER = 'people.jsonl';
-const SOURCES = Object.freeze(['gather', 'calendar', 'live', 'jira']);
+const SOURCES = Object.freeze(['gather', 'calendar', 'live', 'jira', 'plan', 'notes']);
 const HANDLE_KINDS = Object.freeze(['mail', 'slack', 'jira', 'confluence', 'speaker', 'name']);
 const INTERACTION_KINDS = Object.freeze(['Mail', 'Chat', 'Meeting', '1:1', 'Jira', 'Doc', 'Call', 'Mention']);
 const TONES = Object.freeze(['warm', 'neutral', 'cautious', 'tense']);
-const ACTS = Object.freeze(['add', 'ignore', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
+const ACTS = Object.freeze(['add', 'ignore', 'remove', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const ID_RE = /^[a-z0-9][a-z0-9-]{0,59}$/;
 const NOTE_ID_RE = /^n-[0-9a-z]{4,16}$/;
@@ -148,6 +152,7 @@ function checkDecision(body) {
     return { ok: true, row: { kind: 'keep-separate', a: a.value, b: b.value } };
   }
   if (!person()) return { ok: false, error: 'say which person' };
+  if (act === 'remove') return { ok: true, row: { kind: 'remove', person: person() } };
   if (act === 'edit') {
     const row = { kind: 'edit', person: person() };
     for (const [k, max] of [['name', 80], ['role', 120], ['org', 80]]) {
@@ -217,7 +222,7 @@ function matchPeople(people, hay) {
 const sightKey = (r) => [handleKey(r.handle), r.interaction ? r.interaction.date : '', r.interaction ? r.interaction.pointer : '', r.interaction ? r.interaction.text : ''].join('\u0000');
 const pairKey = (a, b) => [handleKey(a), handleKey(b)].sort().join('\u0000');
 const isPm = (r) => typeof r.by === 'string' && PM_BY_RE.test(r.by);
-const DECISION_KINDS = new Set(['add', 'ignore', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
+const DECISION_KINDS = new Set(['add', 'ignore', 'remove', 'merge', 'keep-separate', 'edit', 'tone', 'note', 'note-remove', 'setting']);
 
 /**
  * The one fold. `rows` are the ledger's rows in file order (torn lines already dropped). `items` are plan items (the
@@ -233,7 +238,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
   const sightings = [];
   const proposals = [];
 
-  // 1 · decisions, in file order; the calendar setting first so the sightings below read the final value
+  // 1 · the calendar setting first, so every sighting below reads its final value
   for (const r of rows || []) {
     if (!isObj(r)) continue;
     counts.rows++;
@@ -249,11 +254,44 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     const p = people.get(id);
     if (!p.handles.some((x) => handleKey(x) === k)) p.handles.push({ kind: h.kind, value: h.value });
   };
+  const create = (name, h, at) => {
+    let id = slugOf(name);
+    for (let n = 2; people.has(id); n++) id = `${slugOf(name).slice(0, 56)}-${n}`;
+    people.set(id, { id, name, role: null, org: null, external: null, handles: [], tone: null, notes: new Map(), addedAt: at || null, edited: {} });
+    attach(id, h);
+    return id;
+  };
+  // A sighting whose name is a person's full name is that person: "Ana Lee" from Jira and "Ana Lee" from a meeting. A
+  // bare first name from a weak handle (a name or a speaker, never a mail or chat handle) joins the one person with that
+  // first name; when two people share it, it joins nobody.
+  const byName = (name, kind) => {
+    const n = str(name).toLowerCase();
+    const live = [...people.values()].filter((p) => p.handles.length);
+    const full = live.find((p) => str(p.name).toLowerCase() === n);
+    if (full) return full.id;
+    if ((kind !== 'name' && kind !== 'speaker') || n.includes(' ')) return null;
+    const firsts = live.filter((p) => str(p.name).toLowerCase().split(' ')[0] === n);
+    return firsts.length === 1 ? firsts[0].id : null;
+  };
+  // One pass in file order, so a person exists before the PM's later presses about them.
+  const seen = new Set();
   for (const r of rows || []) {
     if (!isObj(r)) continue;
     if (r.kind === 'sighting') {
       const c = checkSighting(r);
-      if (c.ok) sightings.push({ ...c.row, at: r.at || null });
+      if (!c.ok) continue;
+      const s = { ...c.row, at: r.at || null };
+      const key = sightKey(s);
+      if (seen.has(key)) { counts.duplicates++; continue; }
+      seen.add(key);
+      if (s.source === 'calendar' && !settings.calendar_names) { counts.hiddenCalendar++; continue; }
+      const k = handleKey(s.handle);
+      if (ignored.has(k)) continue;
+      if (!owner.has(k) || !people.has(owner.get(k))) {
+        const id = byName(s.name, s.handle.kind);
+        if (id) attach(id, s.handle); else create(s.name, s.handle, s.at);
+      }
+      sightings.push(s);
       continue;
     }
     if (r.kind === 'merge-proposal') {
@@ -268,20 +306,23 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     if (d.kind === 'add') {
       const k = handleKey(d.handle);
       if (owner.has(k) && people.has(owner.get(k))) continue;
-      let id = slugOf(d.name);
-      for (let n = 2; people.has(id); n++) id = `${slugOf(d.name).slice(0, 56)}-${n}`;
-      people.set(id, { id, name: d.name, role: null, org: null, external: null, handles: [], tone: null, notes: new Map(), addedAt: r.at || null, edited: {} });
-      attach(id, d.handle);
+      create(d.name, d.handle, r.at);
     } else if (d.kind === 'ignore') {
       const k = handleKey(d.handle);
-      if (!owner.has(k)) ignored.add(k);
+      const o = owner.get(k);
+      if (o && people.has(o)) { const pp = people.get(o); pp.handles = pp.handles.filter((x) => handleKey(x) !== k); }
+      owner.delete(k);
+      ignored.add(k);
     } else if (d.kind === 'merge') {
       if (people.has(d.person)) attach(d.person, d.handle);
     } else if (d.kind === 'keep-separate') {
       closed.add(pairKey(d.a, d.b));
     } else if (people.has(d.person)) {
       const p = people.get(d.person);
-      if (d.kind === 'edit') {
+      if (d.kind === 'remove') {
+        for (const h of p.handles) { owner.delete(handleKey(h)); ignored.add(handleKey(h)); }
+        p.handles = [];
+      } else if (d.kind === 'edit') {
         for (const k of ['name', 'role', 'org', 'external']) if (d[k] !== undefined) { p[k] = d[k]; p.edited[k] = true; }
       } else if (d.kind === 'tone') p.tone = d.tone;
       else if (d.kind === 'note') p.notes.set(d.id, { id: d.id, text: d.text, at: r.at || null });
@@ -289,38 +330,21 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     }
   }
 
-  // 2 · sightings: dedup, drop calendar ones while the setting is off, then hand each to its person or the review list
-  const seen = new Set();
-  const fresh = new Map();   // handle key -> { handle, name, role, org, external, count, sources, last }
+  // 2 · each sighting's details go to the person who holds its handle at the end
   const interactions = new Map();   // person id -> []
+  const sourcesOf = new Map();      // person id -> Set of sources
   for (const s of sightings) {
-    const key = sightKey(s);
-    if (seen.has(key)) { counts.duplicates++; continue; }
-    seen.add(key);
-    if (s.source === 'calendar' && !settings.calendar_names) { counts.hiddenCalendar++; continue; }
-    const k = handleKey(s.handle);
-    const id = owner.get(k);
-    if (id && people.has(id)) {
-      const p = people.get(id);
-      for (const f of ['role', 'org']) if (s[f] && !p.edited[f]) p[f] = s[f];
-      if (s.external === true && !p.edited.external) p.external = true;
-      if (s.interaction) {
-        if (!interactions.has(id)) interactions.set(id, []);
-        interactions.get(id).push({ ...s.interaction, source: s.source, handle: s.handle, at: s.at });
-      }
-      continue;
+    const id = owner.get(handleKey(s.handle));
+    if (!id || !people.has(id)) continue;
+    const p = people.get(id);
+    if (!sourcesOf.has(id)) sourcesOf.set(id, new Set());
+    sourcesOf.get(id).add(s.source);
+    for (const f of ['role', 'org']) if (s[f] && !p.edited[f]) p[f] = s[f];
+    if (s.external === true && !p.edited.external) p.external = true;
+    if (s.interaction) {
+      if (!interactions.has(id)) interactions.set(id, []);
+      interactions.get(id).push({ ...s.interaction, source: s.source, handle: s.handle, at: s.at });
     }
-    if (ignored.has(k)) continue;
-    const f = fresh.get(k) || { handle: s.handle, name: s.name, role: null, org: null, external: false, count: 0, sources: [], last: null };
-    f.name = s.name;
-    if (s.role) f.role = s.role;
-    if (s.org) f.org = s.org;
-    if (s.external) f.external = true;
-    f.count++;
-    if (!f.sources.includes(s.source)) f.sources.push(s.source);
-    const d = s.interaction ? s.interaction.date : (s.at || '').slice(0, 10);
-    if (d && (!f.last || d > f.last)) f.last = d;
-    fresh.set(k, f);
   }
 
   // 3 · each person's page
@@ -340,6 +364,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
       id: p.id, name: p.name, role: p.role || null, org: p.org || null, external: p.external === true,
       group: p.external === true ? 'External' : 'Team',
       handles: p.handles.slice(),
+      sources: [...(sourcesOf.get(p.id) || [])],
       interactions: ints,
       tone: { proposed, confirmed: p.tone || null, mix, pending: !!proposed && !p.tone },
       notes: [...p.notes.values()],
@@ -367,7 +392,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
   }
   list.sort((a, b) => String(b.last || '').localeCompare(String(a.last || '')) || a.name.localeCompare(b.name));
 
-  // 5 · the review list: new handles, open merge proposals, tones the PM has not confirmed
+  // 5 · the review list: open merge proposals and tones the PM has not confirmed (a new person is added, not listed)
   const merges = [];
   const shown = new Set();
   for (const m of proposals) {
@@ -375,7 +400,7 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     if (closed.has(pk) || shown.has(pk)) continue;
     const oa = owner.get(handleKey(m.a)); const ob = owner.get(handleKey(m.b));
     if (oa && ob && oa === ob) continue;
-    // Merge needs a person to join: the one holding a (or else b). Two handles nobody holds wait in "new" instead.
+    // Merge needs a person to join: the one holding a (or else b).
     const into = oa && people.has(oa) ? oa : ob && people.has(ob) ? ob : null;
     if (!into) continue;
     const other = into === oa ? m.b : m.a;
@@ -383,11 +408,10 @@ function fold(rows, { now = Date.now(), items = [], meetings = [] } = {}) {
     shown.add(pk);
     merges.push({ a: m.a, b: m.b, why: m.why, person: into, personName: people.get(into).name, handle: other });
   }
-  const freshList = [...fresh.values()].sort((a, b) => String(b.last || '').localeCompare(String(a.last || '')) || b.count - a.count);
   const tones = list.filter((p) => p.tone.pending).map((p) => p.id);
   return {
     people: list,
-    review: { new: freshList, merges, tones, count: freshList.length + merges.length + (tones.length ? 1 : 0) },
+    review: { merges, tones, count: merges.length + (tones.length ? 1 : 0) },
     settings,
     counts,
   };

package/workspace/package-lock.json

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

package/workspace/package.json

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

package/workspace/public/pm/dest-people.js

@@ -6,14 +6,14 @@
  * only the body is rebuilt when its own data changed.
  *
  * What it shows, for the repository the tab names (or the open one):
- *   - Waiting for you: new people agent sessions saw (Add to People · Ignore), possible duplicates (Merge · Keep
- *     separate), and how many tones wait for a confirm;
+ *   - Waiting for you: possible duplicates (Merge · Keep separate) and how many tones wait for a confirm. A new person
+ *     is added, not listed here (the PM, 2026-10-06): Remove from People on their page keeps them out;
  *   - the list: search over names, handles and initiatives, All · Team · External, sort by latest, most or name;
  *   - the person's page: who, interactions with where each came from, tone (Confirm · Set another · Change), shared
  *     work (initiatives, items they own with Blocked shown, coming meetings), notes (Add · Remove), and identity and
  *     sources (handles, how many interactions each source gave, the file the person lives in).
- * Every press is a page press to POST /api/people/decide. Nothing here reads a source: agent sessions record what they
- * saw through `pmos people record`. A link from another place opens a person through the tab's slug (people-link.js).
+ * Every press is a page press to POST /api/people/decide. Nothing here reads a source: GET /api/people records the names
+ * the workspace's own records hold, and agent sessions record what they saw through `pmos people record`. A link from another place opens a person through the tab's slug (people-link.js).
  * In fixture mode it reads nothing.
  */
 
@@ -26,7 +26,7 @@ import { registerCommand, openDestination } from './registry.js';
 import { forgetPeople } from './people-link.js';
 
 const TONES = ['warm', 'neutral', 'cautious', 'tense'];
-const SOURCE = { gather: 'Gathered notes', calendar: 'Calendar', live: 'Live notes', jira: 'Jira' };
+const SOURCE = { gather: 'Gathered notes', calendar: 'Calendar', live: 'Live notes', jira: 'Jira', plan: 'Plan items', notes: 'Meeting notes' };
 const HANDLE = { mail: 'Mail', slack: 'Chat', jira: 'Jira', confluence: 'Confluence', speaker: 'Speaker', name: 'Name' };
 
 export const COPY = Object.freeze({
@@ -37,16 +37,13 @@ export const COPY = Object.freeze({
   readError: 'People could not be read.',
   find: 'Find a person',
   waiting: 'Waiting for you',
-  newPerson: (n, src) => `${n} sighting${n === 1 ? '' : 's'} · ${src}`,
-  add: 'Add to People',
-  ignore: 'Ignore',
   same: (a, b) => `${a} may be the same person as ${b}`,
   merge: 'Merge',
   keep: 'Keep separate',
   tonesWait: (n) => `${n} tone${n === 1 ? '' : 's'} to confirm. Open the person to confirm it.`,
   all: 'All', team: 'Team', external: 'External',
   latest: 'Latest', most: 'Most', name: 'Name',
-  none: 'Nobody yet. Agent sessions that gather requirements, take live notes or sync Jira record the people they see. They wait here for you to add them.',
+  none: 'Nobody yet. People adds everyone it finds: the owners of plan items, the speakers in Live notes and your meeting notes, the calendar when calendar names are on, and the people agent sessions see when they gather requirements or sync Jira.',
   noMatch: (q) => `Nobody matches “${q}”.`,
   pick: 'Choose a person to see their page.',
   interactions: 'Interactions',
@@ -70,8 +67,9 @@ export const COPY = Object.freeze({
   remove: 'Remove',
   identity: 'Identity and sources',
   lives: (f) => `Lives in ${f}`,
-  added: (n) => `${n} added to People.`,
-  ignored: (n) => `${n} is ignored. Later sightings stay hidden.`,
+  removeFromPeople: 'Remove from People',
+  removed: (n) => `${n} is removed. Later sightings stay out.`,
+  foundIn: (s) => `Found in ${s}`,
   merged: 'Merged.',
   kept: 'Kept separate.',
   noteAdded: 'Note added.',
@@ -174,21 +172,6 @@ function review(inst) {
   const r = inst.view.review;
   if (!r.count) return null;
   const rows = [];
-  for (const f of r.new) {
-    const key = f.handle.kind + ':' + f.handle.value;
-    rows.push(el('div', { class: 'rp-people-row', role: 'listitem', 'data-people-new': key },
-      row({
-        title: f.name,
-        meta: [[f.role, f.org].filter(Boolean).join(' · ') || handleText(f.handle), COPY.newPerson(f.count, f.sources.map((s) => SOURCE[s] || s).join(', '))],
-        trail: [
-          button({ label: COPY.add, variant: 'primary', size: 'sm', attrs: { 'data-people-act': 'add', 'data-people-key': key },
-            onClick: async () => { const x = await decide(inst, { act: 'add', handle: f.handle, name: f.name }, COPY.added(f.name)); if (x && x.person) { inst.open = x.person; draw(inst); } } }),
-          button({ label: COPY.ignore, variant: 'ghost', size: 'sm', attrs: { 'data-people-act': 'ignore', 'data-people-key': key },
-            onClick: () => decide(inst, { act: 'ignore', handle: f.handle }, COPY.ignored(f.name)) }),
-        ],
-        attrs: { title: handleText(f.handle) },
-      })));
-  }
   for (const m of r.merges) {
     const key = m.handle.kind + ':' + m.handle.value;
     rows.push(el('div', { class: 'rp-people-row', role: 'listitem', 'data-people-merge': key },
@@ -340,6 +323,7 @@ function identitySec(inst, p) {
     el('ul', { class: 'rp-people-list-plain' },
       p.handles.map((h) => el('li', { class: 'rp-people-handle', 'data-people-handle': h.kind + ':' + h.value }, handleText(h))),
       Object.entries(by).map(([s, n]) => el('li', { class: 'rp-people-hint' }, `${SOURCE[s] || s}: ${n} interaction${n === 1 ? '' : 's'}`))),
+    (p.sources || []).length ? el('p', { class: 'rp-people-hint', 'data-people-sources': p.sources.join(',') }, COPY.foundIn(p.sources.map((s) => SOURCE[s] || s).join(', '))) : null,
     el('p', { class: 'rp-people-hint rp-people-file' }, COPY.lives(file)),
   ], { 'data-people-sec': 'identity' });
 }
@@ -350,7 +334,9 @@ function personPane(inst) {
   return el('article', { class: 'rp-people-page', 'data-people-page': p.id },
     el('header', { class: 'rp-people-who' },
       el('h3', { class: 'rp-people-who__name' }, p.name),
-      el('p', { class: 'rp-people-hint' }, [who(p), p.external && (p.role || p.org) ? COPY.external : null].filter(Boolean).join(' · '))),
+      el('p', { class: 'rp-people-hint' }, [who(p), p.external && (p.role || p.org) ? COPY.external : null].filter(Boolean).join(' · ')),
+      el('div', { class: 'rp-people-acts' }, button({ label: COPY.removeFromPeople, variant: 'ghost', size: 'sm', attrs: { 'data-people-act': 'remove' },
+        onClick: async () => { const r = await decide(inst, { act: 'remove', person: p.id }, COPY.removed(p.name)); if (r) { inst.open = null; draw(inst); } } }))),
     interactionsSec(p), toneSec(inst, p), sharedSec(p), notesSec(inst, p), identitySec(inst, p));
 }
 

package/workspace/public/pm/mobile.css

@@ -43,6 +43,7 @@
     border-left: 1px solid var(--border);
     border-right: 1px solid var(--border);
   }
+  html.pm-vv body { height: var(--fr-vvh, 100vh); }
 
   /* Explicit placement, never auto-placement: app.js appends its root LAST, so source order would
    * put the screen underneath the bottom nav. */
@@ -363,3 +364,19 @@
 .mob[hidden], .mobmenu[hidden], .mob-back[hidden], .mob-brand[hidden] { display: none !important; }
 .mob-repo[hidden], .mob-set[hidden], .mob-sync[hidden], .mob-theme[hidden], .mobnav-n[hidden] { display: none !important; }
 .mob-deck[hidden], .mob-pager[hidden], .mob-deck__views[hidden] { display: none !important; }
+
+/* ── a touch screen: the visible height, no page bounce, no zoom on focus ─────────────────────
+ * pm/mobile.js sets `pm-vv` and `--fr-vvh` (the visual viewport's height) on a touch screen. The
+ * page is that tall, so the soft keyboard sits under the terminal and does not cover it. Above the
+ * breakpoint (an iPad) that is app.js's root; at the breakpoint and below it is <body>, in the phone rules above.
+ * A drag at the top or bottom of the terminal does not pull the page or reload it. Every rule here
+ * needs `pm-vv`, so a desktop with a mouse is untouched. */
+html.pm-vv, html.pm-vv body { overscroll-behavior: none; }
+html.pm-vv { -webkit-text-size-adjust: 100%; text-size-adjust: 100%; }
+@media (min-width: 761px) {
+  html.pm-vv body > [data-pm-theme] { height: var(--fr-vvh, 100vh) !important; }
+}
+/* xterm types through a hidden textarea and gives it the terminal's 12.5px font. iOS zooms the
+ * page in on a focused field under 16px, which pushes the terminal off the side of the screen. The
+ * textarea is invisible, so its size changes nothing else. */
+html.pm-vv .xterm .xterm-helper-textarea { font-size: 16px !important; }

package/workspace/public/pm/mobile.js

@@ -475,13 +475,42 @@ function onChromeClick(e) {
 
 /* The terminal has to re-measure when the soft keyboard shows or hides and after a rotation, or
  * xterm keeps the row count it had and the bottom of the session is clipped. The fit itself belongs
- * to the terminal panel; this only tells it that the box changed. */
+ * to the terminal panel; this only tells it that the box changed. It calls the terminal's refit
+ * directly: a synthetic window `resize` also re-lays the card deck and the report slides. */
 function refit() {
   const t = window.pmTerm;
-  if (t && typeof t.fit === 'function') { try { t.fit(); return; } catch { /* fall through */ } }
+  if (t && typeof t.refitVisible === 'function') { try { t.refitVisible(); return; } catch { /* fall through */ } }
   window.dispatchEvent(new Event('resize'));
 }
 
+/* ── the visible height, on a touch screen ───────────────────────────────────────────────────
+ * iOS does not shrink the page when the soft keyboard opens. `100vh` stays the full screen, the
+ * keyboard covers its bottom, and that bottom is where the agent's prompt and the control keys
+ * are. Safari then scrolls the page to show the focused field, so the screen jumps. And with
+ * Safari's toolbar shown, `100vh` is already taller than what is visible.
+ *
+ * So on a touch screen the page height is the VISUAL viewport's: `--fr-vvh` on <html>, read by
+ * pm/mobile.css, with the page held at the top. A pinch zoom also changes the visual viewport, and
+ * that is not the page getting smaller, so the height is in layout pixels (height × scale). */
+const TOUCH = window.matchMedia('(hover: none) and (pointer: coarse)');
+let vvh = 0;
+
+function fitViewport() {
+  const vv = window.visualViewport;
+  const root = document.documentElement;
+  if (!vv || !TOUCH.matches) {
+    if (root.classList.contains('pm-vv')) { root.classList.remove('pm-vv'); vvh = 0; refit(); }
+    return;
+  }
+  root.classList.add('pm-vv');
+  if (window.scrollY || window.scrollX) window.scrollTo(0, 0);
+  const h = Math.round(vv.height * (vv.scale || 1));
+  if (!h || h === vvh) return;
+  vvh = h;
+  root.style.setProperty('--fr-vvh', h + 'px');
+  refit();
+}
+
 /* ── mount ──────────────────────────────────────────────────────────────────────────────────── */
 
 /**
@@ -515,10 +544,12 @@ export function mountMobile(context) {
   document.addEventListener('click', onChromeClick);
 
   if (window.visualViewport) {
-    window.visualViewport.addEventListener('resize', refit);
-    window.visualViewport.addEventListener('scroll', refit);
+    window.visualViewport.addEventListener('resize', fitViewport);
+    window.visualViewport.addEventListener('scroll', fitViewport);
   }
-  window.addEventListener('orientationchange', () => setTimeout(refit, 250));
+  if (TOUCH.addEventListener) TOUCH.addEventListener('change', fitViewport);
+  window.addEventListener('orientationchange', () => setTimeout(() => { fitViewport(); refit(); }, 250));
+  fitViewport();
 
   // Crossing the breakpoint (rotate a tablet, drag a window narrow) has to re-decide whether the
   // phone shell exists at all AND repaint the panels — a shell left mounted above 760px is a second

package/workspace/public/pm/tab-term.js

@@ -699,6 +699,18 @@ function syncSize(rec, claim) {
   if (send({ t: 'resize', id: rec.sessionId, cols, rows })) { rec.sentCols = cols; rec.sentRows = rows; }
 }
 
+/**
+ * State a grid that a refit changed, once the box stops moving. A phone's soft keyboard and a
+ * rotation move the box several times in a few hundred milliseconds, and every grid the PTY hears
+ * makes the agent redraw its whole frame. Typing still sends at once: `onData` calls syncSize
+ * before the keystroke, which states the latest grid and makes the queued call a no-op.
+ */
+const SIZE_SETTLE_MS = 120;
+function queueSize(rec) {
+  clearTimeout(rec.sizeTimer);
+  rec.sizeTimer = setTimeout(() => { rec.sizeTimer = null; syncSize(rec, true); }, SIZE_SETTLE_MS);
+}
+
 /** Write a status line into the terminal itself — once per distinct message, dimmed. */
 function note(rec, line, force) {
   if (!rec.term) return;
@@ -726,8 +738,9 @@ export function refitVisible() {
       try { rec.fit.fit(); } catch { /* a terminal mid-teardown */ }
       // …and state the resulting grid to the PTY. `fit()` only fires xterm's `onResize` when the
       // grid MOVES, so a pane that was measured before it had a session would otherwise never tell
-      // the shell how wide it is. See the `attached` handler.
-      syncSize(rec);
+      // the shell how wide it is. See the `attached` handler. A grid change the fit just queued
+      // (see queueSize) goes out when the box settles, not here.
+      if (!rec.sizeTimer) syncSize(rec);
     }
   };
   if (typeof requestAnimationFrame === 'function') requestAnimationFrame(run);
@@ -891,12 +904,12 @@ function buildReal(tab) {
   term.attachCustomKeyEventHandler((e) => !((e.metaKey || e.ctrlKey) && (e.key === 'k' || e.key === 'K')));
 
   const rec = {
-    kind: 'real', tab, host, term, fit, sessionId: null, attachedId: null, noted: null, ro: null,
+    kind: 'real', tab, host, term, fit, sessionId: null, attachedId: null, noted: null, ro: null, sizeTimer: null,
   };
   // Typing, focusing or re-sizing THIS pane takes the session's grid back from another screen, and
   // the grid goes out before the keystroke so the agent answers it at this pane's size.
   term.onData((d) => { if (rec.sessionId) { syncSize(rec, true); send({ t: 'input', id: rec.sessionId, data: d }); } });
-  term.onResize(() => syncSize(rec, true));
+  term.onResize(() => queueSize(rec));
   host.addEventListener('focusin', () => syncSize(rec, true));
   if (typeof ResizeObserver === 'function') {
     rec.ro = new ResizeObserver(() => refitVisible());
@@ -951,6 +964,7 @@ export function disposeTerm(tab) {
    * pane for the id and detaches from the orphan instead. */
   if (rec.kind !== 'real') return;
   if (rec.ro) { try { rec.ro.disconnect(); } catch { /* ignore */ } }
+  clearTimeout(rec.sizeTimer);
   if (rec.sessionId) {
     send({ t: 'detach', id: rec.sessionId });
     SOCK.attached.delete(rec.sessionId);

package/workspace/server.js

@@ -6623,17 +6623,20 @@ async function handleRequest(req, res) {
     return json(res, { ok: started, session: s.id, error: started ? undefined : (s.note || 'could not start the session') }, started ? 200 : 500);
   }
   // ── People: the people the PM works with in a repository (people-directory, PRD R9 to R14, proposed D90) ──────────
-  // GET folds people.jsonl with the plan items and the coming meetings this machine remembers (the calendar memory and
-  // today's brief). POST is one PM page press: add, ignore, merge, keep separate, edit, tone, a note, or the calendar
-  // setting. Agent sessions record sightings through `pmos people record`; no route here reads a source.
+  // GET first records the names this machine's own records hold (people-store scan: plan item owners, Live notes
+  // speakers, the PM's meeting notes for this repository, and the remembered calendar while calendar names are on), then
+  // folds people.jsonl with the plan items and the coming meetings. POST is one PM page press: add, remove, ignore,
+  // merge, keep separate, edit, tone, a note, or the calendar setting. Agent sessions record what they read from mail,
+  // chat and Jira through `pmos people record`; no route here reads a connector.
   if (p === '/api/people' && req.method === 'GET') {
     const w = getWs(url.searchParams.get('ws'));
     const root = w ? w.root : SELF_ROOT;
     const now = Date.now();
     const mem = readCalMemory();
     const brief = briefOfDay(briefLib.localDate(now));
-    const meetings = [...((mem && mem.events) || []), ...((brief && brief.calendar) || [])]
-      .filter((e) => e && e.start && Date.parse(e.end || e.start) >= now);
+    const calendar = [...((mem && mem.events) || []), ...((brief && brief.calendar) || [])];
+    peopleStore.scan(root, { now, calendar, notesDir: STATE, ws: w ? w.id : null });
+    const meetings = calendar.filter((e) => e && e.start && Date.parse(e.end || e.start) >= now);
     const v = peopleStore.view(root, { now, meetings });
     if (!v.ok) return json(res, v, 500);
     return json(res, { ...v, ws: w ? w.id : null });

package/workspace/skills/gather-requirements.skill

@@ -4,7 +4,7 @@ label: "Gather requirements"
 description: "Read what changed in the PM's mail, chat, Jira, Confluence, calendar and meeting notes since the last note, and file one dated note of requirements — each with its source, how sure it is, and which initiative it touches."
 run: agent
 agent: claude
-version: 1.2.0
+version: 1.3.0
 owner: wawan
 risk: low
 scope: read:connectors, read:state, write:state/requirements, write:state/people
@@ -55,7 +55,7 @@ Procedure (each step ends with a check that shows it is done):
    Done when: the file starts with this frontmatter and holds the four sections in order.
 7. Under "Sources reached and not reached", list every source kind you tried, with `reached` or `not reached — <why>`, and the number of private items skipped.
    Done when: every source kind you tried has a line, and the private count is stated.
-8. Record the people in People. For each author of an item you filed (other than the PM), write one sighting: {"source": "gather", "handle": {"kind": "mail" | "slack" | "jira" | "confluence", "value": "<their address or name in that source>"}, "name": "<display name>", "role"?: "<their role, when the source states it>", "org"?: "<their organisation, when it is not the PM's>", "external"?: true (when they are outside the PM's company), "interaction": {"date": "YYYY-MM-DD", "kind": "Mail" | "Chat" | "Jira" | "Doc" | "Meeting", "text": "<what they asked or said, in your words, at most 200 characters>", "pointer": "<the item's pointer>", "tone": "warm|neutral|cautious|tense" (only when the exchange shows one), "initiative": "<the item's initiative id, or omit when unmatched>"}}. Tone describes the exchange, not the person. When two handles look like one person (the same name in mail and in chat), add a merge {"a": <handle>, "b": <handle>, "why": "<one line>"}. Put them in one file {"sightings": [...], "merges": [...]} in the scratch folder and run `pmos people record --file <that file>` once. Contact details beyond the handle are never recorded.
+8. Record the people in People. For each author of an item you filed, and each other person an item names (an owner, a stakeholder, a decision maker), other than the PM, write one sighting (for a person an item only names, the interaction kind is "Mention"): {"source": "gather", "handle": {"kind": "mail" | "slack" | "jira" | "confluence", "value": "<their address or name in that source>"}, "name": "<display name>", "role"?: "<their role, when the source states it>", "org"?: "<their organisation, when it is not the PM's>", "external"?: true (when they are outside the PM's company), "interaction": {"date": "YYYY-MM-DD", "kind": "Mail" | "Chat" | "Jira" | "Doc" | "Meeting", "text": "<what they asked or said, in your words, at most 200 characters>", "pointer": "<the item's pointer>", "tone": "warm|neutral|cautious|tense" (only when the exchange shows one), "initiative": "<the item's initiative id, or omit when unmatched>"}}. Tone describes the exchange, not the person. When two handles look like one person (the same name in mail and in chat), add a merge {"a": <handle>, "b": <handle>, "why": "<one line>"}. Put them in one file {"sightings": [...], "merges": [...]} in the scratch folder and run `pmos people record --file <that file>` once. Contact details beyond the handle are never recorded.
    Done when: the command printed how many sightings it recorded, or you said no item had an author.
 9. Finish by saying in one line how many items you filed and where, and how many people you recorded. Do not commit; the PM's Sync carries the file.
    Done when: the count and the path are said once, and no commit was made.

package/workspace/skills/jira-sync.skill

@@ -31,7 +31,7 @@ Procedure:
    - `url`: the issue's browse link, `https://<site>.atlassian.net/browse/<KEY>`.
    The shape Jira returned (`{"issues": [{"key", "self", "fields": {...}}]}`) is also accepted.
 4. Run `pmos jira sync <initiative> --from <the file> --query "<the JQL>"`. Then delete the file.
-5. Record the people in People. For each assignee and reporter other than the PM, write one sighting per issue: {"source": "jira", "handle": {"kind": "jira", "value": "<their Jira display name>"}, "name": "<display name>", "interaction": {"date": "<the issue's last update, YYYY-MM-DD>", "kind": "Jira", "text": "<Assignee|Reporter> of <KEY>: <summary, at most 150 characters>", "pointer": "jira · <KEY> · <url>", "initiative": "<the initiative id>"}}. Put all of them in one file {"sightings": [...]} in the scratch folder, run `pmos people record --file <that file>` once, and delete the file. An issue with no assignee gives no assignee sighting.
+5. Record the people in People. For each assignee and reporter other than the PM, write one sighting per issue (People adds each new person at once): {"source": "jira", "handle": {"kind": "jira", "value": "<their Jira display name>"}, "name": "<display name>", "interaction": {"date": "<the issue's last update, YYYY-MM-DD>", "kind": "Jira", "text": "<Assignee|Reporter> of <KEY>: <summary, at most 150 characters>", "pointer": "jira · <KEY> · <url>", "initiative": "<the initiative id>"}}. Put all of them in one file {"sightings": [...]} in the scratch folder, run `pmos people record --file <that file>` once, and delete the file. An issue with no assignee gives no assignee sighting.
 6. Finish with the three sections of the output contract, one short line each:
    - Checked: the initiative, the number of tickets read, and each change (status, sprint, blocked). If nothing changed, say "no change". Add how many people you recorded.
    - Not reached: each initiative whose search failed, with the reason.

package/workspace/skills/live-notes.skill

@@ -5,7 +5,7 @@ description: "Take the talking points of a conversation, place each against the
 run: agent
 agent: claude
 tier: balanced
-version: 1.1.0
+version: 1.2.0
 owner: wawan
 risk: low
 scope: read:connectors, read:state, write:state/live-notes
@@ -48,7 +48,7 @@ Procedure (each step ends with a check that shows it is done):
    Done when: you have shown the list and recorded nothing the PM did not say.
 6. When the PM says the conversation is over, run `node workspace/bin/live-notes.js close --repo . --session <id>`. It appends a section to today's requirements note and deletes the raw transcript.
    Done when: the command printed the note path and "transcript: deleted", or the retention date the PM set.
-7. Record the speakers in People. For each named speaker other than the PM, write one sighting: {"source": "live", "handle": {"kind": "speaker", "value": "<the speaker's name as the transcript gives it>"}, "name": "<display name>", "interaction": {"date": "YYYY-MM-DD", "kind": "Meeting" (or "1:1" when only the PM and this speaker talk), "text": "<what this speaker raised, in your words, at most 200 characters>", "pointer": "<wispr:meeting id, or the segments file> · <date>", "tone": "warm|neutral|cautious|tense" (only when the exchange shows one), "initiative": "<the initiative id their points were placed on, or omit>"}}. Tone describes the exchange, not the person. Never copy what the speaker said. Put the sightings in one file {"sightings": [...]} in the scratch folder and run `pmos people record --file <that file>` once. A speaker with no name ("Speaker 2") is not recorded.
+7. Record the speakers in People. For each named speaker, and each person the meeting names as the owner of an action, other than the PM, write one sighting (for a named owner, the handle kind is "name" and the interaction kind is "Mention"): {"source": "live", "handle": {"kind": "speaker", "value": "<the speaker's name as the transcript gives it>"}, "name": "<display name>", "interaction": {"date": "YYYY-MM-DD", "kind": "Meeting" (or "1:1" when only the PM and this speaker talk), "text": "<what this speaker raised, in your words, at most 200 characters>", "pointer": "<wispr:meeting id, or the segments file> · <date>", "tone": "warm|neutral|cautious|tense" (only when the exchange shows one), "initiative": "<the initiative id their points were placed on, or omit>"}}. Tone describes the exchange, not the person. Never copy what the speaker said. Put the sightings in one file {"sightings": [...]} in the scratch folder and run `pmos people record --file <that file>` once. A speaker with no name ("Speaker 2") is not recorded.
    Done when: the command printed how many sightings it recorded, or you said no speaker was named.
 8. Finish by saying in two lines how many points were placed, how many are still unanswered, which path ran, how many people you recorded, and which sources were not reached. Do not commit; the PM's Sync carries the files.
    Done when: the two lines are said once and no commit was made.