create-pmos 0.18.1 → 0.20.0

package/workspace/public/pm/tab-term.js

@@ -446,7 +446,7 @@ if (typeof window !== 'undefined') {
 
 /* ── fixture pane ──────────────────────────────────────────────────────────────────────────── */
 
-const SCROLL_STYLE = 'flex:1;overflow-y:auto;padding:14px 16px;font-family:var(--mono);font-size:12.5px;line-height:1.65;color:#c4ccce';
+const SCROLL_STYLE = 'flex:1;min-height:0;overflow-y:auto;padding:14px 16px;font-family:var(--mono);font-size:12.5px;line-height:1.65;color:#c4ccce';
 const LINE_STYLE = (c) => 'color:' + c + ';white-space:pre-wrap;overflow-wrap:anywhere';
 const PROMPT_ROW_STYLE = 'display:flex;gap:8px;align-items:baseline';
 const PROMPT_STYLE = 'color:#47cf79;flex:none';
@@ -639,6 +639,22 @@ export function sendToTerm(tab, data) {
   return send({ t: 'input', id: rec.sessionId, data });
 }
 
+/**
+ * End a running session, by id — the `＋ session` chooser's one destructive action.
+ *
+ * The wire message already existed (`t:'kill'`); what did not exist anywhere in the four-panel
+ * surface was a way to reach it, which is why "is it safe to end this?" had no answer the PM could
+ * act on. This is a bare send: the CONFIRMATION lives in the chooser, next to the reading of what
+ * ending it would cost, because that is the only place the PM is looking at both at once.
+ *
+ * Returns false when the socket is not up, so a caller can say "not sent" rather than imply a kill
+ * that never left the page.
+ */
+export function killSession(id) {
+  if (FIXTURE || !id) return false;
+  return send({ t: 'kill', id });
+}
+
 /**
  * The SERVER's session id this tab is bound to, or null. The scratchpad reads it: a pad belongs to
  * the session, and the session's identity is this id — not the tab id (which survives a session

package/workspace/server.js

@@ -369,6 +369,36 @@ function treeForWs(wsIdent) {
 function treeTenants(tree, excludeId) {
   return treeShare.coTenants([...sessions.values()], treeOfWsMap(), tree, excludeId);
 }
+/**
+ * A registry row, described for a human deciding whether to JOIN it rather than start another
+ * (workspace-session-choice). "2 sessions already running" names a fact the PM cannot act on; what
+ * they need is which one, what it is doing, and what ending it would cost.
+ *
+ * Every field is one the sidebar already publishes — the joined presented state, the quiet clock,
+ * the sidebar's own word for it, and the agent's last words. Nothing new is derived here and no
+ * word is re-invented: `sessionState` owns the vocabulary and `treeShare.endRisk` owns the
+ * consequence, and this function only joins them onto one row.
+ */
+function describePeer(s, now) {
+  const d = harness.deriveState(s.state, s.lastOutputAt, now || Date.now());
+  const hx = transcriptHarness(s);
+  const shown = sessionState.presented(d.state, hx && hx.turn);
+  const oc = hx && hx.openCall;
+  const call = oc && oc.verb
+    ? { verb: oc.verb, ageMs: oc.sinceTs ? Math.max(0, (now || Date.now()) - Date.parse(oc.sinceTs)) : null }
+    : null;
+  return {
+    id: s.id, ws: s.ws, name: s.name, agent: s.agent, state: s.state, shown,
+    quietMs: d.quietMs,
+    label: sessionState.label(shown, { quietMs: d.quietMs, call, fmtDur: treeShare.ago }),
+    doing: (harnessOf(s) || {}).lastWords || null,
+  };
+}
+/** The same set as `treeTenants`, each row described. The order is the registry's, unchanged. */
+function treePeersDescribed(tree, excludeId) {
+  const now = Date.now();
+  return treeTenants(tree, excludeId).map((s) => describePeer(s, now));
+}
 function treeWriter(tree) {
   return treeShare.writerOf(treeClaims, treeOfWsMap(), [...sessions.values()], tree);
 }
@@ -382,12 +412,16 @@ function announceTree(s) {
   const tree = treeForWs(s.ws);
   s.tree = tree || null;
   if (!tree) return [];
-  const mates = treeTenants(tree, s.id);
+  // DESCRIBED rows, not bare registry objects: the pane line now carries what each co-tenant is
+  // doing and what ending it would cost, and it must read from the same join the sidebar does.
+  const mates = treePeersDescribed(tree, s.id);
   const holder = treeWriter(tree);
   if (!holder) treeClaims.set(tree, s.id);           // vacant → this session declares itself
   if (!mates.length) return [];                      // alone in the tree: nothing to say
   const held = holder ? (sessions.get(holder) || {}).name : null;
-  const line = treeShare.paneAdvisory(mates, { role: holder ? 'reader' : 'writer', writerName: held });
+  const line = treeShare.paneAdvisory(mates, {
+    role: holder ? 'reader' : 'writer', writerName: held, writerId: holder || s.id, tree,
+  });
   if (line) appendBuf(s, line);
   return mates;
 }
@@ -396,7 +430,9 @@ function treeNoticeFor(s, mates) {
   if (!mates || !mates.length) return null;
   const holder = treeWriter(s.tree);
   const held = holder && holder !== s.id ? (sessions.get(holder) || {}).name : null;
-  return treeShare.coTenancyNotice(mates, { role: holder === s.id ? 'writer' : 'reader', writerName: held });
+  return treeShare.coTenancyNotice(mates, {
+    role: holder === s.id ? 'writer' : 'reader', writerName: held, writerId: holder, tree: s.tree,
+  });
 }
 function wsList() {
   return [...workspaces.values()].map((w) => {
@@ -410,6 +446,12 @@ function wsList() {
       // the client renders the first quietly and the second as a fault (R1/R2).
       repo_key: rid.key, repo_name: rid.name, branch: rid.branch,
       branch_error: rid.branchError, branch_code: rid.branchCode,
+      // The COLLISION UNIT (workspace-session-concurrency), published so a client can answer "who
+      // else is in the tree I am about to start in?" BEFORE it starts anything. Without it the
+      // browser could only find co-tenants via a session that already exists there, which is
+      // exactly one session too late for a chooser. Null for a folder with no git — no index to
+      // collide over, so no group.
+      tree: rid.tree || null,
       // Where the tree came from, and the ONE label the repository list can honestly put on a row.
       // `remote` is the raw origin URL (null when there is none) so a caller can derive a richer
       // answer without guessing; `kind` is the surface's own two-value vocabulary — a repository
@@ -1559,6 +1601,17 @@ function sessionList() {
       // `failed` does not exist (no observable for it). The client re-derives this from the SAME
       // module — see /lib/session-state.js below — so the two can never hold different opinions.
       shown: sessionState.presented(d.state, hx && hx.turn), quietMs: d.quietMs,
+      // The rendered word for that state — computed HERE rather than in each client, because it is
+      // the same join (`sessionState.label`) with the same clock, and a client re-deriving it was
+      // already producing a second, slightly different sentence for one session.
+      label: sessionState.label(sessionState.presented(d.state, hx && hx.turn), {
+        quietMs: d.quietMs,
+        call: hx && hx.openCall && hx.openCall.verb
+          ? { verb: hx.openCall.verb,
+            ageMs: hx.openCall.sinceTs ? Math.max(0, now - Date.parse(hx.openCall.sinceTs)) : null }
+          : null,
+        fmtDur: treeShare.ago,
+      }),
       lastOutputAt: s.lastOutputAt || null,
       lastWords: h.lastWords,
       // the harness proper — structured record, not rendered bytes. Resolved ONCE above and
@@ -2115,7 +2168,7 @@ function spawnWithBranch({ name, agent, cwd, ws, branch, createBranch, isolate,
   // Both facts travel: `notice` is a single string on the wire and a branch notice and a co-tenancy
   // notice can both be true of one spawn. joinNotices keeps them both rather than letting the
   // second evict the first exactly when the PM most needs both.
-  const shared = treeNoticeFor(s, treeTenants(s.tree, s.id));
+  const shared = treeNoticeFor(s, treePeersDescribed(s.tree, s.id));
   return { ok: true, session: s, notice: treeShare.joinNotices(notice, shared) };
 }
 
@@ -3091,6 +3144,7 @@ async function handleRequest(req, res) {
   if (p === '/lib/layout.js') return serveFile(res, path.join(__dirname, 'lib', 'layout.js'));
   if (p === '/lib/mobile-nav.js') return serveFile(res, path.join(__dirname, 'lib', 'mobile-nav.js'));
   if (p === '/lib/session-state.js') return serveFile(res, path.join(__dirname, 'lib', 'session-state.js'));
+  if (p === '/lib/tree-share.js') return serveFile(res, path.join(__dirname, 'lib', 'tree-share.js'));
   // The editor computes its live diff with the SAME module the server saves through, so what the PM
   // sees while typing and what gets written cannot disagree. NB: /lib/ is an explicit allowlist, not
   // a directory route — a <script src> for a file missing from this list 404s silently, and the
@@ -3630,9 +3684,13 @@ async function handleRequest(req, res) {
         note: 'this workspace is not inside a git working tree — there is no shared index to collide over' });
     }
     const writer = treeWriter(tree);
-    const rows = treeTenants(tree, null).map((s) => ({
-      id: s.id, name: s.name, ws: s.ws, agent: s.agent, state: s.state,
+    // Described, not merely listed (workspace-session-choice): a caller deciding between joining a
+    // running session and starting another needs the state, the word for it, what the agent is
+    // doing and what ending it would cost — the same four facts the chooser and the pane line show.
+    const rows = treePeersDescribed(tree, null).map((s) => ({
+      ...s,
       role: treeShare.roleOf(s.id, tree, writer),
+      risk: treeShare.endRisk(s.shown, s.quietMs),
     }));
     return json(res, { ok: true, tree, writer, sessions: rows, advisory: true,
       note: writer
@@ -3792,6 +3850,11 @@ async function handleRequest(req, res) {
         : null,
       artifactLinks: fourPanel.readDeclarations(stateDir, fourPanel.ARTIFACT_LINKS),
       initiativeLinks: fourPanel.readDeclarations(stateDir, fourPanel.INITIATIVE_LINKS),
+      // Which destinations a session could look up, derived from the PM's agent profiles. The home
+      // directory is passed IN rather than read inside four-panel.js for the same reason
+      // readProfiles takes it as a parameter: a module that reads os.homedir() itself can only be
+      // tested against the machine running the suite.
+      homeDir: os.homedir(),
     });
     // Discriminated READ results stay 200 — the body carries the reason, the transport code cannot.
     return json(res, { ws: w ? w.id : null, ...out });
@@ -3819,7 +3882,20 @@ async function handleRequest(req, res) {
       built.row,
     );
     // A write that failed returns 500 and says so — never a false green (the /api/gate rule).
-    return json(res, { ...wrote, connectors: fourPanel.connectors() }, wrote.ok ? 200 : 500);
+    return json(res, { ...wrote, connectors: fourPanel.connectors(os.homedir()) }, wrote.ok ? 200 : 500);
+  }
+  if (p === '/api/initiative/lookup-task' && req.method === 'POST') {
+    // The task a SESSION runs to resolve a reference. This endpoint composes a string and returns
+    // it. It contacts nothing — that is the entire point of the design: PMOS describes the lookup,
+    // an agent session holding the PM's own MCP performs it, and the result comes back through
+    // /api/initiative/link like any other declaration. There is no branch here that reaches out.
+    let body = {};
+    try { body = JSON.parse((await readBody(req)) || '{}'); }
+    catch { return json(res, { ok: false, error: 'invalid JSON body' }, 400); }
+    const built = fourPanel.lookupTask({
+      kind: body.kind, subject: body.subject, hint: body.hint, profile: body.profile,
+    });
+    return json(res, built, built.ok ? 200 : 400);
   }
   if (p === '/api/search') {
     // Episodic recall over this workspace's own past sessions. Localhost only, like everything
@@ -4406,6 +4482,10 @@ module.exports = { server, spawnSession, removeSession, renameSession, sessions,
   // (one repo registered twice is one tree; two worktrees of one repo are two) without driving
   // every case through a spawn.
   treeForWs, treeTenants, treeWriter, treeClaims,
+  // …and the DESCRIBED form, exported for the same reason: "what is that session doing and what
+  // would ending it cost?" is the half of co-tenancy the PM actually acts on, so the suite asserts
+  // it directly rather than reading it back out of a rendered sentence.
+  describePeer, treePeersDescribed,
   // exported so the suite can assert the D08 invariant end-to-end: the harness parsers consume
   // scrubbed text, so a secret printed into scrollback must not survive into a rendered value.
   scrub, harnessOf,