create-pmos 0.496.0 → 0.498.0

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/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/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})`));
@@ -1438,11 +1466,11 @@ function documentDuplicates(root, opts) {
   return { ok: true, profile, archive, groups };
 }
 /**
- * Jira keys the repository holds for an initiative (S4): the Jira tab's draft; the record's `jira:` keys; in the
- * record's text, a Jira link (`…/browse/KEY`) or a key on a line that says Jira; and a Jira link in its found
- * documents. A bare key elsewhere is not read: "UTF-8" and "ISO-8601" have the same shape.
+ * Jira keys a handoff record holds for an initiative (S4): the Jira tab's draft (`- jira: KEY` lines) and the
+ * record's `jira:` / `jira_key:` / `jira_keys:` / `jira_epic:` / `jira_issue_key:` frontmatter. Body text and found documents are not
+ * read: a key a PM mentions in prose ("see Jira LOY-41", an epic link in a spec) is a reference, not a handoff.
  */
-function jiraKeysOf(root, L, id, fm, found) {
+function jiraKeysOf(L, id, fm) {
   const keys = [];
   const draft = path.join(path.dirname(L.initiatives), 'tracker', 'jira', `${id}-tickets.md`);
   try {
@@ -1451,21 +1479,9 @@ function jiraKeysOf(root, L, id, fm, found) {
       if (m && JIRA_KEY.test(m[1].toUpperCase())) keys.push(m[1].toUpperCase());
     }
   } catch { /* no draft */ }
-  for (const k of ['jira', 'jira_key', 'jira_keys', 'jira_epic']) {
+  for (const k of ['jira', 'jira_key', 'jira_keys', 'jira_epic', 'jira_issue_key']) {
     for (const m of String(fm[k] || '').toUpperCase().matchAll(/\b([A-Z][A-Z0-9_]+-\d+)\b/g)) keys.push(m[1]);
   }
-  const fromText = (text, lines) => {
-    for (const m of String(text).matchAll(/\/browse\/([A-Z][A-Z0-9_]+-\d+)\b/g)) keys.push(m[1]);
-    if (lines) for (const line of String(text).split('\n')) {
-      if (!/jira/i.test(line)) continue;
-      for (const m of line.matchAll(/\b([A-Z][A-Z0-9_]+-\d+)\b/g)) keys.push(m[1]);
-    }
-  };
-  try { fromText(fs.readFileSync(path.join(L.initiatives, `${id}.md`), 'utf8'), true); } catch { /* no record text */ }
-  for (const rel of found ? [].concat(found.brief, found.draft, found.review, found.handoff) : []) {
-    if (!SCAN_TEXT.test(rel)) continue;
-    try { fromText(fs.readFileSync(path.join(root, rel), 'utf8').slice(0, 200000), false); } catch { /* unreadable */ }
-  }
   return [...new Set(keys)];
 }
 
@@ -1483,7 +1499,7 @@ function jiraKeysOf(root, L, id, fm, found) {
  *   handoff  — `handed_off:` names where it went; n/a for decision records, reports and chores
  * When the record names no file for brief, draft or review, or names one that does not exist, a
  * document the repository scan found for the id completes the step (scan-documents S3); Jira keys
- * in the repository complete the handoff (S4). Found evidence never blocks and never fails CI.
+ * in the Jira tab's draft or the record's `jira:` frontmatter complete the handoff (S4), never a key in body text. Found evidence never blocks and never fails CI.
  * Track: `light` (guidance — only route and anchor can fail CI) or `governed` (brief and draft
  * existence and their order fail CI for a non-legacy record). Review, approval and handoff are never
  * CI-blocking in either track: none can be true before the PR exists.
@@ -1564,7 +1580,7 @@ function pmLadder({ id, fm, lane, effLane, knownLane, legacy, steps, root, L, re
   if (!flows('handoff')) steps.push(step('handoff', 'handed off', 'na', `${effLane} — nothing to hand off`));
   else {
     const to = String(fm.handed_off || '').trim();
-    const keys = to ? [] : jiraKeysOf(root, L, id, fm, found);
+    const keys = to ? [] : jiraKeysOf(L, id, fm);
     steps.push(to ? step('handoff', 'handed off', 'done', `handed off — ${to}`)
       : keys.length ? step('handoff', 'handed off', 'done', `handed off to Jira — ${keys.slice(0, 5).join(', ')}${keys.length > 5 ? ` and ${keys.length - 5} more` : ''}`)
       : foundOf('handoff') ? step('handoff', 'handed off', 'done', `${foundOf('handoff')} — handoff found by the repository scan`)

package/workspace/package-lock.json

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

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.496.0",
+  "version": "0.498.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/chat-turn-end.js

@@ -0,0 +1,19 @@
+/* pm/chat-turn-end.js — tells when a chat turn ended, so the page beside the chat reads its records again (batch 25 item 3: "When chat
+ * said it has made changes to the doc or content shown on the viewer, the content on the viewer should automatically update without
+ * the user needing to refresh"). home-chat.js takes a snapshot on each read of the conversation; the host re-reads what the Viewer shows
+ * when a turn ends.
+ *
+ *   snapOf(key, busy, messages)   { key, busy, agents }: the conversation's place, whether Claude is still at work, and how many of its
+ *                                 messages are not the PM's.
+ *   turnEnded(prev, cur)          true once per finished turn: the same conversation, not at work now, and either at work on the last read
+ *                                 or with more of Claude's messages than then (a turn that started and finished between two reads).
+ *                                 The first read of a conversation is never a finished turn: opening a chat does not re-read the page. */
+export function snapOf(key, busy, messages) {
+  const agents = (Array.isArray(messages) ? messages : []).filter((m) => m && m.role !== 'user').length;
+  return { key: String(key || ''), busy: !!busy, agents };
+}
+
+export function turnEnded(prev, cur) {
+  if (!prev || !cur || !cur.key || prev.key !== cur.key || cur.busy) return false;
+  return prev.busy || cur.agents > prev.agents;
+}

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

@@ -47,7 +47,7 @@ import * as YD from './home-day.js';
 import * as AD from './cozy-adler.js';   // Adler, Claude's face (batch 16 item 2)
 import * as OKL from './okr-list.js';   // the product page's Goals line (batch 16 item 6, GsProduct)
 import { canDictate, dictate } from './home-dictate.js';
-import { mountIni, iniList, iniOverview, iniPage, iniAddTask } from './home-ini.js';   // the initiative's page, its stage move, Tasks and Core documents (premium-uncovered-features, HbC)
+import { mountIni, iniList, iniOverview, iniPage, iniAddTask, iniFresh } from './home-ini.js';   // the initiative's page, its stage move, Tasks and Core documents (premium-uncovered-features, HbC)
 import * as MEN from './home-mentions.js';
 import * as LS from './load-shapes.js';   // the last view, the grey shapes and the held Viewer column while Home reads (page-open-speed)   // @Mentions, the permanent row at the top of Home and its Viewer (Viewer kit, XvANew)
 import { mountRecRow, clockOf as recClock } from './home-rec-row.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] || []) });
@@ -756,7 +756,15 @@ const chat = mountChat($('#hmChat'), {
   desk: () => !isPhone(),
   reopenViewer: () => reopenViewer(),
   head: (t) => (isPhone() ? '' : TD.chatHeadHtml(chatHead(t))),   // the phone names it in its top bar (#hmTop)
+  // a chat turn finished: read the records again, so the list and the Viewer show what Claude changed with no refresh (batch 25 item 3).
+  // load() keeps the open folds (ini-view.js FOLD) and the Viewer's scroll (home-ini.js redrawView); the initiative's layout is read again too
+  turnEnded: () => turnEnded(),
 });
+let turnT = null;
+function turnEnded() {
+  clearTimeout(turnT);
+  turnT = setTimeout(async () => { await load(); iniFresh(); }, 400);   // two chats that finish together read once
+}
 /* claude-onboarding-build: set up a project as a conversation in this chat's place (cozy-onboard.js). It opens on ?onboard=1, shows the
  * finished project's next steps on ?onboarded=1, and opens by itself on a first run: setup not finished and no registered folder holds an
  * initiative. A named workspace does not stop it: the installer opens its own empty ~/PMOS folder by name (bug 2026-11-02, Windows). */
@@ -859,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. */

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

@@ -16,7 +16,7 @@
  * A loose session the host can place (host.suggestLink(target, firstText) → { id, title }) shows one chip: Link it (host.linkTo) or × (host.dismissLink).
  * Every write is the PM's press. mountChat(el, host) returns { open(target), refresh(), focus(), send(text) }.
  *   target: { key?, sid?, title, scope: { text, icon, loose }, role: { name, initial }, intro?: { role, text, at, mood? (Adler as the avatar while the log is empty), pills: [{ label, primary, go }] },
- *             ini?, rich, also?: { text, go } }
+ *             ini?, rich, also?: { text, go, verb? ('Answer' when absent; 'Review' for Claude's ✦ proposal) } }
  *   host:   { esc, toast, pmGet, pmPost, roles(), seen(key), markSeen(key), onScope(btn), onLink(btn), onTo(btn), workItem(text, target),
  *             viewerClosed(), reopenViewer(), head(target), touch(sid) (the PM opened, typed in or answered that session: the Live pill) } */
 import { mdHtml, userHtml, toolLine, webKind } from './chat-md.js';
@@ -33,6 +33,7 @@ import { splitFiles, filesHtml, sizeText, MAX_BYTES, MAX_FILES, setAttachSink }
 import * as VWC from './cozy-viewer.js';
 import { canDictate, dictate } from './home-dictate.js';
 import { adler } from './cozy-adler.js';
+import { snapOf, turnEnded } from './chat-turn-end.js';   // a finished turn re-reads what the Viewer shows (batch 25 item 3)
 /* The views a chat opens go in the Viewer: on a page with no dialog the old viewer's views draw in the cozy card (premium-viewer.js). */
 const views = {
   ctx: () => import('./premium-vw-ctx.js'), file: () => import('./premium-vw-file.js'), attach: () => import('./premium-attach.js'),
@@ -92,7 +93,11 @@ export function mountChat(el, host) {
     C.th = th && th.ok ? th : null; C.conv = conv && conv.ok ? conv : null;
     if (host.touch && sid() && C.touched !== sid()) { C.touched = sid(); host.touch(C.touched); }   // the Live pill: the PM opened it now
     C.sess = host.session ? host.session(t.sid || (C.th && C.th.session)) : null;
+    // a turn that finished: Claude may have changed what the Viewer shows (tasks, documents), so the host reads it again (batch 25 item 3)
+    const snap = snapOf(t.key || t.sid, running() || !!(C.th && C.th.working), C.conv && C.conv.messages);
+    const ended = turnEnded(C.turn, snap); C.turn = snap;
     draw();
+    if (ended && host.turnEnded) host.turnEnded(t);
     clearTimeout(C.timer);
     const live = (C.th && (C.th.session || C.th.working)) || (t.sid && C.conv && C.conv.state !== 'ended');
     C.timer = setTimeout(() => { if (!document.hidden) read(); else C.timer = setTimeout(read, IDLE_POLL); }, live ? POLL : IDLE_POLL);
@@ -395,7 +400,7 @@ export function mountChat(el, host) {
   const chipsOf = (items) => (chipsHtmlFn ? chipsHtmlFn(items) : '');
   function drawFoot(R) {
     const t = C.t, goal = C.th && C.th.goal;
-    const also = t.also && !(C.conv && C.conv.ask) ? `<button type="button" class="hm-also" data-hm-also><i aria-hidden="true"></i><span><b>Also waiting on you:</b> ${esc(t.also.text)}</span><em>Answer</em></button>` : '';
+    const also = t.also && !(C.conv && C.conv.ask) ? `<button type="button" class="hm-also" data-hm-also><i aria-hidden="true"></i><span><b>Also waiting on you:</b> ${esc(t.also.text)}</span><em>${esc(t.also.verb || 'Answer')}</em></button>` : '';
     // while it works the PM talks as usual (Claude reads it after its tool call); a goal that stopped says how to go on (principle 8)
     const ph = C.conv && C.conv.ask ? 'Or tell ' + R.role.name + ' what to do instead' : goal && goal.state === 'stopped' && !running() ? 'Reply to go on, or /goal for a new goal' : t.placeholder || 'Message Claude';
     const sc = t.scope || { text: 'All work', icon: 'M5 21V4M5 4h12l-2 4 2 4H5' };

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

@@ -201,6 +201,13 @@ function ask(anchor, label, value, go, o = {}) {   // one line of words, inline
   i.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); const v = i.value.trim(); if (v) { closePop(); go(v); } } });
 }
 
+/** The open initiative's records changed elsewhere (a chat turn finished, batch 25 item 3): read its layout again, as a press does.
+ * The page redraws in place; the folds and the scroll stay. */
+export function iniFresh() {
+  if (!X.ctx) return;
+  const id = X.ctx.S.ini, M = curM();
+  if (M) readL(id, M, true);
+}
 export function iniList(sc) {
   if (!X.ctx || !sc) return;
   sc.querySelectorAll('[data-hi-slot]').forEach((n) => n.remove());
@@ -287,7 +294,7 @@ function wirePage(b, id) {
       const M = curM(); if (!M) return;
       inp.disabled = true;
       const D = opt ? opt : ADD_DATES || {};
-      const r = await C.pmPost('/api/boards/tasks/add', { ...bw(M), initiative: id, title, ...(D.start ? { start: D.start } : {}), ...(D.due ? { due: D.due } : {}), ...(opt && opt.section != null ? { section: opt.section } : {}) });
+      const r = await C.pmPost('/api/boards/tasks/add', { ...bw(M), initiative: id, title, ...(D.start ? { start: D.start } : {}), ...(D.due ? { due: D.due } : {}), ...(opt && opt.section != null ? { section: opt.section } : {}), ...(opt && opt.milestone ? { milestone: true } : {}), ...(opt && opt.owner ? { owner: opt.owner } : {}) });
       inp.disabled = false;
       if (!r || r.ok === false) { say((r && r.error) || 'The task was not added.'); return; }
       const uid = r.item && r.item.uid;

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

@@ -74,7 +74,7 @@ function whyBlocked(step, rule, lane) {
   if (step === 'prototype') return 'This idea needs a prototype people can look at before a PRD says what to build.';
   if (step === 'contract') return 'The run needs its done-criteria agreed before it starts, so there is something to check it against.';
   if (step === 'anchor') return 'Every initiative names the goal it moves. Work with no goal is turned away.';
-  if (step === 'route') return 'The initiative needs its lane, so the right rules run on it.';
+  if (step === 'route') return 'The initiative needs a workflow, so its stages can run.';
   return 'The ' + step + ' step is not done yet.';
 }
 const lineOf = (step, rule) => (/^O[12]$/.test(rule || '') ? 'Blocked: ' + (STEP_WORD[step] || 'the ' + step) + ' came after the build'