create-pmos 0.26.0 → 0.28.0

package/workspace/public/pm/data.js

@@ -795,6 +795,11 @@ function schedulePoll() {
 export async function loadRepos() {
   if (FIXTURE) return [];
   const out = await getJson('/api/workspaces');
+  // The server's one answer to "is the runtime state settled?", published straight onto state so
+  // panel 1 can say so. Under an unmigrated conflict the lists below are short by everything the
+  // per-user state directory does not hold, and a list that is short without saying so is the
+  // silent failure this key exists to end. `{ok:true}` publishes too — the banner reads `ok`.
+  const health = out && out.state_health ? out.state_health : null;
   const rows = foldWorkspaces(out && out.workspaces);
   productOrder = rows.map((r) => r.name);
   for (const r of rows) products.set(r.name, Object.assign(products.get(r.name) || {}, r));
@@ -808,6 +813,7 @@ export async function loadRepos() {
   // actually on screen. A restored selection from the PM's last session always wins.
   const sel = state.sel || (p ? firstSlugOf(p.name) : null);
   setState({
+    stateHealth: health,
     wsId: p ? p.ws : null,
     // 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
@@ -942,6 +948,63 @@ export async function listFolder(dir) {
   return getJson('/api/fs/list', dir ? { path: dir } : null);
 }
 
+/* ── what the session pre-flight asks the server ───────────────────────────────────────────────
+ * Four read-only endpoints that have been served all along with no client reading them. They are
+ * the questions the retired composer asked before a session started, and losing the client half is
+ * what left `＋ session` spawning on defaults nobody chose.
+ *
+ * Every one declines in FIXTURE mode, and that is load-bearing rather than tidy: the fixture render
+ * must make no network call at all — it is what lets no-network.test.js and the design comparator
+ * trust a fixture run. The form degrades to "no repository was read" and the fixture's own profile
+ * list, which is a true statement about fixture mode rather than a blank.
+ */
+
+/**
+ * Every branch of a workspace's repository, plus which one is current and which are already
+ * checked out in another working tree. Returns the server's `gitInfo.branchInfo` verbatim, so a
+ * non-repo answers `{ok:false, code, error}` and NEVER a fabricated branch — the difference
+ * between "this folder has no git" and "git failed" is the picker's to show, so it must survive
+ * the trip.
+ */
+export async function loadBranches(ws) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode reads no repository' };
+  if (!ws) return { ok: false, error: 'no repository selected' };
+  return getJson('/api/git/branches', { ws });
+}
+
+/**
+ * The Claude profile descriptors, as `{ok, absent, dir, profiles, broken, prefs, error}`.
+ *
+ * All six fields matter to the caller and none may be flattened here: `absent` ("the directory does
+ * not exist") is a different sentence from a successful read that found none; `broken` names a
+ * descriptor that must be shown and NOT offered, while every good one beside it is still offered;
+ * and `prefs` is what preselects a chip, replacing a hardcoded 'claude-work' that named a file this
+ * client had never opened.
+ *
+ * `env` values are absent by construction on the server side (profileWire) — D08's discipline
+ * covers anything the browser receives, and an overlay is where a credential lives.
+ */
+export async function loadProfiles() {
+  if (FIXTURE) return { ok: false, error: 'fixture mode reads no profiles' };
+  return getJson('/api/profiles');
+}
+
+/** Remember the profile this agent should preselect next time. The server refuses a preference for
+ * a descriptor it cannot read, so a stored id always resolves to a chip that is on screen. */
+export async function preferProfile(agent, profile) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode remembers nothing' };
+  return postJson('/api/profiles/prefer', { agent, profile });
+}
+
+/** Every working tree of this workspace's repo. The pre-flight reads it for ONE purpose: a branch
+ * checked out elsewhere is a branch git will refuse, and the PM should read that in the picker
+ * rather than as an error after the click. */
+export async function loadWorktrees(ws) {
+  if (FIXTURE) return { ok: false, error: 'fixture mode reads no repository' };
+  if (!ws) return { ok: false, error: 'no repository selected' };
+  return getJson('/api/git/worktrees', { ws });
+}
+
 /**
  * panel-tabs.js — `startSession(slug, sess)`. Deliberately NOT a spawn.
  *
@@ -1030,6 +1093,23 @@ export async function readDoc(path) {
   return res.text();
 }
 
+/**
+ * panel-initiatives.js — `searchFiles(q, limit)`. Every file under THIS workspace's root whose path
+ * or contents match, from the one endpoint that walks the folder. Bounded on the server, and the
+ * bound comes back in the payload (`truncated`, `scanned`) rather than being silently applied — a
+ * capped list rendered as a complete one is the defect the search box already had.
+ *
+ * FIXTURE mode resolves to an empty, untruncated result WITHOUT fetching: rule 1 of this file is
+ * that a fixture render is provably not a real read wearing a costume, and `no-network.test.js`
+ * checks that claim at source level.
+ */
+export async function searchFiles(query, limit) {
+  const q = String(query == null ? '' : query).trim();
+  if (FIXTURE || !q) return { ok: true, q, hits: [], truncated: false, scanned: 0 };
+  const p = products.get(currentProductName());
+  return getJson('/api/search/files', { ws: state.wsId || (p ? p.ws : ''), q, limit });
+}
+
 /**
  * tab-doc.js — `saveDoc({ws, path, base, text})`. Refuse-on-stale: the server compares `base`
  * against the file on disk and REFUSES rather than overwriting a file that changed underneath.

package/workspace/public/pm/panel-initiatives.js

@@ -264,7 +264,14 @@ export function openTerm(slug, sess) {
   const key = slug ? 'term:' + slug + ':' + sess.name : 'term:sess:' + ((sess && sess.id) || sess.name);
   openTab({
     id: key, kind: 'term', title: sess.name, slug: slug || null,
-    repo: slug ? slugProduct()[slug] : null, sess: sess.name, state: sess.st, profile: sess.profile || 'claude-work',
+    /* `profile` is the session's OWN, or null — never the literal 'claude-work'. It used to default
+     * to that string, which was a claim about a descriptor this client had never read: nothing in
+     * data.js reads /api/profiles, so the name was invented here and then filed on the session. It
+     * also became load-bearing the moment the tab's profile started travelling to the server on a
+     * spawn, because `resolveProfileForSpawn` REFUSES a profile it cannot find — a fabricated
+     * default would have turned "no profile chosen" into "session refused". Every display reader
+     * (fixture.js:853, modes.js:658/808) already supplies its own fallback for null. */
+    repo: slug ? slugProduct()[slug] : null, sess: sess.name, state: sess.st, profile: sess.profile || null,
     /* The SERVER's session id, when the row that was clicked carries one. This is the exact join:
      * with it, the terminal attaches to precisely the PTY the PM pointed at, and a reload attaches
      * to the same one again. Without it the tab falls back to matching by NAME, and names repeat
@@ -278,7 +285,13 @@ export function openTerm(slug, sess) {
 export function openDoc(slug, path, role) {
   openTab({
     id: 'doc:' + path, kind: 'doc', title: path.split('/').pop(), slug,
-    repo: slugProduct()[slug], path, role: role || 'DOC',
+    /* A file opened from the FOLDER search belongs to no initiative, so `slugProduct()` has no
+     * answer for it — and `panel-tabs.visibleTabs` shows a tab whose repo is `undefined` in EVERY
+     * repository, which would hang this workspace's file in another one's tab strip and read its
+     * path against that root. The repository it was opened FROM is the true answer, and it is used
+     * only where there is no slug: every existing call site keeps its exact previous value. */
+    repo: slug ? slugProduct()[slug] : currentProduct(),
+    path, role: role || 'DOC',
   });
 }
 
@@ -488,6 +501,147 @@ function hitNode(ht) {
   );
 }
 
+/* ── "files in this folder" — the half of `search everything…` that was missing ────────────────
+ *
+ * `searchHits` above is the board's search: initiative slugs, paths DECLARED on a record, session
+ * names. A file the board was never told about is in none of those lists, so it could not be found
+ * by typing its exact name — and the miss printed "nothing matches — a successful read of nothing",
+ * which is this repo's phrase for *we looked and there was nothing*, after a search that had never
+ * opened the folder. This block is the folder half, from /api/search.
+ *
+ * ── Three constraints the shape below is a response to ──────────────────────────────────────
+ *
+ * 1. THE SEARCH IS ASYNCHRONOUS AND THE RENDER IS NOT. `state.q` changes on every keystroke and
+ *    every change repaints this panel, so a result has to arrive by a route that survives a
+ *    re-render: a cache keyed by the QUERY, a fetch kicked off during render, and `setState({})` on
+ *    arrival. It is exactly `tab-doc.js`'s `requestDoc` pattern, for the same reason.
+ * 2. ONE WORD IS ONE SEARCH, NOT SIX. A 140 ms debounce collapses the keystrokes of a word, and
+ *    only the LATEST query is ever in flight — an earlier reply landing late must not repaint the
+ *    panel with results for a query the PM has already typed past.
+ * 3. A BOUNDED ANSWER SAYS SO. `truncated` travels from the walk to the payload to this heading. A
+ *    capped list drawn as a complete one is the same lie with a longer walk behind it.
+ *
+ * A hit is labelled `file · <kind>`, never `artifact · <role>`: a file no initiative declares has no
+ * role, and inventing one would file a claim nobody made. A file the reader cannot show (an image,
+ * an inert binary) is LISTED and greyed rather than hidden — found-but-not-openable is a true
+ * answer, and it beats a tab that opens onto a failure the surface could have predicted.
+ */
+
+const fileCache = new Map();     // q -> { hits, truncated, scanned, error }
+let fileWanted = null;           // the query the PM has actually typed — the only reply that may land
+let fileTimer = null;
+let dataMod;                     // undefined = not tried · null = unavailable · module = ready
+
+function dataModule() {
+  if (dataMod !== undefined) return dataMod;
+  dataMod = null;
+  import('./data.js').then((m) => { dataMod = m; setState({}); }).catch(() => { dataMod = null; });
+  return null;
+}
+
+function requestFiles(q) {
+  fileWanted = q;
+  if (fileTimer) clearTimeout(fileTimer);
+  fileTimer = setTimeout(() => {
+    fileTimer = null;
+    const mod = dataModule();
+    if (!mod || typeof mod.searchFiles !== 'function') return;
+    const asked = q;
+    Promise.resolve(mod.searchFiles(asked)).then(
+      (r) => {
+        if (fileWanted !== asked) return;                      // the PM has typed past this query
+        fileCache.set(asked, (r && r.ok === false)
+          ? { hits: [], truncated: false, contentTruncated: false, scanned: 0, contentScanned: 0, error: r.error || 'the folder could not be searched' }
+          : {
+            hits: (r && r.hits) || [], truncated: !!(r && r.truncated),
+            contentTruncated: !!(r && r.content_truncated),
+            scanned: (r && r.scanned) || 0, contentScanned: (r && r.content_scanned) || 0, error: null,
+          });
+        if (fileCache.size > 40) fileCache.delete(fileCache.keys().next().value);
+        setState({});
+      },
+      (e) => {
+        if (fileWanted !== asked) return;
+        fileCache.set(asked, { hits: [], truncated: false, contentTruncated: false, scanned: 0, contentScanned: 0, error: (e && e.message) || String(e) });
+        setState({});
+      },
+    );
+  }, 140);
+}
+
+/** The result for `q`, or null while nothing has come back yet. Kicks the fetch off on a miss. */
+function fileResults(q) {
+  if (!q || FIXTURE) return null;
+  if (fileCache.has(q)) return fileCache.get(q);
+  requestFiles(q);
+  return null;
+}
+
+const fileLabel = (h) => 'file · ' + (h.kind || 'file') + (h.match === 'content' ? ' · line ' + h.line : '');
+
+function fileHitNode(h) {
+  const where = h.dir ? h.dir + '/' : '';
+  const sub = h.match === 'content' ? h.snippet : (where + h.name);
+  if (!h.openable) {
+    return el('div', {
+      style: 'display:block;width:100%;padding:6px 12px;min-height:40px;opacity:.55',
+      title: h.path + '\nfound, but this workspace\'s reader cannot show a ' + h.kind + ' file — nothing was opened.',
+    },
+      el('span', { style: 'display:block;font-family:var(--mono);font-size:10px;color:var(--muted-foreground)' }, iv(fileLabel(h) + ' · not openable')),
+      el('span', { style: 'display:block;font-family:var(--mono);font-size:11px;color:var(--muted-foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' }, iv(h.path)),
+    );
+  }
+  return el('button', {
+    onClick: () => openDoc(null, h.path, 'FILE'),
+    style: 'display:block;width:100%;padding:6px 12px;min-height:40px;text-align:left',
+    hover: 'background:var(--accent)',
+    title: h.path,
+  },
+    el('span', { style: 'display:block;font-family:var(--mono);font-size:10px;color:var(--info)' }, iv(fileLabel(h))),
+    el('span', { style: 'display:block;font-family:var(--mono);font-size:11px;color:var(--foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' }, iv(h.name)),
+    el('span', { style: 'display:block;font-family:var(--mono);font-size:10px;color:var(--muted-foreground);overflow:hidden;text-overflow:ellipsis;white-space:nowrap' }, iv(sub)),
+  );
+}
+
+/**
+ * The whole block, or null when there is nothing to say. Rendered in EVERY mode — the box says
+ * `search everything…` in all seven of them, and modes.js reads `state.q` in none.
+ */
+export function fileHitsBlock(q) {
+  if (!q || FIXTURE) return null;
+  const r = fileResults(q);
+  const head = (text, tone) => el('div', {
+    style: 'padding:4px 12px 4px;font-family:var(--mono);font-size:10px;letter-spacing:.12em;'
+      + 'text-transform:uppercase;color:' + (tone || 'var(--muted-foreground)') + ';border-bottom:1px solid var(--border)',
+  }, iv(text));
+
+  if (!r) return el('div', { 'data-pm-files': '' }, head('files in this folder · searching…'));
+  if (r.error) {
+    return el('div', { 'data-pm-files': '' }, head('files in this folder · not searched', 'var(--destructive)'),
+      el('div', { style: 'padding:6px 12px;font-size:11px;color:var(--muted-foreground)' }, iv(r.error)));
+  }
+  /* WHAT THE WALK DID NOT DO, in the heading, in the caller's own words. Two flags, never merged:
+   * `truncated` means files were never looked at AT ALL — the one that changes what a PM should
+   * conclude from an empty list. `contentTruncated` means every file was NAMED and some bodies
+   * were not read, which is the ordinary state of any repository holding a lock file. Folding the
+   * second into the first would light the serious flag permanently and thereby retire it. */
+  const bound = r.truncated
+    ? ' · BOUNDED — files beyond the walk limit were not looked at'
+    : (r.contentTruncated ? ' · all ' + r.scanned + ' names searched; ' + r.contentScanned + ' bodies read' : '');
+
+  if (!r.hits.length) {
+    // The board's own phrase is used ONLY when it is true — when the walk really did reach
+    // everything. A cut-short walk found nothing *of what it looked at*, which is a different claim.
+    return el('div', { 'data-pm-files': '' },
+      head('files in this folder · ' + (r.truncated
+        ? 'no match in the ' + r.scanned + ' files searched — the walk was BOUNDED, more were not looked at'
+        : 'no file matches — a successful read of nothing' + (r.contentTruncated ? bound : ''))));
+  }
+  const kids = [head('files in this folder · ' + r.hits.length + ' of ' + r.scanned + ' searched' + bound)];
+  for (const h of r.hits) kids.push(fileHitNode(h));
+  return el('div', { 'data-pm-files': '' }, kids);
+}
+
 /* ── the file-new form's view model (prototype `nw`, lines 1620–1687) ──────────────────────────
  * The form itself renders in PANEL 3 (`detail.kind === 'new'`), which panel-detail.js owns — but
  * every field it edits and every record it files belongs to this board, so the model is derived
@@ -603,7 +757,10 @@ export function renderInitiatives(host) {
   if (searchInput.value !== state.q) searchInput.value = state.q;
 
   if (mode !== 'product') {
-    setChildren(host, [header, searchBox]);
+    // The folder results render HERE TOO. The box says `search everything…` in all seven modes and
+    // modes.js reads `state.q` in none of them, so until now typing in six of them did nothing at
+    // all — including in the library/folder lens, the one surface that actually lists files.
+    setChildren(host, [header, searchBox, fileHitsBlock(state.q || '')]);
     const modes = modesModule();
     if (modes && typeof modes.renderMode === 'function') {
       try { modes.renderMode(host, null, mode); } catch (e) { console.error('[pm] renderMode failed:', e); }
@@ -685,7 +842,15 @@ export function renderInitiatives(host) {
       'matches elsewhere'));
     for (const ht of hits) kids.push(hitNode(ht));
   }
-  if (total === 0 && hits.length === 0) {
+  // THE FOLDER. Below the board's own hits, because a record the PM filed outranks a file that
+  // merely matched — and it is the block that makes the box's name true.
+  const files = fileHitsBlock(q);
+  if (files) kids.push(files);
+  // The prototype's line, unchanged and shown under the same condition it always was — plus the
+  // folder. It claims nothing matched ANYWHERE, so a file hit has to suppress it or it is a lie
+  // rendered directly above its own counter-example.
+  const fileRes = fileResults(q);
+  if (total === 0 && hits.length === 0 && !(fileRes && fileRes.hits.length)) {
     kids.push(el('div', { style: 'padding:10px 14px;font-size:12px;color:var(--muted-foreground);font-style:italic' },
       'nothing matches — a successful read of nothing'));
   }