create-pmos 0.52.0 → 0.53.0

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

@@ -0,0 +1,57 @@
+/* pm/board-copy.js — every word the Board destination shows (pm-os-absorb Run 4, slice 4D).
+ *
+ * Pure data and pure functions. No DOM and no import, so glossary.test.js loads this file in Node and checks every string
+ * against the glossary. The four column names, the signals and the item sheet's words are the Breakdown's own
+ * (breakdown-copy.js): the Board reuses them, so a state has one name on every screen.
+ *
+ * The word Release is exempt from the glossary's `release` rule for this file only. On the Board it names the D65 gate that
+ * a person presses on a batch of work items, which is the one place the rule lets it stand.
+ */
+
+export const COPY = {
+  reading: 'Reading…',
+  readFailed: (why) => `Could not read the Board: ${why}`,
+  filter: 'Board filter',
+  filters: { active: 'Active', mine: 'Mine' },
+  initiative: 'Initiative',
+  anyInitiative: 'All initiatives',
+  addItem: 'Add item',
+  adding: {
+    title: 'Add item',
+    sub: 'The item goes to its initiative. Enter adds it.',
+    fieldTitle: 'Title',
+    fieldInitiative: 'Initiative',
+    fieldStage: 'Stage',
+    add: 'Add',
+    cancel: 'Cancel',
+    needTitle: 'Type a title first.',
+    needInitiative: 'No initiative can take an item yet.',
+  },
+  added: 'Item added.',
+  noItems: 'No item matches this filter. Choose another filter, or press Add item.',
+  noWorkspace: 'No repository is open. Open one to see its Board.',
+  noInitiatives: 'No initiative does work yet. A document initiative has no items.',
+  stageOf: (initiative, stage) => `${initiative} · ${stage}`,
+  notMerged: 'Done · your call · not merged',
+  summary: (n) => (n === 1 ? '1 item' : `${n} items`),
+  release: {
+    head: 'Release',
+    title: (initiative) => `Release · ${initiative}`,
+    batch: (id) => `Batch ${id}`,
+    items: (n) => (n === 1 ? '1 work item ready' : `${n} work items ready`),
+    press: 'Release',
+    pressLabel: (initiative, id) => `Release batch ${id} of ${initiative}`,
+    pressed: (n) => (n === 1 ? 'Release granted for 1 work item.' : `Release granted for ${n} work items.`),
+    waiting: 'Release arrives in Run 2.',
+    failed: (why) => `Release was not granted: ${why}`,
+    note: 'One press grants the whole batch. The factory opens pull requests only. It never merges.',
+  },
+  aria: {
+    open: (t) => `Open ${t}`,
+  },
+};
+
+export const GLOSSARY = {
+  exempt: { release: 'On the Board, Release is the name of the D65 gate that a person presses on a batch of work items.' },
+  guide: 'board.md',
+};

package/workspace/public/pm/breakdown-api.js

@@ -0,0 +1,58 @@
+/* pm/breakdown-api.js — the four requests the Breakdown makes (pm-os-absorb Run 1), plus the needs read Today uses.
+ *
+ * Relative URLs only, to this server. Every POST goes through pm/http.js pressFetch, so it carries the
+ * per-launch nonce, and the browser adds the page's own Origin: the server's guard (lib/pm-guard.js) requires both before
+ * it records a write as the PM's (`pm:wawan`, via `ui`). Nothing here sends `by`, `via` or `at`; the writer sets them.
+ *
+ * Every function resolves to the server's JSON, or to `{ ok:false, error }` when the server could not be reached or did
+ * not answer JSON. None of them throws. In FIXTURE mode none of them makes a request.
+ */
+
+import { FIXTURE } from './state.js';
+import { pressFetch } from './http.js';
+
+const qs = (o) => Object.entries(o).filter(([, v]) => v !== null && v !== undefined && v !== '')
+  .map(([k, v]) => encodeURIComponent(k) + '=' + encodeURIComponent(v)).join('&');
+
+async function call(method, url, body, opts) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode' };
+  let res;
+  try {
+    res = await (method === 'GET' ? fetch(url) : pressFetch(url, {
+      method, body: JSON.stringify(body),   // pm/http.js: carries the per-launch nonce, and renews a stale one
+      keepalive: !!(opts && opts.keepalive),
+    }));
+  } catch (e) {
+    return { ok: false, error: 'could not reach the workspace server — ' + ((e && e.message) || String(e)) };
+  }
+  let out;
+  try { out = await res.json(); } catch { return { ok: false, status: res.status, error: 'the server did not answer JSON (HTTP ' + res.status + ')' }; }
+  if (!res.ok && out && out.ok !== false) return { ok: false, status: res.status, error: 'HTTP ' + res.status };
+  if (out && typeof out === 'object' && !res.ok) out.status = res.status;
+  return out;
+}
+
+/** GET the Layout of one initiative. `ladder:false` is the fast path: no owed rows, used when only the items changed. */
+export function getLayout(ws, id, { ladder = true } = {}) {
+  return call('GET', '/api/plan-items?' + qs({ ws, id, ladder: ladder ? null : '0' }));
+}
+
+/** POST 1 to 50 events. `keepalive` lets a held write still reach the server while the page unloads. */
+export function postEvents(ws, events, { keepalive = false } = {}) {
+  return call('POST', '/api/plan-items', { ws, events }, { keepalive });
+}
+
+/** Ask the server what Hand to agent would start. Starts nothing. */
+export function prepareHandoff(ws, item) {
+  return call('POST', '/api/plan-items/handoff/prepare', { ws, item });
+}
+
+/** Start exactly what was prepared: the server refuses a prompt that changed since `sha`. */
+export function goHandoff(ws, item, sha) {
+  return call('POST', '/api/plan-items/handoff/go', { ws, item, confirm: true, prompt_sha: sha });
+}
+
+/** The needs-you queue of one workspace (the existing route). Today reads its Keep, evidence and check rows. */
+export function getNeeds(ws) {
+  return call('GET', '/api/needs?' + qs({ ws }));
+}

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

@@ -0,0 +1,138 @@
+/* pm/breakdown-copy.js — every word the Breakdown shows (pm-os-absorb Run 1).
+ *
+ * Pure data and pure functions. No DOM and no import, so `glossary.test.js` can load this file in Node and check every
+ * string against the glossary rules. A string that a person reads on the Breakdown, in the item sheet, on a Keep card
+ * or in a toast is written here and nowhere else.
+ */
+
+const MON = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+
+/** "2026-10-20" -> "20 Oct". A date-only value is read as a calendar day, never shifted by the time zone. */
+export function shortDate(ymd) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(String(ymd || ''));
+  if (!m) return '';
+  return Number(m[3]) + ' ' + MON[Number(m[2]) - 1];
+}
+
+/** An ISO timestamp -> "5 Oct", in the viewer's own calendar. */
+export function dayOf(iso) {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return '';
+  return d.getDate() + ' ' + MON[d.getMonth()];
+}
+
+/** An ISO timestamp -> "just now", "4 min ago", "3 h ago", "2 days ago", or the day for anything older than a week. */
+export function ago(iso, now) {
+  const t = new Date(iso).getTime();
+  const n = Number.isFinite(now) ? now : Date.now();
+  if (!Number.isFinite(t)) return '';
+  const s = Math.max(0, Math.round((n - t) / 1000));
+  if (s < 60) return 'just now';
+  if (s < 3600) return Math.round(s / 60) + ' min ago';
+  if (s < 86400) return Math.round(s / 3600) + ' h ago';
+  const d = Math.round(s / 86400);
+  if (d < 8) return d === 1 ? '1 day ago' : d + ' days ago';
+  return dayOf(iso);
+}
+
+/** 1 -> "1 item", 9 -> "9 items". */
+export const items = (n) => (n === 1 ? '1 item' : `${n} items`);
+
+/** "agent · sess-3" -> "Agent · sess-3": a label at the start of a sentence. */
+const cap = (s) => String(s || '').charAt(0).toUpperCase() + String(s || '').slice(1);
+
+export const STATES = ['todo', 'doing', 'review', 'done'];
+
+export const COPY = {
+  breakdown: 'Breakdown',
+  noBreakdown: 'no breakdown',
+  proposedOnly: (n) => `no breakdown · ${n} proposed`,
+  progress: (d, t) => `${d} of ${t}`,
+  reading: 'Reading…',
+  readFailed: (why) => `Could not read the breakdown: ${why}`,
+  owedFailed: (why) => `Owed steps are not shown. The workflow could not be read: ${why}`,
+  flagsHead: (n) => (n === 1 ? 'plan-items.jsonl has 1 flagged line:' : `plan-items.jsonl has ${n} flagged lines:`),
+  flagsMore: (n) => `and ${n} more`,
+  tree: 'Tree',
+  board: 'Board',
+  views: 'Breakdown view',
+  states: { todo: 'Todo', doing: 'Doing', review: 'Review', done: 'Done' },
+  stateCount: (s, n) => `${s} ${n}`,
+  columns: 'Board column',
+  signals: { blocked: 'Blocked', noEvidence: 'no evidence', late: 'late', movedByYou: 'moved by you', proposed: 'Proposed' },
+  owed: (noun, actor) => `Owed: ${noun} · ${actor}`,
+  derived: 'derived',
+  current: 'current',
+  other: 'Other',
+  proposedCount: (n) => `${n} proposed`,
+  showDone: (n) => `Show ${n} done`,
+  hideDone: (n) => `Hide ${n} done`,
+  addItem: 'Add item',
+  newItem: 'New item',
+  newItemHint: 'Enter adds it. Paste a list to add one item per line.',
+  tooMany: (n) => `${n} lines is more than 50. Nothing was added.`,
+  due: (d) => `due ${d}`,
+  by: (who) => `by ${who}`,
+  owners: { you: 'You', agent: 'Agent', person: 'Person', tracker: 'Tracker' },
+  keepTree: (n, date, who) => `${who ? cap(who) : 'The agent'} proposed ${items(n)} on ${date}.`,
+  keepToday: (n, who) => (who ? `${items(n)} · ${who}` : items(n)),
+  proposedBy: (who, date) => `Proposed by ${who || 'the agent'}${date ? ' on ' + date : ''}. It does not count until you keep it.`,
+  keepAll: 'Keep all',
+  addEvidence: 'Add evidence',
+  evidenceHint: 'commit:<sha>, pr:<number>, file:<path> or note:<text>',
+  keep: 'Keep',
+  withdrawAll: 'Withdraw all',
+  kept: (n) => `Kept ${items(n)}.`,
+  handToAgent: 'Hand to agent',
+  agentWill: (first, where) => `Agent will: ${first} · ${where}`,
+  preparing: 'Preparing…',
+  go: 'Go',
+  details: 'Details',
+  cancel: 'Cancel',
+  branch: 'Branch',
+  folder: 'Folder',
+  busy: 'A session is already working on this item.',
+  openSession: 'Open session',
+  sessionStarted: (name) => `Session started: ${name}`,
+  undo: 'Undo',
+  markedDone: 'Marked done.',
+  withdrawn: 'Withdrawn.',
+  withdrewN: (n) => `Withdrew ${items(n)}.`,
+  olderInTree: (n) => `${n} older in the Tree`,
+  nothingHere: 'Nothing here.',
+  emptyColumn: (s) => `Nothing in ${s}.`,
+  labels: {
+    title: 'Title', owner: 'Owner', ownerName: 'Name', trackerRef: 'Reference', stage: 'Stage', after: 'After', start: 'Start',
+    due: 'Due', milestone: 'Milestone', blocked: 'Blocked', blockedBecause: 'Blocked because', note: 'Note', history: 'History',
+    close: 'Close', withdraw: 'Withdraw', state: 'State',
+  },
+  afterNone: 'Nothing. It can start any time.',
+  addPredecessor: 'Add predecessor',
+  otherItemId: 'Item id from another initiative',
+  add: 'Add',
+  aria: {
+    reorder: (t) => `Reorder ${t}`,
+    markDone: (t) => `Mark done: ${t}`,
+    markNotDone: (t) => `Mark not done: ${t}`,
+    more: (t) => `More for ${t}`,
+    collapse: (s) => `Collapse ${s}`,
+    expand: (s) => `Expand ${s}`,
+    remove: (t) => `Remove ${t}`,
+    open: (t) => `Open ${t}`,
+  },
+  menu: { open: 'Open', moveTo: (s) => `Move to ${s}`, moveUp: 'Move up', moveDown: 'Move down' },
+  needs: {
+    evidence: 'no evidence',
+    flag: 'check',
+    open: 'Open',
+  },
+};
+
+/** The owner as a person reads it: `person:Mei` -> "Mei", `tracker:NW-430` -> "NW-430". */
+export function ownerLabel(owner) {
+  const o = String(owner || 'you');
+  if (o === 'you') return COPY.owners.you;
+  if (o === 'agent') return COPY.owners.agent;
+  const i = o.indexOf(':');
+  return i > 0 ? o.slice(i + 1) : o;
+}