create-pmos 0.497.0 → 0.499.0

package/workspace/lib/context-use.js

@@ -5,26 +5,55 @@ const path = require('path');
 /* context-use.js — how full a session's context window is, and whether Claude proposes to compact it (batch 13 item 8, canvas XctxA1Desk).
  *
  *   of(seen, hints) → { used, window, pct, level, at } | null
- *     seen  = transcript-read's `context`: { used, peak, at } of the newest real (not subagent) model turn, or null
- *     hints = model ids that can name the window: the model PMOS started the session with, the CLI's own setting
+ *     seen  = transcript-read's `context`: { used, peak, at, model } of the newest real (not subagent) model turn, or null
+ *     hints = model ids that can name the window: the model PMOS started the session with, the CLI's own setting (cliHints, which
+ *             also carries OFF_HINT when CLAUDE_CODE_DISABLE_1M_CONTEXT is set)
+ *   native1M(model) → true for a model whose window is 1M with no [1m] suffix
  *   advise(ctx, shown) → 'compact' | null
- *   cliHints(root, home?) → the model the CLI itself is set to: `model` in ~/.claude and <root>/.claude settings, and ANTHROPIC_MODEL
+ *   cliHints(root, home?) → the model the CLI itself is set to: `model` in ~/.claude and <root>/.claude settings, and ANTHROPIC_MODEL;
+ *                           OFF_HINT last when CLAUDE_CODE_DISABLE_1M_CONTEXT is set in the environment or in a settings file's `env`
  * The words under the wedge ("116k of 200k used · last turn 10:12") are drawn by pm/ctx-wedge.js, in the PM's own clock.
  *
  * THE NUMBER is what the next turn starts from: the newest reply's input + cache-read + cache-write tokens (what the model was sent) plus
- * its output. It is not a running total, so it drops after a compact. THE WINDOW is 1M when a hint names a [1m] model or a turn already
- * went past 200k, else 200k (the CLI's default). With no turn read, or an agent that is not Claude, there is nothing: no %, no advice.
+ * its output. It is not a running total, so it drops after a compact. THE WINDOW is 1M when a turn already went past 200k, when a hint
+ * names a [1m] model, or when the model is one the CLI runs with 1M by itself (batch 25 item 8: Claude Code's model docs list Fable,
+ * Opus 4.7 and later, Sonnet 5 and later and Haiku 5.5; the CLI's default model, Opus 5.5, is one of them). The model of the newest turn
+ * in the transcript decides; with none read, the first hint does. CLAUDE_CODE_DISABLE_1M_CONTEXT makes the CLI treat every model as 200k, so it does
+ * here too. An unknown model is 200k. With no turn read, or an agent that is not Claude, there is nothing: no %, no advice.
  * Advice only on the PM's turn (a session that works is never told to compact), and only from 70%. */
 
 const BASE = 200000;
 const LONG = 1000000;
 const LEVELS = [[90, 'crit'], [70, 'warn'], [50, 'quiet']];
 
+const OFF_HINT = '[no-1m]';   // not a model: cliHints' word for CLAUDE_CODE_DISABLE_1M_CONTEXT, so a caller passes one list
 const isLong = (m) => /\[1m\]/i.test(String(m || ''));
 
+/* The release a model id names: claude-opus-4-8 → [4, 8], claude-sonnet-5-20260101 → [5, 0], opus → null (an alias: the latest). */
+function versionOf(model, family) {
+  const m = String(model).match(new RegExp(`${family}-(\\d+)(?:[-.](\\d{1,2}))?(?!\\d)`, 'i'));
+  return m ? [Number(m[1]), Number(m[2] || 0)] : null;
+}
+const atLeast = (v, major, minor) => v[0] > major || (v[0] === major && v[1] >= minor);
+function native1M(model) {
+  const s = String(model || '').toLowerCase();
+  if (!s) return false;
+  if (isLong(s)) return true;
+  if (/claude-\d/.test(s)) return false;                      // the old naming (claude-3-5-sonnet): all 200k
+  if (/fable/.test(s)) return true;
+  for (const [family, major, minor] of [['opus', 4, 7], ['sonnet', 5, 0], ['haiku', 5, 5]]) {
+    if (!new RegExp(`(^|[^a-z])${family}([^a-z]|$)`).test(s)) continue;
+    const v = versionOf(s, family);
+    return v ? atLeast(v, major, minor) : true;                  // a bare alias names the latest release
+  }
+  return false;
+}
+
 function of(seen, hints = []) {
   if (!seen || !(seen.used > 0)) return null;
-  const window = hints.some(isLong) || (seen.peak || 0) > BASE ? LONG : BASE;
+  const models = hints.filter((h) => h && h !== OFF_HINT);
+  const long = !hints.includes(OFF_HINT) && (models.some(isLong) || native1M(seen.model || models[0]));
+  const window = long || (seen.peak || 0) > BASE ? LONG : BASE;
   const pct = Math.min(100, Math.floor((seen.used / window) * 100));   // floor: 69.6% is not yet 70%
   const lv = LEVELS.find(([n]) => pct >= n);
   return { used: seen.used, window, pct, level: lv ? lv[1] : null, at: seen.at || null };
@@ -37,18 +66,31 @@ function advise(ctx, shown) {
 
 /* The CLI's own model setting. A session PMOS started with no model choice runs the CLI's default, and that setting is what can make it a
  * [1m] model. Read again only when a settings file changes (sessionList runs on every broadcast). */
-const memo = new Map();   // file → { stamp, model }
-function modelIn(file) {
+const memo = new Map();   // file → { stamp, model, off }
+const OFF = 'CLAUDE_CODE_DISABLE_1M_CONTEXT';
+const isOn = (v) => v != null && v !== '' && !/^(0|false|no)$/i.test(String(v));
+function settingsIn(file) {
   let stamp = null; try { const st = fs.statSync(file); stamp = st.size + ':' + st.mtimeMs; } catch { return null; }
-  const m = memo.get(file); if (m && m.stamp === stamp) return m.model;
-  let model = null; try { const j = JSON.parse(fs.readFileSync(file, 'utf8')); model = typeof j.model === 'string' ? j.model : null; } catch { model = null; }
-  memo.set(file, { stamp, model });
-  return model;
+  const m = memo.get(file); if (m && m.stamp === stamp) return m;
+  let model = null, off = false;
+  try {
+    const j = JSON.parse(fs.readFileSync(file, 'utf8'));
+    model = typeof j.model === 'string' ? j.model : null;
+    off = !!(j.env && typeof j.env === 'object' && isOn(j.env[OFF]));
+  } catch { model = null; off = false; }
+  const out = { stamp, model, off };
+  memo.set(file, out);
+  return out;
 }
-function cliHints(root, home = os.homedir()) {
+function settingsFiles(root, home) {
   const files = [path.join(home, '.claude', 'settings.json')];
   if (root) files.push(path.join(String(root), '.claude', 'settings.json'), path.join(String(root), '.claude', 'settings.local.json'));
-  return files.map(modelIn).concat(process.env.ANTHROPIC_MODEL || null).filter(Boolean);
+  return files;
+}
+function cliHints(root, home = os.homedir()) {
+  const read = settingsFiles(root, home).map((f) => settingsIn(f) || {});
+  const off = isOn(process.env[OFF]) || read.some((x) => x.off);
+  return read.map((x) => x.model || null).concat(process.env.ANTHROPIC_MODEL || null, off ? OFF_HINT : null).filter(Boolean);
 }
 
-module.exports = { of, advise, cliHints, BASE, LONG };
+module.exports = { of, advise, cliHints, native1M, OFF_HINT, BASE, LONG };

package/workspace/lib/engine/workflow-state.js

@@ -556,6 +556,29 @@ function profileOf(root) {
   } catch { return 'product-code'; }
 }
 
+/*
+ * workflowOf(root, id) — the workflow an initiative runs, when its repository runs initiatives on workflows (Boards, Settings ›
+ * Workflows). The workspace gives every repository it keeps state for a default board, so every initiative there runs a workflow:
+ * an `ini-wf` line in the boards ledger (<state dir>/boards.jsonl, the dirs workspace/server.js stateDirFor reads) names its
+ * own, else it runs its board's (Product feature by default). A repository runs on workflows when it holds that ledger or a
+ * pmos/state/ dir. PMOS itself holds neither (its state is the workspace's own), so it still routes by lane and R0 still binds it.
+ * → the workflow's id, '' (its board's), or null (no workflows). The ledger is read again when its size or mtime changes.
+ */
+const wfMemo = new Map();
+function workflowOf(root, id) {
+  const f = [['pmos', 'state'], ['state'], ['.pmos']].map((rel) => path.join(root, ...rel, 'boards.jsonl')).find((x) => fs.existsSync(x));
+  const on = !!f || fs.existsSync(path.join(root, 'pmos', 'state'));
+  if (!on) return null;
+  let key = '';
+  try { const st = f ? fs.statSync(f) : null; key = st ? st.size + ':' + st.mtimeMs : '-'; } catch { key = '?'; }
+  let m = wfMemo.get(root);
+  if (!m || m.key !== key) {   // a held module sees a new line on the next read (the in-process freshness rule)
+    m = { key, wf: new Map() };
+    for (const l of f ? jsonl.readJsonl(f).rows : []) if (l && l.kind === 'ini-wf' && typeof l.id === 'string' && typeof l.wf === 'string' && l.wf) m.wf.set(l.id, l.wf);
+    wfMemo.set(root, m);
+  }
+  return m.wf.get(id) || '';
+}
 /** The lanes a repository's initiatives may declare — what the lane picker offers and the lane write accepts. */
 function laneNames(profile) { return laneDefs.laneNames(profile === 'pm-artifacts' ? 'pm-artifacts' : 'product-code'); }
 function lanesFor(root) {
@@ -735,6 +758,7 @@ function computeWorkflowDerived(id, opts) {
   // ── route ─ the lane is chosen and the two intake questions are answered ─────────────────────
   const sRoute = specimenRoute(fm.specimen_test);
   const fRoute = surfaceRoute(fm.surface_check);
+  const onWf = workflowOf(root, id);
   {
     const missing = [];
     if (sRoute === 'undeclared' || sRoute === 'malformed') missing.push('specimen_test');
@@ -742,6 +766,10 @@ function computeWorkflowDerived(id, opts) {
     if (!missing.length) {
       steps.push(step('route', 'route', 'done',
         `${lane} lane · specimen test ${sRoute} · surface ${fRoute}`));
+    } else if (onWf !== null) {
+      // Batch 25 item 6: an initiative on a workflow is routed. The workflow's stages say what comes first, and PMOS proposes a
+      // switch when the BRD says another workflow fits, so the two intake questions are not asked of it again.
+      steps.push(step('route', 'route', 'done', `${onWf ? `runs the ${onWf} workflow` : 'runs its board\'s workflow'} — the workflow routes it`));
     } else if (effLane !== 'feature') {
       // The routing questions are asked of feature work only.
       steps.push(step('route', 'route', 'done', `${lane} lane — routing questions are for features only (${CUT_NOTE})`));

package/workspace/lib/git-identity-cli.js

@@ -0,0 +1,67 @@
+'use strict';
+/* git-identity-cli.js — `pmos git-identity [set …]` (feedback batch 25 item 1, lib/git-identity.js).
+ *
+ *   pmos git-identity                                             this repository's identity and push login, or what is missing and
+ *                                                                 the ones the PM uses elsewhere
+ *   pmos git-identity set --name <n> --email <e> [--login <gh>]   save the PM's choice in this repository's own git config (never --global)
+ *   pmos git-identity set --login <gh>                            save only the GitHub login that pushes this repository
+ *
+ * An agent runs the first when a commit fails with "Author identity unknown" or a push fails with "Repository not found", asks the
+ * PM once which identity and GitHub login this product uses, and runs `set` with the answer. Nothing here picks one by itself. The
+ * other repositories are the ones the workspace hosts (workspaces.json in the state folder). Exit codes: 0 done (or all is set),
+ * 1 something is missing or refused, 2 usage. */
+const fs = require('fs');
+const path = require('path');
+const G = require('./git-identity.js');
+const stateRoot = require('./state-root');
+
+const COMMANDS = { 'git-identity': ['set'] };
+const USAGE = [
+  'usage: pmos git-identity [set [--name <name> --email <email>] [--login <github-login>]]',
+  '  pmos git-identity                                          the identity and GitHub login this repository uses, or the ones you use elsewhere',
+  '  pmos git-identity set --name <n> --email <e> --login <gh>  save your choice for this repository only',
+  '  pmos git-identity set --login <gh>                         save only the GitHub login that pushes this repository',
+];
+
+function hostedRoots(env) {
+  let reg = [];
+  try { reg = JSON.parse(fs.readFileSync(path.join(stateRoot.defaultRoot({ env }), 'workspaces.json'), 'utf8')); } catch { reg = []; }
+  return Array.isArray(reg) ? reg.filter((x) => x && typeof x.root === 'string').map((x) => x.root) : [];
+}
+function flag(argv, name) { const i = argv.indexOf(name); return i >= 0 && i + 1 < argv.length ? argv[i + 1] : null; }
+
+const ghLine = (login) => `GH_TOKEN="$(gh auth token --user ${login})" gh …`;
+
+function run(argv, { say = console.log, cwd = process.cwd(), env = process.env, git = 'git' } = {}) {
+  const sub = argv[1];
+  if (sub === 'help' || sub === '--help') { USAGE.forEach((l) => say(l)); return 0; }
+  if (!G.isRepo(cwd, git)) { say('This folder is not a git repository.'); return 1; }
+  if (sub === 'set') {
+    const name = flag(argv, '--name'); const email = flag(argv, '--email'); const login = flag(argv, '--login');
+    if ((name == null) !== (email == null) || (name == null && login == null)) { USAGE.forEach((l) => say(l)); return 2; }
+    const r = G.set(cwd, { name: name == null ? undefined : name, email: email == null ? undefined : email, login: login == null ? undefined : login }, { git });
+    if (!r.ok) { say(`Not saved: ${r.error}.`); return 1; }
+    if (name != null) say(`This repository now commits as ${r.name} <${r.email}>.`);
+    if (login != null) { say(`git push here now uses the GitHub login ${r.login}, whichever gh login is active.`); say(`Run gh here as: ${ghLine(r.login)}`); }
+    return 0;
+  }
+  if (sub !== undefined) { USAGE.forEach((l) => say(l)); return 2; }
+  const have = G.identity(cwd, { git });
+  const login = G.pushLogin(cwd, { git });
+  const okId = !!(have.name && have.email);
+  const needLogin = !login && G.githubHttps(cwd, { git });   // an ssh or non-GitHub origin does not use the login
+  if (okId) say(`This repository commits as ${have.name} <${have.email}>.`);
+  if (login) { say(`It pushes with the GitHub login ${login}. Run gh here as: ${ghLine(login)}`); }
+  if (okId && !needLogin) return 0;
+  say(okId ? 'It has no saved GitHub login, so git push uses whichever gh login is active and can fail with "Repository not found".'
+    : 'This repository has no git identity, so commits fail.');
+  say('Ask the PM once which ' + (okId ? 'GitHub login' : needLogin ? 'identity and GitHub login' : 'identity') + ' this product uses, then run:');
+  say('  pmos git-identity set' + (okId ? '' : ' --name "<name>" --email "<email>"') + (needLogin ? ' --login <github-login>' : ''));
+  const list = G.choices(cwd, hostedRoots(env), { git });
+  if (!list.length) { say('No other repository here has one to offer.'); return 1; }
+  say('Used in the other repositories:');
+  list.forEach((c, i) => say(`  ${i + 1}. ${c.name} <${c.email}>${c.login ? ', login ' + c.login : ''} — ${c.repos.map((r) => path.basename(r)).join(', ')}`));
+  return 1;
+}
+
+module.exports = { run, COMMANDS, USAGE };

package/workspace/lib/git-identity.js

@@ -0,0 +1,93 @@
+'use strict';
+/* git-identity.js — which git author identity a product repository commits as (feedback batch 25 item 1).
+ *
+ *   identity(root, { git })        → { name, email } as git resolves it in `root` (local, then global), either may be null
+ *   localIdentity(root, { git })   → { name, email } set in `root`'s own .git/config only, either may be null
+ *   pushLogin(root, { git })       → the GitHub login this repository pushes with (`pmos.pushLogin` in its own config), or null
+ *   choices(root, roots, { git })  → [{ name, email, login, repos: [root…] }] the distinct identities (and push logins) of the other repositories
+ *   set(root, { name, email, login }, { git }) → { ok, name, email, login } | { ok: false, error }   writes `root`'s own config, never --global
+ *
+ * Why: a Mac with no global identity keeps one per repository, and the PM uses different ones for different products (a personal
+ * one, a work one). A product repository seeded from another had none, so the agent could not commit and left the PM's files staged.
+ * PMOS never inherits or guesses an identity: committing as the wrong person cannot be taken back once pushed. The agent asks the PM
+ * once which identity this product uses, offering choices() (`pmos git-identity`), and saves the answer with set()
+ * (`pmos git-identity set`). The kit's AGENTS.md says so.
+ *
+ * The push login (batch 25, after #1176): the PM's Mac has more than one gh login (wawancsui, wsetiawan-pm), and a private repository
+ * of one account is "not found" to the other. set() with a login saves it as `pmos.pushLogin` and gives the repository its own
+ * credential helper for https://github.com: the inherited helpers are reset, and the one left asks gh for that login's token
+ * (`gh auth token --user <login>`), so `git push` there uses that login whichever gh login is active. `gh` commands run in the
+ * repository take GH_TOKEN from the same call (lib/git-identity-cli.js prints the line). The login is asked once, with the identity. */
+const cp = require('child_process');
+const path = require('path');
+
+function cfg(git, root, args) {
+  try {
+    const out = cp.execFileSync(git, ['config', ...args], { cwd: root, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000, windowsHide: true,
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } });
+    return String(out).trim() || null;
+  } catch { return null; }
+}
+function isRepo(root, git = 'git') {
+  try { cp.execFileSync(git, ['rev-parse', '--git-dir'], { cwd: root, stdio: 'ignore', timeout: 5000, windowsHide: true }); return true; } catch { return false; }
+}
+function identity(root, { git = 'git' } = {}) { return { name: cfg(git, root, ['user.name']), email: cfg(git, root, ['user.email']) }; }
+function localIdentity(root, { git = 'git' } = {}) { return { name: cfg(git, root, ['--local', 'user.name']), email: cfg(git, root, ['--local', 'user.email']) }; }
+
+/** The identities the PM set in the other repositories, each once, with the repositories that use it, in the order first seen. */
+function choices(root, roots, { git = 'git' } = {}) {
+  const self = root ? path.resolve(root) : null;
+  const seen = new Map();
+  for (const r of roots || []) {
+    if (!r || path.resolve(r) === self) continue;
+    const id = localIdentity(r, { git });
+    if (!id.name || !id.email) continue;
+    const login = pushLogin(r, { git });
+    const k = id.name + '\n' + id.email + '\n' + (login || '');
+    if (!seen.has(k)) seen.set(k, { name: id.name, email: id.email, login, repos: [] });
+    const e = seen.get(k); if (!e.repos.includes(path.resolve(r))) e.repos.push(path.resolve(r));
+  }
+  return [...seen.values()];
+}
+
+/** True when origin is an https GitHub URL: the only case the saved login's credential helper serves (an ssh origin uses ssh keys). */
+function githubHttps(root, { git = 'git' } = {}) { return /^https:\/\/([^@/]+@)?github\.com\//i.test(cfg(git, root, ['--get', 'remote.origin.url']) || ''); }
+function pushLogin(root, { git = 'git' } = {}) { return cfg(git, root, ['--local', 'pmos.pushLogin']); }
+
+const LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,38})$/;   // a GitHub login: letters, digits and hyphens, so it is safe inside the helper's shell line
+const HELPER_KEY = 'credential.https://github.com.helper';
+const helperFor = (login) => `!f() { test "$1" = get || exit 0; echo username=${login}; echo "password=$(gh auth token --user ${login} --hostname github.com)"; }; f`;
+
+const ONE_LINE = (v, max) => typeof v === 'string' && v.trim().length >= 1 && v.trim().length <= max && !/[\r\n\x00-\x1f\x7f]/.test(v);
+const EMAIL = /^[^\s@<>]+@[^\s@<>]+$/;
+
+/** Save the PM's choice in this repository only: the identity (name and email together), the push login, or both. Refuses a folder
+ *  that is not a repository, a malformed name, email or login, and a call with nothing to save. */
+function set(root, { name, email, login } = {}, { git = 'git' } = {}) {
+  if (!root || !isRepo(root, git)) return { ok: false, error: 'this folder is not a git repository' };
+  const ident = name != null || email != null;
+  if (!ident && login == null) return { ok: false, error: 'give --name and --email, --login, or all three' };
+  if (ident) {
+    if (!ONE_LINE(name, 120) || /[<>]/.test(name)) return { ok: false, error: 'give a name of 1 to 120 characters on one line' };
+    if (!ONE_LINE(email, 254) || !EMAIL.test(email.trim())) return { ok: false, error: 'give an email address, for example you@example.com' };
+  }
+  if (login != null && !LOGIN.test(String(login).trim())) return { ok: false, error: 'give a GitHub login: letters, digits and hyphens, at most 39' };
+  if (ident) {
+    cfg(git, root, ['--local', 'user.name', name.trim()]);
+    cfg(git, root, ['--local', 'user.email', email.trim()]);
+  }
+  if (login != null) {
+    const l = String(login).trim();
+    cfg(git, root, ['--local', 'pmos.pushLogin', l]);
+    cfg(git, root, ['--local', '--unset-all', HELPER_KEY]);
+    cfg(git, root, ['--local', '--add', HELPER_KEY, '']);   // an empty value drops the helpers inherited from the global config
+    cfg(git, root, ['--local', '--add', HELPER_KEY, helperFor(l)]);
+  }
+  const now = localIdentity(root, { git });
+  if (ident && (now.name !== name.trim() || now.email !== email.trim())) return { ok: false, error: 'git did not save the identity' };
+  const l = pushLogin(root, { git });
+  if (login != null && l !== String(login).trim()) return { ok: false, error: 'git did not save the push login' };
+  return { ok: true, name: now.name, email: now.email, login: l };
+}
+
+module.exports = { identity, localIdentity, pushLogin, githubHttps, choices, set, isRepo, helperFor };

package/workspace/lib/initiative-cli.js

@@ -18,7 +18,9 @@
  * PM types the confirmation at a terminal, and an agent session passes with its own actor (D98); every other command
  * takes lib/actor.js fromCli: the PM at a terminal, the bound agent session from
  * PMOS_SESSION, `agent:unknown` otherwise. An agent's placement applies at once and its line names the agent (D98).
- * Work lanes only (D86 point 4): `list` and `export` leave document-lane initiatives out.
+ * Work lanes only (D86 point 4): `list` and `export` leave document-lane initiatives out. `list` names them in one closing
+ * line, because a record on a document lane is never on Home, the Board or the Roadmap: a feature record written by hand on
+ * the `prd` lane otherwise disappears with no word (batch 25 item 7). `new` refuses a document lane already (the writer).
  * D105 retired Now / Next / Later: `now`, `next` and `later` answer with what to use instead and change nothing.
  * Exit codes: 0 done, 1 refused, 2 usage.
  */
@@ -47,6 +49,16 @@ function startOnDefault(root, r, actor) {
   } catch { /* the initiative is made; it runs Product feature */ }
 }
 
+/** The records on a document lane (D86 point 4): never on the Roadmap, Home or the Board. Stopped and accepted ones are left out. */
+const documentsOf = (rows) => (rows || []).filter((r) => r && r.ok !== false && r.group && r.group !== 'work' && !r.accepted && !r.stopped)
+  .map((r) => ({ id: r.id, lane: r.lane || null }));
+const WORK_LANES = 'new-feature, improvement, bug-fix, discovery or chore';
+/** One line: what is not on the Roadmap, and what to do when it is work and not a document. */
+function docNote(docs) {
+  const names = docs.map((d) => `${d.id} (${d.lane || 'document'})`).join(', ');
+  return `Not on the Roadmap · ${docs.length} on a document lane: ${names}. A document lane does not show on Home or the Board. If it is work, set lane: in its record to ${WORK_LANES}.`;
+}
+
 const COMMANDS = { initiative: ['new', 'top', 'up', 'down', 'bottom', 'after', 'check-by', 'adopt', 'drop', 'list', 'export'] };
 /** The horizon verbs D105 retired: they answer with what to use instead. */
 const RETIRED = Object.freeze(['now', 'next', 'later']);
@@ -147,7 +159,7 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
     const stage = (id) => lifecycle.labelOf(byRow.get(id));
     if (json) {
       say(JSON.stringify({ ok: true, ranked: o.placed.ranked, byInit: o.placed.byInit, stages: Object.fromEntries(o.placed.ranked.map((id) => [id, stage(id)])),
-        proposals: o.placed.proposals.map((p) => ({ ...p, by: actorLib.pageName(p.by) })) }));
+        proposals: o.placed.proposals.map((p) => ({ ...p, by: actorLib.pageName(p.by) })), documents: documentsOf(o.rows) }));
       return 0;
     }
     const ids = o.placed.ranked;
@@ -163,6 +175,8 @@ async function run(argv, { say = (s) => console.log(s), cwd = process.cwd(), isT
       say(`  ${p.rank + 1}. ${id} — ${(byRow.get(id) || {}).title || id}${bits.length ? ' · ' + bits.join(' · ') : ''}`);
     }
     for (const p of o.placed.proposals) say(`proposal ${p.eid}: ${p.init} ${p.after ? `after ${p.after}` : 'to the top'} · ${actorLib.pageName(p.by)}`);
+    const docs = documentsOf(o.rows);
+    if (docs.length) say(docNote(docs));
     return 0;
   }
 

package/workspace/lib/pmos-verbs.js

@@ -98,6 +98,9 @@ const VERBS = Object.freeze({
   // Not a pm-os-absorb verb (run: null): the Grill and Forecast build (F-A) added it through the same table.
   forecast: Object.freeze({ module: 'forecast-cli.js', run: null, guide: 'forecast.md',
     help: 'pmos forecast baseline|baseline-off|turned … — a goal forecast\'s kept baseline, and the forecasts that turned (pmos forecast help)' }),
+  // Not a pm-os-absorb verb (run: null): feedback batch 25 item 1 added it through the same table.
+  'git-identity': Object.freeze({ module: 'git-identity-cli.js', run: null, guide: 'launcher.md',
+    help: 'pmos git-identity [set --name <n> --email <e> --login <gh>] — which git identity and GitHub login this repository uses; save your choice for it' }),
   launcher: Object.freeze({ module: 'launcher-cli.js', run: null, guide: 'launcher.md',
     help: 'pmos launcher on|off|status — a PMOS app and a login item, so the workspace starts without a terminal' }),
 });

package/workspace/lib/routes-boards.js

@@ -26,7 +26,8 @@
  *   POST /api/boards/settings      { ws, board, buildDeliver?, jira?, offer?, defTpl? }       → { ok, board }   jira: one key or a list
  *   POST /api/boards/ini-workflow  { ws, board, id, template?, stages, moveTo? }         → { ok, row, moved }
  *   POST /api/boards/ini-epics     { ws, board, id, epics: [Jira key] }                  → { ok, row }   the Jira epics of an initiative ([] unlinks)
- *   POST /api/boards/tasks/add     { ws, board, initiative, title, type?, epic?, start?, due?, owner?, notes?, section? } → { ok, item }   also `pmos task add`
+ *   POST /api/boards/tasks/add     { ws, board, initiative, title, type?, epic?, start?, due?, owner?, notes?, section?, milestone? } → { ok, item }   also `pmos task add`
+ *                                 (milestone: true adds it as a milestone, ◇ with one date: the due day, no start; batch 25 item 5)
  *                                 (section: the stage it goes under, as tasks/edit's section: the + on a stage of the Tasks list, batch 18 item 16)
  *   POST /api/boards/tasks/order   { ws, board, initiative, section, tasks: [id] } → { ok, from }   the PM's order inside one stage (a drag in the
  *                                 Tasks list, batch 18 item 16): a task-order line; tasks [] takes the order out; Undo sends `from` back
@@ -1284,6 +1285,7 @@ const WRITES = {
     if (body.epic != null && body.epic !== '' && !ONE_LINE(body.epic, 80)) return fail(ctx, res, 400, 'epic is one line of at most 80 characters');
     if (body.notes != null && (typeof body.notes !== 'string' || body.notes.length > 4000)) return fail(ctx, res, 400, 'notes are text of at most 4000 characters');
     if (body.start && body.due && body.start > body.due) return fail(ctx, res, 400, 'the start is after the due day');
+    if (body.milestone != null && typeof body.milestone !== 'boolean') return fail(ctx, res, 400, 'milestone is true or false');
     if (!p.file) return fail(ctx, res, 409, NO_STATE);
     const base = needRows(ctx, res, p.w);
     if (!base) return;
@@ -1296,11 +1298,14 @@ const WRITES = {
       if (body.section && !st.some((x) => x.key === body.section)) return fail(ctx, res, 400, `"${body.section}" is not a stage of this initiative's workflow: one of ${st.map((x) => x.key).join(', ')}, or ''`);
     }
     const id = `task-${crypto.randomBytes(5).toString('hex')}`;
-    const start = body.start || (body.due && body.due < B.shiftDay(today(), 1) ? body.due : B.shiftDay(today(), 1));
-    const due = body.due || B.shiftDay(start, 7);
+    // a milestone has one date, the due day, and no start (the ◇ of the Viewer's add field, batch 25 item 5)
+    const ms = body.milestone === true;
+    const start = ms ? '' : body.start || (body.due && body.due < B.shiftDay(today(), 1) ? body.due : B.shiftDay(today(), 1));
+    const due = body.due || (ms ? body.start || B.shiftDay(today(), 8) : B.shiftDay(start, 7));
     append(p.file, g.actor, { kind: 'task', board: p.board.id, task: id, type: body.type || 'Task', initiative: body.initiative, title: body.title.trim(), epic: body.epic ? String(body.epic).trim() : null,
       owner: body.owner ? String(body.owner).trim() : actorLib.pageName(g.actor.by), state: 'To do', start, due, ...(body.notes && body.notes.trim() ? { notes: body.notes.replace(/\s+$/, '') } : {}) });
     if (typeof body.section === 'string') append(p.file, g.actor, { kind: 'task-section', board: p.board.id, task: id, section: body.section, why: body.section ? 'placed under ' + body.section : 'placed under no stage' });
+    if (ms) append(p.file, g.actor, { kind: 'task-milestone', board: p.board.id, task: id, milestone: true, why: 'added as a milestone' });
     const t = B.taskOf(B.fold(readLedger(ctx, p.w)), id);
     ctx.json(res, { ok: true, item: B.rollupItems([B.taskItem(t)])[0] });
   },

package/workspace/lib/routes-onboard.js

@@ -100,7 +100,7 @@ async function handle(req, res, url, ctx) {
       const bound = r.ok && ctx.claudeSetup.bound(r.profile);
       // A new check of another login, or a failed check, drops everything bound to the old one.
       const keep = bound && st.profile === r.profile && st.fingerprint === bound.fingerprint;
-      write(ctx, { ...(keep ? st : { project: st.project, folder: st.folder }), profile: r.profile || b.profile, fingerprint: bound ? bound.fingerprint : null, checked: { state: r.state, at: r.checked_at || null } });
+      write(ctx, { ...(keep ? st : { project: st.project, folder: st.folder }), profile: r.profile || b.profile, fingerprint: bound ? bound.fingerprint : null, checked: { state: r.state, at: r.checked_at || null, message: r.message || null } });
       return send({ ...view(ctx), ...r });
     }
     const bound = verified(ctx, st);

package/workspace/lib/transcript-read.js

@@ -290,7 +290,7 @@ function feedHarness(acc, raw, clean) {
       // context use (batch 13 item 8): the NEWEST real turn's size, not the sum. A subagent's turn has its own context and is left out.
       if (m.model && m.model !== SYNTHETIC && !r.isSidechain) {
         const used = (u.input_tokens || 0) + (u.cache_read_input_tokens || 0) + (u.cache_creation_input_tokens || 0) + (u.output_tokens || 0);
-        if (used > 0) { acc.ctx = { used, at: r.timestamp || null }; if (used > acc.peak) acc.peak = used; }
+        if (used > 0) { acc.ctx = { used, at: r.timestamp || null, model: clean(m.model) }; if (used > acc.peak) acc.peak = used; }   // model: lib/context-use.js names the window from it
       }
     }
     for (const c of (m.content || [])) {

package/workspace/lib/vendor/scripts/workflow-state.js

@@ -556,6 +556,29 @@ function profileOf(root) {
   } catch { return 'product-code'; }
 }
 
+/*
+ * workflowOf(root, id) — the workflow an initiative runs, when its repository runs initiatives on workflows (Boards, Settings ›
+ * Workflows). The workspace gives every repository it keeps state for a default board, so every initiative there runs a workflow:
+ * an `ini-wf` line in the boards ledger (<state dir>/boards.jsonl, the dirs workspace/server.js stateDirFor reads) names its
+ * own, else it runs its board's (Product feature by default). A repository runs on workflows when it holds that ledger or a
+ * pmos/state/ dir. PMOS itself holds neither (its state is the workspace's own), so it still routes by lane and R0 still binds it.
+ * → the workflow's id, '' (its board's), or null (no workflows). The ledger is read again when its size or mtime changes.
+ */
+const wfMemo = new Map();
+function workflowOf(root, id) {
+  const f = [['pmos', 'state'], ['state'], ['.pmos']].map((rel) => path.join(root, ...rel, 'boards.jsonl')).find((x) => fs.existsSync(x));
+  const on = !!f || fs.existsSync(path.join(root, 'pmos', 'state'));
+  if (!on) return null;
+  let key = '';
+  try { const st = f ? fs.statSync(f) : null; key = st ? st.size + ':' + st.mtimeMs : '-'; } catch { key = '?'; }
+  let m = wfMemo.get(root);
+  if (!m || m.key !== key) {   // a held module sees a new line on the next read (the in-process freshness rule)
+    m = { key, wf: new Map() };
+    for (const l of f ? jsonl.readJsonl(f).rows : []) if (l && l.kind === 'ini-wf' && typeof l.id === 'string' && typeof l.wf === 'string' && l.wf) m.wf.set(l.id, l.wf);
+    wfMemo.set(root, m);
+  }
+  return m.wf.get(id) || '';
+}
 /** The lanes a repository's initiatives may declare — what the lane picker offers and the lane write accepts. */
 function laneNames(profile) { return laneDefs.laneNames(profile === 'pm-artifacts' ? 'pm-artifacts' : 'product-code'); }
 function lanesFor(root) {
@@ -735,6 +758,7 @@ function computeWorkflowDerived(id, opts) {
   // ── route ─ the lane is chosen and the two intake questions are answered ─────────────────────
   const sRoute = specimenRoute(fm.specimen_test);
   const fRoute = surfaceRoute(fm.surface_check);
+  const onWf = workflowOf(root, id);
   {
     const missing = [];
     if (sRoute === 'undeclared' || sRoute === 'malformed') missing.push('specimen_test');
@@ -742,6 +766,10 @@ function computeWorkflowDerived(id, opts) {
     if (!missing.length) {
       steps.push(step('route', 'route', 'done',
         `${lane} lane · specimen test ${sRoute} · surface ${fRoute}`));
+    } else if (onWf !== null) {
+      // Batch 25 item 6: an initiative on a workflow is routed. The workflow's stages say what comes first, and PMOS proposes a
+      // switch when the BRD says another workflow fits, so the two intake questions are not asked of it again.
+      steps.push(step('route', 'route', 'done', `${onWf ? `runs the ${onWf} workflow` : 'runs its board\'s workflow'} — the workflow routes it`));
     } else if (effLane !== 'feature') {
       // The routing questions are asked of feature work only.
       steps.push(step('route', 'route', 'done', `${lane} lane — routing questions are for features only (${CUT_NOTE})`));

package/workspace/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pmos-workspace",
-  "version": "0.497.0",
+  "version": "0.499.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pmos-workspace",
-      "version": "0.497.0",
+      "version": "0.499.0",
       "license": "MIT",
       "dependencies": {
         "@anthropic-ai/sdk": "^1.3.0",

package/workspace/package.json

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

package/workspace/public/pm/bd-ini-panel.js

@@ -205,7 +205,7 @@ function wire(body, key) {
     hold: (i, b) => { const r = O.rowOf(key); if (r && O.hold) O.hold(r, i, b); },
     addCancel: () => { adding = null; addTo = ''; addDates = null; redraw(); },
     // opt (batch 18 item 16): the + on a stage, with the dates its field picked
-    addTask: async (title, inp, opt) => { const r = O.rowOf(key); if (!r || !O.addTask) return; inp.disabled = true; const ok = await O.addTask(r, title, opt ? opt.section : addTo, opt ? (opt.start || opt.due ? opt : null) : addDates, opt ? opt.name : ''); inp.disabled = false; if (ok && !opt) { inp.value = ''; inp.focus(); } },
+    addTask: async (title, inp, opt) => { const r = O.rowOf(key); if (!r || !O.addTask) return; inp.disabled = true; const ok = await O.addTask(r, title, opt ? opt.section : addTo, opt ? (opt.start || opt.due || opt.milestone || opt.owner ? opt : null) : addDates, opt ? opt.name : ''); inp.disabled = false; if (ok && !opt) { inp.value = ''; inp.focus(); } },
     primary: (act, b) => {
       const r = O.rowOf(key); if (!r) return;
       if (act === 'grill') O.grillOpen(r, b);

package/workspace/public/pm/cozy-onboard.js

@@ -43,21 +43,26 @@ export function mountOnboard(host, { ws = '', done = false } = {}) {
   function turns() {
     const p = P(), c = (S.data && S.data.claude) || { profiles: [] }, out = [];
     // 1. connect and test
-    const profiles = c.profiles || [];
-    const pick = S.profile || p.profile || c.selected || (profiles[0] && profiles[0].id);
+    // One row per login that really differs: a pinned copy of the login on this computer shows as that login, and PMOS's own
+    // profile is the "separate login" row (bug 2026-11-03: "My usual Claude login" and "PMOS" repeated the other two rows).
+    const profiles = c.profiles || [], ownId = c.own || '__own__';
+    const row = (id) => (id === '__own__' || (id && id === c.own) ? ownId : (c.alias && c.alias[id]) || id);
+    const pick = row(S.profile || p.profile || c.selected || (profiles[0] && profiles[0].id));
     if (!p.verified) {
-      const failed = p.checked && p.checked.state && p.checked.state !== 'ready' && p.profile === pick;
-      const opts = profiles.map((x) => `<label class="ob-opt${x.id === pick ? ' on' : ''}"><input type="radio" name="ob-login" value="${esc(x.id)}"${x.id === pick ? ' checked' : ''}><span><b>${esc(x.id === '__default__' ? 'The Claude login on this computer' : x.label)}</b>${x.id === '__default__' ? '<em>Whatever account Claude Code uses in your usual terminal</em>' : ''}</span></label>`).join('');
+      const failed = p.checked && p.checked.state && p.checked.state !== 'ready' && row(p.profile) === pick;
+      const opt = (id, label, note) => `<label class="ob-opt${id === pick ? ' on' : ''}"><input type="radio" name="ob-login" value="${esc(id)}"${id === pick ? ' checked' : ''}><span><b>${esc(label)}</b>${note ? `<em>${esc(note)}</em>` : ''}</span></label>`;
+      const opts = profiles.map((x) => opt(x.id, x.id === '__default__' ? 'The Claude login on this computer' : x.label, x.id === '__default__' ? 'Whatever account Claude Code uses in your usual terminal' : '')).join('')
+        + opt(ownId, 'A separate login just for PMOS', 'Keeps PMOS on its own account. You sign in once.');
       out.push({ mood: failed ? 'honest' : 'needs-you', body: `<p>${failed ? '' : 'Let’s set up a product or project. First, which Claude login should PMOS use? I’ll run one short check on exactly that login.'}</p>`
-        + (failed ? `<div class="ob-bad" role="alert"><b>${esc(S.data.claude.status && S.data.claude.status.profile === p.profile ? S.data.claude.status.message : (p.checked.state === 'signed_out' ? 'This login needs signing in again.' : 'This login did not pass the check.'))}</b><span>I won’t switch to a different account on my own. Sign this one in, or pick another login.</span></div>` : '')
-        + `<div class="ut-card ob-card" role="radiogroup" aria-label="Claude login">${opts}<label class="ob-opt${pick === '__own__' ? ' on' : ''}"><input type="radio" name="ob-login" value="__own__"${pick === '__own__' ? ' checked' : ''}><span><b>A separate login just for PMOS</b><em>Keeps PMOS on its own account. You sign in once.</em></span></label>`
+        + (failed ? `<div class="ob-bad" role="alert"><b>${esc(p.checked.message || (p.checked.state === 'signed_out' ? 'This login needs signing in again.' : 'This login did not pass the check.'))}</b><span>I won’t switch to a different account on my own. Sign this one in, or pick another login.</span></div>` : '')
+        + `<div class="ut-card ob-card" role="radiogroup" aria-label="Claude login">${opts}`
         + `<div class="ob-row">${btn('check', 'Test this login', 'pri')}${btn('login', 'Sign in to it', '')}</div>`
         + `<p class="ob-note">The test sends one short message to Claude with no tools. It uses a little of this account’s usage.</p>`
         + (S.session ? '<p class="ob-note">Finish signing in in the browser window Claude opened. If it asks for a code, paste it below. I test the login as soon as you are done.</p><div class="cs-term ob-term" aria-label="Claude sign-in terminal"></div>' : '')
         + `</div>` });
       return out;
     }
-    const label = (profiles.find((x) => x.id === p.profile) || {}).label || p.profile;
+    const label = row(p.profile) === ownId ? 'A separate login just for PMOS' : (profiles.find((x) => x.id === row(p.profile)) || {}).label || p.profile;
     out.push({ mood: 'handled', body: `<div class="ob-good">${CHECK}<b>Login works · ${esc(label)}</b><span>Tested ${p.checked && p.checked.at ? new Date(p.checked.at).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : 'just now'} · one test message, no tools</span></div>`
       + (p.project ? '' : `<p>What product or project is this for? Its name is enough to start.</p><p class="ob-sub">If you have them, add the team, a Jira key, a link or the folder where it lives. They help me find the right sources, not a same-name one.</p><div class="ob-row"><button type="button" class="hm-chip loose" data-ob="relogin">Use another login</button></div>`) });
     if (!p.project) return out;
@@ -151,7 +156,9 @@ export function mountOnboard(host, { ws = '', done = false } = {}) {
     S.busy = a; S.note = ''; draw();
     try {
       if (a === 'check' || a === 'login') {
-        let profile = S.profile || p.profile || (S.data.claude && S.data.claude.selected);
+        const cl = S.data.claude || {};
+        let profile = S.profile || p.profile || cl.selected;
+        if (cl.alias && cl.alias[profile]) profile = cl.alias[profile];   // a pinned copy of the usual login is tested as that login
         if (profile === '__own__') { const own = await post('own'); if (!own.ok) throw new Error(own.error || 'The PMOS login could not be made.'); profile = own.id; S.profile = profile; await load(); }
         const r = await post(a, { profile });
         if (a === 'login') {

package/workspace/public/pm/home-app.js

@@ -509,7 +509,7 @@ function iniViewOf(id) {
   const need = H.needsOf(S.D).find((r) => r.ini === id);
   const p = programOf(S.D.programs || [], row.ws || (B.board || {}).ws || '', id);
   return iniView(rowFor({ ...row, trail: t || row.trail || null }), { steps: B.steps || STEPS, today: B.today, usual: WFM.usualOf(S.D.trail, row),
-    ask: need ? { title: need.name, n: H.needsOf(S.D).filter((r) => r.ini === id).length } : null, program: p ? { id: p.id, title: p.title } : null, jiraReadAt: ((B.jira || {}).readAt) || '',
+    ask: need ? { title: need.name, n: H.needsOf(S.D).filter((r) => r.ini === id).length, propose: (need.row && need.row.propose) || null } : null, program: p ? { id: p.id, title: p.title } : null, jiraReadAt: ((B.jira || {}).readAt) || '',
     // the card (batch 18 item 1): Claude's line while a session works on it, the stakeholders
     claude: (() => { const w = S.D.sessions.find((s) => H.iniOfSession(s) === id && s.shown === 'working'); return w ? 'I’m working on “' + H.nameOf(w) + '”. I’ll say here when it is ready.' : ''; })(),
     people: (((S.D.desk && S.D.desk.stakeholders) || {})[id] || []) });
@@ -867,7 +867,9 @@ function alsoOf(ini) {
   // in an initiative's chat only that initiative's own next step shows; another initiative's is not "also" this conversation's
   const other = H.needsOf(S.D).filter((r) => !(S.sel && S.sel === r.id));
   const n = ini ? other.find((r) => r.ini === ini) : other[0];
-  return n ? { text: n.name, go: () => select(n.id) } : null;
+  // a blocked step reaches the PM as Claude's ✦ proposal (batch 25 item 6): the line names what Claude will do, the press reviews it
+  const pr = n && n.row && n.row.propose;
+  return n ? { text: pr ? '✦ ' + pr.label : n.name, go: () => select(n.id), verb: pr ? 'Review' : 'Answer' } : null;
 }
 /* An ask's conversation (batch 18 item 2-A, OvA10Desk): the Viewer holds the summary and the one verb, so the chat asks a question instead
  * of saying it again. A decision's choices are pills that open the Viewer with that choice picked; it is recorded there. */