create-pmos 0.71.0 → 0.72.0

package/workspace/lib/routes-my-work.js

@@ -0,0 +1,122 @@
+'use strict';
+/* routes-my-work.js — the My work destination's routes (initiative my-work, PRD R1 to R5, R11).
+ *
+ *   GET  /api/my-work                    → { ok, today, read_at, items, counts, banner }   every item assigned to the PM,
+ *                                          ranked (lib/my-work.js fold), across every registered repository
+ *   POST /api/my-work/read  { items }    → { ok, read_at, count }   the my-work-read skill's submission (`pmos my-work submit`)
+ *   POST /api/my-work/act   { action: brief|handle|reopen, item, instruction?, ws }
+ *                                        → { ok, item, task? }      the PM's press; a brief adds one day task (R5)
+ *   POST /api/my-work/refresh { ws }     → { ok, session }          Read again: starts the my-work-read skill
+ *
+ * STATE. The latest read is <runtime>/my-work/read.json and the presses are <runtime>/my-work/actions.jsonl, append-only.
+ * Both stay in the per-user runtime state and never land in a repository: they hold paraphrases of Jira comments. The
+ * WBS items are folded from each repository's Board (lib/board-fold.js, filter mine) on every GET, and nothing is
+ * written to a plan ledger (D88).
+ *
+ * THE SERVER NEVER READS JIRA (D53, D71). An agent session reads it with the PM's own connection and posts the read.
+ * The two presses that start a session (act brief, refresh) pass pm-guard requirePagePress first: an agent session
+ * cannot brief itself or another agent.
+ */
+const fs = require('fs');
+const path = require('path');
+const guard = require('./pm-guard.js');
+const myWork = require('./my-work.js');
+const boardFold = require('./board-fold.js');
+const { localDate } = require('./brief.js');
+
+const dirOf = (ctx) => path.join(ctx.runtimeDir, 'my-work');
+const readFile = (ctx) => path.join(dirOf(ctx), 'read.json');
+const actionsFile = (ctx) => path.join(dirOf(ctx), 'actions.jsonl');
+
+function loadRead(ctx) {
+  try { const r = JSON.parse(fs.readFileSync(readFile(ctx), 'utf8')); return r && Array.isArray(r.items) ? r : null; } catch { return null; }
+}
+function loadActions(ctx) {
+  try { return myWork.parseActions(fs.readFileSync(actionsFile(ctx), 'utf8')); } catch { return []; }
+}
+
+/** The whole list, as GET answers it. */
+function listFor(ctx, now) {
+  const today = localDate(now);
+  const banner = [];
+  const boards = [];
+  const all = typeof ctx.workspaceList === 'function' ? ctx.workspaceList() : [];
+  for (const w of all) {
+    try {
+      const b = boardFold.boardFor({ id: w.id, root: w.root }, { filter: 'mine', now });
+      if (b.ok) boards.push({ ws: w.id, repo: w.name || path.basename(w.root), board: b });
+      else banner.push({ source: 'wbs:' + w.id, error: b.error });
+    } catch (e) { banner.push({ source: 'wbs:' + w.id, error: String((e && e.message) || e).slice(0, 160) }); }
+  }
+  const read = loadRead(ctx);
+  const actions = loadActions(ctx);
+  const runs = {};
+  for (const d of new Set(actions.filter((a) => a.action === 'brief').map((a) => String(a.at).slice(0, 10)).concat([today]))) {
+    try { const r = ctx.readDayRun ? ctx.readDayRun(d) : null; if (r) runs[d] = r; } catch { /* a run that cannot be read is no run */ }
+  }
+  // a run of a later day can hold a task too: today's covers every brief made today
+  const out = myWork.fold({ read, wbs: myWork.wbsItems(boards), actions, runs, today });
+  return { ok: true, today, read_at: read ? read.read_at || null : null, items: out.items, counts: out.counts, banner };
+}
+
+function writeAtomic(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, text);
+  fs.renameSync(tmp, file);
+}
+
+async function handle(req, res, url, ctx) {
+  const p = url.pathname;
+  const now = Date.now();
+  if (p === '/api/my-work') {
+    if (req.method !== 'GET') { ctx.json(res, { ok: false, error: 'GET only' }, 405); return true; }
+    ctx.json(res, listFor(ctx, now));
+    return true;
+  }
+  if (!['/api/my-work/read', '/api/my-work/act', '/api/my-work/refresh'].includes(p)) return false;
+  if (req.method !== 'POST') { ctx.json(res, { ok: false, error: 'POST only' }, 405); return true; }
+  const got = await ctx.readJson(req);
+  if (!got.ok) { ctx.json(res, { ok: false, error: 'invalid JSON body' }, 400); return true; }
+  const body = got.body;
+
+  if (p === '/api/my-work/read') {
+    const c = myWork.checkRead(body, now);
+    if (!c.ok) { ctx.json(res, { ok: false, error: c.error }, 400); return true; }
+    try { writeAtomic(readFile(ctx), JSON.stringify(c.read) + '\n'); }
+    catch { ctx.json(res, { ok: false, error: 'could not save the read — nothing changed' }, 500); return true; }
+    ctx.json(res, { ok: true, read_at: c.read.read_at, count: c.read.items.length });
+    return true;
+  }
+
+  const g = guard.requirePagePress(req, body);
+  if (!g.ok) { ctx.json(res, { ok: false, error: g.error }, g.status); return true; }
+
+  if (p === '/api/my-work/refresh') {
+    const r = ctx.myWorkRead(String(body.ws || ''));
+    ctx.json(res, r.ok ? { ok: true, session: r.session } : { ok: false, error: r.error }, r.ok ? 200 : r.status || 500);
+    return true;
+  }
+
+  // act
+  const c = myWork.checkAct(body, now);
+  if (!c.ok) { ctx.json(res, { ok: false, error: c.error }, 400); return true; }
+  const list = listFor(ctx, now);
+  const item = list.items.find((x) => x.id === c.record.item);
+  if (!item) { ctx.json(res, { ok: false, error: `no item ${c.record.item} is assigned to you` }, 404); return true; }
+  const why = myWork.refusal(item, c.record.action);
+  if (why) { ctx.json(res, { ok: false, error: why }, 409); return true; }
+  let task = null;
+  if (c.record.action === 'brief') {
+    const b = ctx.myWorkBrief(myWork.taskSpec(item, c.record), String(body.ws || ''));
+    if (!b.ok) { ctx.json(res, { ok: false, error: b.error }, b.status || 500); return true; }
+    task = b.task;
+  }
+  try { fs.mkdirSync(dirOf(ctx), { recursive: true }); fs.appendFileSync(actionsFile(ctx), JSON.stringify(c.record) + '\n'); }
+  catch { ctx.json(res, { ok: false, error: 'could not save your press' }, 500); return true; }
+  const after = listFor(ctx, Date.now()).items.find((x) => x.id === item.id) || null;
+  ctx.json(res, { ok: true, item: after, task });
+  return true;
+}
+
+module.exports = { prefixes: ['/api/my-work'], handle, listFor };

package/workspace/lib/sync.js

@@ -118,7 +118,36 @@ async function status(root) {
 }
 
 // The press. Returns { ok, steps:[{step, ok, note}], stopped_at?, message }.
-async function sync(root, { label } = {}) {
+// While a replay stops on a conflict, the PM's choice settles each conflicted file whole. In a rebase, stage 2 (`--ours`)
+// is the remote's side being built on, and stage 3 (`--theirs`) is this machine's commit being replayed. A side that
+// deleted the file is honoured by removing it. A commit left with nothing of its own is skipped. Bounded: each round
+// replays one commit, so the loop ends after at most one round per unpushed commit plus one.
+async function settleReplay(root, prefer, rounds) {
+  for (let i = 0; i <= rounds; i++) {
+    const rp = await run(root, ['rev-parse', '--git-path', 'rebase-merge']);
+    if (!rp.ok || !fs.existsSync(path.resolve(root, rp.out))) return { ok: true };
+    const u = await run(root, ['diff', '--name-only', '--diff-filter=U']);
+    const files = u.ok && u.out ? u.out.split('\n').filter(Boolean) : [];
+    if (!files.length) return { ok: false, err: 'the replay stopped with no conflicted file' };
+    const stage = prefer === 'mine' ? '3' : '2';
+    for (const f of files) {
+      const has = await run(root, ['cat-file', '-e', `:${stage}:${f}`]);
+      const r = has.ok ? await run(root, ['checkout', prefer === 'mine' ? '--theirs' : '--ours', '--', f]) : await run(root, ['rm', '-q', '--', f]);
+      if (!r.ok) return { ok: false, err: r.err };
+      if (has.ok) { const a = await run(root, ['add', '--', f]); if (!a.ok) return { ok: false, err: a.err }; }
+    }
+    const empty = (await run(root, ['diff', '--cached', '--quiet'])).ok;
+    const next = await run(root, ['-c', 'core.editor=true', 'rebase', empty ? '--skip' : '--continue']);
+    if (next.ok) return { ok: true };
+  }
+  return { ok: false, err: 'the replay did not finish' };
+}
+
+// `prefer` is the PM's answer after a stop on a conflict, and only the press passes it (never auto-sync): 'mine' keeps
+// this machine's version of each file both machines changed, 'theirs' keeps the other machine's. Every other change
+// from both machines is kept either way. Still a rebase of this machine's own commits: no force, no merge commit.
+async function sync(root, { label, prefer } = {}) {
+  if (prefer !== undefined && prefer !== 'mine' && prefer !== 'theirs') prefer = undefined;
   const steps = [];
   const stop = (step, message) => { steps.push({ step, ok: false, note: message }); return { ok: false, steps, stopped_at: step, message }; };
   const done = (step, note) => steps.push({ step, ok: true, note });
@@ -157,20 +186,26 @@ async function sync(root, { label } = {}) {
   if (s2.behind) {
     // Fast-forward when we have nothing of our own; otherwise replay OUR unpushed commits on top.
     const attrs = s2.ahead ? unionAttributesFor(root) : null;
-    const verb = s2.ahead ? [...(attrs ? ['-c', `core.attributesFile=${attrs}`] : []), 'rebase', '--autostash', s2.upstream]
+    // With the PM's choice, a conflicted hunk takes that side (-X); in a rebase `theirs` is this machine's commit.
+    const side = prefer && s2.ahead ? ['-X', prefer === 'mine' ? 'theirs' : 'ours'] : [];
+    const verb = s2.ahead ? [...(attrs ? ['-c', `core.attributesFile=${attrs}`] : []), 'rebase', '--autostash', ...side, s2.upstream]
       : ['merge', '--ff-only', s2.upstream];
-    const r = await run(root, verb);
+    let r = await run(root, verb);
+    if (!r.ok && prefer && s2.ahead) r = await settleReplay(root, prefer, s2.ahead);
     if (!r.ok) {
       if (!s2.ahead) return stop('integrate', `cannot fast-forward — ${r.err.split('\n')[0] || 'see git'}`);
       // Name the files before the abort clears them: the PM has to open these, and "the same lines" alone says not where.
       const u = await run(root, ['diff', '--name-only', '--diff-filter=U']);
       const files = u.ok && u.out ? u.out.split('\n').filter(Boolean) : [];
       await run(root, ['rebase', '--abort']);
-      return stop('integrate', files.length
-        ? `both machines changed ${files.join(', ')} — rebase aborted, nothing changed; keep the version you want in each file on one machine, sync it, then sync the other`
-        : `the two machines changed the same lines — rebase aborted, nothing changed — ${r.err.split('\n')[0] || 'see git'}`);
+      const out = stop('integrate', files.length
+        ? `both machines changed ${files.join(', ')} — rebase aborted, nothing changed; choose which machine's version to keep`
+        : `the two machines changed the same lines — rebase aborted, nothing changed — ${(r.err || '').split('\n')[0] || 'see git'}`);
+      // The surface offers the choice only for a conflict it can settle, and never again once one was made.
+      if (!prefer) out.conflict = { files };
+      return out;
     }
-    done('integrate', s2.ahead ? `replayed ${s2.ahead} local commit(s) on the remote` : `fast-forwarded ${s2.behind} commit(s)`);
+    done('integrate', s2.ahead ? `replayed ${s2.ahead} local commit(s) on the remote${prefer ? `, keeping ${prefer === 'mine' ? 'this' : 'the other'} machine's version where both changed a file` : ''}` : `fast-forwarded ${s2.behind} commit(s)`);
   } else done('integrate', 'nothing to bring in');
 
   const s3 = await status(root);

package/workspace/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.71.0",
+  "version": "0.72.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

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

package/workspace/public/pm/app.js

@@ -39,7 +39,7 @@ import { isMobile, mountMobile, applyMobile } from './mobile.js';
 /* The frame's parts (Run 3, slice 3A). Small modules with no effect at import: a fixture page loads them and calls none. */
 import { createTopbar, unsyncedOf } from './topbar.js';
 import { createDockRail } from './dock.js';
-import { SEL, ensureComponentsCss, iconButton, menu, toast } from './primitives.js';
+import { SEL, ensureComponentsCss, iconButton, menu, toast, sheet, button } from './primitives.js';
 import { ensureSprite } from './icons.js';
 import { COPY as FC } from './frame-copy.js';
 import { registerCommand } from './registry.js';
@@ -406,7 +406,7 @@ function render() {
 
 const FRAME = !FIXTURE && !LEGACY_LAYOUT_FLAG;
 const FRAME_KEY = 'pmos.workspace.pm.frame';
-const FRAME_DESTS = Object.freeze(['today', 'initiatives', 'board', 'reports', 'docs', 'people', 'settings']);
+const FRAME_DESTS = Object.freeze(['today', 'mywork', 'initiatives', 'board', 'reports', 'docs', 'people', 'settings']);
 
 function readFrame() {
   if (!FRAME) return {};
@@ -512,17 +512,34 @@ function syncReading(repo) {
   }
   return syncSeen.get(repo).st;
 }
-async function runSync() {
+async function runSync(prefer) {
   const repo = fr.scope === 'all' ? null : activeRepo();
   if (!repo || fr.syncing || !mods.data || typeof mods.data.syncRepository !== 'function') return;
   fr.syncing = true;
   setState({});
   let res;
-  try { res = await mods.data.syncRepository(repo); } catch (e) { res = { ok: false, message: String((e && e.message) || e) }; }
+  const opts = prefer === 'mine' || prefer === 'theirs' ? { prefer } : undefined;
+  try { res = await mods.data.syncRepository(repo, opts); } catch (e) { res = { ok: false, message: String((e && e.message) || e) }; }
   fr.syncing = false;
   syncSeen.delete(repo);
-  toast({ text: res && res.ok ? FC.sync.done : FC.sync.stopped((res && (res.stopped_at || res.step)) || FC.sync.label, (res && (res.message || res.error)) || '') });
   setState({});
+  // Both machines changed the same lines and nothing changed: the PM chooses which version to keep (D70 amended
+  // 2026-10-07). The server offers the choice only once per press, so a choice that still stops ends in the toast.
+  if (res && !res.ok && res.conflict) return chooseSyncSide(res.conflict.files || []);
+  toast({ text: res && res.ok ? FC.sync.done : FC.sync.stopped((res && (res.stopped_at || res.step)) || FC.sync.label, (res && (res.message || res.error)) || '') });
+}
+function chooseSyncSide(files) {
+  const C = FC.sync.conflict;
+  let s = null;
+  const pick = (side) => () => { s.close(); runSync(side); };
+  s = sheet({
+    title: C.title, sub: C.sub(files), body: [el('p', {}, C.body)], attrs: { 'data-sync-conflict': '' },
+    actions: [
+      button({ label: C.push, variant: 'primary', onClick: pick('mine'), attrs: { 'data-sync-prefer': 'mine' } }),
+      button({ label: C.pull, onClick: pick('theirs'), attrs: { 'data-sync-prefer': 'theirs' } }),
+      button({ label: C.cancel, variant: 'ghost', onClick: () => s.close() }),
+    ],
+  });
 }
 
 /* Closing the tab with work that is not yet pushed asks first (D70 as amended 2026-10-06): idle auto-sync waits for a
@@ -637,7 +654,7 @@ function pressIn(r, key) {
   if (b && !b.disabled) { b.click(); return true; }
   return false;
 }
-const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs', p: 'people' };
+const G_KEYS = { t: 'today', i: 'initiatives', b: 'board', r: 'reports', d: 'docs', p: 'people', w: 'mywork' };
 
 function frameKey(e) {
   const mod = e.metaKey || e.ctrlKey;

package/workspace/public/pm/components.css

@@ -5653,6 +5653,123 @@
   }
 }
 
+/* My work (my-work): the work assigned to the PM, ranked, beside the chosen item's context card and brief. */
+.rp-mywork {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-mywork-top {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 12px;
+}
+.rp-mywork-top > .rp-head__title {
+  margin-right: auto;
+}
+.rp-mywork-body {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+}
+.rp-mywork-grid {
+  display: grid;
+  grid-template-columns: minmax(280px, 3fr) 2fr;
+  gap: 24px;
+  align-items: start;
+}
+.rp-mywork-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  min-width: 0;
+}
+.rp-mywork-views {
+  border-bottom: 1px solid var(--border);
+}
+.rp-mywork-row {
+  border-top: 1px solid var(--border);
+}
+.rp-mywork-row:last-child {
+  border-bottom: 1px solid var(--border);
+}
+.rp-mywork-row--open {
+  box-shadow: inset 2px 0 0 var(--foreground);
+}
+.rp-mywork-state {
+  display: inline-flex;
+  align-items: center;
+  color: var(--muted-foreground);
+}
+.rp-mywork-page {
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  min-width: 0;
+}
+.rp-mywork-who {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.rp-mywork-who__title {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 500;
+}
+.rp-mywork-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  font-size: 12px;
+  color: var(--foreground);
+}
+.rp-mywork-sec,
+.rp-mywork-brief,
+.rp-mywork-status {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.rp-mywork-sec__title,
+.rp-mywork-sub {
+  margin: 0;
+  font-size: 12px;
+  font-weight: 500;
+  color: var(--muted-foreground);
+}
+.rp-mywork-hint {
+  margin: 0;
+  font-size: 12px;
+  color: var(--muted-foreground);
+}
+.rp-mywork-text {
+  margin: 0;
+  font-size: 14px;
+  overflow-wrap: anywhere;
+}
+.rp-mywork-quote {
+  padding-left: 8px;
+  border-left: 2px solid var(--border);
+  white-space: pre-wrap;
+}
+.rp-mywork-open {
+  margin: 0;
+  padding-left: 16px;
+  font-size: 14px;
+}
+.rp-mywork-acts {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+@media (max-width: 760px) {
+  .rp-mywork-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
 /* -- layouts · .nt- Notes: one meeting on one screen — notes and what was caught beside a quiet transcript (meeting-notes Runs 1 and 2) -- */
 .nt-wrap {
   display: flex;

package/workspace/public/pm/data.js

@@ -1559,11 +1559,12 @@ export async function syncStatusOf(name) {
   return getJson('/api/sync/status', { ws });
 }
 
-export async function syncRepository(name) {
+// prefer: 'mine' | 'theirs' — the PM's answer after Sync stopped on a conflict (D70 as amended 2026-10-07).
+export async function syncRepository(name, { prefer } = {}) {
   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 res = await postJson('/api/sync', prefer ? { ws, prefer } : { 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' };