create-pmos 0.24.0 → 0.26.0

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 };
   });
 }
 
@@ -662,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); }
 }
@@ -780,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,
   });
@@ -926,6 +957,29 @@ export function startSession(slug, sess) {
   setTimeout(pollSessions, 800);
 }
 
+/**
+ * Bind a RUNNING session to an initiative — the PM's own word about work already in flight
+ * (workspace-session-attribution R3).
+ *
+ * Every session that existed before the recorded field shipped has no attribution, and so does every
+ * session started outside PMOS. Without this the field would be a promise about future sessions and
+ * no help at all with the ones on screen.
+ *
+ * What comes back is the server's answer, not an assumption: `previous` names the initiative this
+ * replaced, so a re-bind the PM did not mean to make is visible rather than silent. Pass
+ * `initiative: null` to clear a binding — the honest way back from a wrong one.
+ *
+ * The poll is scheduled rather than the state patched locally: `/api/sessions` is the one reader of
+ * this fact, and writing a second opinion into `state.sessions` here is how the board and the server
+ * would come to disagree about what a session is for.
+ */
+export async function bindSessionInitiative(id, initiative) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode has no server' };
+  const out = await postJson('/api/session/initiative', { id, initiative: initiative || null });
+  if (out && out.ok) setTimeout(pollSessions, 200);
+  return out || { ok: false, error: 'the workspace server did not answer' };
+}
+
 /* ── the scratchpad ─────────────────────────────────────────────────────────────────────────────
  * The pad is PER SESSION, and the server has always stored it that way: `/api/scratchpad` is keyed
  * by the server-issued session id (workspace-scoped, one file per session, deleted with it). What
@@ -992,7 +1046,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', {
@@ -1001,11 +1055,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})`.
  *
@@ -1018,13 +1098,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;