create-pmos 0.73.0 → 0.75.0

package/workspace/public/pm/initiatives-ui.js

@@ -7,15 +7,18 @@
  *   checkBySheet({…})               a sheet with a date and Save or Clear
  *   say(out, ok)                    a toast for the answer of a write: the success text, or the server's refusal
  *   rescanRepo(ws)                  read the repository again now, with a toast at the start and at the end (scan-consistency R6);
- *                                   the tidy sheet first when a document repository has duplicates (scan-documents S10)
- *   tidySheet(duplicates)           the groups of duplicate documents, the one to keep in each, and Cancel, Skip or Archive
+ *                                   in a document repository, Jev's check first when its gates are open (scan-documents S11),
+ *                                   then the tidy sheet when there are kinds to change or duplicates (S10)
+ *   jevPlanSheet(plan)              what Jev would read and how many requests it sends, and Cancel, Scan without Jev or Check
+ *   tidySheet(duplicates)           the kinds Jev would change, the groups of duplicate documents, the one to keep in each,
+ *                                   and Cancel, Skip or Archive
  * No native dialog is used anywhere here. Every control is a primitive (primitives.js).
  */
 
 import { el } from './dom.js';
 import { button, field, signal, sheet, tabs, toast } from './primitives.js';
 import { COPY } from './initiatives-copy.js';
-import { rescan, duplicates, tidy } from './initiatives-api.js';
+import { rescan, duplicates, tidy, jevCheck } from './initiatives-api.js';
 
 export const horizonLabel = (h) => COPY.horizons[h] || h;
 export const progressText = (row) => (row && row.progress && row.progress.label) || '';
@@ -52,22 +55,25 @@ export function scanMoves(before, after) {
 
 /**
  * The tidy sheet (scan-documents S10): each group of documents that share an initiative and a role, with the one to keep
- * chosen, a switch to leave the group as it is, and three answers. Resolves { keep: [{ id, role, keep }] } on the confirm,
- * 'skip' on Scan without tidying, and null on Cancel, Escape or the backdrop.
+ * chosen, a switch to leave the group as it is, and three answers. Resolves { keep: [{ id, role, keep }], kinds } on the
+ * confirm, 'skip' on Scan without tidying, and null on Cancel, Escape or the backdrop. After Jev's check (S11) it also lists
+ * the kinds Jev would change, each with a switch, and each group says which version Jev picks; `kinds` is the switched-on ones.
  */
 export function tidySheet(d) {
   return new Promise((resolve) => {
     let settled = false;
     const finish = (v) => { if (settled) return; settled = true; resolve(v); };
     const state = d.groups.map((g) => ({ g, on: true, keep: g.keep }));
+    const fixes = (d.corrections || []).map((c) => ({ c, on: true }));
     const count = () => state.reduce((n, x) => n + (x.on ? x.g.files.length - 1 : 0), 0);
+    const label = () => (fixes.length ? COPY.jevConfirm(fixes.filter((x) => x.on).length, count()) : COPY.tidyConfirm(count()));
     const day = (t) => (t ? new Date(t * 1000).toISOString().slice(0, 10) : '');
     const err = el('p', { class: 'in-error', role: 'alert', 'data-in-error': '' });
     err.hidden = true;
     const groups = state.map((x, gi) => {
       const box = el('fieldset', { class: 'in-tidy__group', 'data-in-tidy-group': x.g.id + ':' + x.g.role });
       const toggle = el('input', { type: 'checkbox', checked: true, 'aria-label': COPY.tidyGroupToggle, 'data-in-tidy-on': '' });
-      toggle.addEventListener('change', () => { x.on = toggle.checked; if (x.on) box.removeAttribute('data-off'); else box.setAttribute('data-off', ''); go.textContent = COPY.tidyConfirm(count()); });
+      toggle.addEventListener('change', () => { x.on = toggle.checked; if (x.on) box.removeAttribute('data-off'); else box.setAttribute('data-off', ''); go.textContent = label(); });
       const head = el('legend', { class: 'in-tidy__head' }, toggle, `${x.g.title} · ${COPY.tidyRole[x.g.role] || x.g.role}`);
       const files = x.g.files.map((f) => {
         const radio = el('input', { type: 'radio', name: 'in-tidy-' + gi, value: f.path, checked: f.path === x.keep, 'data-in-tidy-keep': f.path });
@@ -76,21 +82,34 @@ export function tidySheet(d) {
         return el('label', { class: 'in-tidy__file' }, radio, el('span', null, el('span', { class: 'in-tidy__path' }, f.path), meta ? el('span', { class: 'in-note' }, ' · ' + meta) : null));
       });
       const shared = (x.g.shared || []).map((p) => el('p', { class: 'in-note in-tidy__file' }, COPY.tidyShared(p)));
-      box.replaceChildren(head, ...files, ...shared);
+      const jev = x.g.jev && x.g.jev.words ? [el('p', { class: 'in-note in-tidy__file', 'data-in-tidy-jev': '' }, x.g.jev.words)] : [];
+      box.replaceChildren(head, ...jev, ...files, ...shared);
       return box;
     });
+    const kindsBox = fixes.length ? (() => {
+      const box = el('fieldset', { class: 'in-tidy__group', 'data-in-tidy-kinds': '' });
+      const rows = fixes.map((x) => {
+        const t = el('input', { type: 'checkbox', checked: true, 'aria-label': COPY.jevKindToggle, 'data-in-tidy-kind': x.c.path });
+        t.addEventListener('change', () => { x.on = t.checked; go.textContent = label(); });
+        return el('label', { class: 'in-tidy__file' }, t, el('span', null, el('span', { class: 'in-tidy__path' }, COPY.jevKindLine(x.c)), x.c.words ? el('span', { class: 'in-note' }, ' · ' + x.c.words) : null));
+      });
+      box.replaceChildren(el('legend', { class: 'in-tidy__head' }, COPY.jevKindsHead(fixes.length)), el('p', { class: 'in-note in-tidy__file' }, COPY.jevKindsBody), ...rows);
+      return box;
+    })() : null;
     const inits = new Set(d.groups.map((g) => g.id)).size;
     const go = button({
-      label: COPY.tidyConfirm(count()), variant: 'primary', attrs: { 'data-in-tidy-confirm': '' },
+      label: label(), variant: 'primary', attrs: { 'data-in-tidy-confirm': '' },
       onClick: () => {
         const keep = state.filter((x) => x.on).map((x) => ({ id: x.g.id, role: x.g.role, keep: x.keep }));
-        if (!keep.length) { err.textContent = COPY.tidyNone; err.hidden = false; return; }
-        finish({ keep }); s.close();
+        const kinds = fixes.filter((x) => x.on).map((x) => ({ path: x.c.path, kind: x.c.kind, was: x.c.was, p: x.c.p }));
+        if (!keep.length && !kinds.length) { err.textContent = COPY.tidyNone; err.hidden = false; return; }
+        finish(kinds.length ? { keep, kinds } : { keep }); s.close();
       },
     });
     const s = sheet({
-      mode: 'auto', title: COPY.tidyTitle,
-      body: [el('p', { class: 'in-note' }, COPY.tidyBody(d.groups.length, inits, d.archive)), el('div', { class: 'in-tidy' }, groups), err],
+      mode: 'auto', title: fixes.length ? COPY.jevTitle : COPY.tidyTitle,
+      body: [d.groups.length ? el('p', { class: 'in-note' }, COPY.tidyBody(d.groups.length, inits, d.archive)) : null,
+        el('div', { class: 'in-tidy' }, ...(kindsBox ? [kindsBox] : []), ...groups), err].filter(Boolean),
       attrs: { 'data-in-sheet': 'tidy' },
       onClose: () => finish(null),
       actions: [
@@ -102,25 +121,73 @@ export function tidySheet(d) {
   });
 }
 
-/** Re-scan: read the repository again now. In a document repository with duplicates, the tidy sheet comes first (S10).
- *  A toast says the scan started and another says how it ended. Answers the rescan answer; the caller reloads what it
- *  shows when `ok`. */
+/**
+ * Jev's plan (scan-documents S11): how many documents Jev would read and how many requests that sends, before anything
+ * is sent. Resolves 'jev' on the check, 'skip' on Scan without Jev, and null on Cancel, Escape or the backdrop.
+ */
+export function jevPlanSheet(plan) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (v) => { if (settled) return; settled = true; resolve(v); };
+    const s = sheet({
+      mode: 'auto', title: COPY.jevTitle,
+      body: [el('p', { class: 'in-note' }, COPY.jevPlan(plan)), plan.withheld_count || plan.excluded ? el('p', { class: 'in-note' }, COPY.jevWithheld((plan.withheld_count || 0) + (plan.excluded || 0))) : null].filter(Boolean),
+      attrs: { 'data-in-sheet': 'jev-plan' },
+      onClose: () => finish(null),
+      actions: [
+        button({ label: COPY.cancel, variant: 'outline', onClick: () => s.close(), attrs: { 'data-in-cancel': '' } }),
+        button({ label: COPY.jevSkip, variant: 'outline', onClick: () => { finish('skip'); s.close(); }, attrs: { 'data-in-jev-skip': '' } }),
+        button({ label: COPY.jevGo(plan.requests), variant: 'primary', onClick: () => { finish('jev'); s.close(); }, attrs: { 'data-in-jev-go': '' } }),
+      ],
+    });
+  });
+}
+
+/** Jev's part of a scan (S11): the plan, the PM's confirm, then the check. Answers { cancelled } on Cancel, { review } with
+ *  the kinds to change and the groups when Jev answered, or { note } with what to say when Jev did not check. */
+async function jevStep(ws) {
+  const j = await jevCheck(ws);
+  if (!j || !j.ok || j.profile !== 'pm-artifacts') return {};
+  if (!j.gates || !j.gates.open) return { note: COPY.jevShut(j.gates && j.gates.sentence ? j.gates.sentence : 'it is switched off.') };
+  if (!j.plan || !j.plan.documents) return {};
+  const go = await jevPlanSheet(j.plan);
+  if (!go) return { cancelled: true };
+  if (go === 'skip') return {};
+  toast({ text: COPY.jevReading, timeout: 6000 });
+  const r = await jevCheck(ws, j.plan);
+  if (!r || !r.ok) return { failed: COPY.jevFailed((r && r.error) || 'no answer') };
+  const pre = r.paused ? COPY.jevPaused(r.paused) + ' ' : '';
+  if (!(r.corrections || []).length && !(r.groups || []).length) return { note: pre + COPY.jevClean(r.checked || 0) };
+  return { review: { corrections: r.corrections || [], groups: r.groups || [], archive: r.archive }, note: pre || null };
+}
+
+/** Re-scan: read the repository again now. In a document repository, Jev's check comes first when its gates are open
+ *  (S11), then the tidy sheet: the kinds Jev would change and the duplicates by Jev's kinds and picks. With Jev's gates
+ *  shut, or on Scan without Jev, the tidy sheet lists the duplicates the file names show (S10). A toast says the scan
+ *  started and another says how it ended. Answers the rescan answer; the caller reloads what it shows when `ok`. */
 export async function rescanRepo(ws) {
   let first = null;
-  const d = await duplicates(ws);
-  if (d && d.ok && Array.isArray(d.groups) && d.groups.length) {
+  const jv = await jevStep(ws);
+  if (jv.cancelled) return { ok: false, cancelled: true };
+  if (jv.failed) toast({ text: jv.failed, tone: 'error', timeout: 8000 });
+  let d = jv.review || null;
+  if (!d) { const dup = await duplicates(ws); if (dup && dup.ok && Array.isArray(dup.groups) && dup.groups.length) d = dup; }
+  if (d) {
     const pick = await tidySheet(d);
     if (!pick) return { ok: false, cancelled: true };
-    if (pick !== 'skip') first = () => tidy(ws, pick.keep);
+    if (pick !== 'skip') first = () => tidy(ws, pick.keep, pick.kinds);
   }
   toast({ text: COPY.rescanning, timeout: 4000 });
   const a = await rescan(ws, first ? { first } : null);
   const t = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
   const moved = a && a.ok && a.after ? scanMoves(a.before, a.after) : null;
-  const archived = a && a.tidied && Array.isArray(a.tidied.moved) && a.tidied.moved.length ? COPY.tidyArchived(a.tidied.moved.length) + ' ' : '';
+  const td = a && a.tidied;
+  const archived = (td && td.kinds_written ? COPY.jevRecorded(td.kinds_written) + ' ' : '')
+    + (td && Array.isArray(td.moved) && td.moved.length ? COPY.tidyArchived(td.moved.length) + ' ' : '');
+  const note = jv.note ? ' ' + jv.note : '';
   if (!a || !a.ok) toast({ text: first && a && !a.after && !a.slow ? COPY.tidyFailed((a && a.error) || 'no answer') : COPY.rescanFailed((a && a.error) || 'no answer'), tone: 'error', timeout: 8000 });
-  else if (a.slow) toast({ text: archived + COPY.rescanSlow, timeout: 6000 });
-  else toast({ text: archived + (moved ? COPY.rescanResult(moved.checked, moved.moves, (a.after && a.after.scan) || null) : COPY.rescanDone(t)), timeout: 10000 });
+  else if (a.slow) toast({ text: archived + COPY.rescanSlow + note, timeout: 6000 });
+  else toast({ text: archived + (moved ? COPY.rescanResult(moved.checked, moved.moves, (a.after && a.after.scan) || null) : COPY.rescanDone(t)) + note, timeout: 10000 });
   try { if (a && a.ok) window.dispatchEvent(new CustomEvent('pmos:initiatives-changed')); } catch { /* no window */ }
   return a || { ok: false };
 }

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

@@ -159,7 +159,7 @@ export const COPY = {
     all: 'All',
     status2: {
       waiting: 'waiting', working: 'agent working', review: 'approve', reviewAuto: 'check it', sending: 'sending', sent: 'sent',
-      done: 'done', failed: 'failed', you: 'your act', notStarted: 'not started', handled: 'handled', replyNeeded: 'reply needed',
+      done: 'done', failed: 'failed', notStarted: 'not started', handled: 'handled', replyNeeded: 'reply needed',
     },
     newItem: 'new',
     pill: { prepare: 'prepare', ready: 'ready', ended: 'ended', notes: 'notes', goal: (n) => `goal ${n}` },
@@ -189,8 +189,6 @@ export const COPY = {
     prep: 'Prepare',
     phases: { before: 'Before', during: 'During', after: 'After' },
     who: { pm: 'you', agent: 'agent' },
-    needPrep: 'You need to prepare',
-    nothingToPrep: 'Nothing to prepare',
     initiative: 'Initiative',
     suggested: (why) => `Suggested. ${why}`,
     openInitiative: 'Open the initiative',
@@ -235,7 +233,6 @@ export const COPY = {
     waitingNote: 'The agent has not started this job yet. At most 5 sessions run at once.',
     workingNote: 'An agent session is doing this job now.',
     sendingNote: 'You said yes to this draft. An agent session is sending it now.',
-    youNote: 'Only you can do this one. The link opens the conversation.',
     autoNote: 'The agent did this alone. Nothing went outside this machine.',
     notTask: 'The agent starts this job when you press Prepare my day.',
     related: 'Related',
@@ -351,6 +348,87 @@ export const COPY = {
       today: 'Today',
     },
   },
+  /** The items the PM acts on and the meetings the PM prepares for (initiative today-act-prepare, PRD A1 to D4). A verb
+   *  first, one sentence of what to do, then the steps, one button that fits the first open step, and the marks. */
+  act: {
+    verb: { reply: 'Reply', review: 'Review', decide: 'Decide', 'sign-off': 'Sign off', read: 'Read', do: 'Do', prepare: 'Prepare', approve: 'Approve' },
+    groups: { later: 'Snoozed', waiting: 'Waiting on others', done: 'Done today' },
+    by: (at) => `by ${at}`,
+    at: (at) => `at ${at}`,
+    left: (min) => (min <= 0 ? 'now' : min < 60 ? `in ${min} min` : `in ${Math.floor(min / 60)} h ${min % 60} min`),
+    back: (at) => `back ${at}`,
+    check: (at) => `ask ${at}`,
+    chip: { done: 'done', ready: 'ready', dismissed: 'not mine', skipped: 'no prep', today: 'today' },
+    from: (who, where) => (who && where ? `${who} in ${where}` : who || where || ''),
+    howTitle: (d, n) => `How to do it · ${d} of ${n}`,
+    beforeTitle: (at) => `Before ${at}`,
+    more: 'More context',
+    moreMeeting: (during, after) => `In the meeting (${during}) · After (${after})`,
+    readOnly: 'Read only. Nothing is sent before you press a button that says so.',
+    open: { slack: 'Reply in Slack ↗', jira: 'Open in Jira ↗', confluence: 'Open in Confluence ↗', github: 'Open on GitHub ↗', figma: 'Open in Figma ↗',
+      mail: 'Open the mail ↗', drive: 'Open in Google Drive ↗', calendar: 'Open the event ↗', wispr: 'Open the notes ↗', website: 'Open the page ↗' },
+    openLink: 'Open the link ↗',
+    startStep: (t) => `Start: ${t}`,
+    askAgentStep: 'Ask the agent',
+    draft: 'Have the agent draft it',
+    drafting: 'The agent is drafting. The draft shows here, and nothing is sent before you approve it.',
+    draftStarted: 'The agent is drafting it. Approve or revise the draft when it is ready.',
+    done: 'Mark done',
+    ready: 'Mark ready',
+    snooze: 'Snooze',
+    remind: 'Remind me',
+    hold: 'Waiting on…',
+    notMine: 'Not mine',
+    skip: 'Skip prep',
+    snoozeTo: { hour: 'In 1 hour', later: 'Later today, 16:00', due: 'Before it is due', end: 'End of the day, 17:30', m30: '30 min before it', m15: '15 min before it' },
+    holdWho: 'Who or what you wait on',
+    holdHint: 'For example: Raj, or the cost model',
+    holdWhen: 'Ask again',
+    holdWhenOpts: { h2: 'In 2 hours', end: 'At 17:30' },
+    holdGo: 'Put on hold',
+    holdNeed: 'Say who or what you wait on, in 1 to 80 characters.',
+    why: { 'no-action': 'No action needed', 'someone-else': 'Someone else handles it', 'done-elsewhere': 'It is already done', nothing: 'Nothing to prepare', elsewhere: 'I prepare elsewhere' },
+    did: {
+      done: (t) => `Done: ${t}.`, ready: (t) => `Ready: ${t}.`, snooze: (at) => `Snoozed. It comes back at ${at}.`,
+      hold: (who, at) => `Waiting on ${who}. Today asks you again at ${at}.`, dismiss: (why) => `${why}. Taken off Needs you.`, reopen: 'Back in Needs you.',
+    },
+    undo: 'Undo',
+    undone: 'Put back as it was.',
+    state: {
+      snoozed: (at) => `Snoozed. It comes back to Needs you at ${at}.`,
+      waiting: (who, at) => `On hold: waiting on ${who}. Today asks you again at ${at}.`,
+      done: (at) => `Done at ${at}.`, ready: (at) => `Ready at ${at}.`,
+      dismissed: (why) => `Not on your list: ${why}.`,
+      back: 'Back from snooze or hold: the time you set has come.',
+    },
+    bringBack: 'Bring it back now',
+    reopen: 'Reopen',
+    readiness: (d, n) => `${d} of ${n} ready`,
+    fit: { ok: 'Your prep is done.', time: (left, free) => `${left} ${left === 1 ? 'step' : 'steps'} left, ${free} min free before it.`,
+      short: (left, free) => `${left} ${left === 1 ? 'step' : 'steps'} left and ${free} min free. Give a step to the agent, or snooze.` },
+    noSteps: 'No steps were given. The sentence above says what to do.',
+    stepFailed: (why) => `The step was not saved: ${why}`,
+    // the context and the answer in the card (PRD X1, X2, F1 to F3)
+    threadTitle: 'The conversation',
+    refsTitle: 'What the sources say',
+    refRead: 'Read: ',
+    refOpen: 'Open the source ↗',
+    compose: { reply: 'Your reply', review: 'Your review', decide: 'Your answer', 'sign-off': 'Your sign-off' },
+    composeHint: 'Write it here, or start from a suggestion.',
+    startFrom: 'Start from:',
+    verdictLabel: 'Your verdict',
+    verdict: { approve: 'Approve', changes: 'Ask for changes' },
+    sendTo: (to) => `Send to ${to}`,
+    postReview: (to) => `Post the review to ${to}`,
+    sendNote: 'When you press, the agent posts exactly this text, as you, to that place. Nothing else is sent.',
+    sendNeed: 'Write the text to send first.',
+    verdictNeed: 'Choose Approve or Ask for changes first.',
+    sendStarted: (to) => `Sending to ${to}. The job shows Sent when it is posted.`,
+    noteTitle: 'Your note',
+    noteHint: 'Write it here. It is saved when you leave the box.',
+    noteStays: 'Saved with the meeting on this machine. Nothing is sent.',
+    noteSaved: 'Note saved.',
+  },
   /** The Acceptance Gate card (D12): the PM's own act on a run. */
   accept: {
     review: 'Review',