create-pmos 0.521.0 → 0.522.0

package/bin/create-pmos.js

@@ -21,7 +21,7 @@
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
-const { spawnSync } = require('child_process');
+const cp = require('child_process');                         // cp.spawnSync, so a test can stand in for it
 
 const PAYLOAD = path.join(__dirname, '..', 'payload');       // the assembled pmos/ kit (file-mode)
 const WORKSPACE = path.join(__dirname, '..', 'workspace');   // the bundled Terminal Workspace app (D62)
@@ -173,13 +173,18 @@ function update(dirArg, opts) {
 // global install can't run (locked-down npm prefix), we DON'T fail — we launch straight from the
 // bundled copy (its own bin/pmos.js installs runtime deps on first run) and print the one manual
 // line to get the bare `pmos` word for next time.
+// No console window on Windows when nobody watches a terminal (batch 27 item 7). The in-app update (Settings > Updates)
+// runs this with its output in a log file; then each child here starts hidden. In a terminal the children share it, as
+// before: windowsHide there would give each one a console of its own, away from the one the person reads.
+const hide = () => ({ windowsHide: !process.stdout.isTTY });
+
 function onPath(cmd) {
   // `command -v` (POSIX) and `where` (Windows) are shell BUILTINS — neither has a standalone binary on
   // Linux, so the probe MUST run through a shell or it ENOENTs and always reports "not found" (which,
   // after a successful install, prints a false PATH warning and defeats the idempotent fast path). cmd
   // is always a literal, so the string form is injection-safe.
   const probe = process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`;
-  try { return spawnSync(probe, { stdio: 'ignore', shell: true }).status === 0; }
+  try { return cp.spawnSync(probe, { stdio: 'ignore', shell: true, ...hide() }).status === 0; }
   catch { return false; }
 }
 
@@ -204,14 +209,41 @@ function launchStatus(r) {
 
 // --no-open: the in-app update (Settings > Updates) reinstalls through here while the PM's tab waits and reloads itself;
 // the restarted server then opens no second tab (batch 18 item 5). It is pmos's own flag, so the server does not inherit it.
-function runInstalledPmos(args) {
-  if (process.platform !== 'win32') return spawnSync('pmos', args, { stdio: 'inherit' });
+// { capture: true } returns the output in r.stdout instead of printing it.
+function runInstalledPmos(args, { capture = false } = {}) {
+  const io = capture ? { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] } : { stdio: 'inherit' };
+  if (process.platform !== 'win32') return cp.spawnSync('pmos', args, { ...io, ...hide() });
   // cmd.exe does not preserve spawnSync argument boundaries. Run Node directly so a
   // repository under a Windows user name with spaces still reaches the app intact.
-  const root = spawnSync('npm.cmd', ['root', '-g'], { encoding: 'utf8', shell: true });
+  const root = globalRoot();
   if (root.error || root.status !== 0) return root;
-  if (!root.stdout || !root.stdout.trim()) return { status: 1, error: new Error('npm did not report its global install folder') };
-  return spawnSync(process.execPath, [path.join(root.stdout.trim(), 'pmos-workspace', 'bin', 'pmos.js'), ...args], { stdio: 'inherit' });
+  if (!root.dir) return { status: 1, error: new Error('npm did not report its global install folder') };
+  return cp.spawnSync(process.execPath, [path.join(root.dir, 'pmos-workspace', 'bin', 'pmos.js'), ...args], { ...io, ...hide() });
+}
+
+// `npm root -g`, asked once per run: every Windows launch step needs it, and each ask starts npm again.
+let rootMemo = null;
+function globalRoot() {
+  if (rootMemo) return rootMemo;
+  const win = process.platform === 'win32';
+  const r = cp.spawnSync(win ? 'npm.cmd' : 'npm', ['root', '-g'], { encoding: 'utf8', shell: win, ...hide() });
+  const res = { status: r.status, error: r.error, dir: r.status === 0 && r.stdout ? r.stdout.trim() : '' };
+  if (res.status === 0 && !res.error) rootMemo = res;
+  return res;
+}
+
+// Is the launcher already set up for this repository? `pmos launcher status` says so with exit 0 when the app and its
+// node and pmos.js are in place, and names the repository. Then `launcher on` would write the same files again, and on
+// Windows run PowerShell twice, so it is skipped. Any other answer (no launcher, a moved node, another repository, an
+// older pmos without the command) runs `launcher on` as before.
+function launcherCurrent(targetDir) {
+  const r = runInstalledPmos(['launcher', 'status'], { capture: true });
+  if (r.error || r.status !== 0) return false;
+  const m = /^\s*repository: (.+?)\s*$/m.exec(String(r.stdout || ''));
+  if (!m || /✗/.test(m[1])) return false;
+  const win = process.platform === 'win32';
+  const norm = (p) => (win ? path.win32.resolve(p).toLowerCase() : path.resolve(p));
+  return norm(m[1]) === norm(targetDir);
 }
 
 function launchWorkspace(targetDir, viaGlobal) {
@@ -223,8 +255,11 @@ function launchWorkspace(targetDir, viaGlobal) {
       console.error('create-pmos: launcher setup needs the installed pmos command. Fix the global install and run workspace again.');
       return 1;
     }
-    const launcher = runInstalledPmos(['launcher', 'on', targetDir]);
-    if (launchStatus(launcher) !== 0) return 1;
+    if (launcherCurrent(targetDir)) console.log('✓ PMOS app and login item already set up — kept as they are.');
+    else {
+      const launcher = runInstalledPmos(['launcher', 'on', targetDir]);
+      if (launchStatus(launcher) !== 0) return 1;
+    }
   }
 
   if (viaGlobal && onPath('pmos')) {
@@ -233,8 +268,8 @@ function launchWorkspace(targetDir, viaGlobal) {
   }
   // Fallback: run the bundled launcher directly. Its ensureInstalled() pulls runtime deps on first run.
   console.log('Launching from the bundled copy (the `pmos` command is not on PATH).');
-  return launchStatus(spawnSync(process.execPath, [path.join(WORKSPACE, 'bin', 'pmos.js'), targetDir, ...NO_OPEN],
-    { stdio: 'inherit', env: process.env }));
+  return launchStatus(cp.spawnSync(process.execPath, [path.join(WORKSPACE, 'bin', 'pmos.js'), targetDir, ...NO_OPEN],
+    { stdio: 'inherit', env: process.env, ...hide() }));
 }
 
 // Compare two dotted numeric versions. Returns -1 if a<b, 0 if equal, 1 if a>b. Missing/non-numeric
@@ -257,10 +292,9 @@ function bundledWorkspaceVersion() {
 // Version of the globally-installed `pmos-workspace`, or null if absent/unreadable. Read from the
 // npm global root rather than the app's CLI — no dependency on the old binary supporting --version.
 function installedWorkspaceVersion() {
-  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-  const r = spawnSync(npmCmd, ['root', '-g'], { encoding: 'utf8', shell: process.platform === 'win32' });
-  if (r.status !== 0 || !r.stdout) return null;
-  const dir = path.join(r.stdout.trim(), 'pmos-workspace');
+  const r = globalRoot();
+  if (r.status !== 0 || !r.dir) return null;
+  const dir = path.join(r.dir, 'pmos-workspace');
   try {
     // A SYMLINK is not an install. `npm install -g <folder>` links to the folder and installs no
     // dependencies, so the link reads as the bundled version (it IS the bundled folder, here the npx
@@ -278,12 +312,12 @@ function installWorkspaceGlobal() {
   const shell = process.platform === 'win32';
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'pmos-ws-'));
   try {
-    const pack = spawnSync(npmCmd, ['pack', WORKSPACE, '--pack-destination', tmp, '--silent'],
-      { encoding: 'utf8', shell });
+    const pack = cp.spawnSync(npmCmd, ['pack', WORKSPACE, '--pack-destination', tmp, '--silent'],
+      { encoding: 'utf8', shell, ...hide() });
     const tgz = pack.status === 0 ? (pack.stdout || '').trim().split('\n').pop() : '';
     if (!tgz) { console.error(`create-pmos: could not pack the workspace app${pack.stderr ? ' — ' + pack.stderr.trim() : ''}`); return 1; }
-    return spawnSync(npmCmd, ['install', '-g', path.join(tmp, tgz), '--no-audit', '--no-fund'],
-      { stdio: 'inherit', shell }).status;
+    return cp.spawnSync(npmCmd, ['install', '-g', path.join(tmp, tgz), '--no-audit', '--no-fund'],
+      { stdio: 'inherit', shell, ...hide() }).status;
   } finally {
     try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {}
   }
@@ -291,7 +325,7 @@ function installWorkspaceGlobal() {
 // A persistent server started by the OLD code keeps serving OLD assets after an upgrade — stop it so
 // the next launch brings the server up on the freshly installed code. Best-effort; ignore failures.
 function stopWorkspaceServer() {
-  try { spawnSync('pmos', ['stop'], { stdio: 'ignore', shell: process.platform === 'win32' }); }
+  try { cp.spawnSync('pmos', ['stop'], { stdio: 'ignore', shell: process.platform === 'win32', ...hide() }); }
   catch { /* no server running, or pmos not launchable — nothing to stop */ }
 }
 
@@ -347,26 +381,31 @@ function workspace(targetArg, opts) {
   process.exit(launchWorkspace(targetDir, false));
 }
 
-const args = process.argv.slice(2);
-const positional = args.filter((a) => !a.startsWith('-'));
-if (args.includes('--help') || args.includes('-h')) {
-  console.log('usage:');
-  console.log('  create-pmos [target-dir]              vendor the file-mode kit into a repo (pm-artifacts profile, D68)');
-  console.log('  create-pmos [target-dir] --code       …as a product-code repository instead (code lanes and ladder)');
-  console.log('  create-pmos [target-dir] --no-mod     …without offering the pmos-cockpit mod in .claude/settings.json');
-  console.log('  create-pmos --update [kit-or-repo]    refresh only the kit kernel (add --offer-mod to offer the mod in .claude/settings.json)');
-  console.log('  create-pmos workspace [repo-dir]      install/upgrade + launch the Terminal Workspace GUI');
-  console.log('  create-pmos workspace --reinstall     force-reinstall the workspace app (drop a stale global copy)');
-  console.log('  create-pmos workspace --no-launcher   skip the default Mac/Windows app and login item');
-  console.log('  create-pmos --version                 print version + bundled kernel provenance');
-} else if (args.includes('--version') || args.includes('-v')) {
-  console.log(`create-pmos ${PKG.version}`);
-  console.log(kitVersion());
-  console.log(`workspace bundled: ${fs.existsSync(path.join(WORKSPACE, 'bin', 'pmos.js')) ? 'yes' : 'no'}`);
-} else if (positional[0] === 'workspace') {
-  workspace(positional[1], { reinstall: args.includes('--reinstall') });
-} else if (args.includes('--update')) {
-  update(positional[0], { offerMod: args.includes('--offer-mod') });
-} else {
-  vendor(path.resolve(positional[0] || '.'), { code: args.includes('--code'), noMod: args.includes('--no-mod') });
+// Run as the create-pmos command; required (by workspace/kit-update.test.js), it only lends its launch steps.
+function main() {
+  const args = process.argv.slice(2);
+  const positional = args.filter((a) => !a.startsWith('-'));
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log('usage:');
+    console.log('  create-pmos [target-dir]              vendor the file-mode kit into a repo (pm-artifacts profile, D68)');
+    console.log('  create-pmos [target-dir] --code       …as a product-code repository instead (code lanes and ladder)');
+    console.log('  create-pmos [target-dir] --no-mod     …without offering the pmos-cockpit mod in .claude/settings.json');
+    console.log('  create-pmos --update [kit-or-repo]    refresh only the kit kernel (add --offer-mod to offer the mod in .claude/settings.json)');
+    console.log('  create-pmos workspace [repo-dir]      install/upgrade + launch the Terminal Workspace GUI');
+    console.log('  create-pmos workspace --reinstall     force-reinstall the workspace app (drop a stale global copy)');
+    console.log('  create-pmos workspace --no-launcher   skip the default Mac/Windows app and login item');
+    console.log('  create-pmos --version                 print version + bundled kernel provenance');
+  } else if (args.includes('--version') || args.includes('-v')) {
+    console.log(`create-pmos ${PKG.version}`);
+    console.log(kitVersion());
+    console.log(`workspace bundled: ${fs.existsSync(path.join(WORKSPACE, 'bin', 'pmos.js')) ? 'yes' : 'no'}`);
+  } else if (positional[0] === 'workspace') {
+    workspace(positional[1], { reinstall: args.includes('--reinstall') });
+  } else if (args.includes('--update')) {
+    update(positional[0], { offerMod: args.includes('--offer-mod') });
+  } else {
+    vendor(path.resolve(positional[0] || '.'), { code: args.includes('--code'), noMod: args.includes('--no-mod') });
+  }
 }
+if (require.main === module) main();
+else module.exports = { hide, globalRoot, runInstalledPmos, launcherCurrent, launchWorkspace, installedWorkspaceVersion, installWorkspaceGlobal, stopWorkspaceServer, resetRoot: () => { rootMemo = null; } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.521.0",
+  "version": "0.522.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": {
@@ -32,6 +32,31 @@
     "audit"
   ],
   "pmosChanges": [
+    {
+      "v": "0.522.0",
+      "at": "2026-11-04T07:22:01.639Z",
+      "f": 4,
+      "prs": [
+        {
+          "n": 1218,
+          "t": "The in-app update on Windows is fast and opens no console window",
+          "s": "The in-app update on Windows is fast and opens no console window",
+          "k": "fix"
+        },
+        {
+          "n": 1219,
+          "t": "Chat keeps its answers when the terminal opens; terminal fills the Viewer",
+          "s": "Chat keeps its answers when the terminal opens; terminal fills the Viewer",
+          "k": "fix"
+        },
+        {
+          "n": 1220,
+          "t": "Share several products or programs in one link, and a way back to PMOS",
+          "s": "Share several products or programs in one link, and a way back to PMOS",
+          "k": "new"
+        }
+      ]
+    },
     {
       "v": "0.521.0",
       "at": "2026-11-04T02:17:43.880Z",
@@ -379,21 +404,6 @@
           "d": "A recording showed everything at once. Now it opens on a short summary, each point has one check, and you can fix a misheard word in place."
         }
       ]
-    },
-    {
-      "v": "0.502.0",
-      "at": "2026-11-03T04:57:38.850Z",
-      "f": 4,
-      "prs": [
-        {
-          "n": 1185,
-          "t": "Full task names in the Timeline too",
-          "s": "Full task names in the Timeline too",
-          "k": "fix",
-          "h": "Full task names in the Timeline",
-          "d": "The Timeline still cut long task names short. Now they wrap in full there too."
-        }
-      ]
     }
   ]
 }

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@2ac0d2f5
+kernel-source: pmos@60230431
 assembled: 2026-11-04
 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-11-04T02:17:40Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T07:21:58Z"}
 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-11-04T02:17:40Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T07:21:58Z"}
 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-11-04T02:17:40Z"}
+generated: {by: process:create-pmos, at: "2026-11-04T07:21:58Z"}
 status: stable
 ---
 

package/workspace/bin/pmos.js

@@ -200,7 +200,8 @@ function openBrowser(url) {
   const cmd = process.platform === 'darwin' ? ['open', [url]]
     : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
     : ['xdg-open', [url]];
-  try { spawn(cmd[0], cmd[1], { detached: true, stdio: 'ignore' }).unref(); } catch {}
+  // windowsHide: `cmd /c start` from a launcher with no console would otherwise flash a console window (batch 27 item 7).
+  try { spawn(cmd[0], cmd[1], { detached: true, stdio: 'ignore', windowsHide: true }).unref(); } catch {}
 }
 
 function npm(args) {

package/workspace/board-publish-ui-test.js

@@ -113,7 +113,7 @@ const ok = (name, cond, extra = '') => { n++; if (!cond) bad++; console.log(`${c
   await s.p.click('[data-bp-sel="program:project-ascent"]'); await s.p.fill('#bpTeam', 'Product'); await s.p.click('[data-bp-days="30"]'); await s.p.fill('#bpPass', 'my-own-password-1');
   await s.p.click('[data-bp="make"]'); await s.p.waitForSelector('[data-bp="copy"]');
   const sent = W.posts[0] && W.posts[0].body;
-  ok('D1 a press sends what was picked, the team, the typed password and the days', sent && sent.ws === 'idpf' && sent.team === 'Product' && sent.password === 'my-own-password-1' && sent.days === 30 && sent.select.some((x) => x.kind === 'program' && x.id === 'project-ascent') && sent.select.some((x) => x.kind === 'initiative' && x.id === first), JSON.stringify(sent));
+  ok('D1 a press sends what was picked, the team, the typed password and the days', sent && sent.ws === 'idpf' && sent.team === 'Product' && sent.password === 'my-own-password-1' && sent.days === 30 && sent.parts.some((x) => x.kind === 'program' && x.id === 'project-ascent') && sent.parts.some((x) => x.kind === 'initiative' && x.id === first && x.ws === 'idpf'), JSON.stringify(sent));
   const t = await pop(s.p).textContent();
   ok('D2 the link is ready: the link, the password once, one Copy button, and the note says it is shown once', /boards\.test\/b\/link00000003/.test(t) && /my-own-password-1/.test(t) && (await s.p.locator('[data-bp="copy"]').getAttribute('aria-label')) === 'Copy link and password' && /It is shown once/.test(t) && /for the Product team/.test(t));
   await s.ctx.grantPermissions(['clipboard-read', 'clipboard-write']).catch(() => {});

package/workspace/changelog.json

@@ -1,4 +1,29 @@
 [
+ {
+  "v": "0.522.0",
+  "at": "2026-11-04T07:22:01.639Z",
+  "f": 4,
+  "prs": [
+   {
+    "n": 1218,
+    "t": "The in-app update on Windows is fast and opens no console window",
+    "s": "The in-app update on Windows is fast and opens no console window",
+    "k": "fix"
+   },
+   {
+    "n": 1219,
+    "t": "Chat keeps its answers when the terminal opens; terminal fills the Viewer",
+    "s": "Chat keeps its answers when the terminal opens; terminal fills the Viewer",
+    "k": "fix"
+   },
+   {
+    "n": 1220,
+    "t": "Share several products or programs in one link, and a way back to PMOS",
+    "s": "Share several products or programs in one link, and a way back to PMOS",
+    "k": "new"
+   }
+  ]
+ },
  {
   "v": "0.521.0",
   "at": "2026-11-04T02:17:43.880Z",

package/workspace/guide/home.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Home: your list, the chat and the Viewer"
 description: "Home: the list grouped by product, the Viewer, the place menu, Your day and its New for you fold, Search, and the initiative, meeting, report, Board and Insights features designed after it."
-timestamp: 2026-11-03
+timestamp: 2026-11-04
 ---
 
 # Home
@@ -193,7 +193,7 @@ There is no My work page. The list on Home is your list:
 - **Sessions.** A session row names its agent. The coloured dot beside it is its state: blue waits on you, amber may be blocked, green is running. A session PMOS started itself (a skill or a background job) shows on Home only while it works or asks you something. Once it finishes its prompt, it leaves the list. On an initiative's page, a session that waits on you shows once, under **Needs you**, not again under **Sessions**. **Finished sessions** does not list an old run of a chat that is open again.
 - **One chat box.** Every conversation has the same box: **+** (attach a file, notes, the terminal, and **Link to an initiative** for a loose chat), **/** for commands, **@** inside an initiative, the To or In chip, the mic, and Send. A chat opens at its newest message.
 - **While Claude works.** A line at the top of the chat shows what Claude is trying to do. If Claude keeps a to-do list, the line shows the to-do in progress and how many are done, for example **2 of 5 done**. Tap the line to see the full list. If Claude has no to-do list, the line shows Claude's newest one-line status and the time since your message. The line never shows raw commands. To see the commands, tap the terminal icon.
-- **A session's terminal.** **Watch its terminal** in **+**, or a session row such as **Claude sign-in**, opens the session's terminal in the Viewer. While the session runs, it is a real terminal: type in it to answer Claude or paste a code. When the session has ended, the Viewer shows it read only and says so.
+- **A session's terminal.** **Watch its terminal** in **+**, or a session row such as **Claude sign-in**, opens the session's terminal in the Viewer. While the session runs, it is a real terminal: type in it to answer Claude or paste a code. It fills the Viewer and fits its lines again when you resize the Viewer or the window. The chat goes on showing every answer while the terminal is open and after you close it: the terminal is a second view of the same session. When the session has ended, the Viewer shows it read only and says so.
 - **Setting up your first project opens by itself** until a registered folder holds an initiative or setup has finished. The `PMOS` folder that the one-line installer makes holds no initiative yet, so a new user who opens PMOS from the Start menu or the Dock still gets the setup conversation, not an empty Home.
 - **Signing in to Claude when you set up your first project.** If the login you choose is signed in already, PMOS does not open a terminal. It tests the login at once. Otherwise PMOS runs `claude auth login`: Claude opens your browser to sign in, and the terminal under the question shows only Claude's request for a code, if it needs one. Claude's theme and trust-this-folder screens do not appear. When the sign-in ends, PMOS tests the login by itself. **The Claude login on this computer** is the login your usual terminal uses (`~/.claude.json`); PMOS no longer points it at a different file. You choose between two logins only: **The Claude login on this computer** and **A separate login just for PMOS**. The test passes for a login that works in your terminal. Claude updates its own files when it runs, and the test does not count that as a changed setup.
 - **Documents not written yet.** A document that does not exist yet shows **Draft it**, in its stage or ahead of it. The agent writes a draft. Nothing is issued until you read it.

package/workspace/guide/published-board.md

@@ -2,7 +2,7 @@
 type: Guide
 title: "Published board: a read-only copy of a Board"
 description: "What a published board is, how to publish one from the Board, what a reader sees and cannot do, and how to preview one."
-timestamp: 2026-11-01
+timestamp: 2026-11-04
 ---
 
 # Published board: a read-only copy of a Board
@@ -18,7 +18,10 @@ Press the share icon on the Board's toolbar. A popover opens under it, inside th
 The button is not on a narrow screen (720 px or less) and not on the All products page. Open one product to publish from it.
 
 1. **Set the host.** The first time, the popover asks for the address of the board host. Ask the person who runs it. Write it as `https://boards.example.com`. The **Change** button on the form sets it again. If the computer has the `PMOS_BOARDS_HOST` variable, the variable is used.
-2. **What to share.** The product of this board is picked. Press a program to add it. Press **An initiative** to pick one initiative. Press a picked chip again to remove it. **Publish** stays off while nothing is picked.
+2. **What to share.** The product of this board is picked. Your other products and your programs are chips under **Products** and **Programs**. A program chip names the products it reaches. Press a chip to add it. Press **Initiative** to pick one initiative of this board. Press a picked chip again to remove it. **Publish** stays off while nothing is picked.
+   - **Several picks are one link.** The reader sees one tab for each pick, in the order you picked them. A program tab opens the program's page with all its products. One pick shows no tabs.
+   - **The name.** With two or more picks, the link's name is made from them: three names, then "+ N more". Press the pencil to change it. **Republish** keeps every pick and the name.
+   - **The size.** The whole link can be at most 2 MB. When your picks are more, PMOS says so and sends nothing. Pick less.
 3. **Team.** Type the name of a team, or leave it empty. The host tells you when there is no team with that name.
 4. **Password.** It is on, with a password that PMOS made. Press **New** for another one, or write your own. Turn the switch off for a link with no password.
 5. **Ends.** The link ends after 1, 7 or 30 days.
@@ -54,6 +57,14 @@ The chips are **All**, **Yours** and one for each team. **Yours** shows only whe
 - **Yours.** Your own links have **Republish** and **Turn off**, the same as in the Publish popover. **Turn off** asks you to press a second time.
 - **A date in red.** The copy ends within a day and a half.
 
+**Shared with you.** Paste a shared board link in the field at the top of **Shared** and press **+**. PMOS asks the host first. When the board has a password, PMOS asks for it once. PMOS keeps the link and its password on this computer only, the same as a team password. The board then shows under **Shared with you** and on the **With you** chip.
+
+- Press the name of a board to open it in a new browser tab. You do not type its password again.
+- A board that ends within 7 days shows how many days are left.
+- A board that has ended, was turned off, or has a new password stays as one dimmed line with the reason. Press the name of a board with a new password to type it. Press **×** to forget a board.
+
+**Open in my PMOS.** A shared board has two icons at the end of its "shared by" line. **Open in my PMOS** opens Board › Shared in the PMOS on the reader's own computer, with the link already in the field. Nothing is added until the reader presses **+**. The link never carries the password. It works when PMOS runs at its usual address, `http://127.0.0.1:7433`. **Get PMOS** opens pm-os.app/welcome in a new tab.
+
 **A team that cannot be read.** One line shows in its place. It says if the team password was changed, if the host locked the team after too many wrong tries, or if the host did not answer. Press **Paste a new invite link** or **Refresh**. The other teams still show. PMOS shows no old rows for a team it cannot read.
 
 **Leave a team.** Press the chip of the team. Then press **Leave team**, and press it a second time. PMOS forgets the team and its password on this computer. The copies that you published stay on the host. Join again with the invite link.
@@ -66,7 +77,8 @@ The tab is not in the read-only Board. A reader sees no Shared tab.
 - On the Timeline, the view opens on today.
 - On the Timeline, a milestone ◇ sits on its date, the same as on your own Board. A reader cannot press it.
 - The span picker, the Deliveries lane, and the folds of a program and a product.
-- One line above the Board. It names the selection, the date of the copy, who shared it and when the link ends.
+- One line above the Board. It names the selection, the date of the copy, who shared it and when the link ends. It ends with **Open in my PMOS** and **Get PMOS**.
+- One tab for each pick, when the link holds two or more products or programs.
 - A viewer for each initiative. Press the name of an initiative to open it, on the stage track or on the Timeline. The viewer shows the stage card, About and Tasks. Tasks show for every initiative, also when a stage has a note such as "The rest, by work package". Tasks show as a List or as a Timeline, grouped by stage, owner or status.
 - The panel divider and the panel layout: full screen, split or slide over.
 

package/workspace/lib/board-pack.js

@@ -190,4 +190,47 @@ function buildPack({ ws, board, selection, answers, meta }) {
   return pack;
 }
 
-module.exports = { VIEWS, SCHEMA, MAX_BYTES, KINDS, MODEL_KEYS, buildPack, assertSize, teammateDash };
+/** The name of a link of several picks (batch 27 item 1, ShA): the first three names, then "+ N more". */
+function nameOf(labels) {
+  const l = (labels || []).map((x) => String(x || '').trim()).filter(Boolean);
+  return l.length > 3 ? l.slice(0, 3).join(' + ') + ' + ' + (l.length - 3) + ' more' : l.join(' + ');
+}
+
+/** One pack for several products and programs (batch 27 item 1, ShA): one link, one tab per pick.
+ *   packs   [pack]  one per product, each made by buildPack for that product's picks, so each is swept as it is today
+ *   parts   [{ label, ws, board, program?, kind? }]  the tabs, in pick order: a product's Board, or a program's page opened on its home product
+ *   name    the link's name (nameOf the parts' labels when the PM did not rename it)
+ * The answers are joined: each product's keys name its ws, so they do not meet. The programs list is the one answer every product carries:
+ * a program is joined by id, its members being the union of what each product's pack kept. The 2 MB check runs on the whole. */
+function combinePacks(packs, parts, name) {
+  const list = (packs || []).filter((p) => p && p.schema === SCHEMA && p.responses);
+  if (!list.length) plain('There is nothing to publish.');
+  const first = list[0];
+  const responses = {}; const progs = new Map();
+  for (const pk of list) {
+    for (const k of Object.keys(pk.responses)) {
+      if (k === '/api/programs') {
+        for (const p of (pk.responses[k] && pk.responses[k].programs) || []) {
+          if (!p || !p.id) continue;
+          const had = progs.get(p.id);
+          if (!had) { progs.set(p.id, clone(p)); continue; }
+          const seen = new Set((had.members || []).map((m) => m.ws + '|' + m.initiative));
+          for (const m of p.members || []) if (m && !seen.has(m.ws + '|' + m.initiative)) { had.members.push(clone(m)); seen.add(m.ws + '|' + m.initiative); }
+        }
+      } else if (!(k in responses)) responses[k] = pk.responses[k];
+    }
+  }
+  responses['/api/programs'] = { ok: true, programs: [...progs.values()] };
+  const sorted = {}; for (const k of Object.keys(responses).sort()) sorted[k] = responses[k];
+  const tabs = (parts || []).filter((t) => t && t.ws).map((t) => Object.assign({ label: String(t.label || t.ws), ws: String(t.ws), board: String(t.board || t.ws) }, t.program ? { program: String(t.program) } : {}));
+  const label = String(name || '').trim() || nameOf(tabs.map((t) => t.label));
+  const pack = { schema: SCHEMA, viewer: first.viewer || '', scope: { kind: 'multi', id: tabs.map((t) => t.ws + (t.program ? ':' + t.program : '')).join(','), label }, by: first.by || '', at: first.at || '', ends: first.ends || '' };
+  if (first.hub) pack.hub = first.hub;
+  if (first.view) pack.view = first.view;
+  if (tabs.length) pack.parts = tabs;   // the read-only Board opens on the first, and draws the tab row only for two or more
+  pack.responses = sorted;
+  assertSize(pack);
+  return pack;
+}
+
+module.exports = { VIEWS, SCHEMA, MAX_BYTES, KINDS, MODEL_KEYS, buildPack, assertSize, teammateDash, combinePacks, nameOf };

package/workspace/lib/board-publish-choices.js

@@ -1,7 +1,8 @@
 'use strict';
 /* board-publish-choices.js — what can be published from a board (initiative board-publish, slice 2, page side; PRD P1): its product, the programs that hold
  * one of its initiatives, and its initiatives. Read from the Board's own routes, the way lib/board-pack-route.js reads them.
- *   choicesOf(req, ctx, ws, board) -> { products, programs, initiatives } | null while the board is still being read */
+ *   choicesOf(req, ctx, ws, board) -> { products, programs, initiatives } | null while the board is still being read
+ *   contextOf(req, ctx, ws, board) -> { model, programs, boards } | null   what a publish of several picks needs (lib/board-publish-parts.js) */
 const BoardPremium = require('./routes-board-premium.js');
 const Programs = require('./routes-programs.js');
 
@@ -13,13 +14,28 @@ async function via(mod, pathAndQuery, req, ctx) {
   return handled === false ? null : out;
 }
 
-async function choicesOf(req, ctx, ws, board) {
+/** What a publish needs to know besides the picks: every program (with its members), and the products (boards) this workspace has, from the
+ *  board on screen's own switcher. { model, programs, boards } | null while the board is still being read. */
+async function contextOf(req, ctx, ws, board) {
   const b = await via(BoardPremium, '/api/board-premium?ws=' + encodeURIComponent(ws) + '&board=' + encodeURIComponent(board), req, ctx);
   if (!b || b.ok === false || !b.model) return null;
-  const rows = (b.model.rows || []).filter((r) => r && r.id); const have = new Set(rows.map((r) => r.id));
   const pg = await via(Programs, '/api/programs', req, ctx);
-  const programs = ((pg && pg.programs) || []).filter((p) => p && p.id && (p.members || []).some((m) => m && m.ws === ws && have.has(m.initiative))).map((p) => ({ id: p.id, label: p.title || p.id }));
-  return { products: [{ id: board, label: (b.model.board && b.model.board.name) || board }], programs, initiatives: rows.map((r) => ({ id: r.id, label: r.title || r.id })) };
+  const here = { id: board, ws, name: (b.model.board && b.model.board.name) || board };
+  const boards = [here].concat(((b.model.board && b.model.board.switcher) || []).filter((x) => x && x.ws && !(x.ws === ws && x.id === board)));
+  return { model: b.model, programs: ((pg && pg.programs) || []).filter((p) => p && p.id && !p.archived), boards };
+}
+
+/** The Share sheet's chips (batch 27 item 1, ShA): the board on screen first, then the other products; every program that holds an initiative of a
+ *  product here, with the products it reaches; and the initiatives of the board on screen. A program says which products it reaches (`reach`). */
+async function choicesOf(req, ctx, ws, board) {
+  const c = await contextOf(req, ctx, ws, board);
+  if (!c) return null;
+  const rows = (c.model.rows || []).filter((r) => r && r.id); const have = new Set(rows.map((r) => r.id));
+  const nameOf = new Map(c.boards.map((x) => [x.ws, x.name]));
+  const programs = c.programs.filter((p) => (p.members || []).some((m) => m && (m.ws === ws ? have.has(m.initiative) : nameOf.has(m.ws))))
+    .map((p) => ({ id: p.id, label: p.title || p.id, reach: [...new Set((p.members || []).map((m) => m && nameOf.get(m.ws)).filter(Boolean))].join(', ') }));
+  const products = c.boards.map((x, i) => Object.assign({ id: x.id, ws: x.ws, label: x.name || x.id }, i === 0 ? { n: rows.length } : {}));
+  return { products, programs, initiatives: rows.map((r) => ({ id: r.id, label: r.title || r.id })) };
 }
 
-module.exports = { choicesOf };
+module.exports = { choicesOf, contextOf };

package/workspace/lib/board-publish-parts.js

@@ -0,0 +1,95 @@
+'use strict';
+/* board-publish-parts.js — a publish of several products and programs in one link (batch 27 item 1, ShA; initiative board-share-several).
+ *
+ * A PART is one pick of the Share sheet, in pick order: { kind: 'product', ws, board } · { kind: 'program', id } · { kind: 'initiative', id, ws, board }.
+ * A program can reach several products: it is picked by id, and its products come from its members (GET /api/programs).
+ *
+ *   groupsOf(parts, programs)  -> { groups: [{ ws, board, select: 'kind:id,…' }], tabs: [{ label?, ws, board, program?, kind, id }] } | { error }
+ *                                 one group per product the picks touch (its selection is the union of the picks there), one tab per pick. Pure.
+ *   packOf(parts, { programs, boards, name, make }) -> { ok, pack, kind, label } | { ok: false, status, error }
+ *                                 make(group) -> { ok, pack } is lib/routes-board-publish.js makePack: each product's pack is made and swept as today,
+ *                                 then lib/board-pack.js combinePacks joins them. A product that cannot be read stops the publish with its sentence.
+ *   parseParts(raw)            -> [part] | null   the parts of a request, checked; null when the request is not one of parts */
+const Pack = require('./board-pack.js');
+
+const MAX_PARTS = 12;
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,119}$/;
+
+function parseParts(raw) {
+  if (!Array.isArray(raw) || !raw.length) return null;
+  const out = [];
+  for (const p of raw.slice(0, MAX_PARTS + 1)) {
+    if (!p || typeof p !== 'object') return null;
+    const kind = String(p.kind || '');
+    if (kind === 'program') { if (!ID.test(String(p.id || ''))) return null; out.push({ kind, id: String(p.id) }); continue; }
+    if (kind !== 'product' && kind !== 'initiative') return null;
+    const ws = String(p.ws || ''); const board = String(p.board || ws);
+    if (!ID.test(ws) || !ID.test(board)) return null;
+    if (kind === 'initiative' && !ID.test(String(p.id || ''))) return null;
+    out.push(kind === 'product' ? { kind, ws, board } : { kind, id: String(p.id), ws, board });
+  }
+  return out.length > MAX_PARTS ? null : out;
+}
+
+function groupsOf(parts, programs, boards) {
+  const G = new Map(); const tabs = [];
+  const boardOf = (ws) => ((boards || []).find((b) => b && b.ws === ws) || {}).id || ws;
+  const add = (ws, board, sel) => { const g = G.get(ws) || { ws, board, select: [] }; if (!g.select.includes(sel)) g.select.push(sel); G.set(ws, g); return g; };
+  for (const p of parts) {
+    if (p.kind === 'product') { add(p.ws, p.board, 'product:' + p.board); tabs.push({ kind: 'product', ws: p.ws, board: p.board }); continue; }
+    if (p.kind === 'initiative') { add(p.ws, p.board, 'initiative:' + p.id); tabs.push({ kind: 'initiative', id: p.id, ws: p.ws, board: p.board }); continue; }
+    const prog = (programs || []).find((x) => x && x.id === p.id);
+    if (!prog) return { error: 'The program "' + p.id + '" is not in this workspace.' };
+    const wss = [...new Set((prog.members || []).map((m) => m && m.ws).filter(Boolean))];
+    if (!wss.length) return { error: prog.title ? prog.title + ' has no initiatives to share yet.' : 'This program has no initiatives to share yet.' };
+    for (const ws of wss) add(ws, boardOf(ws), 'program:' + p.id);
+    const home = prog.home && wss.includes(prog.home) ? prog.home : wss[0];
+    tabs.push({ kind: 'program', id: p.id, ws: home, board: boardOf(home), program: p.id, label: prog.title || p.id });
+  }
+  return { groups: [...G.values()].map((g) => Object.assign({}, g, { select: g.select.join(',') })), tabs };
+}
+
+/** The label of a product or initiative tab, read from that product's own pack: the board's name, or the initiative's title. */
+function labelFrom(pack, tab) {
+  const key = Object.keys((pack && pack.responses) || {}).find((k) => k.startsWith('/api/board-premium?') && new URLSearchParams(k.split('?')[1]).get('ws') === tab.ws);
+  const model = key && pack.responses[key] && pack.responses[key].model;
+  if (tab.kind === 'initiative') { const r = ((model && model.rows) || []).find((x) => x && x.id === tab.id); return (r && r.title) || tab.id; }
+  return (model && model.board && (model.board.product || model.board.name)) || tab.ws;
+}
+
+async function packOf(parts, o) {
+  const g = groupsOf(parts, o.programs, o.boards);
+  if (g.error) return { ok: false, status: 400, error: g.error };
+  const packs = new Map();
+  for (const grp of g.groups) {
+    const r = await o.make(grp);
+    if (!r.ok) {
+      // a product a program only reaches, with nothing of the program on it now: left out, the program's other products still go
+      if (r.status === 400 && /not on this board/.test(r.error) && !parts.some((p) => p.ws === grp.ws)) continue;
+      return r;
+    }
+    packs.set(grp.ws, r.pack);
+  }
+  if (!packs.size) return { ok: false, status: 400, error: 'Nothing in these picks can be shared yet.' };
+  // one tab per pick; an initiative joins its product's tab when that product is picked too, and initiatives of one product share a tab
+  const tabs = []; const seen = new Map();
+  for (const t of g.tabs) {
+    if (!packs.has(t.ws)) continue;
+    const key = t.ws + '|' + (t.program || '');
+    const label = t.label || labelFrom(packs.get(t.ws), t);
+    if (seen.has(key)) { const was = seen.get(key); if (was.kind === 'initiative' && t.kind === 'product') { was.kind = 'product'; was.label = label; } continue; }
+    const tab = { kind: t.kind, label, ws: t.ws, board: t.board }; if (t.program) tab.program = t.program;
+    seen.set(key, tab); tabs.push(tab);
+  }
+  if (packs.size === 1 && tabs.length === 1 && !tabs[0].program) {   // one pick on one product: the pack as it is today, renamed when the PM did
+    const pack = [...packs.values()][0]; if (String(o.name || '').trim()) pack.scope = Object.assign({}, pack.scope, { label: String(o.name).trim().slice(0, 120) });
+    return { ok: true, pack, kind: (pack.scope && pack.scope.kind) || tabs[0].kind, label: pack.scope.label };
+  }
+  try {
+    const pack = Pack.combinePacks([...packs.values()], tabs, o.name);
+    const kind = tabs.length > 1 ? 'multi' : (tabs[0] && tabs[0].kind) || 'multi';
+    return { ok: true, pack, kind, label: pack.scope.label };
+  } catch (e) { return { ok: false, status: 400, error: String((e && e.message) || e) }; }
+}
+
+module.exports = { MAX_PARTS, parseParts, groupsOf, packOf };