create-pmos 0.71.0 → 0.71.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pmos",
-  "version": "0.71.0",
+  "version": "0.71.1",
   "description": "Scaffold the PMOS portable kit — run the PMOS product-management workflow (initiative → lane-fit spec → contract → build → three gates, with work-type lanes for features, research, maintenance, incidents, and content) entirely inside your own repo, with all state as git-versioned files. Includes `workflow-sweep`, which audits the state every board derives from and separates real defects from work you simply have not done. `create-pmos workspace` also installs + launches the local Terminal Workspace GUI. No database, no network, no telemetry.",
   "license": "MIT",
   "bin": {

package/payload/KIT-VERSION

@@ -1,3 +1,3 @@
-kernel-source: pmos@c87956b
+kernel-source: pmos@5a5029e
 assembled: 2026-10-07
 mode: vendor

package/payload/planning/evals/eval-calibration.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Eval calibration log"
 description: "Append-only record of every PM override of an evaluator verdict."
-generated: {by: process:create-pmos, at: "2026-10-07T04:24:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T04:40:31Z"}
 status: stable
 ---
 

package/payload/planning/okrs/health-budgets.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Health budgets"
 description: "Closed registry of health-budget anchors (D59), edited only by the PM."
-generated: {by: process:create-pmos, at: "2026-10-07T04:24:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T04:40:31Z"}
 status: stable
 ---
 

package/payload/state/discoveries.md

@@ -2,7 +2,7 @@
 type: Reference
 title: "Discoveries and friction log"
 description: "Append-only record of what runs discovered and where the process rubbed."
-generated: {by: process:create-pmos, at: "2026-10-07T04:24:34Z"}
+generated: {by: process:create-pmos, at: "2026-10-07T04:40:31Z"}
 status: stable
 ---
 

package/workspace/guide/layout.md

@@ -17,7 +17,7 @@ The top bar has these parts, from left to right:
 - **Branches and sessions** is in ⌘K. It opens a sheet with every branch of the repository (main first) and how many sessions run in each. Press a branch to see its sessions, open one, end one, or start a session there. **＋ branch** makes a branch, and **＋ session** starts one with a branch, an agent and a profile. With All repositories, the sheet lists every repository.
 - **Agenda, Initiatives, Board, Reports, Docs and People** are the six places. Press one to show it. The Agenda count shows how many items need you. Docs shows whether each document is the same as its Google Docs and Confluence copy. People shows the people you work with in the repository ([People](people.md)).
 - **Search or capture ⌘K** opens the command palette. Type to find an initiative, a repository, an open tab or a command.
-- **Sync** shows only when the current repository is not in sync with its remote. Press it to fetch, bring in the work of the other machine, record your changes and push. If the repository has not fetched in the last 10 minutes, Sync also shows, because a push from another machine is not visible until a fetch. When the repository fetched recently and is in sync, Sync is not shown. When two machines add lines to the same ledger (a `.jsonl` file under `pmos/` or `planning/`), Sync keeps the lines from both machines. If Sync stops, the message names the step that stopped. If both machines changed the same lines of another file, the message names the file. Keep the version you want in that file on one machine, sync it, then sync the other machine.
+- **Sync** shows only when the current repository is not in sync with its remote. Press it to fetch, bring in the work of the other machine, record your changes and push. If the repository has not fetched in the last 10 minutes, Sync also shows, because a push from another machine is not visible until a fetch. When the repository fetched recently and is in sync, Sync is not shown. When two machines add lines to the same ledger (a `.jsonl` file under `pmos/` or `planning/`), Sync keeps the lines from both machines. If Sync stops, the message names the step that stopped. If both machines changed the same lines of another file, Sync changes nothing and names the files. Then choose **Push this machine’s version** or **Pull the other machine’s version**. Sync keeps that version of those files, keeps all other changes from both machines, and finishes. It never overwrites the remote history.
 - **Sync on its own.** If you forget to press Sync, the workspace syncs for you. It syncs each repository once when the workspace starts. It also syncs a repository that has records not yet pushed when no record changed for 5 minutes. In a document repository it syncs every changed file on any branch. In a code repository it syncs only on the default branch (for example `main`), and only when every commit not yet pushed changes records and no code. If you close the tab while records are not yet pushed, the browser asks you first. To turn automatic sync off, start the workspace with `PMOS_AUTO_SYNC=0`.
 - **Settings** opens the settings of the workspace.
 

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.71.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/workspace/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmos-workspace",
-  "version": "0.71.0",
+  "version": "0.71.1",
   "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';
@@ -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

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' };

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

@@ -41,6 +41,15 @@ export const COPY = {
     title: 'Sync this repository: fetch, bring in the work of the other machine, record your changes, push.',
     done: 'The repository is in sync.',
     stopped: (step, why) => 'Sync stopped at ' + step + ': ' + why,
+    /** Sync stopped because both machines changed the same lines. The PM chooses which version to keep. */
+    conflict: {
+      title: 'Both machines changed the same files',
+      sub: (files) => (files.length ? files.join(', ') : 'Git did not name the files.'),
+      body: 'Nothing changed. Choose which version to keep in these files. All other changes from both machines are kept.',
+      push: 'Push this machine’s version',
+      pull: 'Pull the other machine’s version',
+      cancel: 'Not now',
+    },
   },
   settings: 'Settings',
   dock: {

package/workspace/server.js

@@ -7095,7 +7095,9 @@ async function handleRequest(req, res) {
     if (syncing.has(w.root)) return json(res, { ok: false, error: 'a sync is already running for this repository' }, 409);
     syncing.add(w.root);
     try {
-      const out = await syncLib.sync(w.root, { label: os.hostname() });
+      // After a stop on a conflict the PM may answer which machine's version to keep; only this press passes it.
+      const prefer = body.prefer === 'mine' || body.prefer === 'theirs' ? body.prefer : undefined;
+      const out = await syncLib.sync(w.root, { label: os.hostname(), prefer });
       boardCache.invalidate(w.root);
       return json(res, { ws: w.id, name: w.name, ...out });
     } finally { syncing.delete(w.root); }