@lmctl-ai/lmctl 0.2.38 → 0.2.39

package/dist/public/app.js

@@ -0,0 +1,379 @@
+const $ = (selector) => document.querySelector(selector);
+
+function escapeHtml(value) {
+  return String(value ?? '').replace(/[&<>"']/g, (ch) => ({
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+  }[ch]));
+}
+
+async function fetchJson(url, options) {
+  const res = await fetch(url, options);
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok) throw new Error(body.error || `request failed: ${res.status}`);
+  return body;
+}
+
+function renderTable(headers, rows) {
+  if (rows.length === 0) return '<p class="muted">(none)</p>';
+  const headHtml = headers.map((h) => `<th>${escapeHtml(h)}</th>`).join('');
+  const bodyHtml = rows
+    .map((row) => `<tr>${row.map((cell) => `<td>${cell}</td>`).join('')}</tr>`)
+    .join('');
+  return `<table><thead><tr>${headHtml}</tr></thead><tbody>${bodyHtml}</tbody></table>`;
+}
+
+function statusClass(status) {
+  if (!status) return '';
+  if (status === 'BLOCKED') return 'status-BLOCKED';
+  if (status === 'DONE') return 'status-DONE';
+  return '';
+}
+
+// Phase 2c (2026-08-31, tools.lmctl's design cue): `/api/liveness`'s `remoteOutbound` is `null` for a
+// RemoteTeam this site has never sent anything -- genuinely nothing observed yet, not an error.
+function remoteOutboundLabel(remoteOutbound) {
+  if (!remoteOutbound) return 'remote -- delivery only';
+  const ts = remoteOutbound.repliedTs ?? remoteOutbound.ackedTs ?? remoteOutbound.sentTs;
+  if (remoteOutbound.state === 'replied') return `remote -- replied ${ts}`;
+  if (remoteOutbound.state === 'acked') return `remote -- acked ${ts}`;
+  return `remote -- sent ${ts}, no ack yet`;
+}
+
+// Populated by renderBoard, read by the enqueue/session-link flows so they know each team's lead
+// alias without a second round-trip.
+let teamsCache = [];
+
+async function renderBoard() {
+  const el = $('#board-table');
+  try {
+    const [teamsBody, stateBody, liveBody, stalledBody] = await Promise.all([
+      fetchJson('api/teams'),
+      fetchJson('api/state'),
+      fetchJson('api/liveness').catch(() => ({ teams: [] })),
+      fetchJson('api/stalled').catch(() => ({ stalled: [], remoteStalled: [] })),
+    ]);
+    teamsCache = teamsBody.teams;
+    const stateByTeam = new Map(stateBody.teams.map((t) => [t.team, t.state]));
+    const progressByTeam = new Map(stateBody.teams.map((t) => [t.team, t.progress]));
+    const liveByTeam = new Map(liveBody.teams.map((t) => [t.team, t]));
+    const stalledSet = new Set(stalledBody.stalled);
+    const remoteStalledSet = new Set(stalledBody.remoteStalled ?? []);
+
+    const rows = teamsBody.teams.map((team) => {
+      // 2026-08-31, Phase 2b3: a RemoteTeam (channel=lmmail) has no leadAlias/promptName and no `lctl`
+      // liveness concept. Phase 2c (tools.lmctl's design cue): once this site has actually SENT the
+      // team something, `/api/liveness`'s `remoteOutbound` gives real ack/reply observation --
+      // "remote -- delivery+observe" with the actual state, not just the static placeholder. Before
+      // that (never sent anything yet), there's genuinely nothing to observe -- stays "delivery only",
+      // honest about the absence of evidence rather than implying observation that hasn't happened.
+      const isRemote = team.channel === 'lmmail';
+      const state = stateByTeam.get(team.name);
+      const progress = progressByTeam.get(team.name);
+      const live = liveByTeam.get(team.name);
+      const liveLabel = isRemote
+        ? remoteOutboundLabel(live?.remoteOutbound)
+        : live
+          ? live.running
+            ? 'Running'
+            : live.deadReclaimable
+              ? 'Dead(reclaimable)'
+              : 'Idle'
+          : '?';
+      const status = state?.status ?? '?';
+      // Objective, git/file-write-evidence-based signal (2026-08-30 status-engine redesign) -- `status`
+      // above is self-report only, kept as a hint; this is the ground truth anti-churn actually uses.
+      const progressLabel = progress?.confirmed_done_ts ? 'DONE(confirmed)' : (progress?.progress_status ?? '?');
+      // Surfaced for the LLM/operator to decide on -- the cron itself never auto-nudges a stalled
+      // team (see cron/scheduler.ts); this badge is the whole point of that surfacing. Phase 2c: a
+      // remote team's stalled signal is a DIFFERENT classification mechanism (ack/reply observation,
+      // not lctl/progress-scan) -- labeled distinctly so it's never confused with the local one.
+      const attention = stalledSet.has(team.name)
+        ? '<span class="status-BLOCKED">STALLED</span>'
+        : remoteStalledSet.has(team.name)
+          ? '<span class="status-BLOCKED">STALLED (remote)</span>'
+          : '';
+      return [
+        isRemote
+          ? escapeHtml(team.name)
+          : `<a href="#" class="team-link" data-team="${escapeHtml(team.name)}" data-alias="${escapeHtml(team.leadAlias)}">${escapeHtml(team.name)}</a>`,
+        isRemote ? '(remote)' : escapeHtml(team.leadAlias),
+        isRemote ? '--' : escapeHtml(team.promptName),
+        `<span class="${statusClass(status)}">${escapeHtml(status)}</span>`,
+        escapeHtml(progressLabel),
+        escapeHtml(state?.changed_ts ?? '-'),
+        escapeHtml(liveLabel),
+        attention,
+      ];
+    });
+    el.innerHTML = renderTable(
+      ['Team', 'Lead', 'Prompt', 'Status(self-report)', 'Progress', 'Changed', 'Live', 'Attention'],
+      rows,
+    );
+    el.querySelectorAll('.team-link').forEach((link) => {
+      link.addEventListener('click', (event) => {
+        event.preventDefault();
+        $('#session-form [name="team"]').value = link.dataset.team;
+        $('#session-form [name="alias"]').value = link.dataset.alias;
+        $('#session-form').requestSubmit();
+      });
+    });
+  } catch (err) {
+    el.innerHTML = `<p class="error">${escapeHtml(err.message)}</p>`;
+  }
+}
+
+async function renderQueue() {
+  const el = $('#queue-table');
+  try {
+    const body = await fetchJson('api/queue');
+    const rows = body.queue.map((row) => [
+      String(row.id),
+      escapeHtml(row.from_id),
+      escapeHtml(row.to_id),
+      escapeHtml(row.status),
+      escapeHtml(row.created_ts),
+      escapeHtml(row.sent_ts ?? row.retrieved_ts ?? '-'),
+    ]);
+    el.innerHTML = renderTable(['ID', 'From', 'To', 'Status', 'Created', 'Sent/Retrieved'], rows);
+  } catch (err) {
+    el.innerHTML = `<p class="error">${escapeHtml(err.message)}</p>`;
+  }
+}
+
+async function renderHistory() {
+  const el = $('#history-table');
+  const team = $('#history-team-filter').value.trim();
+  try {
+    const query = team ? `?team=${encodeURIComponent(team)}` : '';
+    const body = await fetchJson(`api/history${query}`);
+    const rows = body.events.map((row) => [
+      String(row.id),
+      escapeHtml(row.ts),
+      escapeHtml(row.team),
+      `<span class="${statusClass(row.status)}">${escapeHtml(row.status)}</span>`,
+      escapeHtml(row.note ?? ''),
+    ]);
+    el.innerHTML = renderTable(['ID', 'TS', 'Team', 'Status', 'Note'], rows);
+  } catch (err) {
+    el.innerHTML = `<p class="error">${escapeHtml(err.message)}</p>`;
+  }
+}
+
+async function renderSources() {
+  const el = $('#sources-table');
+  try {
+    const body = await fetchJson('api/sources');
+    const rows = [
+      ['-', escapeHtml(body.defaultTeamsConfPath), '(default, always scanned)', ''],
+      ...body.sources.map((s) => [
+        String(s.id),
+        escapeHtml(s.path),
+        escapeHtml(s.label ?? ''),
+        `<button data-remove-path="${escapeHtml(s.path)}">Remove</button>`,
+      ]),
+    ];
+    el.innerHTML = renderTable(['ID', 'Path', 'Label', ''], rows);
+    el.querySelectorAll('[data-remove-path]').forEach((button) => {
+      button.addEventListener('click', async () => {
+        await fetchJson(`api/sources?path=${encodeURIComponent(button.dataset.removePath)}`, {
+          method: 'DELETE',
+        });
+        renderSources();
+      });
+    });
+  } catch (err) {
+    el.innerHTML = `<p class="error">${escapeHtml(err.message)}</p>`;
+  }
+}
+
+async function refreshAll() {
+  $('#generated-at').textContent = `updated ${new Date().toISOString()}`;
+  await Promise.all([renderBoard(), renderQueue(), renderHistory(), renderSources()]);
+}
+
+$('#refresh-all').addEventListener('click', refreshAll);
+$('#history-team-filter').addEventListener('change', renderHistory);
+
+$('#send-form').addEventListener('submit', async (event) => {
+  event.preventDefault();
+  const form = new FormData(event.target);
+  const resultEl = $('#send-result');
+  resultEl.textContent = 'sending...';
+  try {
+    const body = await fetchJson('api/send', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ team: form.get('team'), prompt: form.get('prompt') }),
+    });
+    resultEl.textContent = JSON.stringify(body, null, 2);
+    renderBoard();
+    renderHistory();
+  } catch (err) {
+    resultEl.textContent = `error: ${err.message}`;
+  }
+});
+
+$('#enqueue-form').addEventListener('submit', async (event) => {
+  event.preventDefault();
+  const form = new FormData(event.target);
+  const team = form.get('to');
+  try {
+    await fetchJson('api/enqueue', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ to: team, prompt: form.get('prompt'), from: 'operator' }),
+    });
+    event.target.reset();
+    renderQueue();
+
+    const teamInfo = teamsCache.find((t) => t.name === team);
+    const alias = teamInfo?.leadAlias ?? 'Lead';
+    $('#session-form [name="team"]').value = team;
+    $('#session-form [name="alias"]').value = alias;
+    pollForReply(team, alias);
+  } catch (err) {
+    alert(`enqueue failed: ${err.message}`);
+  }
+});
+
+$('#deliver-btn').addEventListener('click', async () => {
+  try {
+    const body = await fetchJson('api/queue/deliver', { method: 'POST' });
+    renderQueue();
+    renderBoard();
+    alert(`dispatched ${body.delivered} pending prompt(s)`);
+  } catch (err) {
+    alert(`deliver failed: ${err.message}`);
+  }
+});
+
+$('#source-form').addEventListener('submit', async (event) => {
+  event.preventDefault();
+  const form = new FormData(event.target);
+  try {
+    await fetchJson('api/sources', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ path: form.get('path'), label: form.get('label') || undefined }),
+    });
+    event.target.reset();
+    renderSources();
+    renderBoard();
+  } catch (err) {
+    alert(`add source failed: ${err.message}`);
+  }
+});
+
+async function loadSessionSummary(team, alias) {
+  // Best-effort: `lmctl session` loads a team's ENTIRE session before slicing, which can exceed our
+  // exec maxBuffer for a long-running team (live-confirmed against math.lmctl) -- a failure here must
+  // never block the transcript view (loadTranscript, below), which is the reliable one.
+  const el = $('#session-detail');
+  el.innerHTML = '<p class="muted">loading...</p>';
+  try {
+    const body = await fetchJson(
+      `api/session/${encodeURIComponent(team)}/${encodeURIComponent(alias)}?limit=10`,
+    );
+    const tokens = body.tokens?.aggregate ?? {};
+    const summaryRows = [
+      ['Provider', escapeHtml(body.provider ?? '?')],
+      ['Session ID', escapeHtml(body.sessionId ?? '?')],
+      ['Modified', escapeHtml(body.modifiedAt ?? '?')],
+      ['Handled', `${body.handled} (${escapeHtml(body.handledSignal ?? '?')})`],
+      ['Tokens (aggregate)', `in ${tokens.input ?? 0} / out ${tokens.output ?? 0}`],
+      ['Tool calls', String((body.toolCalls ?? []).length)],
+      ['Tracked invocations', String((body.invocations ?? []).length)],
+      ['Last prompt', escapeHtml((body.lastPrompt ?? '').slice(0, 200))],
+    ];
+    el.innerHTML = renderTable(['Field', 'Value'], summaryRows);
+  } catch (err) {
+    el.innerHTML = `<p class="error">${escapeHtml(err.message)}</p>`;
+  }
+}
+
+function renderTranscriptTurns(turns, newFromIndex) {
+  if (turns.length === 0) return '<p class="muted">(no turns)</p>';
+  return (
+    '<div class="transcript">' +
+    turns
+      .map((turn, i) => {
+        const cls = i >= newFromIndex ? 'transcript-turn turn-new' : 'transcript-turn';
+        return (
+          `<div class="${cls}">` +
+          `<div class="turn-head"><span>${escapeHtml(turn.role)}</span><span>${escapeHtml(turn.ts ?? '')}</span></div>` +
+          `<div class="turn-text">${escapeHtml(turn.text)}</div>` +
+          '</div>'
+        );
+      })
+      .join('') +
+    '</div>'
+  );
+}
+
+/** Fetches + renders the real request/response transcript for one team member. Returns the fetched
+ *  turns (or null on error) so callers -- e.g. the enqueue reply-poller -- can detect new turns. */
+async function loadTranscript(team, alias, lines, newFromIndex = Infinity) {
+  const el = $('#transcript-view');
+  try {
+    const body = await fetchJson(
+      `api/transcript?team=${encodeURIComponent(team)}&alias=${encodeURIComponent(alias)}&lines=${lines || 40}`,
+    );
+    el.innerHTML = renderTranscriptTurns(body.turns, newFromIndex);
+    return body.turns;
+  } catch (err) {
+    el.innerHTML = `<p class="error">${escapeHtml(err.message)}</p>`;
+    return null;
+  }
+}
+
+let activeReplyPoll = null;
+
+/** After an operator enqueue, watch that team's transcript for the reply to land (delivered by the
+ *  in-server cron, then answered by the target's own LLM turn) and highlight it on the page --
+ *  the "operator can drive a team from the web app" loop the mission brief asks for (function 3). */
+function pollForReply(team, alias) {
+  if (activeReplyPoll) clearInterval(activeReplyPoll.timer);
+  const statusEl = $('#enqueue-poll-status');
+  const POLL_MS = 5000;
+  const MAX_ATTEMPTS = 60; // ~5 minutes
+
+  loadTranscript(team, alias, 40).then((baseline) => {
+    if (baseline === null) return; // error already rendered by loadTranscript
+    const baselineLength = baseline.length;
+    let attempts = 0;
+    statusEl.textContent = `queued to ${team} -- watching for a new reply...`;
+    const timer = setInterval(async () => {
+      attempts++;
+      const turns = await loadTranscript(team, alias, 40, baselineLength);
+      if (turns === null) return;
+      if (turns.length > baselineLength) {
+        clearInterval(timer);
+        activeReplyPoll = null;
+        statusEl.textContent = `new reply from ${team} landed (see the transcript below).`;
+      } else if (attempts >= MAX_ATTEMPTS) {
+        clearInterval(timer);
+        activeReplyPoll = null;
+        statusEl.textContent =
+          `still waiting on ${team} after 5 minutes -- stopped polling (it may still be running; ` +
+          `click "Inspect" in Active session review to check manually).`;
+      }
+    }, POLL_MS);
+    activeReplyPoll = { team, timer };
+  });
+}
+
+$('#session-form').addEventListener('submit', async (event) => {
+  event.preventDefault();
+  const form = new FormData(event.target);
+  const team = form.get('team');
+  const alias = form.get('alias');
+  const lines = Number(form.get('lines')) || 40;
+  $('#transcript-status').textContent = '';
+  await Promise.all([loadSessionSummary(team, alias), loadTranscript(team, alias, lines)]);
+});
+
+refreshAll();

package/dist/public/index.html

@@ -0,0 +1,78 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>lmauto</title>
+  <link rel="stylesheet" href="styles.css" />
+</head>
+<body>
+  <div class="page-shell">
+    <header class="toolbar">
+      <h1>lmauto</h1>
+      <button id="refresh-all">Refresh</button>
+      <span id="generated-at" class="muted"></span>
+    </header>
+
+    <main class="layout">
+      <section class="panel" id="panel-board">
+        <h2>Team board (S1&harr;S2)</h2>
+        <div id="board-table"></div>
+      </section>
+
+      <section class="panel" id="panel-send">
+        <h2>Send as operator</h2>
+        <form id="send-form">
+          <label>Team <input type="text" name="team" required /></label>
+          <label>Prompt <textarea name="prompt" rows="4" required></textarea></label>
+          <button type="submit">Send</button>
+        </form>
+        <pre id="send-result" class="result"></pre>
+      </section>
+
+      <section class="panel" id="panel-queue">
+        <h2>Queue &mdash; drive a team (e.g. <code>math</code>, the meta-lead) via the outbox</h2>
+        <form id="enqueue-form">
+          <label>To <input type="text" name="to" required /></label>
+          <label>Prompt <textarea name="prompt" rows="2" required></textarea></label>
+          <button type="submit">Enqueue</button>
+          <button type="button" id="deliver-btn">Deliver pending</button>
+        </form>
+        <p id="enqueue-poll-status" class="muted"></p>
+        <div id="queue-table"></div>
+      </section>
+
+      <section class="panel" id="panel-history">
+        <h2>History</h2>
+        <label>Team filter <input type="text" id="history-team-filter" placeholder="(all)" /></label>
+        <div id="history-table"></div>
+      </section>
+
+      <section class="panel" id="panel-sources">
+        <h2>Registry sources</h2>
+        <form id="source-form">
+          <label>Path <input type="text" name="path" required /></label>
+          <label>Label <input type="text" name="label" /></label>
+          <button type="submit">Add source</button>
+        </form>
+        <div id="sources-table"></div>
+      </section>
+
+      <section class="panel" id="panel-session">
+        <h2>Active session review</h2>
+        <form id="session-form">
+          <label>Team <input type="text" name="team" required /></label>
+          <label>Alias <input type="text" name="alias" value="Lead" required /></label>
+          <label>Lines <input type="number" name="lines" value="40" min="1" style="width: 5em" /></label>
+          <button type="submit">Inspect</button>
+        </form>
+        <div id="session-detail"></div>
+        <h3>Transcript (prompts + replies, real request/response history)</h3>
+        <p id="transcript-status" class="muted"></p>
+        <div id="transcript-view"></div>
+      </section>
+    </main>
+  </div>
+  <script src="app.js"></script>
+</body>
+</html>

package/dist/public/styles.css

@@ -0,0 +1,160 @@
+:root {
+  color-scheme: light dark;
+  --border: #d0d0d0;
+  --muted: #666;
+  --bg-panel: rgba(127, 127, 127, 0.06);
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  margin: 0;
+  padding: 1rem;
+  line-height: 1.4;
+}
+
+.page-shell {
+  max-width: 1400px;
+  margin: 0 auto;
+}
+
+.toolbar {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  margin-bottom: 1rem;
+}
+
+.toolbar h1 {
+  margin: 0;
+  font-size: 1.25rem;
+}
+
+.muted {
+  color: var(--muted);
+  font-size: 0.85rem;
+}
+
+.layout {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(360px, 1fr));
+  gap: 1rem;
+}
+
+.panel {
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 1rem;
+  background: var(--bg-panel);
+}
+
+.panel h2 {
+  margin-top: 0;
+  font-size: 1rem;
+}
+
+table {
+  border-collapse: collapse;
+  width: 100%;
+  font-size: 0.85rem;
+}
+
+th,
+td {
+  border-bottom: 1px solid var(--border);
+  padding: 0.35rem 0.5rem;
+  text-align: left;
+  vertical-align: top;
+}
+
+form {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  margin-bottom: 0.75rem;
+}
+
+form label {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  font-size: 0.85rem;
+}
+
+input,
+textarea,
+button {
+  font: inherit;
+  padding: 0.35rem 0.5rem;
+  border: 1px solid var(--border);
+  border-radius: 4px;
+}
+
+button {
+  cursor: pointer;
+  width: fit-content;
+}
+
+.result {
+  white-space: pre-wrap;
+  background: rgba(127, 127, 127, 0.1);
+  padding: 0.5rem;
+  border-radius: 4px;
+  font-size: 0.8rem;
+  max-height: 200px;
+  overflow: auto;
+}
+
+.error {
+  color: #c0392b;
+}
+
+.status-Running {
+  color: #2c7be5;
+}
+
+.status-BLOCKED {
+  color: #c0392b;
+  font-weight: bold;
+}
+
+.status-DONE {
+  color: #1a9850;
+}
+
+.transcript {
+  max-height: 420px;
+  overflow: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.transcript-turn {
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 0.4rem 0.6rem;
+  font-size: 0.82rem;
+}
+
+.transcript-turn.turn-new {
+  border-color: #1a9850;
+  background: rgba(26, 152, 80, 0.08);
+}
+
+.transcript-turn .turn-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 0.5rem;
+  font-size: 0.75rem;
+  color: var(--muted);
+  margin-bottom: 0.25rem;
+}
+
+.transcript-turn .turn-text {
+  white-space: pre-wrap;
+  word-break: break-word;
+}