create-pmos 0.23.0 → 0.25.0

package/workspace/public/index.html

@@ -35,6 +35,13 @@
      Both read this file, so the sentence in the terminal and the sentence in the chooser cannot
      drift apart. Classic script (a UMD setting window.PMOSTreeShare), like the two above. -->
 <script src="/lib/tree-share.js"></script>
+<!-- The session→initiative join, made once over every session instead of once per initiative
+     (workspace-active-visibility). The SERVER makes the same two-hopper per initiative inside
+     /api/initiative (lib/four-panel.js sessionsFor); the BOARD needs it for 178 rows at once and
+     cannot spend 178 requests on it. Loaded here rather than imported so it stays walkable in node
+     — test.js requires it and walks its whole input domain. It reads window.PMOSSessionState for
+     the attention order, so it must come AFTER that script. -->
+<script src="/lib/working-set.js"></script>
 <!-- The phone's navigation reducer. DOM-free, loaded as a classic script (it is a UMD that sets
      window.PMOSMobileNav) and required by test.js, so the whole screen domain is walkable in node
      rather than only in a browser. pm/mobile.js reads it from the global; the module graph does not

package/workspace/public/pm/data.js

@@ -38,11 +38,17 @@
  *
  * ── The one thing this file refuses to do ───────────────────────────────────────────────────
  * Linking an artifact records a DECLARATION (`{artifact_path, kind, target}` appended to
- * `artifact-links.jsonl`). It makes no outbound request, because PMOS holds no credential. The
- * sync panel therefore reports an unconfigured connector rather than a difference summary it never
- * read — `state.connectors` is published empty, which is what makes panel 3's two approval buttons
- * inert. A "2 sections differ" line over a destination nobody contacted is the watermelon this
- * repo has a word for.
+ * `artifact-links.jsonl`) and choosing a sync direction records another (`artifact-sync.jsonl`).
+ * Neither makes an outbound request, because PMOS holds no credential: the request is made by an
+ * agent session holding the PM's own MCP, and what comes back here is a report (D53).
+ *
+ * `state.connectors` used to be published as a literal `[]` on every load. That was written when it
+ * was true of every machine, and it stayed after the server learned to DERIVE the answer from the
+ * PM's agent profiles — so a careful derivation shipped into a client that had already decided. The
+ * panel branches on it (`hasConnector`, `resolverFor`), so the visible cost was a control that never
+ * rendered and a machine with a Jira MCP that reported having none. It is now published from the
+ * payload, and the constant is gone rather than corrected: a constant cannot be wrong, which is
+ * exactly why it could not be trusted.
  */
 
 import { state, setState, subscribe, FIXTURE } from './state.js';
@@ -299,20 +305,36 @@ function linksFor(payload) {
     out.push({ kind: l.kind, label: l.declared, path: l.href || l.declared, st: l.state_text || l.state });
   }
   for (const r of (payload.declarations && payload.declarations.links) || []) {
-    out.push({ kind: r.kind, label: r.label, path: r.target, st: 'declared · not connected' });
+    // The row's OWN provenance, carried rather than replaced. `declared · not connected` was a
+    // literal written before the store had a state vocabulary, and it outlived it: a reference a
+    // session had genuinely resolved rendered the same seven words as one the PM had typed a second
+    // earlier. The panel derives its state text from these fields (`linkStateText`), so carrying
+    // them is the whole fix — there is no second opinion to keep in step.
+    out.push({
+      kind: r.kind, label: r.label, path: r.target,
+      state: r.state, origin: r.origin, profile: r.profile || null,
+      reason: r.reason || null, resolved_at: r.resolved_at || null,
+    });
   }
   return out;
 }
 
-/** Artifacts, with any declared external destination attached. */
+/** Artifacts, with any declared external destination and the latest sync for it attached. */
 function artsFor(payload) {
   const dest = new Map();
   for (const r of (payload.declarations && payload.declarations.artifacts) || []) {
-    dest.set(r.artifact_path, { kind: r.kind, target: r.target });   // a later row supersedes an earlier
+    // The server has already collapsed the store to one row per pair and dropped what the PM
+    // retracted, so what arrives here is the statement of now.
+    dest.set(r.artifact_path, { kind: r.kind, target: r.target, state: r.state, origin: r.origin });
+  }
+  const sync = new Map();
+  for (const r of (payload.declarations && payload.declarations.sync) || []) {
+    sync.set(r.artifact_path + '|' + r.kind, r);
   }
   return (payload.artifacts || []).map((a) => {
     const d = dest.get(a.path);
-    return d ? { role: a.role, path: a.path, dest: d } : { role: a.role, path: a.path };
+    if (!d) return { role: a.role, path: a.path };
+    return { role: a.role, path: a.path, dest: d, sync: sync.get(a.path + '|' + d.kind) || null };
   });
 }
 
@@ -465,6 +487,29 @@ export function branchOfWorkspace(id) {
   return (id && wsBranch.get(id)) || null;
 }
 
+/**
+ * The same map as a plain object, for `setState`.
+ *
+ * `branchOfWorkspace` answers "what branch is THIS workspace on?", which is all the ＋ session
+ * chooser ever needed. The initiative board asks the other direction — "which initiatives does this
+ * machine have a checkout for, and which of my live sessions is on one?" — and a lookup by id
+ * cannot be enumerated.
+ *
+ * It is PUBLISHED rather than exported as a getter for the reason `productWs` is: a panel that has
+ * to import the data layer to render a row cannot render that row until the import resolves, and
+ * panel 2 is the board. Published, the fact arrives in the same patch as everything else the panel
+ * reads, and the panel needs no adapter at all.
+ *
+ * `wsBranch` stays the single source — this is a projection of it taken at publish time, not a
+ * second copy anything writes to. Nulls are kept out: a folder with no git has no branch, and a map
+ * carrying holes would make every reader re-check the same thing.
+ */
+function branchMap() {
+  const out = {};
+  for (const [id, b] of wsBranch) if (typeof b === 'string' && b) out[id] = b;
+  return out;
+}
+
 /** Group registered working trees into products: several worktrees of one repo share a `repo_key`. */
 function foldWorkspaces(rows) {
   const byRepo = new Map();
@@ -595,7 +640,11 @@ function publishBoards() {
     board[name] = p.board;
     records = { ...records, ...p.records };
   }
-  setState({ board, productWs, records: { ...records, ...(hydrated) } });
+  // `wsBranches` rides the same patch as `productWs` and for the same reason: it is a fact about
+  // every registered working tree, read once from /api/workspaces, that a panel needs in order to
+  // draw a row. panel 2 joins it against `state.sessions` to say which initiative each live agent is
+  // on — the same `initiative/<id>` join lib/four-panel.js makes per initiative on the server.
+  setState({ board, productWs, wsBranches: branchMap(), records: { ...records, ...(hydrated) } });
 }
 
 /* Hydrated (fully derived) records live apart from the light ones so that a board reload cannot
@@ -635,7 +684,14 @@ async function hydrate(slug) {
     // and its footer ("read failed · as of …") is entitled to say when it was attempted.
     const asOf = readStamp();
     hydrated[slug] = { ...recordFrom(payload), asOf };
-    setState((s) => ({ records: { ...s.records, [slug]: hydrated[slug] } }));
+    setState((s) => ({
+      records: { ...s.records, [slug]: hydrated[slug] },
+      // The server's `{configured:[{kind, profile, server, declared}], declaredBy, note}`, straight
+      // through. Published on every hydration rather than once at boot, because a profile added
+      // while the workspace is open should reach the panel on the next selection rather than on the
+      // next restart — and because the payload is the only place this fact is ever produced.
+      connectors: payload && payload.connectors ? payload.connectors : s.connectors,
+    }));
     return payload;
   } finally { inFlight.delete(slug); }
 }
@@ -753,7 +809,9 @@ export async function loadRepos() {
   const sel = state.sel || (p ? firstSlugOf(p.name) : null);
   setState({
     wsId: p ? p.ws : null,
-    connectors: [],          // no connector is configured — panel 3's approvals stay inert
+    // NOT initialised to a value here. What is resolvable is the server's derivation from the PM's
+    // agent profiles, it arrives with the first `/api/initiative` payload, and seeding a `[]` in the
+    // meantime is not a placeholder — it is an answer, and the panel would render it as one.
     product: state.product && products.has(state.product) ? state.product : first,
     sel,
   });
@@ -965,7 +1023,7 @@ export async function saveDoc({ ws, path, base, text }) {
  * Appends ONE declaration to `artifact-links.jsonl`. It contacts nothing: PMOS holds no credential,
  * so this records what the PM says the mapping is and says nothing about the destination.
  */
-export async function recordArtifactLink({ artifact_path, slug, kind, target }) {
+export async function recordArtifactLink({ artifact_path, slug, kind, target, origin, state: st }) {
   if (FIXTURE) return { ok: true };
   const p = products.get(currentProductName());
   const out = await postJson('/api/initiative/link', {
@@ -974,11 +1032,37 @@ export async function recordArtifactLink({ artifact_path, slug, kind, target })
     // The surface labels a Google destination `google doc`; the store's vocabulary is `google`.
     kind: String(kind || '').startsWith('google') ? 'google' : kind,
     target,
+    // Passed through rather than defaulted here. The server owns the rules about which origin may
+    // claim which state — including that a retraction is the PM's alone — and a client that filled
+    // these in itself would be a second opinion about provenance, which is the one thing this store
+    // must have exactly one of.
+    origin, state: st,
   });
   if (out && out.ok === false) console.warn('[pm] the artifact link was NOT recorded: ' + out.error);
   return out;
 }
 
+/**
+ * panel-detail.js — `recordSync({artifact_path, slug, kind, target, direction, profile})`.
+ *
+ * Records the direction the PM chose and returns the TASK a session will run to carry it out. It
+ * syncs nothing: the row lands as `proposed`, which is the only state PMOS can produce on its own,
+ * and it stays that way until a session that actually performed the write reports back and names
+ * itself. Nothing here contacts Confluence, Jira or Google, and nothing here can.
+ */
+export async function recordSync({ artifact_path, slug, kind, target, direction, profile }) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode records no sync' };
+  const p = products.get(currentProductName());
+  const out = await postJson('/api/initiative/sync', {
+    ws: state.wsId || (p ? p.ws : ''),
+    initiative_id: slug, artifact_path,
+    kind: String(kind || '').startsWith('google') ? 'google' : kind,
+    target, direction, profile: profile || null,
+  });
+  if (out && out.ok === false) console.warn('[pm] the sync direction was NOT recorded: ' + out.error);
+  return out;
+}
+
 /**
  * panel-detail.js — `lookupTask({kind, subject, hint, profile})`.
  *
@@ -991,13 +1075,13 @@ export async function lookupTask({ kind, subject, hint, profile }) {
   return postJson('/api/initiative/lookup-task', { kind, subject, hint, profile });
 }
 
-/** panel-detail.js — `recordInitiativeLink({slug, kind, label, path, st})` → `initiative-links.jsonl`. */
-export async function recordInitiativeLink({ slug, kind, label, path }) {
+/** panel-detail.js — `recordInitiativeLink({slug, kind, label, path, origin, state})` → `initiative-links.jsonl`. */
+export async function recordInitiativeLink({ slug, kind, label, path, origin, state: st }) {
   if (FIXTURE) return { ok: true };
   const p = products.get(currentProductName());
   const out = await postJson('/api/initiative/link', {
     store: 'initiative', ws: state.wsId || (p ? p.ws : ''),
-    initiative_id: slug, kind, label, target: path,
+    initiative_id: slug, kind, label, target: path, origin, state: st,
   });
   if (out && out.ok === false) console.warn('[pm] the reference link was NOT recorded: ' + out.error);
   return out;