create-pmos 0.61.1 → 0.63.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.61.1",
+  "version": "0.63.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@05e2d82
+kernel-source: pmos@8370b9c
 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-06T16:49:07Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T17:30:54Z"}
 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-06T16:49:07Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T17:30:54Z"}
 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-06T16:49:07Z"}
+generated: {by: process:create-pmos, at: "2026-10-06T17:30:54Z"}
 status: stable
 ---
 

package/workspace/first-paint-audit.js

@@ -20,13 +20,15 @@
 // The budgets start at specimen A's counts. reports: 14 → 15 in Run 6 for Present, the one control the PM asked to keep
 // with the slides (2026-10-06). Every place +1 for Docs in the top bar (the PM, 2026-10-06, docs-three-way-sync): the
 // budget is for the whole screen and the bar is on every screen. The calibration stays specimen A's own count: the
-// specimen did not change.
+// specimen did not change. Every place +1 again for People in the top bar (the PM, 2026-10-06, people-directory).
 const SPECIMEN_A = Object.freeze({ today: 17, initiatives: 24, board: 33, reports: 14 });
 const BAR_DOCS = 1;
+const BAR_PEOPLE = 1;
+const BAR = BAR_DOCS + BAR_PEOPLE;
 // Agenda opens on the month (the PM's Agenda mockup v5, 2026-10-06): the month adds its own controls to Today's budget,
 // at most six week rows of a week button and seven days, the two month arrows and the five lenses.
 const AGENDA_MONTH = 6 * 8 + 2 + 5;
-const EXPECT = Object.freeze({ today: 17 + BAR_DOCS + AGENDA_MONTH, initiatives: 24 + BAR_DOCS, board: 33 + BAR_DOCS, reports: 15 + BAR_DOCS });
+const EXPECT = Object.freeze({ today: 17 + BAR + AGENDA_MONTH, initiatives: 24 + BAR, board: 33 + BAR, reports: 15 + BAR });
 
 /* ── shoot.js audit(), copied verbatim (scratchpad/specimens2/shoot.js, 2026-10-05) ─────────────────────────────── */
 // runs in the page

package/workspace/guide/index.md

@@ -12,8 +12,8 @@ This guide describes the PMOS workspace as it works today. It ships with the app
 
 On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 
-1. **The top bar.** Repository ▾, the five places (Docs included), search (⌘K), Sync when the repository is not in sync, and Settings.
-2. **The place.** One of Agenda, Initiatives, Board or Reports, or Docs (⌘K or `g d`). It fills the screen under the bar.
+1. **The top bar.** Repository ▾, the six places (Docs and People included), search (⌘K), Sync when the repository is not in sync, and Settings.
+2. **The place.** One of Agenda, Initiatives, Board or Reports, or Docs (⌘K or `g d`), or People (⌘K or `g p`). It fills the screen under the bar.
 3. **The detail.** The item you opened: an initiative with its status, next steps and artifacts, or the profiles. It opens beside the place and closes with ×.
 4. **The agent dock.** Terminals, documents, conversations and web pages. It is open on Agenda and a thin rail elsewhere.
 
@@ -27,7 +27,8 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 | The items of an initiative | Board, or Breakdown in the initiative detail |
 | Run reports | Reports |
 | Whether a document is the same as its Google Docs or Confluence copy | Docs: ⌘K → **Docs**, or press `g d` |
-| Repositories, Profiles, New sessions (the default CLI and model), Validate consent, Theme | Settings |
+| The people you work with: who they are, your interactions, their tone, your notes and shared work | People: ⌘K → **People**, or press `g p` |
+| Repositories, Profiles, New sessions (the default CLI and model), Validate consent, People (calendar names), Theme | Settings |
 | Validate | Settings, under Validate consent: **Open Validate** |
 | A document, a decision record, a memory entry, a page of this guide | ⌘K, with its scope: Knowledge, Memory or Guide |
 | A report across every repository | ⌘K: Portfolio report |
@@ -37,6 +38,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 
 - [Start the workspace without a terminal](launcher.md): the PMOS app, the login item and `pmos launcher`.
 - [Jira tickets](jira.md): Jira tickets drafted from the PRD, pushed when you select them, and their status.
+- [People](people.md): the people you work with in a repository, how they get there, and `pmos people`.
 - [Docs](docs.md): whether each linked document is the same as, ahead of or behind its Google Docs and Confluence copy.
 - [Layout](layout.md): the frame, the keys and the rule for where a list or a detail opens.
 - [Statuses](statuses.md): what each status means, where it comes from, and what you can change.
@@ -46,6 +48,7 @@ On a desktop the workspace is one frame. [Layout](layout.md) explains each part.
 - [Validate a repository](validate-with-typesafe.md): what each kind of document is compared with, how to read the verdict, and what leaves your machine.
 - [Today and the proactive engine](proactive-engine.md): what Today finds, what you can do with an item, the settings, the commands and the limits.
 - [Live notes](live-notes.md): take notes in a meeting, confirm each talking point, and what goes to Jev when you turn it on.
+- [Notes](notes.md): listen to a meeting on this machine, see decisions, actions and questions caught and checked against the repository, and get a summary.
 - [Find knowledge without reading whole files](knowledge-graph.md): what `pmos kg` finds, its commands, how to read its numbers, and its limits.
 - [Initiatives: the Roadmap, the List and the initiative sheet](initiatives-screen.md): how to read and order the initiatives of a repository, open the sheet, make a new initiative, and review the cycle.
 - [Initiatives and the Roadmap: Now, Next and Later](initiatives-roadmap.md): what day one shows, how an agent proposes a move, and `pmos initiative` and `pmos measure` from a terminal.

package/workspace/guide/layout.md

@@ -15,7 +15,7 @@ The top bar has these parts, from left to right:
 
 - **Repository ▾** names the current repository. Press it to choose another repository, or **All repositories** to see the work of every repository at once. All repositories replaces the old Portfolio mode.
 - **Branches and sessions** is in ⌘K. It opens a sheet with every branch of the repository (main first) and how many sessions run in each. Press a branch to see its sessions, open one, end one, or start a session there. **＋ branch** makes a branch, and **＋ session** starts one with a branch, an agent and a profile. With All repositories, the sheet lists every repository.
-- **Agenda, Initiatives, Board, Reports and Docs** are the five places. Press one to show it. The Agenda count shows how many items need you. Docs shows whether each document is the same as its Google Docs and Confluence copy.
+- **Agenda, Initiatives, Board, Reports, Docs and People** are the six places. Press one to show it. The Agenda count shows how many items need you. Docs shows whether each document is the same as its Google Docs and Confluence copy. People shows the people you work with in the repository ([People](people.md)).
 - **Search or capture ⌘K** opens the command palette. Type to find an initiative, a repository, an open tab or a command.
 - **Sync** shows only when the current repository is not in sync with its remote. Press it to fetch, bring in the work of the other machine, record your changes and push. If the repository has not fetched in the last 10 minutes, Sync also shows, because a push from another machine is not visible until a fetch. When the repository fetched recently and is in sync, Sync is not shown. If Sync stops, the message names the step that stopped.
 - **Sync on its own.** If you forget to press Sync, the workspace syncs for you. It syncs each repository once when the workspace starts. It also syncs a repository that has records not yet pushed when no record changed for 5 minutes. In a document repository it syncs every changed file on any branch. In a code repository it syncs only on the default branch (for example `main`), and only when every commit not yet pushed changes records and no code. If you close the tab while records are not yet pushed, the browser asks you first. To turn automatic sync off, start the workspace with `PMOS_AUTO_SYNC=0`.
@@ -25,12 +25,13 @@ Each place is drawn when its run is built. Until then the place says which run b
 
 ## Settings
 
-Settings holds settings only, in seven sections:
+Settings holds settings only, in eight sections:
 
 - **Repositories**: every registered repository. Press a repository to make it the current one. Press its ⋯ for **Rename** or **Remove from PMOS**. Each asks in a sheet, and a remove asks you to confirm. **Add repository** shows the scan of a folder before you add it.
 - **Profiles**: the Claude profiles a session can start with. They open in the detail.
 - **New sessions**: the default CLI and the default model for a new session in the dock.
 - **Validate consent**: the consent of the current repository. Turn it on or off here. **Open Validate** opens the Validate page as a tab.
+- **People**: whether the morning brief keeps attendee names from the calendar for the current repository. It is off until you turn it on. Turning it off also hides the names recorded before.
 - **Online**: puts this workspace at your own address, such as `pmos.pm-os.app`, through a Cloudflare tunnel. Enter the public address, the tunnel name, your Cloudflare team domain, the Access audience (AUD) tag and your email, then press **Turn on**. The workspace runs the tunnel and remembers the switch when it restarts. On your phone, open the address and sign in with Cloudflare Access (Google or an email code). The workspace does not ask for its token there. Only the computer that runs the workspace can change this section. A phone sees whether it is on. When a sign-in at the address is refused, this section names the check that failed, such as the email or the AUD tag. [REMOTE.md](../REMOTE.md) has the one-time Cloudflare steps.
 - **Theme**: Dark or Light.
 - **Updates**: the version of the workspace app and the version of the kit in the current repository. Press **Check for updates** to compare them with the latest published version of PMOS. This is the only time the workspace asks the internet for a version, and it asks only when you press. When a newer version is available, one button shows: **Update to** and the version. It updates every part that is older, in this order:
@@ -75,7 +76,7 @@ The workspace is neutral. A primary button is the text colour on the page colour
 
 | Key | What it does |
 |---|---|
-| g t, g i, g b, g r, g d | Show Agenda, Initiatives, Board, Reports or Docs. |
+| g t, g i, g b, g r, g d, g p | Show Agenda, Initiatives, Board, Reports, Docs or People. |
 | ⌘K (Ctrl-K) | Open or close the command palette. |
 | ⌘J (Ctrl-J) | Open or fold the dock. |
 | ⌘⇧J (Ctrl-Shift-J) | Focus: give the dock the whole window, or show the place again. |
@@ -126,7 +127,7 @@ The address options `?layout=legacy` and `?fixture=cockpit` keep the older layou
 
 The rail is 64 pixels wide and shows one tile for each repository. A dot on a tile means that repository has something that needs you. The selected repository has no dot, because the list beside it shows what needs you. The `+` tile adds a repository. The rail has no tools menu: the repository list and Validate are in Settings, and everything else is in ⌘K.
 
-Today, Validate, live notes and Add repository open as a tab, not in place of the list. Choose the same one again and the existing tab comes to the front.
+Today, Validate, live notes, notes and Add repository open as a tab, not in place of the list. Choose the same one again and the existing tab comes to the front.
 
 Press ⌘K (Ctrl-K) to jump to anything: an initiative, a repository, an open tab, a session or a tool. Type to filter, use the arrow keys to choose, and press Enter. Esc closes it.
 

package/workspace/guide/notes.md

@@ -0,0 +1,72 @@
+---
+type: Guide
+title: "Guide: notes"
+description: "How to take notes in a meeting: listen to your microphone and the meeting on this machine, see decisions, actions and questions caught as they are said, check them against the repository, and get a summary."
+timestamp: 2026-10-06
+---
+
+# Guide: notes
+
+The Notes view is one screen for one meeting. Your own notes are on the left, with the decisions, actions and questions that the workspace catches while people talk. The transcript is on the right. Notes are kept on this machine, outside every repository.
+
+## Start a meeting
+
+1. Press ⌘K, type **notes** and press Enter. The view opens as a tab. It is the same in every repository.
+2. Press **New meeting**. Type a title. Type your own notes in the box below it; they steer the summary. The note saves itself when you stop typing.
+3. Press **All notes** to open an earlier note. Press the settings button for local transcription, Jev, private and delete.
+
+## Listen
+
+1. Press **Listen**. Select what to listen to:
+   - **My microphone**: what you say.
+   - **The meeting**: the other people in an online meeting. Select the meeting's tab or window next, and tick **Share tab audio**.
+2. Press **Start**. The header shows a red dot, the time, and the sources. Tell people that you are taking notes.
+3. Each line shows in the transcript a few seconds after it is said, with who said it, the time and its label. Your lines are **You**. The meeting's lines are **Meeting**: click the name to change it. The transcript cannot tell the people in the meeting apart.
+4. Press **Stop** to end. The summary shows at the top of your notes.
+
+The meeting can only be heard when local transcription is set up. Until then, **Listen** hears your microphone only, through the browser's own recognition on this device.
+
+## What is caught
+
+Each line gets a label: decision, action, question, topic, statement or small talk. Decisions, actions and questions go into their sections as they are said. After **Stop**, statements with a number go under **Facts mentioned**.
+
+- To remove an item that does not belong, press the **x** beside it.
+- When a caught line is about something in the repository, the closest file shows beside it: **see** the file, a check mark when Jev finds that the file says the same, or **≠** the file when Jev finds that the line says something different. Point at the mark to see the file and the line.
+
+## Set up local transcription
+
+Local transcription uses whisper.cpp, a free program that runs on your machine. A Mac with Apple silicon (M1 or later) and 8 GB of memory is enough. The model is about 1.6 GB on disk and uses about 3 GB of memory while it runs.
+
+1. Open the settings and press **Set up in a terminal**. A terminal opens with the setup commands typed in. They install whisper.cpp with Homebrew and download the model into the workspace's own folder.
+2. Read the commands and press Enter in the terminal. The workspace does not run them for you.
+3. When the download is done, open the settings again. It says **Whisper is set up**.
+
+## Use Jev for labels and checks
+
+Without Jev, the workspace labels each line with its own rules and finds the closest file by shared words. Jev labels better and can say whether a line agrees with the file.
+
+1. Save a TypeSafe key and switch on validation for the repository (see [Validate with TypeSafe](validate-with-typesafe.md)).
+2. Open the settings and switch on **Label lines with Jev**. Switch on **Check notes against this repository with Jev** for the checks too. Both are off until you switch them on, for each repository.
+
+With the switches on, each line goes to TypeSafe for its label. For a caught line, that line and one passage of the closest file go too. Audio, speaker names and private notes never go. A line that looks like a secret is not sent.
+
+## Dictate into your notes
+
+1. Put the cursor where the text must go, then press **Dictate** and speak.
+2. Say **new line** or **new paragraph** to start one. Say **scratch that** to remove the phrase you just said.
+3. Press **Stop dictating** when you are done.
+
+## Copy, private and delete
+
+- **Copy as Markdown** puts the title, the summary, your notes, the caught items and the transcript on the clipboard.
+- In the settings, **Mark private** stops listening at once. A private note is not recorded again, and nothing from it goes to Jev or to an agent. **Mark not private** undoes it.
+- **Summary by agent** starts an agent session in the selected repository that writes a summary into the note. Lines that look like a secret are removed first.
+- **Delete** removes the note, its transcript and its summaries from this machine after you confirm. You cannot undo it.
+
+## What stays on your machine
+
+- Audio never leaves this machine. The page sends it to the workspace on this machine, which gives it to whisper.cpp in a temporary file and deletes the file at once. The browser's own recognition is used only on the device, never in the cloud.
+- Notes are files in the workspace's own folder on this machine (`notes/` in the state folder). They are never written into a repository.
+- Only Jev, with the switches on, and **Summary by agent**, when you press it, receive any text from a note.
+
+Live notes is a different tool: it maps each talking point to an initiative. See [Live notes](live-notes.md).

package/workspace/guide/people.md

@@ -0,0 +1,70 @@
+---
+type: Guide
+title: "People: the people you work with in a repository, their interactions, tone, notes and shared work"
+timestamp: 2026-10-06
+---
+
+# People
+
+Open People from the top bar, from ⌘K (**People**), or press `g p`.
+
+People lists the people you work with in the current repository. For each person it shows who they are, your interactions with them and where each one came from, the tone of those interactions, your own notes, and the work you share.
+
+## 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:
+
+- **Gather requirements** records the author of each item it gathers.
+- **Live notes** records each named speaker.
+- **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).
+
+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.
+
+A sighting does not make a person. New people wait for you in **Waiting for you** at the top of People.
+
+## 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.
+
+## The list
+
+Type in **Find a person** to search names, handles and initiatives. **All**, **Team** and **External** filter the list. **Latest**, **Most** and **Name** sort it by the last interaction, the number of interactions or the name. Press a person to open their page beside the list.
+
+## A person's page
+
+- **Interactions.** Newest first. Each line shows the date, the kind (Mail, Chat, Meeting, 1:1, Jira, Doc, Call or Mention), the line, and where it came from with its pointer and tone.
+- **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.
+
+## Ways in from other places
+
+- **Agenda.** A meeting's detail shows a link for each person its attendee line names.
+- **Initiative sheet.** The **People** tab lists the people whose interactions name the initiative or who own one of its items.
+- **Item sheet.** When an item's owner is a person in People, the owner is a link to their page.
+
+A link matches a full name, a first name of three letters or more, or a handle, as a whole word. Two people with the same first name both match.
+
+## Settings
+
+Settings has a **People** section for the current repository. **Keep attendee names from the calendar** is off until you turn it on. While it is off, the morning brief records nobody from the calendar, `pmos people record` refuses calendar sightings, and names recorded before stay hidden.
+
+## Where People keeps its records
+
+People keeps one append-only file, `people.jsonl`, in the repository's state directory (`pmos/state/` in a product repository). Sync sends it with your other records, so People is the same on every machine that syncs the repository. Every clone of the repository can read your tone choices and notes. Keep them to work context.
+
+## Commands
+
+- `pmos people list` lists each person with their role, interactions and tone, and the new people waiting for you. Add `--json` for the whole view.
+- `pmos people show <person>` shows one person's page: interactions, tone, shared work, notes and handles. `<person>` is the id from the list or the full name.
+- `pmos people record --file <sightings.json>` records the people a session saw. Agent sessions run it. It must name who recorded it: in a workspace session the session token does this; outside the workspace, add `--by <profile>`. A sighting already recorded is skipped and counted.
+- `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" }`.
+
+No command adds a person, ignores or merges a handle, sets a tone or writes a note. Do those in People.

package/workspace/lib/calendar-memory.js

@@ -90,6 +90,7 @@ function validateMemory(raw, { now = Date.now() } = {}) {
     if (e.series !== undefined && !str(e.series, 200)) return { ok: false, error: `${at}: series is a text of at most 200 characters` };
     if (e.attendees !== undefined && !(Number.isInteger(e.attendees) && e.attendees >= 0 && e.attendees <= 1000)) return { ok: false, error: `${at}: attendees is a whole number from 0 to 1000` };
     for (const b of ['external', 'exec']) if (e[b] !== undefined && typeof e[b] !== 'boolean') return { ok: false, error: `${at}: ${b} is true or false` };
+    if (e.with !== undefined && !str(e.with, 120)) return { ok: false, error: `${at}: with is one line of at most 120 characters` };
     if (e.role !== undefined && !ROLES.includes(e.role)) return { ok: false, error: `${at}: role is one of ${ROLES.join(', ')}` };
     const past = f <= now;
     if (e.notes !== undefined) {
@@ -107,7 +108,7 @@ function validateMemory(raw, { now = Date.now() } = {}) {
     if (ids.has(id)) return { ok: false, error: `${at}: two events have the same start and title` };
     ids.add(id);
     const out = { id, start: new Date(s).toISOString(), end: new Date(f).toISOString(), title };
-    for (const k of ['series', 'attendees', 'external', 'exec', 'role', 'notes', 'open', 'prep', 'prep_done']) if (e[k] !== undefined) out[k] = e[k];
+    for (const k of ['series', 'attendees', 'external', 'exec', 'role', 'with', 'notes', 'open', 'prep', 'prep_done']) if (e[k] !== undefined) out[k] = e[k];
     events.push(out);
   }
   events.sort((a, b) => Date.parse(a.start) - Date.parse(b.start));

package/workspace/lib/jev-notes.js

@@ -0,0 +1,162 @@
+'use strict';
+/* jev-notes.js — the one bridge from the Notes view to Jev (meeting-notes Run 2, D91).
+ *
+ *   gatesFor(key, flags) · checkGatesFor(key, flags) · senderFor(key, flags, askOpts) · infoFor(present, flags)
+ *   label({ ask, key, askOpts, text, pause })            → { cat, p } | { cat: null, reason }
+ *   compare({ ask, key, askOpts, text, passage, pause }) → { verdict: 'agrees'|'differs'|'related', words } | { verdict: null, reason }
+ *   getSwitch(runtimeDir, root) · setSwitch(runtimeDir, root, { jev, check })
+ *
+ * WHAT MAY LEAVE THE MACHINE. For a label: one cleaned transcript line and one Choice question. For a check: the line and
+ * ONE repository passage (lib/notes-repo.js closest, at most 1,200 characters) and two Noul questions. Only through
+ * lib/typesafe.js. Labels need three gates: a saved key, D79 consent for the repository and the switch "notes may use Jev".
+ * A check needs those and the switch "check notes against this repository". Both switches default off and live in the
+ * per-user runtime directory. Never sent: audio, a speaker's name, a line or passage the secret scan matches, a private
+ * note (the caller refuses it before this module), anything while paused.
+ *
+ * WHAT A RESULT IS. Advisory (D40), shown in words. A label under UNSURE_BELOW keeps the local label. A check says
+ * "agrees" or "differs" only above SURE; otherwise "related", which is what the local match alone also says.
+ *
+ * PAUSE. Two rejected keys or three failed asks in a row pause Jev for the repository until the server restarts or the
+ * PM turns a switch off and on again; the local labels carry on.
+ */
+const fs = require('fs');
+const path = require('path');
+const typesafe = require('./typesafe');
+const scanner = require('./secret-scan');
+
+const UNSURE_BELOW = 0.55;
+const SURE = 0.65;
+const REJECTED_LIMIT = 2;
+const UNREACHABLE_LIMIT = 3;
+const NOTES_ASK = { timeoutMs: 10000, retries: 1, backoffMs: 400 };
+
+const CATS = {
+  decision: 'A decision: something the group agreed, chose, approved or ruled out.',
+  action: 'An action item: a task someone will do, or is asked to do, often with an owner or a due day.',
+  question: 'An open question the meeting raises and has not answered.',
+  topic: 'A topic explanation: it introduces or explains what is being discussed, or moves to a new subject.',
+  statement: 'A statement of fact, data, a claim or an opinion about the work.',
+  'small talk': 'Small talk, a greeting, thanks, or talk about the meeting itself.',
+};
+const LABEL_INSTRUCTIONS = 'This is one line from a meeting transcript. Which kind of line is it?';
+const SAME_Q = 'Does the PASSAGE from the repository already say what the MEETING LINE says?';
+const DIFF_Q = 'Does the MEETING LINE say something different from, or in conflict with, the PASSAGE from the repository (for example another number, date, owner or choice)?';
+
+/* ── gates and switches ─────────────────────────────────────────────────────────────────────────── */
+function gates({ key, consent, jev }) {
+  const missing = [];
+  if (!key) missing.push('key');
+  if (!consent) missing.push('consent');
+  if (!jev) missing.push('jev');
+  return { open: missing.length === 0, missing };
+}
+function checkGates({ key, consent, jev, check }) {
+  const g = gates({ key, consent, jev });
+  if (!check) g.missing.push('check');
+  return { open: g.missing.length === 0, missing: g.missing };
+}
+const GATE_WORDS = {
+  key: 'No TypeSafe key is saved.',
+  consent: 'Validation is not switched on for this repository.',
+  jev: 'Notes may not use Jev in this repository.',
+  check: 'Checking notes against this repository is off.',
+};
+const gateSentence = (missing) => missing.map((m) => GATE_WORDS[m]).join(' ');
+const gatesFor = (key, f) => gates({ key: typesafe.validKey(key), consent: !!(f && f.consent), jev: !!(f && f.jev) });
+const checkGatesFor = (key, f) => checkGates({ key: typesafe.validKey(key), consent: !!(f && f.consent), jev: !!(f && f.jev), check: !!(f && f.check) });
+
+/** { ask, check, askOpts }: `ask` sends labels and `check` is true when checks may also be sent. Both shut when a gate is. */
+function senderFor(key, flags, askOpts = {}) {
+  const g = gatesFor(key, flags);
+  if (!g.open) return { ask: null, check: false, gates: g, askOpts: {} };
+  return { ask: (a) => typesafe.ask(a), check: checkGatesFor(key, flags).open, gates: g, askOpts: { ...NOTES_ASK, ...askOpts } };
+}
+/** What the view needs to explain the two switches. Booleans and sentences only. */
+function infoFor(present, flags) {
+  const f = { key: !!present, consent: !!(flags && flags.consent), jev: !!(flags && flags.jev), check: !!(flags && flags.check) };
+  const l = gates(f); const c = checkGates(f);
+  return { jev: f.jev, check: f.check, label_open: l.open, check_open: c.open, missing: c.missing,
+    sentence: l.open ? (c.open ? null : gateSentence(c.missing.filter((m) => m === 'check'))) : gateSentence(l.missing) };
+}
+
+const readJson = (f, d) => { try { return JSON.parse(fs.readFileSync(f, 'utf8')); } catch { return d; } };
+const switchFile = (runtimeDir) => path.join(runtimeDir, 'notes', 'settings.json');
+function getSwitch(runtimeDir, root) {
+  const s = readJson(switchFile(runtimeDir), {});
+  const r = s && s.repos && root ? s.repos[root] : null;
+  return { jev: !!(r && r.jev === true), check: !!(r && r.check === true) };
+}
+function setSwitch(runtimeDir, root, { jev, check } = {}) {
+  const s = readJson(switchFile(runtimeDir), {});
+  const prev = getSwitch(runtimeDir, root);
+  const next = { jev: typeof jev === 'boolean' ? jev : prev.jev, check: typeof check === 'boolean' ? check : prev.check };
+  const f = switchFile(runtimeDir);
+  fs.mkdirSync(path.dirname(f), { recursive: true });
+  const tmp = f + '.' + process.pid + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify({ repos: { ...((s && s.repos) || {}), [root]: next } }), { mode: 0o600 });
+  fs.renameSync(tmp, f);
+  pauses.delete(root);
+  return next;
+}
+
+/* ── pause ─────────────────────────────────────────────────────────────────────────────────────── */
+const pauses = new Map();    // root → { rejected, unreachable, paused }
+const pauseOf = (root) => { if (!pauses.has(root)) pauses.set(root, { rejected: 0, unreachable: 0, paused: null }); return pauses.get(root); };
+function note(p, res) {
+  if (res.ok) { p.rejected = 0; p.unreachable = 0; return; }
+  if (res.status === 401) { p.rejected++; p.unreachable = 0; } else { p.unreachable++; p.rejected = 0; }
+  if (p.rejected >= REJECTED_LIMIT) p.paused = 'The service rejected the key twice, so Jev is paused for notes.';
+  else if (p.unreachable >= UNREACHABLE_LIMIT) p.paused = 'The service could not be reached three times in a row, so Jev is paused for notes.';
+}
+const secretIn = (...texts) => texts.some((t) => scanner.scan(String(t || '')).length > 0);
+
+/* ── asking ────────────────────────────────────────────────────────────────────────────────────── */
+function choiceProbs(ans) {
+  const probs = {};
+  const put = (k, v) => { const n = Number(v); if (typeof k === 'string' && Number.isFinite(n)) probs[k.toLowerCase()] = n; };
+  if (!ans || typeof ans !== 'object') return probs;
+  const raw = ans.probabilities || ans.distribution;
+  if (Array.isArray(raw)) { for (const x of raw) if (x && typeof x === 'object') put(x.option || x.label || x.choice, x.probability != null ? x.probability : x.p); }
+  else if (raw && typeof raw === 'object') for (const [k, v] of Object.entries(raw)) put(k, v);
+  if (!Object.keys(probs).length && typeof ans.choice === 'string') put(ans.choice, ans.confidence != null ? ans.confidence : 1);
+  return probs;
+}
+
+/** One line's label from Jev. The caller has checked the private flag; this checks the pause and the scan. */
+async function label({ ask, key, askOpts = {}, text, root = '' }) {
+  const p = pauseOf(root);
+  if (!ask) return { cat: null, reason: 'off' };
+  if (p.paused) return { cat: null, reason: 'paused', sentence: p.paused };
+  if (secretIn(text)) return { cat: null, reason: 'withheld' };
+  const res = await ask({ key, state: String(text).slice(0, 2000), questions: { kind: { type: 'choice', instructions: LABEL_INSTRUCTIONS, criteria: CATS } }, ...askOpts });
+  note(p, res);
+  if (!res.ok) return { cat: null, reason: 'failed', sentence: res.reason || null };
+  const probs = choiceProbs(res.answers && res.answers.kind);
+  const top = Object.entries(probs).filter(([k]) => CATS[k]).sort((a, b) => b[1] - a[1])[0];
+  if (!top || top[1] < UNSURE_BELOW) return { cat: null, reason: 'unsure' };
+  return { cat: top[0], p: top[1], model: res.model || null };
+}
+
+const wordsFor = (v) => (v >= 0.85 ? 'very likely' : 'likely');
+/** One captured line against one passage. */
+async function compare({ ask, key, askOpts = {}, text, passage, root = '' }) {
+  const p = pauseOf(root);
+  if (!ask) return { verdict: null, reason: 'off' };
+  if (p.paused) return { verdict: null, reason: 'paused', sentence: p.paused };
+  if (!passage || !passage.text) return { verdict: null, reason: 'nothing' };
+  if (secretIn(text, passage.text)) return { verdict: null, reason: 'withheld' };
+  const state = 'MEETING LINE:\n' + String(text).slice(0, 2000) + '\n\nPASSAGE (' + passage.path + '):\n' + String(passage.text).slice(0, 1200);
+  const res = await ask({ key, state, questions: { same: { type: 'noul', instructions: SAME_Q }, differs: { type: 'noul', instructions: DIFF_Q } }, ...askOpts });
+  note(p, res);
+  if (!res.ok) return { verdict: null, reason: 'failed', sentence: res.reason || null };
+  const num = (a) => { const v = a && (a.type == null || a.type === 'noul') ? Number(a.noul) : NaN; return Number.isFinite(v) && v >= 0 && v <= 1 ? v : null; };
+  const same = num(res.answers && res.answers.same); const diff = num(res.answers && res.answers.differs);
+  if (same == null && diff == null) return { verdict: null, reason: 'unreadable' };
+  if (diff != null && diff >= SURE && (same == null || diff > same)) return { verdict: 'differs', words: wordsFor(diff), model: res.model || null };
+  if (same != null && same >= SURE) return { verdict: 'agrees', words: wordsFor(same), model: res.model || null };
+  return { verdict: 'related', words: null, model: res.model || null };
+}
+function pauseStatus(root) { const p = pauses.get(root); return p && p.paused ? p.paused : null; }
+
+module.exports = { gates, checkGates, gatesFor, checkGatesFor, gateSentence, senderFor, infoFor, getSwitch, setSwitch, label, compare, choiceProbs, pauseStatus,
+  CATS, UNSURE_BELOW, SURE, REJECTED_LIMIT, UNREACHABLE_LIMIT };

package/workspace/lib/notes-repo.js

@@ -0,0 +1,133 @@
+'use strict';
+/* notes-repo.js — find the repository passage a meeting line is about (meeting-notes Run 2, D91). Local and read-only.
+ *
+ *   passages(root, { exclude }) → [{ path, line, text }]      the repository's Markdown paragraphs, cached for a minute
+ *   closest(root, text, { exclude }) → { path, line, text, shared } | null
+ *
+ * WHAT IT READS. Every tracked-looking Markdown file under the repository root, skipping dependency, build and hidden
+ * folders, at most MAX_FILES files and MAX_FILE_BYTES each. A paragraph is a run of non-blank lines outside frontmatter
+ * and code fences, cut to PASSAGE_MAX characters. An excluded path (D79 exclusions) is never read.
+ *
+ * HOW IT MATCHES. Content words and numbers shared with the line, each weighted by how rare it is across the paragraphs.
+ * A passage counts only when it shares at least MIN_SHARED words and scores at least MIN_SCORE, so a line about nothing
+ * in particular finds nothing. Numbers count as words: "a 14-day trial" and "21 days" are what a consistency check is for.
+ *
+ * WHAT IT NEVER DOES. It writes nothing and sends nothing. The Jev check (lib/jev-notes.js) decides what leaves.
+ */
+const fs = require('fs');
+const path = require('path');
+const settings = require('./typesafe-settings');
+
+const MAX_FILES = 3000;
+const MAX_FILE_BYTES = 512 * 1024;
+const PASSAGE_MAX = 1200;
+const MIN_SHARED = 3;
+const MIN_SCORE = 3;
+const CACHE_MS = 60000;
+const SKIP = new Set(['node_modules', '.git', 'vendor', 'dist', 'build', 'out', 'coverage', '.next', 'tmp', 'payload']);
+
+const STOP = new Set(('the and for are but not you all any can had her was one our out has have this that with from they will would there their what '
+  + 'about which when make like time just know take into year your some could them than then look only come its over think also back after use '
+  + 'two how work first well way even want because these give most should does did done been being were yeah okay right really thing things '
+  + 'going gonna said say says very much more less here where who why let lets get got need needs maybe sure good great thanks thank '
+  + 'today week next last new old same other each every into onto upon per via yes no').split(/\s+/));
+const NUM_WORDS = { one: '1', two: '2', three: '3', four: '4', five: '5', six: '6', seven: '7', eight: '8', nine: '9', ten: '10', eleven: '11', twelve: '12',
+  thirteen: '13', fourteen: '14', fifteen: '15', sixteen: '16', seventeen: '17', eighteen: '18', nineteen: '19', twenty: '20', thirty: '30', forty: '40', fifty: '50' };
+const stem = (w) => {
+  const x = w.replace(/'s$/, '');
+  if (/(?:ing|ed|es)$/.test(x)) return x.replace(/(?:ing|ed|es)$/, (s) => (x.length - s.length >= 4 ? '' : s));
+  return /[^s]s$/.test(x) && x.length >= 4 ? x.slice(0, -1) : x;
+};
+/** Content words and numbers. "twenty-one" is 21; "14-day" is 14 and day. */
+function termsOf(text) {
+  const t = String(text || '').toLowerCase().replace(/\b(twenty|thirty|forty|fifty)[- ](one|two|three|four|five|six|seven|eight|nine)\b/g,
+    (m, a, b) => String(Number(NUM_WORDS[a]) + Number(NUM_WORDS[b])));
+  const out = [];
+  for (const raw of t.match(/[\p{L}\p{N}']+/gu) || []) {
+    const w = NUM_WORDS[raw] || raw;
+    if (/^\d+$/.test(w)) { out.push(w); continue; }
+    if (w.length < 3 || STOP.has(w)) continue;
+    out.push(stem(w));
+  }
+  return out;
+}
+
+function walk(root, exclude) {
+  const out = [];
+  const go = (dir) => {
+    if (out.length >= MAX_FILES) return;
+    let ents = [];
+    try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of ents) {
+      if (out.length >= MAX_FILES) return;
+      if (e.name.startsWith('.') || SKIP.has(e.name)) continue;
+      const p = path.join(dir, e.name);
+      const rel = path.relative(root, p).split(path.sep).join('/');
+      if (settings.isExcluded(exclude, rel)) continue;
+      if (e.isDirectory()) go(p);
+      else if (e.isFile() && /\.md$/i.test(e.name)) out.push(rel);
+    }
+  };
+  go(root);
+  return out;
+}
+function paragraphsOf(rel, text) {
+  const out = [];
+  const lines = String(text).split(/\r?\n/);
+  let i = 0;
+  if (lines[0] === '---') { i = 1; while (i < lines.length && lines[i] !== '---') i++; i++; }
+  let fence = false; let buf = []; let start = 0;
+  const end = () => { if (buf.length) { const t = buf.join(' ').replace(/\s+/g, ' ').trim(); if (t.length >= 30) out.push({ path: rel, line: start + 1, text: t.slice(0, PASSAGE_MAX) }); } buf = []; };
+  for (; i < lines.length; i++) {
+    const l = lines[i];
+    if (/^\s*(```|~~~)/.test(l)) { end(); fence = !fence; continue; }
+    if (fence) continue;
+    if (!l.trim() || /^#{1,6}\s/.test(l) || /^\s*\|?\s*-{3,}/.test(l)) { end(); continue; }
+    if (!buf.length) start = i;
+    buf.push(l.replace(/^\s*(?:[-*+]|\d+[.)])\s+/, ''));
+  }
+  end();
+  return out;
+}
+
+const cache = new Map();     // root → { at, key, items, df }
+function index(root, { exclude = [], now = Date.now() } = {}) {
+  const key = JSON.stringify(exclude);
+  const hit = cache.get(root);
+  if (hit && hit.key === key && now - hit.at < CACHE_MS) return hit;
+  const items = [];
+  for (const rel of walk(root, exclude)) {
+    let text = '';
+    try { const st = fs.statSync(path.join(root, rel)); if (st.size > MAX_FILE_BYTES) continue; text = fs.readFileSync(path.join(root, rel), 'utf8'); } catch { continue; }
+    for (const p of paragraphsOf(rel, text)) items.push({ ...p, terms: new Set(termsOf(p.text)) });
+  }
+  const df = new Map();
+  for (const it of items) for (const w of it.terms) df.set(w, (df.get(w) || 0) + 1);
+  const ix = { at: now, key, items, df };
+  cache.set(root, ix);
+  return ix;
+}
+function passages(root, opts = {}) { return index(root, opts).items.map(({ path: p, line, text }) => ({ path: p, line, text })); }
+
+/** The passage that shares the most rare words with `text`, or null when none shares enough. */
+function closest(root, text, { exclude = [], now = Date.now() } = {}) {
+  if (!root) return null;
+  const ix = index(root, { exclude, now });
+  const q = new Set(termsOf(text));
+  if (q.size < MIN_SHARED) return null;
+  const n = ix.items.length || 1;
+  let best = null;
+  for (const it of ix.items) {
+    let s = 0; const shared = [];
+    // a shared word counts 1, more when it is rare in the repository; a long passage is not favoured for its length
+    for (const w of q) if (it.terms.has(w)) { s += 1 + Math.log(n / (ix.df.get(w) || 1)); shared.push(w); }
+    if (shared.length < MIN_SHARED || s < MIN_SCORE) continue;
+    const rank = s / Math.sqrt(it.terms.size / 20 + 1);
+    if (!best || rank > best.rank) best = { path: it.path, line: it.line, text: it.text, shared, score: s, rank };
+  }
+  if (!best) return null;
+  return { path: best.path, line: best.line, text: best.text, shared: best.shared };
+}
+function clearCache() { cache.clear(); }
+
+module.exports = { passages, closest, termsOf, paragraphsOf, clearCache, PASSAGE_MAX, MIN_SHARED, MIN_SCORE };