create-pmos 0.155.0 → 0.157.0

package/README.md

@@ -20,6 +20,22 @@ You never need to write code. You need the courage to say what you want, and the
 
 ## Getting started (5 minutes)
 
+**New computer, nothing installed?** Paste one line. It installs what is missing (Node.js, git, Claude Code), makes a `PMOS` folder in your home folder, adds the kit and opens the PMOS app. No Homebrew, no WSL, and no admin password on Windows. Run it again at any time: it skips what is already there.
+
+Mac (Terminal):
+
+```bash
+curl -fsSL https://unpkg.com/create-pmos/install.sh | bash
+```
+
+Windows (PowerShell):
+
+```powershell
+powershell -ExecutionPolicy Bypass -c "iex ((New-Object Net.WebClient).DownloadString('https://unpkg.com/create-pmos/install.ps1'))"
+```
+
+The Mac line also works on Linux. On a Mac without git, Apple's Command Line Tools window opens once: click Install. The first agent session in the app asks you to sign in to Claude.
+
 **Have an existing project?**
 
 ```bash
@@ -98,7 +114,8 @@ Some machines lock down npm's global folder. If the activation prints a warning
 
 ### What to expect
 
-- **Requirements:** Node 18+. macOS, Linux, and Windows. Activation (`create-pmos workspace`) builds `node-pty` once with a C toolchain — most dev machines already have one; `pmos doctor` names the exact fix if not.
+- **Requirements:** Node 18+. macOS, Windows 10 (1809) or later, and Linux; Windows runs natively, with no WSL. On macOS and Windows `node-pty` ships prebuilt; on Linux, activation builds it once with a C toolchain. `pmos doctor` names the exact fix when something is missing. Setup CI runs the one-line setup on clean macOS, Windows and Linux runners.
+- **Not on Windows yet:** `pmos launcher on` (start at login), and meeting-notes transcription (its engine is Apple Silicon only).
 - **It's local and private.** The server binds `127.0.0.1` and is never exposed to the network. Your agent CLI (Claude Code, Codex, a plain shell) runs **untouched** — its own login, slash commands, and keybindings all work; the workspace is the terminal, not a wrapper.
 - **The gates are the same gates.** `approve` / `return` / `accept` in the GUI write the exact file-mode records (`state/acceptances.jsonl`) this kit already uses — only ever on your click. Nothing is recorded automatically.
 - **Works with or without the kit.** Best in a repo you've run `create-pmos` in (it reads and writes `pmos/state/`), but it opens any repo — a plain project just records into the server's own state.

package/bin/cockpit-install.js

@@ -84,7 +84,8 @@ const lstat = (p) => { try { return fs.lstatSync(p); } catch { return null; } };
 const real = (p) => { try { return fs.realpathSync(p); } catch { return null; } };
 
 /**
- * Link `.claude/skills/<name>` to `pmos/skills-native/<name>` for every kit skill that has none.
+ * Link `.claude/skills/<name>` to `pmos/skills-native/<name>` for every kit skill that has none
+ * (a relative symlink; a junction on Windows).
  * @returns {{ linked: string[], ok: string[], blocked: {name:string, reason:string}[], badDescription: string[], errors: string[] }}
  */
 function linkSkills(repoRoot) {
@@ -100,10 +101,14 @@ function linkSkills(repoRoot) {
     if (!descriptionHasText(text)) { out.badDescription.push(e.name); continue; }
 
     const link = path.join(dest, e.name);
-    const target = `../../pmos/skills-native/${e.name}`;
+    // Windows refuses a directory symlink unless Developer Mode is on or the shell is elevated. A
+    // junction needs neither; it takes an absolute target. Everywhere else the link stays relative,
+    // so the repository can move.
+    const target = process.platform === 'win32' ? path.join(native, e.name) : `../../pmos/skills-native/${e.name}`;
+    const type = process.platform === 'win32' ? 'junction' : 'dir';
     const st = lstat(link);
     if (st === null) {
-      try { fs.mkdirSync(dest, { recursive: true }); fs.symlinkSync(target, link, 'dir'); out.linked.push(e.name); }
+      try { fs.mkdirSync(dest, { recursive: true }); fs.symlinkSync(target, link, type); out.linked.push(e.name); }
       catch (err) { out.errors.push(`${e.name}: ${err.message}`); }
       continue;
     }
@@ -113,8 +118,8 @@ function linkSkills(repoRoot) {
       if (r === null) {
         let was = '';
         try { was = fs.readlinkSync(link); } catch { /* keep blocked */ }
-        if (/(^|\/)pmos\/skills-native\//.test(was)) {
-          try { fs.unlinkSync(link); fs.symlinkSync(target, link, 'dir'); out.linked.push(e.name); }
+        if (/(^|[\\/])pmos[\\/]skills-native[\\/]/.test(was)) {
+          try { fs.unlinkSync(link); fs.symlinkSync(target, link, type); out.linked.push(e.name); }
           catch (err) { out.errors.push(`${e.name}: ${err.message}`); }
           continue;
         }

package/install.ps1

@@ -0,0 +1,171 @@
+# PMOS one-line setup for Windows (initiative one-line-setup).
+#
+#   powershell -ExecutionPolicy Bypass -c "iex ((New-Object Net.WebClient).DownloadString('https://unpkg.com/create-pmos/install.ps1'))"
+#
+# Installs what is missing, makes a PMOS folder and opens the PMOS app. No admin rights, no WSL:
+#   1. Node.js   latest LTS from nodejs.org, into %LOCALAPPDATA%\PMOS\node
+#   2. git       the official Portable Git, into %LOCALAPPDATA%\PMOS\git (Claude Code needs its bash)
+#   3. Claude Code   its own installer, claude.ai/install.ps1
+#   4. the PMOS kit in %USERPROFILE%\PMOS   (npx create-pmos)
+#   5. the PMOS app   (npx create-pmos workspace), which opens in the browser
+# Every step checks first and skips what is already there, so running the line again is safe.
+#
+# Settings (environment variables):
+#   PMOS_DIR=<folder>     the PMOS folder (default: %USERPROFILE%\PMOS)
+#   PMOS_NO_OPEN=1        do not open the browser at the end
+#   PMOS_SKIP_CLAUDE=1    do not install Claude Code
+#   PMOS_PKG=<spec>       the create-pmos package to run (default: create-pmos@latest)
+
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'   # Invoke-WebRequest is many times slower with the progress bar on
+[Net.ServicePointManager]::SecurityProtocol = [Net.ServicePointManager]::SecurityProtocol -bor [Net.SecurityProtocolType]::Tls12
+
+$PmosHome = Join-Path $env:LOCALAPPDATA 'PMOS'
+$PmosDir = if ($env:PMOS_DIR) { $env:PMOS_DIR } else { Join-Path $env:USERPROFILE 'PMOS' }
+$PmosPkg = if ($env:PMOS_PKG) { $env:PMOS_PKG } else { 'create-pmos@latest' }
+$NodeMin = 18
+
+function Say($m) { Write-Host "==> $m" -ForegroundColor Cyan }
+function Ok($m) { Write-Host "    [ok] $m" -ForegroundColor Green }
+function Fail($m, $try) {
+  Write-Host ""
+  Write-Host "x $m" -ForegroundColor Red
+  if ($try) { Write-Host "  Try: $try" }
+  # A pasted line runs inside the user's own PowerShell window: throw instead of exit, so the window stays open.
+  throw "PMOS setup stopped: $m"
+}
+function Have($c) { [bool](Get-Command $c -ErrorAction SilentlyContinue) }
+
+# Put a folder on PATH now and for new windows (the user's own PATH; no admin needed).
+function Add-Path($dir) {
+  if (-not (($env:Path -split ';') -contains $dir)) { $env:Path = "$dir;$env:Path" }
+  $user = [Environment]::GetEnvironmentVariable('Path', 'User')
+  if (-not $user) { $user = '' }
+  if (-not (($user -split ';') -contains $dir)) {
+    [Environment]::SetEnvironmentVariable('Path', ($dir + ';' + $user).TrimEnd(';'), 'User')
+  }
+}
+function Get-File($url, $out) {
+  try { Invoke-WebRequest -Uri $url -OutFile $out -UseBasicParsing }
+  catch { Fail "Could not download $url" 'check the internet connection, then paste the line again' }
+}
+function Node-Major {
+  try { [int]((& node -p "process.versions.node.split('.')[0]") 2>$null) } catch { 0 }
+}
+
+$arch = if ($env:PROCESSOR_ARCHITECTURE -eq 'ARM64' -or $env:PROCESSOR_ARCHITEW6432 -eq 'ARM64') { 'arm64' } else { 'x64' }
+New-Item -ItemType Directory -Force -Path $PmosHome | Out-Null
+
+Write-Host ""
+Write-Host "PMOS setup - this installs what is missing and opens PMOS."
+Write-Host ""
+
+# --- 1. Node.js ---
+Say 'Checking Node.js'
+$nodeDir = Join-Path $PmosHome 'node'
+if (Test-Path (Join-Path $nodeDir 'node.exe')) { Add-Path $nodeDir }
+if ((Have node) -and ((Node-Major) -ge $NodeMin)) {
+  Ok "Node.js $(& node -v) is installed"
+} else {
+  Say "Installing Node.js (latest LTS) into $nodeDir"
+  try { $index = Invoke-RestMethod -Uri 'https://nodejs.org/dist/index.json' -UseBasicParsing }
+  catch { Fail 'Could not read the Node.js version list from nodejs.org.' 'check the internet connection, then paste the line again' }
+  $ver = ($index | Where-Object { $_.lts } | Select-Object -First 1).version
+  $zip = Join-Path $env:TEMP "node-$ver-win-$arch.zip"
+  Get-File "https://nodejs.org/dist/$ver/node-$ver-win-$arch.zip" $zip
+  $unz = Join-Path $env:TEMP "pmos-node-$ver"
+  if (Test-Path $unz) { Remove-Item -Recurse -Force $unz }
+  Expand-Archive -Path $zip -DestinationPath $unz -Force
+  if (Test-Path $nodeDir) { Remove-Item -Recurse -Force $nodeDir }
+  Move-Item -Path (Join-Path $unz "node-$ver-win-$arch") -Destination $nodeDir
+  Remove-Item -Force $zip; Remove-Item -Recurse -Force $unz -ErrorAction SilentlyContinue
+  Add-Path $nodeDir
+  Ok "Node.js $(& node -v) installed"
+}
+# Windows blocks PowerShell scripts by default, and npm's `pmos` and `npx` commands are partly scripts.
+# RemoteSigned for this user only (no admin) is the setting npm's own docs give.
+$policy = Get-ExecutionPolicy -Scope CurrentUser
+if ($policy -eq 'Undefined' -or $policy -eq 'Restricted') {
+  try { Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned -Force; Ok 'PowerShell may now run the pmos command (RemoteSigned, this user only)' }
+  catch { Write-Host "    note: could not change the PowerShell script setting; type pmos.cmd instead of pmos" }
+}
+# npm's global folder is where `pmos` lands. It must exist and be on PATH. It is %APPDATA%\npm unless
+# npm is set up otherwise, so ask npm.
+New-Item -ItemType Directory -Force -Path (Join-Path $env:APPDATA 'npm') | Out-Null
+$npmGlobal = ((& npm.cmd prefix -g) | Select-Object -Last 1).Trim()
+if (-not $npmGlobal) { $npmGlobal = Join-Path $env:APPDATA 'npm' }
+New-Item -ItemType Directory -Force -Path $npmGlobal | Out-Null
+Add-Path $npmGlobal
+
+# --- 2. git ---
+Say 'Checking git'
+$gitDir = Join-Path $PmosHome 'git'
+if (Test-Path (Join-Path $gitDir 'cmd\git.exe')) { Add-Path (Join-Path $gitDir 'cmd') }
+if (Have git) {
+  Ok (& git --version)
+} else {
+  Say "Installing Portable Git into $gitDir"
+  try {
+    $h = @{ 'User-Agent' = 'pmos-setup' }
+    if ($env:GITHUB_TOKEN) { $h['Authorization'] = "Bearer $env:GITHUB_TOKEN" }   # CI only: the anonymous rate limit is shared per address
+    $rel = Invoke-RestMethod -Uri 'https://api.github.com/repos/git-for-windows/git/releases/latest' -UseBasicParsing -Headers $h
+  } catch { Fail 'Could not read the Git for Windows release list from GitHub.' 'check the internet connection, then paste the line again' }
+  $want = if ($arch -eq 'arm64') { 'PortableGit-*-arm64.7z.exe' } else { 'PortableGit-*-64-bit.7z.exe' }
+  $asset = $rel.assets | Where-Object { $_.name -like $want } | Select-Object -First 1
+  if (-not $asset) { Fail 'Could not find Portable Git for this computer.' 'install Git from https://git-scm.com/download/win, then paste the line again' }
+  $exe = Join-Path $env:TEMP $asset.name
+  Get-File $asset.browser_download_url $exe
+  if (Test-Path $gitDir) { Remove-Item -Recurse -Force $gitDir }
+  # A self-extracting 7-Zip archive: -o is the target folder, -y answers yes. No installer, no admin.
+  $p = Start-Process -FilePath $exe -ArgumentList "-o`"$gitDir`"", '-y' -Wait -PassThru -WindowStyle Hidden
+  Remove-Item -Force $exe -ErrorAction SilentlyContinue
+  if ($p.ExitCode -ne 0 -or -not (Test-Path (Join-Path $gitDir 'cmd\git.exe'))) { Fail 'Portable Git did not unpack.' 'paste the line again' }
+  Add-Path (Join-Path $gitDir 'cmd')
+  Ok (& git --version)
+}
+# Claude Code runs its commands in Git Bash. Tell it where bash is when git came from Portable Git.
+$bash = Join-Path $gitDir 'bin\bash.exe'
+if ((Test-Path $bash) -and -not $env:CLAUDE_CODE_GIT_BASH_PATH) {
+  [Environment]::SetEnvironmentVariable('CLAUDE_CODE_GIT_BASH_PATH', $bash, 'User')
+  $env:CLAUDE_CODE_GIT_BASH_PATH = $bash
+}
+
+# --- 3. Claude Code ---
+Say 'Checking Claude Code'
+$claudeBin = Join-Path $env:USERPROFILE '.local\bin'
+if (Test-Path (Join-Path $claudeBin 'claude.exe')) { Add-Path $claudeBin }
+if ($env:PMOS_SKIP_CLAUDE -eq '1') {
+  Ok 'skipped (PMOS_SKIP_CLAUDE=1)'
+} elseif (Have claude) {
+  Ok 'Claude Code is installed'
+} else {
+  Say 'Installing Claude Code'
+  # A child PowerShell: the Claude Code installer may end its own session, which must not end this one.
+  & powershell -NoProfile -ExecutionPolicy Bypass -Command "irm https://claude.ai/install.ps1 | iex"
+  if (Test-Path (Join-Path $claudeBin 'claude.exe')) { Add-Path $claudeBin }
+  if (Have claude) { Ok 'Claude Code installed' }
+  else { Fail 'Claude Code did not install.' 'run: irm https://claude.ai/install.ps1 | iex   then paste the line again' }
+}
+
+# --- 4. The PMOS folder and kit ---
+Say "Setting up the PMOS folder: $PmosDir"
+New-Item -ItemType Directory -Force -Path $PmosDir | Out-Null
+if (-not (Test-Path (Join-Path $PmosDir '.git'))) {
+  & git -C $PmosDir init -q
+  Ok 'git folder created'
+}
+if (Test-Path (Join-Path $PmosDir 'pmos\AGENTS.md')) {
+  Ok 'the PMOS kit is already in this folder'
+} else {
+  & npx.cmd -y -p $PmosPkg create-pmos $PmosDir
+  if ($LASTEXITCODE -ne 0) { Fail 'Could not add the PMOS kit.' 'paste the line again; if it fails again, send the text above to your PMOS contact' }
+  Ok 'PMOS kit added'
+}
+
+# --- 5. The PMOS app ---
+Say 'Starting the PMOS app'
+& npx.cmd -y -p $PmosPkg create-pmos workspace $PmosDir
+if ($LASTEXITCODE -ne 0) { Fail 'The PMOS app did not start.' 'run: pmos doctor   and send what it prints to your PMOS contact' }
+
+Write-Host ""
+Ok 'PMOS is ready. Next time, open PowerShell and type: pmos'

package/install.sh

@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+# PMOS one-line setup for macOS and Linux (initiative one-line-setup).
+#
+#   curl -fsSL https://unpkg.com/create-pmos/install.sh | bash
+#
+# Installs what is missing, makes a PMOS folder and opens the PMOS app:
+#   1. Node.js (latest LTS from nodejs.org, into ~/.pmos/node; no Homebrew, no admin)
+#   2. git (macOS: Apple's Command Line Tools, one system dialog; Linux: the package manager)
+#   3. Claude Code (its own installer, claude.ai/install.sh)
+#   4. the PMOS kit in ~/PMOS (npx create-pmos)
+#   5. the PMOS app (npx create-pmos workspace), which opens in the browser
+# Every step checks first and skips what is already there, so running the line again is safe.
+#
+# Settings (environment variables):
+#   PMOS_DIR=<folder>      the PMOS folder (default: ~/PMOS)
+#   PMOS_NO_OPEN=1         do not open the browser at the end
+#   PMOS_SKIP_CLAUDE=1     do not install Claude Code
+#   PMOS_PKG=<spec>        the create-pmos package to run (default: create-pmos@latest)
+set -euo pipefail
+
+PMOS_HOME="${PMOS_HOME:-$HOME/.pmos}"
+PMOS_DIR="${PMOS_DIR:-$HOME/PMOS}"
+PMOS_PKG="${PMOS_PKG:-create-pmos@latest}"
+NODE_MIN=18
+MARK="# added by PMOS setup"
+
+say()  { printf '\033[1m==>\033[0m %s\n' "$*"; }
+ok()   { printf '    \033[32m✓\033[0m %s\n' "$*"; }
+fail() { printf '\n\033[31m✗ %s\033[0m\n' "$1" >&2; [ -n "${2:-}" ] && printf '  Try: %s\n' "$2" >&2; exit 1; }
+have() { command -v "$1" >/dev/null 2>&1; }
+
+OS="$(uname -s)"
+case "$OS" in
+  Darwin) PLAT=darwin ;;
+  Linux)  PLAT=linux ;;
+  *) fail "This setup is for macOS and Linux. On Windows, paste the PowerShell line instead." \
+          "powershell -ExecutionPolicy Bypass -c \"iex ((New-Object Net.WebClient).DownloadString('https://unpkg.com/create-pmos/install.ps1'))\"" ;;
+esac
+case "$(uname -m)" in
+  arm64|aarch64) ARCH=arm64 ;;
+  x86_64|amd64)  ARCH=x64 ;;
+  *) fail "This computer's processor ($(uname -m)) is not supported." ;;
+esac
+
+# The shell start-up files that new Terminal windows read, so PATH changes last. On Linux a new window
+# reads ~/.bashrc and a login reads ~/.bash_profile or ~/.profile, so both get the line.
+profile_files() {
+  case "${SHELL:-}" in
+    */zsh)  echo "$HOME/.zprofile" ;;
+    */bash) if [ "$PLAT" = darwin ]; then echo "$HOME/.bash_profile"
+            else
+              echo "$HOME/.bashrc"
+              # A login shell reads ~/.bash_profile instead of ~/.profile when it exists.
+              if [ -f "$HOME/.bash_profile" ]; then echo "$HOME/.bash_profile"; else echo "$HOME/.profile"; fi
+            fi ;;
+    *)      echo "$HOME/.profile" ;;
+  esac
+}
+# Put a folder on PATH now and in new Terminal windows. Adds the line once per file.
+add_path() {
+  local dir="$1" f
+  case ":$PATH:" in *":$dir:"*) ;; *) export PATH="$dir:$PATH" ;; esac
+  for f in $(profile_files); do
+    touch "$f"
+    grep -qsF "$dir" "$f" || printf '\nexport PATH="%s:$PATH" %s\n' "$dir" "$MARK" >> "$f"
+  done
+}
+
+node_major() { node -p 'process.versions.node.split(".")[0]' 2>/dev/null || echo 0; }
+
+echo
+echo "PMOS setup — this installs what is missing and opens PMOS."
+echo
+
+# ── 1. Node.js ────────────────────────────────────────────────────────────────────────────────
+say "Checking Node.js"
+[ -x "$PMOS_HOME/node/bin/node" ] && add_path "$PMOS_HOME/node/bin"
+if have node && [ "$(node_major)" -ge "$NODE_MIN" ]; then
+  ok "Node.js $(node -v) is installed"
+else
+  say "Installing Node.js (latest LTS) into $PMOS_HOME/node"
+  have curl || fail "curl is missing." "install curl, then paste the line again"
+  # The list is newest first; the first entry whose "lts" is not false is the latest LTS. awk reads to the end
+  # (no early exit), so nothing upstream is cut off mid-write under pipefail.
+  ver="$(curl -fsSL https://nodejs.org/dist/index.json | tr '{' '\n' \
+    | awk '!found && /"version":"v/ && !/"lts":false/ { sub(/.*"version":"/, ""); sub(/".*/, ""); print; found = 1 }')"
+  [ -n "$ver" ] || fail "Could not read the Node.js version list from nodejs.org." "check the internet connection, then paste the line again"
+  tmp="$(mktemp -d)"
+  curl -fsSL "https://nodejs.org/dist/$ver/node-$ver-$PLAT-$ARCH.tar.gz" -o "$tmp/node.tar.gz" \
+    || fail "Could not download Node.js $ver." "check the internet connection, then paste the line again"
+  rm -rf "$PMOS_HOME/node" && mkdir -p "$PMOS_HOME/node"
+  tar -xzf "$tmp/node.tar.gz" -C "$PMOS_HOME/node" --strip-components=1 --no-same-owner
+  rm -rf "$tmp"
+  add_path "$PMOS_HOME/node/bin"
+  hash -r
+  ok "Node.js $(node -v) installed"
+fi
+# A system Node whose global folder needs sudo: point npm's global folder at one the user owns.
+npm_prefix="$(npm prefix -g 2>/dev/null || true)"
+if [ -n "$npm_prefix" ] && [ ! -w "$npm_prefix/lib" ] && [ ! -w "$npm_prefix" ]; then
+  mkdir -p "$PMOS_HOME/npm-global"
+  npm config set prefix "$PMOS_HOME/npm-global"
+  add_path "$PMOS_HOME/npm-global/bin"
+  ok "npm global folder set to $PMOS_HOME/npm-global (no sudo needed)"
+fi
+# npm's global folder is where `pmos` lands: put its bin folder on PATH, wherever npm is set up to keep it.
+npm_prefix="$(npm prefix -g 2>/dev/null || true)"
+[ -n "$npm_prefix" ] && [ -d "$npm_prefix" ] && add_path "$npm_prefix/bin"
+
+# ── 2. git ────────────────────────────────────────────────────────────────────────────────────
+say "Checking git"
+if [ "$PLAT" = darwin ]; then
+  if xcode-select -p >/dev/null 2>&1 && git --version >/dev/null 2>&1; then
+    ok "$(git --version)"
+  else
+    say "Installing Apple's Command Line Tools (they include git)"
+    echo "    A window opens. Click Install and wait for it to finish. This step can take a few minutes."
+    xcode-select --install >/dev/null 2>&1 || true
+    waited=0
+    until xcode-select -p >/dev/null 2>&1; do
+      sleep 5; waited=$((waited + 5))
+      [ "$waited" -ge 3600 ] && fail "The Command Line Tools did not finish installing." "run: xcode-select --install, then paste the line again"
+    done
+    ok "$(git --version)"
+  fi
+else
+  if have git; then
+    ok "$(git --version)"
+  else
+    say "Installing git (your password may be asked)"
+    if have apt-get; then sudo apt-get update -qq && sudo apt-get install -y -qq git
+    elif have dnf; then sudo dnf install -y -q git
+    elif have pacman; then sudo pacman -S --noconfirm git
+    else fail "Could not install git automatically." "install git with your package manager, then paste the line again"; fi
+    ok "$(git --version)"
+  fi
+  # On Linux the terminal component (node-pty) is built from source: it needs a compiler and Python.
+  if ! have make || ! have g++ || ! have python3; then
+    say "Installing build tools for the PMOS app (your password may be asked)"
+    if have apt-get; then sudo apt-get install -y -qq build-essential python3
+    elif have dnf; then sudo dnf install -y -q gcc-c++ make python3
+    elif have pacman; then sudo pacman -S --noconfirm base-devel python
+    else fail "Could not install build tools automatically." "install a C++ compiler, make and python3, then paste the line again"; fi
+    ok "build tools installed"
+  fi
+fi
+
+# ── 3. Claude Code ───────────────────────────────────────────────────────────────────────────
+say "Checking Claude Code"
+[ -x "$HOME/.local/bin/claude" ] && add_path "$HOME/.local/bin"
+if [ "${PMOS_SKIP_CLAUDE:-}" = 1 ]; then
+  ok "skipped (PMOS_SKIP_CLAUDE=1)"
+elif have claude; then
+  ok "Claude Code is installed"
+else
+  say "Installing Claude Code"
+  curl -fsSL https://claude.ai/install.sh | bash \
+    || fail "Could not install Claude Code." "run: curl -fsSL https://claude.ai/install.sh | bash, then paste the line again"
+  add_path "$HOME/.local/bin"
+  hash -r
+  have claude && ok "Claude Code installed" || fail "Claude Code installed, but the claude command is not found." "open a new Terminal window and paste the line again"
+fi
+
+# ── 4. The PMOS folder and kit ──────────────────────────────────────────────────────────────
+say "Setting up the PMOS folder: $PMOS_DIR"
+mkdir -p "$PMOS_DIR"
+if [ ! -d "$PMOS_DIR/.git" ] && ! git -C "$PMOS_DIR" rev-parse --git-dir >/dev/null 2>&1; then
+  git -C "$PMOS_DIR" init -q
+  ok "git folder created"
+fi
+if [ -f "$PMOS_DIR/pmos/AGENTS.md" ]; then
+  ok "the PMOS kit is already in this folder"
+else
+  npx -y -p "$PMOS_PKG" create-pmos "$PMOS_DIR" || fail "Could not add the PMOS kit." "paste the line again; if it fails again, send the text above to your PMOS contact"
+  ok "PMOS kit added"
+fi
+
+# ── 5. The PMOS app ─────────────────────────────────────────────────────────────────────────
+say "Starting the PMOS app"
+npx -y -p "$PMOS_PKG" create-pmos workspace "$PMOS_DIR" || fail "The PMOS app did not start." "run: pmos doctor, and send what it prints to your PMOS contact"
+
+echo
+ok "PMOS is ready. Next time, open Terminal and type: pmos"
+echo "    New Terminal windows find node, claude and pmos by themselves."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.155.0",
+  "version": "0.157.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": {
@@ -10,6 +10,8 @@
     "bin/",
     "payload/",
     "workspace/",
+    "install.sh",
+    "install.ps1",
     "README.md",
     "LICENSE"
   ],

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@8593af2
+kernel-source: pmos@078081c
 assembled: 2026-10-12
 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-12T04:46:53Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T05:27:25Z"}
 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-12T04:46:53Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T05:27:25Z"}
 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-12T04:46:53Z"}
+generated: {by: process:create-pmos, at: "2026-10-12T05:27:25Z"}
 status: stable
 ---
 

package/workspace/bin/pmos.js

@@ -329,6 +329,7 @@ async function up(dir, { remote = false, open = true } = {}) {
   };
   const child = spawn(process.execPath, [path.join(WS, 'server.js')], {
     cwd: WS, detached: true, stdio: ['ignore', log, log], env,
+    windowsHide: true,                                  // Windows: no console window for the background server
   });
   // A server that exits at once (a refused tailnet bind, a port lost to a race) ends the wait below early.
   let exited = false;

package/workspace/doctor.js

@@ -33,7 +33,9 @@ function binaryArch(file) {
   console.log(`pmos workspace doctor — node ${process.version} (${process.platform}/${process.arch})`);
   console.log(`  install dir: ${WSDIR}\n`);
 
-  const REINSTALL = `cd "${WSDIR}" && rm -rf node_modules && npm install   (reinstalls node-pty for this platform)`;
+  const REINSTALL = process.platform === 'win32'
+    ? 'npx create-pmos@latest workspace --reinstall   (reinstalls the app and node-pty for this computer)'
+    : `cd "${WSDIR}" && rm -rf node_modules && npm install   (reinstalls node-pty for this platform)`;
 
   // 1. Node version
   const major = Number(process.versions.node.split('.')[0]);
@@ -101,7 +103,7 @@ function binaryArch(file) {
       bad(`PTY spawn failed: ${e.message}`,
         /posix_spawnp/.test(e.message)
           ? `on macOS this is node-pty's spawn-helper lacking +x (check 3 restores it — re-run \`npm run doctor\`); otherwise a wrong-arch binary — ${REINSTALL}`
-          : process.platform === 'win32' ? 'native Windows needs WSL for a real PTY — run the workspace inside WSL'
+          : process.platform === 'win32' ? `Windows 10 version 1809 or later is needed for terminals (ConPTY); otherwise ${REINSTALL}`
           : 'check that /bin/sh exists and is executable');
     }
   }

package/workspace/guide/launcher.md

@@ -1,7 +1,7 @@
 ---
 type: Guide
 title: "Start the workspace without a terminal"
-timestamp: 2026-10-06
+timestamp: 2026-10-12
 ---
 
 # Start the workspace without a terminal
@@ -47,5 +47,5 @@ Type `pmos launcher off`. It removes the app and the login item. It removes only
 ## Limits
 
 - The login item never starts remote (tailnet) mode, and it writes no token. To open the workspace from your phone, start remote mode yourself as `workspace/REMOTE.md` tells you.
-- Native Windows is not supported. The workspace needs WSL on Windows. Type `pmos launcher on` inside WSL.
+- Windows has no launcher yet. The workspace itself runs on Windows with no WSL: open PowerShell and type `pmos`. If PMOS is not installed yet, the one-line setup in the create-pmos README installs it.
 - The login item runs once, at login. If the server stops, open the app to start it again.

package/workspace/guide/notes.md

@@ -123,12 +123,18 @@ To set up Qwen3-ASR, Parakeet, speech detection and speakers, open the settings
 
 The kept audio holds your microphone and the meeting apart until the final pass is done. When **Keep the audio for replay** is off, both are deleted after the final pass.
 
+When PMOS restarts (for example after you install a new version) while a note waits for its final pass, its summary or Wispr Flow's notes, PMOS starts that work again when you next open PMOS:
+
+- A final pass that was queued or running is queued again. When it can no longer run, for example because the audio is gone, the note says why, and your agent session writes the notes from the live transcript.
+- A summary that was started and never written is started again.
+- A Wispr Flow fetch continues on its own schedule. When its 20 minutes have passed, it stops and says so. Press **Fetch Wispr Flow notes now** to try again.
+
 ## Wispr Flow notes
 
 When you also record the meeting with Wispr Flow, PMOS fetches Wispr Flow's notes and shows them under **Wispr Flow notes**, below yours.
 
 1. Five minutes after **Stop**, PMOS starts an agent session that looks for this meeting in Wispr Flow, by its time and title.
-2. When Wispr Flow has no notes yet, PMOS asks again every two minutes, for up to 20 minutes.
+2. When Wispr Flow has no notes yet, PMOS asks again every two minutes, for up to 20 minutes. Each try starts a new agent session, and the previous one is closed when it is idle.
 3. When it finds them, the summary shows in the note, with **Open in Wispr Flow**. Your agent session also writes your notes again with Wispr Flow's notes added, and the Overview says **merged with Wispr Flow's notes**. What both say is written once, what only one of them has is added, and where they differ the transcript decides. An item that only Wispr Flow has shows **Said (Wispr Flow):** and no meeting time. This runs once for a note. When Wispr Flow's notes were found before your agent session wrote the notes, they are merged at once.
 4. When the fetch failed or Wispr Flow had no notes, the **Wispr Flow notes** section says so and shows **Fetch Wispr Flow notes now**. Press it: your agent session looks again at once, and every two minutes for up to 20 minutes from the press. It works when the automatic fetch is switched off.
 

package/workspace/lib/launcher-cli.js

@@ -16,7 +16,7 @@
  * A file started by the desktop has no shell profile, so the PATH of the terminal that ran `on` is written into the
  * script; that is how `claude`, `git` and `tmux` resolve. It never starts remote (tailnet) mode and writes no token.
  * `off` deletes a file only when it carries MARK, so a file of the same name that the PM wrote is left alone.
- * Native Windows is refused: the workspace needs WSL there for a real PTY (doctor.js says the same).
+ * Windows is refused: no Start-menu or login item is made there yet. Start the workspace with `pmos`.
  *
  * plan() is pure: every input is injected, so each platform's files are assertable from any machine.
  */
@@ -81,7 +81,7 @@ function desktop(entries) {
  * `login: false` leaves the login item out.
  */
 function plan({ platform, home, env = {}, node, bin, repo, login = true }) {
-  if (platform === 'win32') return { refused: 'native Windows needs WSL for a real PTY. Run `pmos launcher on` inside WSL.' };
+  if (platform === 'win32') return { refused: 'no launcher is made on Windows yet. Start the workspace with `pmos` in PowerShell.' };
   if (platform !== 'darwin' && platform !== 'linux') return { refused: `no launcher is made for ${platform}. Start the workspace with \`pmos\`.` };
   const log = path.join(stateRoot.defaultRoot({ env, platform, home }), 'launcher.log');
   const body = script({ node, bin, repo, pathEnv: env.PATH || '/usr/bin:/bin', log });

package/workspace/lib/routes-notes.js

@@ -549,15 +549,13 @@ function askWispr(ctx, id) {
   const h = notes.wisprHandoff(dir, { id, until: stopped });
   if (!h.ok) return;
   const tries = (w0.tries || 0) + 1;
-  let session = w0.session || null;
-  const again = 'Try again: the Wispr Flow notes may be ready now. Read ' + h.handoff + ' again and write ' + h.out + ' as before.';
-  const sent = session && typeof ctx.sendToSession === 'function' && ctx.sendToSession(session, again + '\r');
-  if (!sent) {
-    const ws = cur.note.ws ? ctx.getWs(cur.note.ws) : null;
-    const s = ctx.spawnSession({ name: 'notes: Wispr Flow', agent: 'claude', ws: ws && ws.id === cur.note.ws ? ws.id : undefined, origin: 'notes-wispr:' + id, initialInput: h.prompt + '\r' });
-    if (!s || s.state === 'exited') { notes.setWispr(dir, { id, patch: { state: 'failed', reason: (s && s.note) || 'could not start a claude session', tries } }); return; }
-    session = s.id;
-  }
+  // every try is a fresh session: a try typed into the last one went nowhere when that session sat on a prompt. The last
+  // one is ended first when it is idle (server.js endSupersededRuns; a session still working or waiting on the PM stays).
+  if (typeof ctx.endSupersededRuns === 'function') { try { ctx.endSupersededRuns('notes-wispr:' + id); } catch { /* best effort */ } }
+  const ws = cur.note.ws ? ctx.getWs(cur.note.ws) : null;
+  const s = ctx.spawnSession({ name: 'notes: Wispr Flow', agent: 'claude', ws: ws && ws.id === cur.note.ws ? ws.id : undefined, origin: 'notes-wispr:' + id, initialInput: h.prompt + '\r' });
+  if (!s || s.state === 'exited') { notes.setWispr(dir, { id, patch: { state: 'failed', reason: (s && s.note) || 'could not start a claude session', tries } }); return; }
+  const session = s.id;
   notes.setWispr(dir, { id, patch: { state: 'asking', tries, session, asked_at: new Date().toISOString() } });
   wisprLater(ctx, id, wisprRetry(ctx), () => checkWispr(ctx, id));
 }
@@ -586,7 +584,8 @@ function fetchWisprNow(ctx, id) {
   if (listening(cur.note)) return { ok: false, status: 409, error: 'stop listening first' };
   if (typeof ctx.spawnSession !== 'function') return { ok: false, status: 409, error: 'this workspace cannot start sessions' };
   const w = cur.note.wispr;
-  if (w && (w.state === 'waiting' || w.state === 'asking')) return { ok: true, wispr: w };
+  // a check with its timer in this process is under way; one without (PMOS restarted) is stuck, so it starts again
+  if (w && (w.state === 'waiting' || w.state === 'asking') && wisprTimers.has(id)) return { ok: true, wispr: w };
   const now = new Date().toISOString();
   notes.setWispr(dir, { id, patch: { state: 'waiting', tries: 0, reason: '', manual_at: now, stopped_at: (w && w.stopped_at) || now, due_at: now } });
   askWispr(ctx, id);
@@ -607,12 +606,71 @@ function mergeWispr(ctx, id) {
   return !!(r && r.ok && r.started);
 }
 
+/* AFTER A RESTART. The final pass queue, the Wispr Flow timers and a headless summary run live in this process. A restart
+ * (an update installs a new version and starts PMOS again) dropped them, and their notes stayed "queued", "waiting" or
+ * "writing" for good. The first notes request after a start picks them up (resumeStuck), once per runtime directory:
+ *   - a final pass that was queued or running is queued again; when it can no longer run, it is marked failed with the
+ *     reason, and the agent writes the notes from the live transcript, as Stop does without an engine;
+ *   - a summary run that was started, wrote nothing and is no longer a session is started again;
+ *   - a Wispr Flow check that was waiting or asking carries on from its own clock, or ends as failed once its deadline
+ *     after Stop is past (the PM can press Fetch to try again). */
+let resumedFor = null;
+function resumeStuck(ctx) {
+  const dir = ctx.runtimeDir;
+  if (resumedFor === dir) return [];
+  resumedFor = dir;
+  const done = [];
+  const l = notes.list(dir);
+  if (!l.ok) return done;
+  let live = null;
+  const liveIds = () => {
+    if (live) return live;
+    try { live = new Set((typeof ctx.sessionList === 'function' ? ctx.sessionList() : []).filter((x) => x.state !== 'exited').map((x) => x.id)); } catch { live = new Set(); }
+    return live;
+  };
+  const wsFor = (n) => { const w = n.ws ? ctx.getWs(n.ws) : null; return w && w.id === n.ws ? w : null; };
+  for (const row of l.notes) {
+    const cur = notes.read(dir, row.id);
+    if (!cur.ok || cur.note.private || listening(cur.note)) continue;
+    const n = cur.note;
+    const fst = n.final_state && n.final_state.state;
+    if ((fst === 'queued' || fst === 'running') && !(finalRunner && finalRunner.state(n.id))) {
+      const q = queueFinal(ctx, n.id);
+      if (q.queued) done.push({ id: n.id, final: 'queued' });
+      else {
+        notes.setFinalState(dir, { id: n.id, state: { state: 'failed', reason: 'PMOS restarted before the final pass ended, and it cannot run again: ' + q.reason } });
+        const a = n.agent;
+        if (!a || (!a.imported_at && !a.started)) { startAgent(ctx, dir, n.id, wsFor(n)); done.push({ id: n.id, final: 'failed', agent: 'started' }); }
+        else done.push({ id: n.id, final: 'failed' });
+      }
+    } else if (n.agent && n.agent.started && !n.agent.imported_at && !(n.agent.out && fs.existsSync(n.agent.out)) && n.agent.session && !liveIds().has(n.agent.session)) {
+      startAgent(ctx, dir, n.id, wsFor(n));
+      done.push({ id: n.id, agent: 'started' });
+    }
+    const w = n.wispr;
+    if (w && (w.state === 'waiting' || w.state === 'asking') && !wisprTimers.has(n.id)) {
+      const stopped = Math.max(Date.parse(w.stopped_at) || 0, Date.parse(w.manual_at) || 0);
+      if (Date.now() - stopped >= wisprDeadline(ctx)) {
+        notes.setWispr(dir, { id: n.id, patch: { state: 'failed', reason: 'PMOS restarted while it waited for Wispr Flow, and the ' + Math.round(wisprDeadline(ctx) / 60000) + ' minutes after Stop are past. Press Fetch to try again.' } });
+        done.push({ id: n.id, wispr: 'failed' });
+      } else {
+        const id = n.id;
+        if (w.state === 'waiting') wisprLater(ctx, id, Math.max(0, (Date.parse(w.due_at) || 0) - Date.now()), () => askWispr(ctx, id));
+        else wisprLater(ctx, id, 0, () => checkWispr(ctx, id));
+        done.push({ id, wispr: w.state });
+      }
+    }
+  }
+  return done;
+}
+
 const send = (ctx, res, r) => ctx.json(res, r, r.ok ? 200 : (r.status || 400));
 
 async function handle(req, res, url, ctx) {
   const p = url.pathname;
   const dir = ctx.runtimeDir;
   if (!dir) { ctx.json(res, { ok: false, error: 'the notes store is not available' }, 500); return true; }
+  if (resumedFor !== dir) { try { resumeStuck(ctx); } catch { /* a note that cannot be picked up stays as it was */ } }
   if (p === '/api/notes' || p === '/api/notes/one') {
     if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
     if (p === '/api/notes') { const l = notes.list(dir, { resumeMs: resumeMsOf(ctx) }); if (l.ok) sweepExpired(ctx, l.notes); send(ctx, res, l); return true; }
@@ -991,5 +1049,6 @@ function startAgent(ctx, dir, id, w) {
   return { ok: true, started, session: s ? s.id : null, reason, handoff: h.handoff, out: h.out, withheld: h.withheld };
 }
 
-module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr,
+module.exports = { prefixes, handle, enrich, runMinute, bulletsState, queueFinal, askWispr, checkWispr, fetchWisprNow, mergeWispr, resumeStuck,
+  __resetResume: () => { resumedFor = null; },
   __idle: () => Promise.all([transcriber ? transcriber.idle() : null, finalRunner ? finalRunner.idle() : null, ...chains.values()]) };

package/workspace/package-lock.json

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

package/workspace/package.json

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

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

@@ -546,7 +546,7 @@ export function mountSettings(host, ctx = {}) {
     const values = () => Object.fromEntries(F.map(([k]) => [k, inputs[k].value.trim()]));
     const running = o.on && o.running && o.running.running;
     return [group('Online', [extRow('online.on', swBtn(o.on, 'Online', () => post({ ...values(), on: !o.on }, o.on ? 'Online is off' : 'Online is on'), { disabled: !o.canChange }), { scope: 'computer',
-      note: !o.canChange ? 'Only the computer that runs PMOS can change this.' : !o.cloudflared ? 'cloudflared is not installed. Install it with brew install cloudflared, then switch Online on.' : null })], 'phone'),
+      note: !o.canChange ? 'Only the computer that runs PMOS can change this.' : !o.cloudflared ? 'cloudflared is not installed. Install it (Mac: brew install cloudflared; Windows: winget install Cloudflare.cloudflared), then switch Online on.' : null })], 'phone'),
     running ? fold('check', 'Tunnel running · cloudflared found' + (o.lastRefusal ? '' : ' · no refused sign-in'), 'a') : null,
     sect('Tunnel and sign-in', [list(fieldRows), o.canChange ? el('div', { class: 'iacts' }, btn('Save', { variant: 'primary', onclick: () => post(values()) })) : null,
       o.lastRefusal ? help('Last refused sign-in: ' + o.lastRefusal.reason) : null], { ic: 'phone' }),

package/workspace/public/pm/frame-copy.js

@@ -231,7 +231,7 @@ export const COPY = {
     onlineKeysWait: 'Cloudflare\'s sign-in keys are not loaded yet. Sign-ins are refused until they are.',
     onlineKeysError: (e) => `Cloudflare\'s sign-in keys did not load (${e}). Check the team domain. Sign-ins are refused until they load.`,
     onlineNeedFields: 'Fill in all five fields to turn Online on.',
-    onlineNoCloudflared: 'cloudflared is not installed. Install it (brew install cloudflared), then turn Online on.',
+    onlineNoCloudflared: 'cloudflared is not installed. Install it (Mac: brew install cloudflared; Windows: winget install Cloudflare.cloudflared), then turn Online on.',
     onlineEnv: (host) => `Online at https://${host}/, set by PMOS_PUBLIC_HOST when the workspace started. It signs in with the token. Restart the workspace without PMOS_PUBLIC_HOST to use this switch.`,
     onlineRemote: 'Only the computer that runs the workspace can change this.',
     onlineUnread: 'The Online settings did not load.',

package/workspace/server.js

@@ -3023,8 +3023,8 @@ function spawnFailureAdvice(err, cmd, isShell) {
       `in the workspace install dir.`;
   }
   if (process.platform === 'win32') {
-    return `could not start '${cmd}': ${msg}. Native Windows needs WSL for a real PTY shell — ` +
-      `run the workspace inside WSL.`;
+    return `could not start '${cmd}': ${msg}. Run \`pmos doctor\`: it checks the terminal component and names the fix. ` +
+      `If this is an agent, check that it is installed and that a new PowerShell window finds it.`;
   }
   return isShell
     ? `could not start a shell ('${cmd}'): ${msg}. Set SHELL to a valid shell (e.g. /bin/zsh) and restart.`
@@ -7925,7 +7925,7 @@ async function handleRequest(req, res) {
     const press = pmGuard.requirePagePress(req, body);
     if (!press.ok) return json(res, { ok: false, error: press.error }, press.status || 403);
     if (BIND.publicHost && body.on === true) return json(res, { ok: false, error: `PMOS_PUBLIC_HOST=${BIND.publicHost} was set when the workspace started, so it is already online that way. Restart it without PMOS_PUBLIC_HOST to use the switch.` }, 409);
-    if (body.on === true && !ONLINE.find()) return json(res, { ok: false, field: 'on', error: 'cloudflared is not installed. Install it (brew install cloudflared), then switch Online on again.' }, 409);
+    if (body.on === true && !ONLINE.find()) return json(res, { ok: false, field: 'on', error: 'cloudflared is not installed. Install it (Mac: brew install cloudflared; Windows: winget install Cloudflare.cloudflared), then switch Online on again.' }, 409);
     const out = onlineMode.save(STATE, body);
     if (!out.ok) return json(res, { ok: false, field: out.field || null, error: out.error }, out.field ? 400 : 500);
     ONLINE.settings = out.settings;
@@ -8800,7 +8800,7 @@ async function handleRequest(req, res) {
   // pm-os-absorb Runs 2–5 — the planning layer's routes, one file per run (lib/route-modules.js). Last, so none shadows a route above.
   // meeting-notes Run 1: the Notes routes keep notes in the per-user runtime directory and start the agent-summary session.
   if (await routeModules.dispatch(req, res, url, { json, readBody, getWs, invalidateNeedsAgg, boardCache, consoleState, stateDirFor, sessionList, initiativeIndex,
-    runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession,
+    runtimeDir: STATE, spawnSession, jevModelOpts, sendToSession, endSupersededRuns,
     // workspace-headless-jobs R6: is this session a headless run that is still working?
     headlessBusy: (id) => { const x = sessions.get(String(id || '')); return !!(x && x.headless && x.child); },
     // initiative my-work: every registered repository, the day runs, and the two presses that start sessions