create-pmos 0.37.0 → 0.38.0

package/workspace/public/pm/data.js

@@ -134,7 +134,20 @@ const RUNGS = {
   },
 };
 
-const laneOf = (lane) => (PHASES[lane] ? lane : 'feature');
+/* D68 — the pm-artifacts profile's ladder: every PM lane walks brief → draft → review → approved
+ * (→ handed off). Keyed `pm:<lane>` because `discovery` and `chore` exist in BOTH profiles with
+ * different ladders; the profile comes from the engine's own ladder row, never guessed. */
+const PM_LANES_CLIENT = ['strategy', 'prd', 'project-plan', 'discovery', 'decision-record', 'report', 'chore'];
+const PM_NO_HANDOFF_CLIENT = ['decision-record', 'report', 'chore'];
+for (const l of PM_LANES_CLIENT) {
+  const withHandoff = !PM_NO_HANDOFF_CLIENT.includes(l);
+  PHASES['pm:' + l] = ['intake', 'brief', 'draft', 'review', 'approved'].concat(withHandoff ? ['handed off'] : []);
+  RUNGS['pm:' + l] = Object.assign({ intake: ['route', 'anchor'], brief: ['brief'], draft: ['draft'], review: ['review'], approved: ['approved'] },
+    withHandoff ? { 'handed off': ['handoff'] } : {});
+}
+const laneOf = (lane, profile) => (profile === 'pm-artifacts'
+  ? 'pm:' + (PM_LANES_CLIENT.includes(lane) ? lane : 'prd')
+  : (PHASES[lane] ? lane : 'feature'));
 
 /**
  * The status a phase inherits from the rungs it folds.
@@ -214,8 +227,8 @@ function pathIn(text) {
 }
 
 /** The `steps[]` panel 3 reads: one entry per lane phase, carrying the folded rungs' evidence. */
-function phaseSteps(lane, ladderSteps) {
-  const L = laneOf(lane);
+function phaseSteps(lane, ladderSteps, profile) {
+  const L = laneOf(lane, profile);
   const by = {};
   for (const s of ladderSteps || []) by[s.key] = s;
   return PHASES[L].map((phase) => {
@@ -233,6 +246,28 @@ function phaseSteps(lane, ladderSteps) {
 
 /* ── record derivation ──────────────────────────────────────────────────────────────────────── */
 
+/**
+ * overhaul-r2 B3/B4 — where the initiative belongs: Domain › Objective › KR › Project, from the
+ * resolver's SEPARATE fields (never parsed out of `reason`). A missing level is stated, not blank:
+ * a domain anchor has no OKR and says so; a health anchor is upkeep. `line` is the KR's own
+ * baseline → target text when the OKR document writes one — the measure the KR moves.
+ */
+function crumbFor(anchor, fm) {
+  if (!anchor) return null;
+  const parts = [];
+  const dom = (fm && fm.domain) || (anchor.kind === 'domain' ? 'domain:' + anchor.domain : null);
+  if (dom) parts.push({ k: 'domain', v: String(dom).replace(/^domain:/, '') });
+  if (anchor.kind === 'domain') parts.push({ k: 'objective', v: '(no OKR)', gap: true });
+  else if (anchor.kind === 'health') parts.push({ k: 'budget', v: 'health:' + anchor.budget + ' — upkeep, not a bet' });
+  else if (anchor.kind === 'okr') {
+    parts.push({ k: 'objective', v: anchor.objective_name || anchor.objective || '(unresolved)', gap: !anchor.objective_name });
+    if (anchor.kr) parts.push({ k: 'KR', v: anchor.kr_name || anchor.kr, gap: !anchor.kr_name });
+    else parts.push({ k: 'KR', v: '(objective-level — no KR written)', gap: true });
+  } else parts.push({ k: 'anchor', v: '(none — rejected under D59)', gap: true });
+  if (fm && fm.project) parts.push({ k: 'project', v: String(fm.project) });
+  return { parts, goal: anchor.kind === 'domain' ? anchor.domain_goal || null : null, line: anchor.kr_line || null };
+}
+
 /** The `pills` row: lane, then the resolved anchor or an honest rejection, then a declared flow. */
 function pillsFor({ lane, anchor, flow }) {
   const out = [];
@@ -353,7 +388,7 @@ function recordFrom(payload) {
   const row = (payload.ladder && payload.ladder.ok && payload.ladder.row) || null;
   const scope = (payload.ladder && payload.ladder.scope) || null;
   const lane = fm.lane || (row && row.lane) || null;
-  const steps = row ? phaseSteps(lane, row.steps) : [];
+  const steps = row ? phaseSteps(lane, row.steps, row.profile) : [];
   const ctx = { record: payload.record, prd: fm.prd_path || null, rubric: fm.rubric_path || null };
   // Authored tasks win over derivation, per phase (PRD, "Tasks"). Their absence is not a defect.
   const authored = payload.tasks || {};
@@ -361,7 +396,7 @@ function recordFrom(payload) {
   const byKey = {};
   for (const s of (row && row.steps) || []) byKey[s.key] = s;
   for (const st of steps) {
-    const rungs = (RUNGS[laneOf(lane)][st.k] || []).map((k) => byKey[k]).filter(Boolean);
+    const rungs = (RUNGS[laneOf(lane, row && row.profile)][st.k] || []).map((k) => byKey[k]).filter(Boolean);
     tasks[st.k] = Array.isArray(authored[st.k]) && authored[st.k].length
       ? authored[st.k]
       : derivedTasks(st.k, rungs, ctx);
@@ -371,6 +406,7 @@ function recordFrom(payload) {
     stage: row ? row.stage : null,
     flow: fm.flow || null,
     pills: pillsFor({ lane, anchor: payload.anchor, flow: fm.flow || null }),
+    crumb: crumbFor(payload.anchor, fm),
     // What the ladder was DERIVED ON, which is exactly what the footer sentence claims.
     branch: scope ? scope.branch : null,
     answer: answerFor(row),
@@ -457,6 +493,13 @@ function groupsFromSpine(spine) {
       gct: String(b.initiatives.length), hasKr: false, slugs: b.initiatives.map((i) => i.id),
     });
   }
+  // D67: a domain group — work that serves the domain's standing goal with no OKR, said plainly
+  for (const d of spine.domains || []) {
+    groups.push({
+      gid: d.id, idc: C.fg, gname: 'domain — no OKR' + (d.goal ? ' · ' + d.goal : ''),
+      gct: String(d.initiatives.length), hasKr: false, slugs: d.initiatives.map((i) => i.id),
+    });
+  }
   // D59: rejected work is FILED, never hidden. It is the last group and it says what it is.
   groups.push({
     gid: 'unanchored', dyn: true, idc: C.wrn,
@@ -526,7 +569,7 @@ function foldWorkspaces(rows) {
     const key = w.repo_key || w.root;
     if (!byRepo.has(key)) {
       byRepo.set(key, {
-        name: w.repo_name || w.name, ws: w.id, root: w.root, trees: [],
+        name: w.label || w.repo_name || w.name, ws: w.id, root: w.root, trees: [],
         // The server derived this from the tree's `origin` remote (git-info.originUrl). It is read
         // here and never re-derived: a second opinion about what a repository IS would be a second
         // thing to keep true, and this one is the one that did the read.
@@ -539,6 +582,8 @@ function foldWorkspaces(rows) {
     // remote, since a linked worktree of the same repo answers with the same origin anyway.
     if (w.root === key) {
       p.ws = w.id;
+      // the PM's own name for the repository (overhaul-r1 R3.1) lives on the main tree's row
+      if (w.label) p.name = w.label;
       p.kind = w.kind === 'github' ? 'github' : 'local';
       p.remote = w.remote || null;
     }
@@ -585,6 +630,7 @@ async function loadBoard(prod) {
     for (const r of o.direct || []) note(r, { canonical: o.key });
   }
   for (const b of spine.budgets || []) for (const r of b.initiatives) note(r, { canonical: b.id });
+  for (const d of spine.domains || []) for (const r of d.initiatives) note(r, { canonical: d.id });
   for (const r of spine.unanchored || []) note(r, null);
 
   // The library can see initiatives the SPINE has no record for: artifacts that group into a unit
@@ -830,7 +876,7 @@ let sessionDigest = null;
 function sessionProjection(rows) {
   return (rows || []).map((s) => [
     s.id, s.ws, s.name, s.agent, s.state, s.shown, s.note || '', s.cwd || '',
-    s.profile_id || '', s.profile_line || '',
+    s.profile_id || '', s.profile_line || '', s.model_line || '',
     // the label's own resolution, not the millisecond behind it
     s.shown === 'quiet' && Number.isFinite(s.quietMs) ? Math.max(1, Math.round(s.quietMs / 60000)) : '',
     // Joined on U+0000, fields and rows both. A separator that cannot occur in any of these
@@ -939,6 +985,66 @@ export async function loadRepos() {
   });
 }
 
+/**
+ * panel-repos.js — `productTrees(name)`, synchronous. The LINES OF WORK of one repository
+ * (overhaul-r1 R2.1): every registered tree sharing its `repo_key`, main tree first. `initiative`
+ * is read from an `initiative/<id>` branch and says so (`by: 'branch'`) — it is a reading of the
+ * branch name, not a recorded attribution, and the row must not present it as one.
+ */
+export function productTrees(name) {
+  const p = products.get(name);
+  if (!p || !Array.isArray(p.trees)) return [];
+  const key = p.root;
+  return p.trees.map((t) => {
+    const m = /^initiative\/(.+)$/.exec(t.branch || '');
+    return { ws: t.id, branch: t.branch || null, main: t.root === key, sessions: t.sessions || 0,
+      initiative: m ? m[1] : null, by: m ? 'branch' : null };
+  }).sort((a, b) => (b.main - a.main));
+}
+
+/** The branch of a registered tree, or null — for tab labels and the status bar (R2.2/R2.3). */
+export function branchOfWs(ws) {
+  return ws ? (wsBranch.get(ws) || null) : null;
+}
+
+/** True when `ws` is a linked worktree rather than its repository's main tree. */
+export function isLinkedTree(ws) {
+  if (!ws) return false;
+  for (const p of products.values()) {
+    if (!Array.isArray(p.trees)) continue;
+    const t = p.trees.find((x) => x.id === ws);
+    if (t) return t.root !== p.root;
+  }
+  return false;
+}
+
+/**
+ * panel-repos.js — `removeRepository(name)`. Forgets the repository AND its worktree rows; never
+ * deletes a folder (R3.2). Resolves `{ok}` or `{ok:false, reason, error}` with the server's own
+ * words, which the row shows as-is (R3.3).
+ */
+export async function removeRepository(name) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode — nothing is registered' };
+  const p = products.get(name);
+  if (!p) return { ok: false, reason: 'unknown', error: 'unknown repository' };
+  const res = await postJson('/api/workspaces/forget', { id: p.ws, repository: true });
+  if (res && res.ok) {
+    products.delete(name);
+    productOrder = productOrder.filter((n) => n !== name);
+    publishBoards();
+    if (state.product === name) setState({ product: productOrder[0] || null, sel: null, wsId: null });
+  }
+  return res || { ok: false, error: 'the workspace server did not answer' };
+}
+
+/** panel-repos.js — `renameRepository(name, label)`. A display name only (R3.1). */
+export async function renameRepository(name, label) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode — nothing is registered' };
+  const p = products.get(name);
+  if (!p) return { ok: false, reason: 'unknown', error: 'unknown repository' };
+  return (await postJson('/api/workspaces/rename', { id: p.ws, name: label })) || { ok: false, error: 'the workspace server did not answer' };
+}
+
 /**
  * panel-repos.js — `firstSlugOf(id)`, synchronous. The initiative selected when a repository is
  * picked. A repository whose board is loaded and genuinely empty returns null, and panel 3 says so.
@@ -1184,10 +1290,12 @@ export async function saveScratchpad(key, text) {
 }
 
 /** tab-doc.js — `readDoc(path)`. The raw document body, or a rejected promise carrying the reason. */
-export async function readDoc(path) {
+export async function readDoc(path, ws) {
   if (FIXTURE) return '';
   const p = products.get(currentProductName());
-  const url = '/api/doc?' + q({ ws: state.wsId || (p ? p.ws : ''), path });
+  // `ws` is the tree a search hit came from (overhaul-r1 R1.3) — a branch-only file must be read
+  // from its own worktree, not from the product's main tree.
+  const url = '/api/doc?' + q({ ws: ws || state.wsId || (p ? p.ws : ''), path });
   const res = await fetch(url);
   if (!res.ok) throw new Error(res.status === 404 ? 'not a readable text document in this workspace' : 'HTTP ' + res.status);
   return res.text();
@@ -1203,10 +1311,12 @@ export async function readDoc(path) {
  * that a fixture render is provably not a real read wearing a costume, and `no-network.test.js`
  * checks that claim at source level.
  */
-export async function searchFiles(query, limit) {
+export async function searchFiles(query, limit, all) {
   const q = String(query == null ? '' : query).trim();
   if (FIXTURE || !q) return { ok: true, q, hits: [], truncated: false, scanned: 0 };
   const p = products.get(currentProductName());
+  // overhaul-r4 B1 — `all`: every registered repository, each hit tagged with its repository
+  if (all) return getJson('/api/search/files', { scope: 'all', q, limit });
   return getJson('/api/search/files', { ws: state.wsId || (p ? p.ws : ''), q, limit });
 }
 
@@ -1330,3 +1440,43 @@ if (!FIXTURE) {
     }
   });
 }
+
+/* ── D70 — stopped initiatives and press-only sync ───────────────────────────────────────────
+ * Each of these is reached only by a PM press. None runs on load, on a timer or as a side effect. */
+export function wsOf(name) { const p = products.get(name); return p ? p.ws : null; }
+
+/** The lifecycle of every initiative in a repository, from the same surface the board uses. */
+export async function lifecycleMap(name) {
+  const ws = wsOf(name);
+  if (FIXTURE || !ws) return {};
+  const res = await getJson('/api/surface', { name: 'initiatives', ws });
+  const out = {};
+  const items = (res && res.surface && res.surface.initiatives) || (res && res.initiatives) || [];
+  for (const i of items) if (i && i.lifecycle) out[i.id] = i.lifecycle;
+  return out;
+}
+
+export async function setLifecycle(name, initiativeId, newState, reason) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode — nothing is recorded' };
+  const ws = wsOf(name);
+  if (!ws) return { ok: false, error: 'unknown repository' };
+  const res = await postJson('/api/lifecycle', { ws, initiative_id: initiativeId, state: newState, reason });
+  if (res && res.ok) { const p = products.get(name); if (p) { p.board = null; await loadBoard(p); publishBoards(); } }
+  return res || { ok: false, error: 'the workspace server did not answer' };
+}
+
+export async function syncStatusOf(name) {
+  const ws = wsOf(name);
+  if (FIXTURE || !ws) return null;
+  return getJson('/api/sync/status', { ws });
+}
+
+export async function syncRepository(name) {
+  if (FIXTURE) return { ok: false, message: 'fixture mode — nothing to sync' };
+  const ws = wsOf(name);
+  if (!ws) return { ok: false, message: 'unknown repository' };
+  const res = await postJson('/api/sync', { ws });
+  const p = products.get(name);
+  if (res && res.ok && p) { p.board = null; await loadBoard(p); publishBoards(); }
+  return res || { ok: false, message: 'the workspace server did not answer' };
+}

package/workspace/public/pm/lifecycle.js

@@ -0,0 +1,105 @@
+/**
+ * lifecycle.js — D70. The stopped-state control on an initiative, and the Sync control on a repository.
+ *
+ * Both are PM presses and nothing else: this module starts no timer and loads nothing on its own
+ * beyond the local read of the current state. The state is a ledger line (lifecycle.jsonl); closing,
+ * holding or cancelling an initiative takes it off the board and stops it gating, and reopening
+ * puts it back.
+ */
+import { el } from './dom.js';
+import { state, setState, FIXTURE } from './state.js';
+
+let dataMod = null;
+const dataReady = import('./data.js').then((m) => { dataMod = m; }).catch(() => { dataMod = null; });
+
+const known = {};          // product -> { map, at } — the lifecycle of every initiative, read once per press
+const loading = new Set();
+
+const BTN = 'font-family:var(--mono);font-size:10px;padding:2px 7px;background:var(--secondary);border:1px solid var(--border);color:var(--foreground);cursor:pointer';
+const STATES = [['closed', 'close'], ['on-hold', 'hold'], ['cancelled', 'cancel']];
+
+function refresh(product) {
+  if (FIXTURE || !product || loading.has(product)) return;
+  loading.add(product);
+  dataReady.then(() => (dataMod ? dataMod.lifecycleMap(product) : {}))
+    .then((map) => { known[product] = { map: map || {} }; })
+    .catch(() => { known[product] = { map: {} }; })
+    .finally(() => { loading.delete(product); setState((s) => ({ lcTick: (s.lcTick || 0) + 1 })); });
+}
+
+async function apply(product, slug, to) {
+  const word = to === 'active' ? 'Reopen' : to === 'closed' ? 'Close' : to === 'on-hold' ? 'Put on hold' : 'Cancel';
+  const reason = to === 'active' ? '' : (typeof window !== 'undefined' && window.prompt ? window.prompt(word + ' “' + slug + '” — why? (one line, kept in the record)', '') : '');
+  if (reason === null) return;                       // the PM backed out
+  const out = await dataMod.setLifecycle(product, slug, to, String(reason).trim());
+  if (!out || out.ok === false) { setState({ lcNotice: { slug, text: (out && out.error) || 'not recorded' } }); return; }
+  setState({ lcNotice: null });
+  refresh(product);
+}
+
+/** The control row for one initiative. Live mode only; the fixture is the prototype's. */
+export function lifecycleRow(product, slug) {
+  if (FIXTURE || !product || !slug) return null;
+  if (!known[product]) refresh(product);
+  const cur = known[product] && known[product].map[slug];
+  const n = state.lcNotice && state.lcNotice.slug === slug ? state.lcNotice : null;
+  const kids = [];
+  if (cur) {
+    kids.push(el('span', { 'data-r6': 'lifecycle-state', style: 'font-family:var(--mono);font-size:10px;padding:2px 6px;border:1px solid var(--border);color:var(--muted-foreground)',
+      title: 'off the board and not gating' + (cur.reason ? ' — ' + cur.reason : '') }, String(cur.state) + (cur.at ? ' · ' + String(cur.at).slice(0, 10) : '')));
+    kids.push(el('button', { onClick: () => apply(product, slug, 'active'), style: BTN, 'data-r6': 'reopen', title: 'put this back on the board' }, 'reopen'));
+  } else {
+    for (const [st, label] of STATES) {
+      kids.push(el('button', { onClick: () => apply(product, slug, st), style: BTN, 'data-r6': label,
+        title: label + ' this initiative — it leaves the board and stops gating; it can be reopened' }, label));
+    }
+  }
+  if (n) kids.push(el('span', { style: 'font-size:11px;color:var(--destructive)' }, n.text));
+  return el('div', { 'data-r6': 'lifecycle', style: 'display:flex;gap:5px;flex-wrap:wrap;align-items:center;padding:6px 14px;border-bottom:1px solid var(--border)' }, kids);
+}
+
+/* ── Sync ─────────────────────────────────────────────────────────────────────────────────── */
+const syncInfo = {};
+const syncing = new Set();
+function readSync(product) {
+  if (syncInfo[product] && syncInfo[product].loading) return;
+  syncInfo[product] = { ...(syncInfo[product] || {}), loading: true };
+  dataReady.then(() => (dataMod ? dataMod.syncStatusOf(product) : null))
+    .then((s) => { syncInfo[product] = { status: s, last: (syncInfo[product] || {}).last }; })
+    .catch(() => { syncInfo[product] = { status: null }; })
+    .finally(() => setState((s) => ({ lcTick: (s.lcTick || 0) + 1 })));
+}
+
+function glance(st) {
+  if (!st || st.ok === false) return '';
+  const bits = [];
+  if (st.behind) bits.push('↓' + st.behind);
+  if (st.ahead) bits.push('↑' + st.ahead);
+  if (st.dirty_records) bits.push('●' + st.dirty_records);
+  return bits.join(' ');
+}
+
+/** The Sync button for a repository. Shows behind / ahead / uncommitted from LOCAL git, no network. */
+export function syncButton(product) {
+  if (FIXTURE || !product) return null;
+  if (!syncInfo[product]) readSync(product);
+  const info = syncInfo[product] || {};
+  const busy = syncing.has(product);
+  const g = glance(info.status);
+  const tip = info.status && info.status.ok !== false
+    ? 'Sync — fetch, bring in the other machine’s work, commit your records, push. ' + (info.status.state || '') + (g ? ' (' + g + ')' : '')
+    : 'Sync — ' + ((info.status && (info.status.error || info.status.message)) || 'checking…');
+  return el('button', {
+    'data-r6': 'sync', disabled: busy ? 'disabled' : null, title: tip,
+    style: 'font-family:var(--mono);font-size:11px;background:none;border:0;color:var(--muted-foreground);cursor:pointer;padding:0 4px',
+    onClick: async () => {
+      syncing.add(product); setState((s) => ({ lcTick: (s.lcTick || 0) + 1 }));
+      const out = await dataMod.syncRepository(product);
+      syncing.delete(product);
+      const text = out.ok ? 'synced — ' + (out.steps || []).map((x) => x.step + ': ' + x.note).join(' · ')
+        : 'sync stopped at ' + (out.stopped_at || 'start') + ' — ' + (out.message || out.error || 'unknown');
+      syncInfo[product] = { status: null, last: text }; readSync(product);
+      setState({ repoNotice: { name: product, tone: out.ok ? 'ok' : 'bad', text } });
+    },
+  }, busy ? '…' : '⇅' + (g ? ' ' + g : ''));
+}

package/workspace/public/pm/markdown.js

@@ -176,9 +176,18 @@ function mdLink(txt, url, ctx) {
   const u = String(url || '').trim();
   if (!u) return null;
   if (REMOTE.test(u) || MAILTO.test(u)) {
-    return el('a', {
+    const a = el('a', {
       href: u, target: '_blank', rel: 'noopener noreferrer', style: ST.a,
     }, inline(txt, ctx));
+    // overhaul-r5 (D69): beside an http(s) link, ⧉ opens it as a web tab — only when the PM clicks it.
+    // Offered only where the caller supplies `onWeb` (the live doc tab); every other render is unchanged.
+    if (ctx && typeof ctx.onWeb === 'function' && REMOTE.test(u)) {
+      return el('span', null, a, el('button', {
+        onClick: (e) => { e.preventDefault(); ctx.onWeb(u); }, title: 'open this link as a web tab', 'data-r5': 'open-tab',
+        style: 'margin-left:3px;font-size:10px;padding:0 4px;border:1px solid var(--border);color:var(--muted-foreground);vertical-align:1px',
+      }, '⧉'));
+    }
+    return a;
   }
   if (u.startsWith('#')) return null;                 // an in-page anchor has nowhere to go here
   if (!OPENABLE.test(u)) return null;