@yemi33/minions 0.1.2087 → 0.1.2088

package/dashboard/js/render-dispatch.js

@@ -5,6 +5,65 @@ const LOG_PER_PAGE = 50;
 let _completedPage = 0;
 let _logPage = 0;
 
+// Fetch engine/dispatch.json straight off disk through the /state/<path>
+// static-file passthrough so dispatch state flips (queued→active, active→
+// completed, skipReason changes on pending entries) surface within one 4 s
+// poll regardless of /api/status outer-cache state (issue #2949).
+//
+// completedTotal isn't on disk — it's metrics-derived (sum across
+// agents.tasksCompleted + agents.tasksErrored). The renderer already falls
+// back to completed.length when completedTotal is missing, so we just
+// overlay the cached value from the previous /api/status snapshot for
+// continuity. Engine-side _withCompletionReportSummary enrichment (which
+// reads per-dispatch sidecar files) is preserved on the cached snapshot
+// too, so the modal "view report" links keep working — we only overlay the
+// fresh status/timestamp fields onto the cached row when ids match.
+async function fetchDispatchFromDisk(cachedDispatch) {
+  try {
+    const r = await fetch('/state/engine/dispatch.json');
+    if (!r.ok) return null;
+    const fresh = await r.json();
+    if (!fresh || typeof fresh !== 'object') return null;
+    // Cap completed to last 20 to match engine/queries.js getDispatchQueue
+    // — render-dispatch only paginates within this window, and dispatch.json
+    // on disk is already capped to 100 by the engine, so this is the same
+    // shape the renderer has always seen.
+    if (Array.isArray(fresh.completed) && fresh.completed.length > 20) {
+      fresh.completed = fresh.completed.slice(-20);
+    }
+    // Overlay completion-report summaries from the cached snapshot keyed by
+    // dispatch id. They live in sidecar files the client can't read, but
+    // they're slow to change so the cached overlay is fine.
+    if (cachedDispatch) {
+      const cachedById = new Map();
+      for (const list of ['pending', 'active', 'completed']) {
+        for (const d of (cachedDispatch[list] || [])) {
+          if (d && d.id) cachedById.set(d.id, d);
+        }
+      }
+      for (const list of ['pending', 'active', 'completed']) {
+        if (!Array.isArray(fresh[list])) continue;
+        fresh[list] = fresh[list].map((d) => {
+          if (!d || !d.id) return d;
+          const cached = cachedById.get(d.id);
+          if (!cached) return d;
+          const merged = Object.assign({}, d);
+          if (cached._completionReport !== undefined && merged._completionReport === undefined) {
+            merged._completionReport = cached._completionReport;
+          }
+          return merged;
+        });
+      }
+      if (fresh.completedTotal == null && cachedDispatch.completedTotal != null) {
+        fresh.completedTotal = cachedDispatch.completedTotal;
+      }
+    }
+    return fresh;
+  } catch {
+    return null;
+  }
+}
+
 function _completedPrev() { if (_completedPage > 0) { _completedPage--; refresh(); } }
 function _completedNext() { _completedPage++; refresh(); } // clamped in renderDispatch
 function _logPrev() { if (_logPage > 0) { _logPage--; refresh(); } }
@@ -274,6 +333,24 @@ function renderDispatch(dispatch) {
   }
 }
 
+// Pull the engine log straight off disk through /state/engine/log.json.
+// On-disk file is the full append-only array; engine/queries.js getEngineLog
+// slices to the last 50 for /api/status. We replicate that slice client-side
+// after the disk fetch. ETag/304 keeps the steady state cheap; a new log
+// line forces a fresh download (file is ~500 KB at high engine traffic, but
+// it changes only on engine writes — not on every 4 s poll).
+async function fetchEngineLogFromDisk() {
+  try {
+    const r = await fetch('/state/engine/log.json');
+    if (!r.ok) return null;
+    const raw = await r.json();
+    const arr = Array.isArray(raw) ? raw : (raw && Array.isArray(raw.entries) ? raw.entries : []);
+    return arr.slice(-50);
+  } catch {
+    return null;
+  }
+}
+
 function renderEngineLog(log) {
   const el = document.getElementById('engine-log');
   if (!el) return;

package/dashboard/js/render-inbox.js

@@ -3,6 +3,78 @@
 const INBOX_PER_PAGE = 15;
 let _inboxPage = 0;
 
+// Quick relative-time formatter — mirrors engine/queries.js timeSince so the
+// inbox-item "age" chip reads the same as it did via /api/status.
+function _timeSinceMs(mtimeMs) {
+  if (!mtimeMs) return '';
+  const ageMs = Date.now() - Number(mtimeMs);
+  if (ageMs < 0) return 'just now';
+  const sec = Math.floor(ageMs / 1000);
+  if (sec < 60) return sec + 's ago';
+  const min = Math.floor(sec / 60);
+  if (min < 60) return min + 'm ago';
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return hr + 'h ago';
+  const days = Math.floor(hr / 24);
+  return days + 'd ago';
+}
+
+// Fetch the inbox via the /state/notes/inbox directory listing + per-file
+// content fetch. The listing call returns {entries:[{name, mtimeMs, size,
+// isDir}]} and is cheap (one statSync per entry). The per-file fetches run
+// in parallel with their own mtime+size ETag so unchanged files 304 with
+// no body. Issue #2949 — the staleness fix applies here too: the inbox
+// directory mtime advances on every new note, and per-file ETags surface
+// content edits within one 4 s poll.
+async function fetchInboxFromDisk() {
+  try {
+    const listResp = await fetch('/state/notes/inbox');
+    if (!listResp.ok) return null;
+    const listing = await listResp.json();
+    const entries = Array.isArray(listing && listing.entries) ? listing.entries : [];
+    const mdFiles = entries
+      .filter((e) => e && !e.isDir && typeof e.name === 'string' && e.name.endsWith('.md'))
+      .sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0));
+    const items = await Promise.all(mdFiles.map(async (e) => {
+      try {
+        const r = await fetch('/state/notes/inbox/' + encodeURIComponent(e.name));
+        if (!r.ok) return null;
+        const content = await r.text();
+        return {
+          name: e.name,
+          mtime: e.mtimeMs,
+          age: _timeSinceMs(e.mtimeMs),
+          content,
+        };
+      } catch {
+        return null;
+      }
+    }));
+    return items.filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+// Fetch notes.md via /state/notes.md and return the renderer-shaped
+// { content, updatedAt } pair. updatedAt comes from a HEAD-style poll of
+// the ETag (mtime+size); we don't have direct mtime exposure, so a parallel
+// listing of the parent dir would be needed. Cheaper path: just include the
+// ETag value (which is "<mtimeMs>-<size>") and parse it out.
+async function fetchNotesFromDisk() {
+  try {
+    const r = await fetch('/state/notes.md');
+    if (!r.ok) return null;
+    const content = await r.text();
+    const etag = r.headers.get('ETag') || '';
+    const m = etag.match(/^"(\d+)-/);
+    const updatedAt = m ? Number(m[1]) : null;
+    return { content, updatedAt };
+  } catch {
+    return null;
+  }
+}
+
 function _inboxPrev() { if (_inboxPage > 0) { _inboxPage--; renderInbox(inboxData); } }
 function _inboxNext() { _inboxPage++; renderInbox(inboxData); }
 

package/dashboard/js/render-meetings.js

@@ -7,6 +7,61 @@ let _lastMeetingHash = '';
 let _lastMeetingsForPaging = [];
 let _mtgTotalPages = 1;
 
+// Pull meetings straight off disk via /state/meetings (dir listing) +
+// per-file fetch of /state/meetings/<id>.json. Each file is slimmed
+// client-side to match dashboard.js _slimMeetingForStatus so the
+// renderer sees the same shape it always has (findings/debate reduced
+// to {agentId: true} sentinels, transcript/conclusion bodies dropped).
+// Detail view still calls /api/meetings/<id> for the full bodies.
+// Issue #2949 — meetings on /api/status used to inherit the same outer
+// cache staleness as work-items; this disk-direct path sidesteps it.
+function _slimMeetingForRender(m) {
+  if (!m || typeof m !== 'object') return null;
+  const findingsKeys = m.findings && typeof m.findings === 'object' ? Object.keys(m.findings) : [];
+  const debateKeys = m.debate && typeof m.debate === 'object' ? Object.keys(m.debate) : [];
+  const findings = {};
+  for (const k of findingsKeys) findings[k] = true;
+  const debate = {};
+  for (const k of debateKeys) debate[k] = true;
+  const slim = {
+    id: m.id,
+    title: m.title,
+    status: m.status,
+    round: m.round,
+    participants: Array.isArray(m.participants) ? m.participants : [],
+    agenda: m.agenda,
+    createdAt: m.createdAt,
+    findings,
+    debate,
+  };
+  if (m.completedAt !== undefined) slim.completedAt = m.completedAt;
+  if (m.roundStartedAt !== undefined) slim.roundStartedAt = m.roundStartedAt;
+  if (m.createdBy !== undefined) slim.createdBy = m.createdBy;
+  return slim;
+}
+async function fetchMeetingsFromDisk() {
+  try {
+    const listResp = await fetch('/state/meetings');
+    if (!listResp.ok) return null;
+    const listing = await listResp.json();
+    const entries = Array.isArray(listing && listing.entries) ? listing.entries : [];
+    const jsonFiles = entries.filter(e => e && !e.isDir && typeof e.name === 'string' && e.name.endsWith('.json'));
+    const meetings = await Promise.all(jsonFiles.map(async (e) => {
+      try {
+        const r = await fetch('/state/meetings/' + encodeURIComponent(e.name));
+        if (!r.ok) return null;
+        const raw = await r.json();
+        return _slimMeetingForRender(raw);
+      } catch {
+        return null;
+      }
+    }));
+    return meetings.filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
 function renderMeetings(meetings) {
   meetings = (meetings || []).filter(function(m) { return !isDeleted('mtg:' + m.id); });
   meetings.sort((a, b) => (b.createdAt || b.completedAt || '').localeCompare(a.createdAt || a.completedAt || ''));

package/dashboard/js/render-plans.js

@@ -128,12 +128,12 @@ function isFollowUpOutcomeSatisfied(wi, allWorkItems, allPrs) {
  * but completion/progress is always derived from actual work item state.
  *
  * opts.allPrs — optional PR records used to reconcile stale failed follow-up
- * tasks (issue #2366). Falls back to window._lastStatus.pullRequests in the
- * browser. Pass `[]` to disable reconciliation.
+ * tasks (issue #2366). Falls back to window._lastPullRequests in the browser.
+ * Pass `[]` to disable reconciliation.
  */
 function derivePlanStatus(prdFile, mdFile, prdJsonStatus, workItems, opts) {
   const allPrs = (opts && opts.allPrs)
-    || (typeof window !== 'undefined' && window._lastStatus && window._lastStatus.pullRequests)
+    || (typeof window !== 'undefined' && window._lastPullRequests)
     || [];
   const wi = workItems.filter(w =>
     w.sourcePlan === prdFile || w.sourcePlan === mdFile ||
@@ -708,8 +708,11 @@ async function planApprove(file, btn) {
     }
     try { renderPlans(window._lastPlans); } catch { /* render is best-effort */ }
   }
-  if (isPrd && window._lastStatus?.prdProgress?.items) {
-    for (const item of window._lastStatus.prdProgress.items) {
+  // Issue #2949 — prdProgress moved off /api/status to /api/prd; refresh.js
+  // stashes the fresh fetch into window._lastPrdProgress.
+  const _prdProgressForApprove = window._lastPrdProgress;
+  if (isPrd && _prdProgressForApprove?.items) {
+    for (const item of _prdProgressForApprove.items) {
       if (item.source === file) {
         item.planStatus = 'approved';
         item.planStale = false;
@@ -919,14 +922,16 @@ function _renderVerifyBadge(verifyWi) {
   const statusColors = { pending: 'var(--muted)', dispatched: 'var(--blue)', done: 'var(--green)', failed: 'var(--red)' };
   const color = statusColors[verifyWi.status] || 'var(--muted)';
   const label = verifyWi.status === 'dispatched' ? 'Verifying...' : verifyWi.status === 'done' ? '\u2714 Verified' : verifyWi.status === 'failed' ? 'Verify failed' : 'Verify pending';
-  // E2E PR — check by prdItems, branch, or title
-  const allPrs = (window._lastStatus?.pullRequests) || [];
+  // E2E PR — check by prdItems, branch, or title. Issue #2949 — pullRequests
+  // moved off /api/status to /api/pull-requests (window._lastPullRequests).
+  const allPrs = window._lastPullRequests || [];
   const planFile = verifyWi.sourcePlan || '';
   const planSlug = planFile.replace('.json', '');
   const verifyPr = allPrs.find(pr => (pr.prdItems || []).includes(verifyWi.id) || (pr.branch && pr.branch.includes(planSlug) && (pr.title || '').includes('[E2E]')));
   const prLink = verifyPr?.url ? ' <a href="' + escapeHtml(verifyPr.url) + '" target="_blank" onclick="event.stopPropagation()" style="color:var(--blue);text-decoration:underline;font-size:9px">' + escapeHtml(verifyPr.id || 'E2E PR') + '</a>' : '';
-  // Testing guide
-  const guides = window._lastStatus?.verifyGuides || [];
+  // Testing guide. verifyGuides moved to /api/verify-guides
+  // (window._lastVerifyGuides set by refresh.js).
+  const guides = window._lastVerifyGuides || [];
   const guide = guides.find(g => g.planFile === planFile);
   const guideLink = guide ? ' <span onclick="event.stopPropagation();openVerifyGuide(\'' + escapeHtml(guide.file) + '\')" style="color:var(--green);cursor:pointer;text-decoration:underline;font-size:9px">Testing Guide</span>' : '';
   return '<span style="font-size:9px;font-weight:600;color:' + color + ';padding:0 4px">' + label + '</span>' + prLink + guideLink;

package/dashboard/js/render-prd.js

@@ -564,8 +564,10 @@ function renderPrdProgress(prog) {
     '</div>';
   };
 
-  // E2E / verification PRs — group by sourcePlan
-  const allPrs = window._lastStatus?.pullRequests || [];
+  // E2E / verification PRs — group by sourcePlan. Issue #2949 — pullRequests
+  // moved off /api/status to /api/pull-requests; refresh.js stashes the fresh
+  // fetch into window._lastPullRequests.
+  const allPrs = window._lastPullRequests || [];
   const e2eByPlan = {};
   for (const pr of allPrs) {
     // Match by explicit sourcePlan (robust), or fall back to title/branch heuristic (legacy)
@@ -576,8 +578,11 @@ function renderPrdProgress(prog) {
     e2eByPlan[planKey].push(pr);
   }
 
-  // Find testing guides in prd/ (verify-*.md files)
-  const verifyGuides = (window._lastStatus?.verifyGuides || []);
+  // Find testing guides in prd/ (verify-*.md files). Issue #2949 —
+  // verifyGuides moved off /api/status to /api/verify-guides; refresh.js
+  // fetches it alongside /api/prd in a Promise.all and stashes onto
+  // window._lastVerifyGuides.
+  const verifyGuides = window._lastVerifyGuides || [];
   const guideByPlan = {};
   for (const g of verifyGuides) {
     guideByPlan[g.planFile] = g;
@@ -750,9 +755,11 @@ async function prdItemEdit(source, itemId) {
 
   _prdDescRawCache = item.description || '';
 
-  // Look up work item and dispatch completion info
+  // Look up work item and dispatch completion info. Issue #2949 —
+  // dispatch moved off /api/status to /api/dispatch; refresh.js stashes
+  // the fresh queue into window._lastDispatch.
   const wi = (window._lastWorkItems || []).find(w => w.id === itemId && w.sourcePlan === source);
-  const dispatch = window._lastStatus?.dispatch || {};
+  const dispatch = window._lastDispatch || {};
   const completedEntry = (dispatch.completed || []).find(d =>
     d.meta?.item?.id === itemId && d.meta?.item?.sourcePlan === source
   );

package/dashboard/js/render-prs.js

@@ -4,6 +4,61 @@ let allPrs = [];
 let prPage = 0;
 const PR_PER_PAGE = 25;
 
+// Fetch each project's pull-requests.json straight off disk through the
+// /state/projects/<name>/pull-requests.json static-file passthrough. This
+// is the issue #2949 escape hatch — the engine writes PR status / review
+// state / build state directly into pull-requests.json, and the mtime-ETag
+// on /state/ guarantees a fresh read on the next 4 s poll regardless of
+// whether the /api/status outer cache has busted.
+//
+// Engine-side enrichment is minimal: stamping `_project` from the project
+// name (the filename context) and back-filling `url` from `prUrlBase` when
+// missing. Both are applied here to keep parity with the legacy slice.
+// Other engine-derived fields (build status from CI poll, reviewStatus,
+// _buildStatusStale) are PERSISTED to disk by the engine's PR pollers, so
+// they survive the round-trip naturally.
+async function fetchPullRequestsFromDisk(projects) {
+  if (!Array.isArray(projects) || !projects.length) return null;
+  const results = await Promise.all(projects.map(async (p) => {
+    const name = p && (p.name || p.path);
+    if (!name) return [];
+    const urlBase = (p && p.prUrlBase) || '';
+    try {
+      const r = await fetch('/state/projects/' + encodeURIComponent(name) + '/pull-requests.json');
+      if (!r.ok) return [];
+      const arr = await r.json();
+      if (!Array.isArray(arr)) return [];
+      return arr.map((pr) => {
+        if (!pr || typeof pr !== 'object' || !pr.id) return null;
+        const stamped = Object.assign({ _project: name }, pr);
+        if (!stamped.url && urlBase && typeof stamped.number === 'number') {
+          stamped.url = urlBase + stamped.number;
+        }
+        return stamped;
+      }).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }));
+  const out = [];
+  const seen = new Set();
+  for (const arr of results) {
+    for (const pr of arr) {
+      if (seen.has(pr.id)) continue;
+      seen.add(pr.id);
+      out.push(pr);
+    }
+  }
+  // Same sort the engine applies: most recent created first, fall back to id.
+  out.sort((a, b) => {
+    const ac = a.created || '';
+    const bc = b.created || '';
+    if (ac && bc) return bc.localeCompare(ac);
+    return (b.id || '').localeCompare(a.id || '');
+  });
+  return out;
+}
+
 function _countPrFollowups(pr) {
   // PR follow-up chip (W-mpej3cox00099466) — counts WIs whose
   // meta.pr_followup.parent_pr_url or parent_pr_id matches this PR.

package/dashboard/js/render-watches.js

@@ -1,5 +1,21 @@
 // render-watches.js — Watch rendering and CRUD functions for the dashboard
 
+// Pull watches.json straight off disk through /state/engine/watches.json
+// instead of waiting on the /api/status outer cache (issue #2949). The
+// engine writes watch status / _history transitions directly into
+// watches.json, so mtime+size ETag surfaces them on the next 4 s poll.
+// Falls back to data.watches when /state/ returns null.
+async function fetchWatchesFromDisk() {
+  try {
+    const r = await fetch('/state/engine/watches.json');
+    if (!r.ok) return null;
+    const arr = await r.json();
+    return Array.isArray(arr) ? arr : null;
+  } catch {
+    return null;
+  }
+}
+
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 const _WATCH_STATUS_BADGES = {

package/dashboard/js/render-work-items.js

@@ -4,6 +4,76 @@ let allWorkItems = [];
 let wiPage = 0;
 const WI_PER_PAGE = 20;
 
+// Engine-enrichment field names that live on the /api/status workItems slice
+// but are NOT on disk in projects/<name>/work-items.json. The /state/ fetch
+// recovers raw disk state — these get overlaid from the most recent
+// /api/status snapshot (window._lastWorkItems) so the table still renders the
+// PR chip, pending-reason badge, blockedBy hint, etc. The disk fields win
+// for everything else, so a status flip from `pending` → `done` lands within
+// one /state poll regardless of how stale /api/status got.
+const _WI_ENRICHMENT_FIELDS = [
+  '_pr', '_prUrl', '_pendingReason', '_skipReason', '_blockedBy',
+  '_humanFeedback', '_reopened', '_managedSpawnPartial', '_securityFlag',
+  '_artifacts', 'referencesCount', 'acceptanceCriteriaCount',
+];
+
+// Pull each project's work-items.json straight off disk through
+// /state/projects/<name>/work-items.json. The endpoint is a static-file
+// passthrough with mtime+size ETag — there is no server-side cache in the
+// way, so an engine write to `status: 'done'` is visible to the next poll
+// (issue #2949 root fix). Enrichment fields are overlaid from a cached
+// id→item map sourced from window._lastWorkItems (the last /api/status
+// snapshot). All fetches run in parallel; a single project's failure does
+// not block the others.
+async function fetchWorkItemsFromDisk(projects, cachedById) {
+  if (!Array.isArray(projects) || !projects.length) return null;
+  const results = await Promise.all(projects.map(async (p) => {
+    const name = p && (p.name || p.path);
+    if (!name) return [];
+    try {
+      const r = await fetch('/state/projects/' + encodeURIComponent(name) + '/work-items.json');
+      if (!r.ok) return [];
+      const arr = await r.json();
+      if (!Array.isArray(arr)) return [];
+      return arr.map((item) => {
+        if (!item || typeof item !== 'object') return null;
+        const stamped = Object.assign({}, item, { _source: name });
+        const cached = cachedById && cachedById.get(item.id);
+        if (cached) {
+          for (const k of _WI_ENRICHMENT_FIELDS) {
+            if (stamped[k] === undefined && cached[k] !== undefined) {
+              stamped[k] = cached[k];
+            }
+          }
+        }
+        // referencesCount / acceptanceCriteriaCount don't live on disk;
+        // derive from the raw arrays if present so the table icons render
+        // even before the cached snapshot catches up.
+        if (stamped.referencesCount == null && Array.isArray(stamped.references)) {
+          stamped.referencesCount = stamped.references.length;
+        }
+        if (stamped.acceptanceCriteriaCount == null && Array.isArray(stamped.acceptanceCriteria)) {
+          stamped.acceptanceCriteriaCount = stamped.acceptanceCriteria.length;
+        }
+        return stamped;
+      }).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }));
+  // Flatten + dedupe by id (a project rename mid-flight could double-list).
+  const out = [];
+  const seen = new Set();
+  for (const arr of results) {
+    for (const item of arr) {
+      if (!item.id || seen.has(item.id)) continue;
+      seen.add(item.id);
+      out.push(item);
+    }
+  }
+  return out;
+}
+
 // Track retry state per work item so loading/success/error survives re-renders
 const _wiRetryState = {}; // { [id]: { status: 'pending'|'done'|'error', message?, until? } }
 function setWiRetryState(id, state) { _wiRetryState[id] = state; }

package/dashboard/js/settings.js

@@ -390,11 +390,9 @@ async function openSettings() {
     '<div data-search="routing table playbook agent assignment" style="margin-bottom:16px">' +
       '<textarea id="set-routing" rows="10" style="width:100%;padding:8px;background:var(--surface);border:1px solid var(--border);border-radius:4px;color:var(--text);font-family:monospace;font-size:var(--text-base);resize:vertical">' + escHtml(data.routing || '') + '</textarea>' +
     '</div>' +
-    '<h4>Inbox &amp; Status Retention</h4>' +
+    '<h4>Inbox</h4>' +
     '<div class="settings-grid-2">' +
       settingsField('Consolidation Threshold', 'set-inboxConsolidateThreshold', e.inboxConsolidateThreshold || 5, 'notes', 'Inbox notes before auto-consolidation') +
-      settingsField('Status WorkItems Retention', 'set-statusWorkItemsRetentionDays', e.statusWorkItemsRetentionDays ?? 0, 'days', 'Optional age-based trim for done/failed/cancelled work items in the /api/status workItems slice (active items are always shipped). Default 0 = no trim — the slim projection that strips description/AC/references already cuts the payload by ~80%. Set to a positive integer to also drop terminal items older than N days.') +
-      settingsField('Status Meetings Retention', 'set-statusMeetingsRetentionDays', e.statusMeetingsRetentionDays ?? 0, 'days', 'Optional age-based trim for completed/archived meetings in the /api/status meetings slice (active meetings are always shipped). Default 0 = no trim — the slim projection that collapses findings/debate/transcript bodies to {agentId: true} sentinels already cuts the payload by ~80%. Set to a positive integer to also drop terminal meetings older than N days. Detail modal still fetches full bodies via /api/meetings/:id.') +
       settingsField('Version Check Interval', 'set-versionCheckInterval', e.versionCheckInterval || 3600000, 'ms', 'How often to check npm for updates (default: 1 hour)') +
     '</div>' +
     '<h4>Operator &amp; Comments</h4>' +
@@ -841,8 +839,6 @@ async function saveSettings() {
       restartGracePeriod: document.getElementById('set-restartGracePeriod').value,
       meetingRoundTimeout: document.getElementById('set-meetingRoundTimeout').value,
       operatorLogin: (document.getElementById('set-operatorLogin')?.value ?? '').trim(),
-      statusWorkItemsRetentionDays: document.getElementById('set-statusWorkItemsRetentionDays').value,
-      statusMeetingsRetentionDays: document.getElementById('set-statusMeetingsRetentionDays').value,
       autoApprovePlans: document.getElementById('set-autoApprovePlans').checked,
       evalLoop: document.getElementById('set-evalLoop').checked,
       autoDecompose: document.getElementById('set-autoDecompose').checked,

package/dashboard/js/state.js

@@ -208,9 +208,15 @@ document.addEventListener('visibilitychange', function() {
 });
 
 function rerenderPrdFromCache() {
-  if (!window._lastStatus || !window._lastStatus.prdProgress) return;
-  renderPrdProgress(window._lastStatus.prdProgress);
-  renderPrd(window._lastStatus.prd, window._lastStatus.prdProgress);
+  // Issue #2949 — prdProgress + prd moved off /api/status to /api/prd;
+  // refresh.js stashes the fresh fetch into window._lastPrdProgress +
+  // window._lastPrdStatus. `!== undefined` (not a truthy check) so a
+  // cache-was-null state (last PRD archived → /api/prd returned
+  // {progress: null}) still triggers a re-render — renderPrd handles
+  // null gracefully and paints the empty 'No PRD found' affordance.
+  if (window._lastPrdProgress === undefined) return;
+  renderPrdProgress(window._lastPrdProgress);
+  renderPrd(window._lastPrdStatus, window._lastPrdProgress);
 }
 
 // Global fetch wrapper with timeout — prevents connection exhaustion from hung requests.