@flame0510/project-aether 1.6.0 → 1.6.2

package/app/api/update-check/route.ts

@@ -59,7 +59,10 @@ export async function GET(request: Request): Promise<NextResponse> {
     const now = Date.now();
     if (cache && now - cache.checkedAt < CACHE_TTL_MS) {
       latest = cache.latest;
-      updateAvailable = cache.updateAvailable;
+      // Recomputed against the version reading us now: `installed` is not cached, and
+      // reusing the cached flag made the banner offer an update that had just been
+      // installed, for up to the cache's fifteen minutes (seen right after an update).
+      updateAvailable = !!latest && latest !== installed;
     } else {
       try {
         const pkgName = pkg.name || FALLBACK_PKG_NAME;

package/app/components/VersionBanner.tsx

@@ -4,19 +4,22 @@
  * "Update available" banner for Rev4a itself.
  *
  * The update is spawned by `POST /api/update-check` and restarts the server, so this
- * component cannot be told the outcome by the response. It records what it asked for,
- * waits for the server to answer again, and on the next mount compares.
+ * component cannot be told the outcome by the response. It records what it asked for and
+ * follows the restart from the browser.
  *
- * Two rules learned the hard way (2026-09-23):
+ * Three rules learned from the 1.6.0 update (2026-09-23):
  *  - a **success** is only a version that is *readable* and different. During the update
- *    npm rewrites `package.json`, and a read that fails used to answer `0.0.0`, which read
- *    as "the version moved" — the banner then said "Updated to v0.0.0" and reloaded in the
- *    middle of the install.
- *  - the banner never reloads **blindly**: if the version has not moved by the time the
- *    wait is over, it says the update has not finished (it may still be running, or it
- *    failed) and offers a Reload, instead of pretending.
+ *    npm rewrites `package.json`, and a read that failed used to answer `0.0.0`, which read
+ *    as "the version moved" — the banner said "Updated to v0.0.0" and reloaded mid-install.
+ *  - while the restart is in flight the banner shows an **updating** state, never the
+ *    "Update now" button again: nobody should think the update failed and start it twice.
+ *    A page loaded in that window resumes the wait by itself and reloads when the new
+ *    version answers.
+ *  - the banner never reloads **blindly**: if the version has not moved by the deadline it
+ *    says the update has not finished (it may still be running, or it failed), points at
+ *    `update.log` and offers Retry and Reload.
  */
-import { useEffect, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 import { Button } from '../components/ui';
 
 interface VersionInfo {
@@ -27,20 +30,23 @@ interface VersionInfo {
 }
 
 const DISMISS_KEY = 'rev4a-update-dismissed';
-/** What we asked for and from which version, so the next mount can judge the outcome. */
+/** What we asked for and from which version, so a reload can resume the wait. */
 const PENDING_KEY = 'rev4a-update-pending';
 
 /** How long to wait for the restart before saying the update has not finished. */
-const WAIT_MS = 120_000;
+const WAIT_MS = 150_000;
+/** How long a recorded request stays believable across reloads. */
+const PENDING_TTL_MS = 15 * 60 * 1000;
 
-interface Pending { target: string; from: string }
+interface Pending { target: string; from: string; at: number }
 
 function readPending(): Pending | null {
   try {
     const raw = sessionStorage.getItem(PENDING_KEY);
     if (!raw) return null;
     const parsed = JSON.parse(raw) as Pending;
-    return parsed && typeof parsed.target === 'string' && typeof parsed.from === 'string' ? parsed : null;
+    if (!parsed || typeof parsed.target !== 'string' || typeof parsed.from !== 'string') return null;
+    return parsed;
   } catch {
     return null;
   }
@@ -57,6 +63,33 @@ export default function VersionBanner() {
   const [updating, setUpdating] = useState(false);
   const [updateError, setUpdateError] = useState<string | null>(null);
   const [updateOk, setUpdateOk] = useState<string | null>(null);
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  /**
+   * Follow the restart until the server answers with a different, readable version, then
+   * reload. `from` is the version we started from, so a resumed wait knows what to expect.
+   */
+  const followRestart = useCallback((from: string) => {
+    const deadline = Date.now() + WAIT_MS;
+    const poll = async () => {
+      try {
+        const res = await fetch('/api/update-check', { cache: 'no-store' });
+        const d = (await res.json()) as VersionInfo;
+        if (usableVersion(d.installed) && d.installed !== from) {
+          sessionStorage.removeItem(PENDING_KEY);
+          window.location.reload();
+          return;
+        }
+      } catch { /* the server is down for the restart: expected */ }
+      if (Date.now() > deadline) {
+        setUpdating(false);
+        setUpdateError('The update has not finished after a couple of minutes. It may still be running — see update.log, then reload.');
+        return;
+      }
+      timerRef.current = setTimeout(poll, 3000);
+    };
+    timerRef.current = setTimeout(poll, 3000);
+  }, []);
 
   useEffect(() => {
     let active = true;
@@ -72,13 +105,22 @@ export default function VersionBanner() {
           setTimeout(() => { if (active) window.location.reload(); }, 2500);
           return;
         }
+        if (pending && Date.now() - (pending.at ?? 0) < PENDING_TTL_MS) {
+          // The restart is probably in flight (a page loaded inside that window, or a
+          // reload before the new version answered): resume the wait, show no action.
+          setInfo(d);
+          setDismissed(false);
+          setUpdating(true);
+          followRestart(pending.from);
+          return;
+        }
         if (pending) {
-          // Keep the record: a reload asks again. Say what we know, claim nothing.
+          sessionStorage.removeItem(PENDING_KEY);
           setInfo(d);
           setDismissed(false);
           setUpdateError(
             `The update to v${pending.target} has not finished: ${usableVersion(d.installed) ? `Rev4a is still on v${d.installed}` : 'Rev4a is not answering with a version'}.`
-            + ` It may still be running, or it failed — see ${d.log ?? 'update.log'} in the Rev4a data directory, then reload.`,
+            + ` See ${d.log ?? 'update.log'} in the Rev4a data directory, then reload.`,
           );
           return;
         }
@@ -89,7 +131,10 @@ export default function VersionBanner() {
       })
       .catch(() => {});
     return () => { active = false; };
-  }, []);
+  }, [followRestart]);
+
+  // Clear a timer the component no longer owns (unmount or a full reload).
+  useEffect(() => () => { if (timerRef.current) clearTimeout(timerRef.current); }, []);
 
   function handleDismiss() {
     if (info?.latest) localStorage.setItem(DISMISS_KEY, info.latest);
@@ -113,37 +158,16 @@ export default function VersionBanner() {
         setUpdating(false);
         return;
       }
-      sessionStorage.setItem(PENDING_KEY, JSON.stringify({ target: info.latest ?? '', from: info.installed }));
+      sessionStorage.setItem(PENDING_KEY, JSON.stringify({ target: info.latest ?? '', from: info.installed, at: Date.now() }));
       localStorage.removeItem(DISMISS_KEY);
-      setUpdateOk('Update started. Rev4a is restarting…');
-      // The server goes down and comes back on the new version: reload once it answers
-      // with a different, readable version. If it never does, say so rather than reloading
-      // into a state the operator cannot interpret.
-      const deadline = Date.now() + WAIT_MS;
-      const poll = async () => {
-        try {
-          const r = await fetch('/api/update-check', { cache: 'no-store' });
-          const d = (await r.json()) as VersionInfo;
-          if (usableVersion(d.installed) && d.installed !== info.installed) { window.location.reload(); return; }
-        } catch { /* the server is down for the update: expected */ }
-        if (Date.now() > deadline) {
-          setUpdating(false);
-          setUpdateOk(null);
-          setUpdateError('The update has not finished after two minutes. It may still be running — reload in a moment, or check update.log.');
-          return;
-        }
-        setTimeout(poll, 3000);
-      };
-      setTimeout(poll, 3000);
+      followRestart(info.installed);
     } catch (err) {
       setUpdateError(err instanceof Error ? err.message : 'Network error');
       setUpdating(false);
     }
   }
 
-  // The result states stand on their own (there may be no `info` when the update just
-  // succeeded); the "available" state needs the version info and no dismissal.
-  const show = Boolean(updateOk) || Boolean(updateError) || Boolean(info?.updateAvailable && !dismissed);
+  const show = Boolean(updateOk) || Boolean(updateError) || Boolean(updating) || Boolean(info?.updateAvailable && !dismissed);
   if (!show) return null;
 
   return (
@@ -154,6 +178,8 @@ export default function VersionBanner() {
             <span className="update-banner__ok">{updateOk}</span>
           ) : updateError ? (
             <span className="update-banner__err">{updateError}</span>
+          ) : updating ? (
+            <span className="update-banner__ok">Update started. Rev4a is restarting — this page reloads on its own when the new version answers.</span>
           ) : (
             <>
               <span className="update-banner__label">Update available</span>
@@ -166,19 +192,21 @@ export default function VersionBanner() {
 
         {!updateOk && (
           <div className="update-banner__actions">
-            {updateError ? (
-              <Button variant="primary" size="sm" onClick={handleUpdate} disabled={updating}>
-                {updating ? 'Updating…' : 'Retry'}
-              </Button>
+            {updating ? (
+              // No action while the restart runs: the only honest one is to wait.
+              <Button variant="ghost" size="sm" onClick={() => window.location.reload()}>Reload</Button>
+            ) : updateError ? (
+              <>
+                <Button variant="primary" size="sm" onClick={handleUpdate}>Retry</Button>
+                <Button variant="secondary" size="sm" onClick={() => window.location.reload()}>Reload</Button>
+                <Button variant="ghost" size="sm" onClick={handleDismiss}>Dismiss</Button>
+              </>
             ) : (
-              <Button variant="primary" size="sm" onClick={handleUpdate} disabled={updating}>
-                {updating ? 'Updating…' : 'Update now'}
-              </Button>
-            )}
-            {updateError && (
-              <Button variant="secondary" size="sm" onClick={() => window.location.reload()}>Reload</Button>
+              <>
+                <Button variant="primary" size="sm" onClick={handleUpdate}>Update now</Button>
+                <Button variant="ghost" size="sm" onClick={handleDismiss}>Dismiss</Button>
+              </>
             )}
-            <Button variant="ghost" size="sm" onClick={handleDismiss}>Dismiss</Button>
           </div>
         )}
       </div>

package/docs/dev/API-REFERENCE.md

@@ -2596,6 +2596,10 @@ from local state only.
 
 **Response:** `{ "installed": "1.4.2", "latest": "1.5.0", "updateAvailable": true, "package": "@flame0510/project-aether", "log": "update.log" }`
 
+`updateAvailable` is recomputed against the version reading the request, even when the
+registry answer comes from the fifteen-minute cache: reusing the cached flag made the
+banner offer an update that had just been installed, right after an update.
+
 `installed` is `null` when `package.json` cannot be read — during an update npm rewrites
 it, and a transient failure must not look like a version. With `installed` unknown there
 is nothing to compare, so `latest` is `null` and `updateAvailable` false. `installed` is

package/docs/dev/GATEWAY.md

@@ -206,6 +206,29 @@ block, and every number there carries its source:
 No generated field ever replaces a curated one silently: prices are separate files, and the
 modal shows the generated part's date (`asOf`).
 
+### Curating an `info` block
+
+Nothing here is estimated, and every number carries its source and date. The workflow has
+three steps, one command each:
+
+```bash
+npm run info:suggest -- <model id> …   # candidate facts from the model card (read-only)
+# the maintainer, or a worker agent asked to follow the same contract, proposes the block
+npm run info:verify  -- proposals.json   # the gate: refuses what the card does not support
+```
+
+- `scripts/model-info-suggest.mjs` prints the card's size sentences, its benchmark tables
+  (headers included) and its doc links, so the reading is a lookup rather than a hunt.
+- `scripts/model-info-verify.mjs` checks a proposal against the card: `evidence` present,
+  every number in `params` in the card text, every benchmark value in a row named after it
+  **under the column that names this model** (never a sibling variant), and `docUrl` when
+  asked with `--check-links`. It exits non-zero on a rejected proposal.
+- The proposal contract is what makes this safe: one JSON object per model with an
+  `evidence` entry per field, the verbatim line, the column used and the card's own date.
+  A worker that skips the evidence — or takes a value from a variant's column — is caught
+  here, not in the catalogue. Benchmarks that a card states only for a sibling
+  (`-Max`, `-Base`, `-HighSpeed`) are dropped.
+
 ---
 
 ## Per-agent model assignment