@flame0510/project-aether 1.3.0 → 1.4.1

package/app/api/assistant/route.ts

@@ -25,8 +25,8 @@ const PAGE_CONTEXT: Record<string, PageContext> = {
   '/agents': {
     title: 'Agents',
     description: 'List of all Docker containers that run OpenClaw agents. Shows status (running/exited/paused), image, ports, IP, and creation time. Includes a top banner for the agent base image status: yellow warning when outdated or missing, animated progress bar when downloading from registry.',
-    actions: ['Filter by status: all, running, or exited', 'Click an agent to see its details (environment variables, auth token, backups, Telegram channels, and the Model section that sets its primary model and fallbacks)', 'Create a new agent using the "Create Agent" button', 'Download the agent base image when the banner shows it missing or outdated'],
-    hints: 'The status bullet tells you at a glance if an agent is running (green), exited (red), or paused (yellow). The base image banner shows when an updated version is available on the registry — download to pick up CLI updates.',
+    actions: ['Filter by status: all, running, or exited', 'Click an agent to see its details (environment variables, backups, Telegram channels, and the Model section that sets its primary model and fallbacks)', 'Create a new agent using the "Create Agent" button', 'Download the agent base image when the banner shows it missing or outdated'],
+    hints: 'The status bullet tells you at a glance if an agent is running (green), exited (red), or paused (yellow). The base image banner shows when a newer supported version is published on the registry — downloading makes it available to create and update agents on; it changes no agent by itself.',
   },
   '/agents/create': {
     title: 'Create Agent',

package/app/api/gateway/agent/route.ts

@@ -8,6 +8,7 @@
  *   { "containerName": "openclaw-atlas", "model": "rev4a/deepseek-flash", "fallbacks": ["rev4a/deepseek-v4-pro"] }
  */
 import { NextRequest, NextResponse } from 'next/server';
+import { agentBusyReason } from '@/lib/agent-busy';
 import { execSync } from 'child_process';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 
@@ -90,6 +91,19 @@ export async function PUT(request: NextRequest) {
       return NextResponse.json({ status: 'error', error: 'model is required' }, { status: 400 });
     }
 
+    // Refuse while a long operation is running on this agent: the write would race the
+    // recreate/migration that is replacing the container underneath it.
+    try {
+      const agentId = execSync(
+        `docker inspect --format '{{index .Config.Labels "AGENT_ID"}}' ${safeContainer}`,
+        { encoding: 'utf-8', timeout: 5000 },
+      ).trim();
+      if (agentId) {
+        const busy = await agentBusyReason(agentId);
+        if (busy) return NextResponse.json({ status: 'error', error: busy }, { status: 409 });
+      }
+    } catch { /* no container or no label: the rest of the route reports it */ }
+
     // Read current config
     const raw = readFileFromContainer(safeContainer, '/root/.openclaw/openclaw.json');
     if (!raw) {

package/app/api/gateway/provider/balance/route.ts

@@ -7,7 +7,7 @@
  * Supported providers: deepseek, openrouter, glm
  */
 import { NextRequest, NextResponse } from 'next/server';
-import { fetchProviderBalance, type BalanceProvider } from '@/lib/provider-balance';
+import { fetchProviderBalance, BalanceUnsupportedError, type BalanceProvider } from '@/lib/provider-balance';
 import { requireAuthJWT } from '@/lib/rev4a-auth';
 
 export const dynamic = 'force-dynamic';
@@ -33,6 +33,9 @@ export async function GET(request: NextRequest): Promise<NextResponse> {
     return NextResponse.json({ provider, ...result });
   } catch (e: unknown) {
     const message = e instanceof Error ? e.message : String(e);
-    return NextResponse.json({ provider, error: message }, { status: 502 });
+    // A permanent "no balance API for this account" is reported distinctly, so
+    // the UI can hide the badge instead of offering a retry that never works.
+    const reason = e instanceof BalanceUnsupportedError ? 'no-balance-api' : undefined;
+    return NextResponse.json({ provider, error: message, ...(reason && { reason }) }, { status: 502 });
   }
 }

package/app/api/gateway/sync.ts

@@ -19,6 +19,11 @@ import { readProviderKeys } from './provider/keys';
 import { bundledCatalogueStatus, loadOfferedModels, type ModelConfigEntry } from '@/lib/model-catalogue';
 import { singleFileFromTar } from '@/lib/container-file';
 import { detectProviderGatewayUrl } from '@/lib/docker-utils';
+import { isSupportedVersion, modelInputFor, parseOpenClawVersion } from '@/lib/agent-versions';
+import { activeUpdateAgentIds } from '@/lib/agent-update-state';
+import { activeRecreateAgentIds } from '@/lib/agent-recreate-state';
+import { activeRestoreAgentIds } from '@/lib/agent-restore-state';
+import { activeEditAgentIds } from '@/lib/agent-edit-state';
 
 const PROVIDER_GATEWAY_BASE_URL = detectProviderGatewayUrl();
 
@@ -31,19 +36,57 @@ const PROVIDER_GATEWAY_BASE_URL = detectProviderGatewayUrl();
  * OpenClaw `input` array. Filters out values not in the allowed set
  * (text | image | video | audio).
  */
-const ALLOWED_INPUT = new Set(['text', 'image', 'video', 'audio']);
-
-function modalityToInput(modality: string): string[] {
+/**
+ * Model `input` values an agent's OpenClaw version accepts. The list is per version
+ * (lib/agent-versions.json): 7.1-2 knows only `text | image`, and one value it does not
+ * know invalidates the whole generated catalogue ("model catalog load issue").
+ */
+function modalityToInput(modality: string, version?: string | null): string[] {
+  const allowed = new Set(modelInputFor(version));
   const arrowIdx = modality.indexOf('->');
   const left = arrowIdx >= 0 ? modality.slice(0, arrowIdx) : modality;
-  return left.split('+').map((s) => s.trim()).filter((s) => ALLOWED_INPUT.has(s));
+  return left.split('+').map((s) => s.trim()).filter((s) => allowed.has(s));
+}
+
+/** Where the image entrypoint records the version an agent last started on. */
+const LAST_VERSION_PATH = '/root/.openclaw/.last-version';
+
+/**
+ * The OpenClaw version a container runs, for its model `input` list. Best-effort and
+ * synchronous: the image tag when it names a version, else the `.last-version` file the
+ * entrypoint writes (through `docker exec` when running, `docker cp` when stopped).
+ * Null when nothing says — the caller then falls back to the newest version's list.
+ */
+function containerVersionSync(name: string): string | null {
+  try {
+    const image = execFileSync('docker', ['inspect', '--format', '{{.Config.Image}}', name], {
+      timeout: 5000, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+    const fromTag = parseOpenClawVersion(image);
+    if (fromTag && isSupportedVersion(fromTag)) return fromTag;
+  } catch { /* no such container or no image: fall through */ }
+  try {
+    const raw = execFileSync('docker', ['exec', name, 'cat', LAST_VERSION_PATH], {
+      timeout: 5000, maxBuffer: 64 * 1024, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const running = parseOpenClawVersion(raw);
+    if (running && isSupportedVersion(running)) return running;
+  } catch { /* not running or no file: try the stopped path */ }
+  try {
+    const file = singleFileFromTar(execFileSync('docker', ['cp', `${name}:${LAST_VERSION_PATH}`, '-'], {
+      timeout: 5000, maxBuffer: 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'],
+    }));
+    const stopped = parseOpenClawVersion(file.body.toString('utf-8'));
+    if (stopped && isSupportedVersion(stopped)) return stopped;
+  } catch { /* nothing to read */ }
+  return null;
 }
 
-function getActiveRev4aModels(): { id: string; name: string; input?: string[] }[] {
+function getActiveRev4aModels(version?: string | null): { id: string; name: string; input?: string[] }[] {
   return loadOfferedModels()
     .map((m) => {
       const entry: { id: string; name: string; input?: string[] } = { id: m.id, name: m.name };
-      if (m.modality) entry.input = modalityToInput(m.modality);
+      if (m.modality) entry.input = modalityToInput(m.modality, version);
       return entry;
     });
 }
@@ -56,7 +99,23 @@ function firstLine(e: unknown): string {
 }
 
 /** A container carrying an AGENT_ID label, and whether it is running. */
-interface AgentContainer { name: string; running: boolean }
+interface AgentContainer { name: string; running: boolean; agentId: string }
+
+/**
+ * AGENT_IDs whose volume is being archived by a cold backup (lib/cold-backup.ts). Their
+ * config must not change while tar reads the volume; the next sync catches them up.
+ */
+function agentsUnderBackup(): Set<string> {
+  try {
+    const raw = execSync(
+      `docker ps --filter "label=rev4a.backup.agent" --format '{{.Label "rev4a.backup.agent"}}'`,
+      { timeout: 5000, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] },
+    ).trim();
+    return new Set(raw ? raw.split('\n').map((s) => s.trim()).filter(Boolean) : []);
+  } catch {
+    return new Set();
+  }
+}
 
 /**
  * Every container carrying an AGENT_ID label, running or stopped.
@@ -74,7 +133,7 @@ function getAgentContainers(): AgentContainer[] {
   let raw: string;
   try {
     raw = execSync(
-      `docker ps -a --filter "label=AGENT_ID" --format '{{.Names}}\t{{.State}}'`,
+      `docker ps -a --filter "label=AGENT_ID" --format '{{.Names}}\t{{.State}}\t{{.Label "AGENT_ID"}}'`,
       { timeout: 5000, maxBuffer: 64 * 1024, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'pipe'] },
     ).trim();
   } catch (e) {
@@ -83,8 +142,8 @@ function getAgentContainers(): AgentContainer[] {
   if (!raw) return [];
   return raw.split('\n')
     .map((line) => {
-      const [name, state] = line.split('\t');
-      return { name: (name ?? '').trim(), running: (state ?? '').trim() === 'running' };
+      const [name, state, agentId] = line.split('\t');
+      return { name: (name ?? '').trim(), running: (state ?? '').trim() === 'running', agentId: (agentId ?? '').trim() };
     })
     .filter((c) => c.name);
 }
@@ -184,10 +243,10 @@ function writeContainerJson(container: AgentContainer, remotePath: string, data:
  * Shared between the create route and syncAllAgents — single source of truth
  * for the provider block injected into every agent container.
  */
-export function buildRev4aProviderConfig(): { baseUrl: string; apiKey: string; api: string; models: { id: string; name: string; input?: string[] }[] } {
+export function buildRev4aProviderConfig(version?: string | null): { baseUrl: string; apiKey: string; api: string; models: { id: string; name: string; input?: string[] }[] } {
   const providerKeys = readProviderKeys();
   const rev4aApiKey = providerKeys['rev4a'] || '';
-  const activeModels = getActiveRev4aModels();
+  const activeModels = getActiveRev4aModels(version);
   return {
     baseUrl: PROVIDER_GATEWAY_BASE_URL,
     apiKey: rev4aApiKey,
@@ -211,7 +270,8 @@ export function patchRev4aProvider(container: string): void {
   if (bundledCatalogueStatus() === 'unavailable') {
     throw new Error('models.config.json could not be read; models.providers.rev4a left unchanged');
   }
-  const input = JSON.stringify({ models: { providers: { rev4a: buildRev4aProviderConfig() } } });
+  // The agent's own version: an older release rejects `input` values it does not know.
+  const input = JSON.stringify({ models: { providers: { rev4a: buildRev4aProviderConfig(containerVersionSync(container)) } } });
   execFileSync('docker', ['exec', '-i', container, 'sh', '-c', 'openclaw config patch --stdin'], {
     timeout: 15000,
     stdio: 'pipe',
@@ -293,9 +353,32 @@ export function syncAllAgents(): SyncOutcome {
   }
 
   outcome.total = containers.length;
+  const underBackup = agentsUnderBackup();
+  // Any long operation replaces or rewrites the container/config: skip the agent.
+  let busyAgents = new Set<string>();
+  try {
+    busyAgents = new Set([
+      ...activeUpdateAgentIds(),
+      ...activeRecreateAgentIds(),
+      ...activeRestoreAgentIds(),
+      ...activeEditAgentIds(),
+    ]);
+  } catch {
+    // No operation state readable: nothing to skip on that account.
+  }
   for (const container of containers) {
+    if (busyAgents.has(container.agentId)) {
+      outcome.failed.push({ container: container.name, error: 'an operation of this agent is running; it applies Rev4a config itself' });
+      continue;
+    }
+    if (underBackup.has(container.agentId)) {
+      outcome.failed.push({ container: container.name, error: 'a cold backup of this agent is running; sync again once it finishes' });
+      continue;
+    }
     try {
-      syncContainer(container, rev4aProviderConfig);
+      // Per agent: the `input` list follows the version that agent runs, so a 7.x
+      // release never receives a modality value it would reject.
+      syncContainer(container, buildRev4aProviderConfig(containerVersionSync(container.name)));
       outcome.synced.push(container.name);
       if (!container.running) outcome.stopped.push(container.name);
     } catch (e: unknown) {

package/app/api/setup/agent-image/route.ts

@@ -1,60 +1,36 @@
 /**
  * GET /api/setup/agent-image
  *
- * Checks if openclaw-agent-base:latest exists locally or needs downloading.
- * Returns status and a hint for the UI.
+ * Whether a supported OpenClaw version of the agent base image is downloaded.
+ * Returns `{ exists, version }`, the version being the newest one present.
  *
  * POST /api/setup/agent-image
  *
- * Downloads openclaw-agent-base:latest from ghcr.io (public registry).
- * Streams progress via SSE so the setup wizard can show a live progress bar.
+ * Downloads the newest supported version the registry publishes, and streams
+ * progress via SSE so the setup wizard can show a live progress bar. Nothing is
+ * downloaded when that version is already here.
  *
  * Only one download at a time — returns 409 if already running.
- * Cleans up the docker process if the client disconnects.
  */
 import { NextResponse, type NextRequest } from 'next/server';
 import { downloadAgentImage, getIsDownloading } from '@/lib/buildAgentImage';
-import { execSync } from 'child_process';
 import { requireAuthIfConfigured } from '@/lib/rev4a-auth';
+import { dockerAvailable } from '@/lib/docker-socket';
+import { listLocalAgentImages, newestLocalSupportedVersion } from '@/lib/agent-images';
 
 export const dynamic = 'force-dynamic';
 
-function dockerOk(): boolean {
-  try {
-    execSync('docker version --format "{{.Client.Version}}" 2>/dev/null', {
-      encoding: 'utf-8',
-      timeout: 2000,
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 export async function GET(request: NextRequest): Promise<NextResponse> {
   const denied = await requireAuthIfConfigured(request);
   if (denied) return denied;
-  if (!dockerOk()) {
-    return NextResponse.json({ exists: false });
+  if (!dockerAvailable()) {
+    return NextResponse.json({ exists: false, version: null });
   }
   try {
-    const { exec } = await import('child_process');
-    const result = await new Promise<string>((resolve, reject) => {
-      exec(
-        'docker image inspect openclaw-agent-base:latest --format "{{.ID}}" 2>/dev/null',
-        { timeout: 5000 },
-        (err, stdout) => {
-          if (err) return reject(err);
-          resolve(stdout.trim());
-        },
-      );
-    });
-    if (result) {
-      return NextResponse.json({ exists: true, imageId: result });
-    }
-    return NextResponse.json({ exists: false });
+    const version = newestLocalSupportedVersion(await listLocalAgentImages());
+    return NextResponse.json({ exists: version !== null, version });
   } catch {
-    return NextResponse.json({ exists: false });
+    return NextResponse.json({ exists: false, version: null });
   }
 }
 
@@ -81,11 +57,7 @@ export async function POST(request: NextRequest): Promise<Response> {
       const ctrl = controller as ReadableStreamDefaultController & { signal?: AbortSignal };
 
       try {
-        await downloadAgentImage({
-          force: false, // setup: skip if already exists
-          onEvent: send,
-          signal: ctrl.signal,
-        });
+        await downloadAgentImage({ onEvent: send, signal: ctrl.signal });
       } catch (e: unknown) {
         send(JSON.stringify({
           type: 'error',
@@ -94,7 +66,7 @@ export async function POST(request: NextRequest): Promise<Response> {
       }
       controller.close();
     },
-    cancel() { /* downloadAgentImage handles cleanup via signal */ },
+    cancel() { /* downloadAgentImage stops the docker process through the signal */ },
   });
 
   return new Response(stream, {

package/app/api/version/route.ts

@@ -15,7 +15,8 @@ export const dynamic = 'force-dynamic';
  * GET /api/version
  *
  * Returns the installed Rev4a version from package.json.
- * No auth required.
+ *
+ * Auth: the rev4a_token cookie or Authorization: Bearer <REV4A_TOKEN>.
  */
 export async function GET(request: NextRequest): Promise<NextResponse> {
   const denied = await requireAuthJWT(request); if (denied) return denied as any;

package/app/components/DashboardToolbar.tsx

@@ -32,7 +32,7 @@ export default function DashboardToolbar({ filter, onChange, agents = ['all'] }:
         className={`agent-btn ${filter.showOnlyActive ? 'active' : ''}`}
         onClick={() => onChange({ showOnlyActive: !filter.showOnlyActive })}
       >
-        solo attivi
+        active only
       </button>
 
       <button

package/app/gateway/PageClient.tsx

@@ -88,7 +88,7 @@ export default function GatewayPageClient() {
   const [modelSearch, setModelSearch] = useState<Record<string, string>>({});
 
   // Balance fetch state (per provider)
-  const [balances, setBalances] = useState<Record<string, { balance: string; label?: string; loading?: boolean; error?: string } | null>>({});
+  const [balances, setBalances] = useState<Record<string, { balance: string; label?: string; loading?: boolean; error?: string; unsupported?: boolean } | null>>({});
   const [fetchingBalance, setFetchingBalance] = useState<Record<string, boolean>>({});
 
   // Accordion state — which provider cards are expanded
@@ -135,6 +135,9 @@ export default function GatewayPageClient() {
             const bJson = await bRes.json();
             if (bRes.ok && bJson.balance) {
               setBalances((prev) => ({ ...prev, [bp]: { balance: bJson.balance, label: bJson.label } }));
+            } else if (bJson.reason === 'no-balance-api') {
+              // Permanent: this provider has no balance API for the account — hide the badge.
+              setBalances((prev) => ({ ...prev, [bp]: { balance: '', unsupported: true } }));
             } else {
               setBalances((prev) => ({ ...prev, [bp]: { balance: '—', error: bJson.error || 'Failed' } }));
             }
@@ -198,6 +201,8 @@ export default function GatewayPageClient() {
       const json = await res.json();
       if (res.ok && json.balance) {
         setBalances((prev) => ({ ...prev, [provider]: { balance: json.balance, label: json.label } }));
+      } else if (json.reason === 'no-balance-api') {
+        setBalances((prev) => ({ ...prev, [provider]: { balance: '', unsupported: true } }));
       } else {
         setBalances((prev) => ({ ...prev, [provider]: { balance: '—', error: json.error || 'Failed' } }));
       }
@@ -519,43 +524,33 @@ export default function GatewayPageClient() {
                 <span style={{ marginLeft: 'auto', fontSize: 11, color: 'var(--text-dim)' }}>
                   {p.models.length} models
                 </span>
-                {/* Balance badge — auto-loaded for supported providers with configured key */}
-                {p.configured && ['deepseek','openrouter','glm'].includes(p.provider) && (
-                  balances[p.provider] && !balances[p.provider]?.error ? (
-                    <span
-                      title={balances[p.provider]?.label || ''}
-                      onClick={(e) => { e.stopPropagation(); fetchBalance(p.provider); }}
-                      style={{
-                        fontSize: 11, fontWeight: 600,
-                        color: 'var(--green)',
-                        background: 'rgba(var(--green-rgb,34,197,94),0.1)',
-                        padding: '2px 8px', borderRadius: 0,
-                        border: '1px solid rgba(var(--green-rgb,34,197,94),0.2)',
-                        cursor: 'pointer',
-                      }}
-                    >
-                      {balances[p.provider]!.balance}
-                    </span>
-                  ) : (
-                    <span
-                      onClick={(e) => { e.stopPropagation(); fetchBalance(p.provider); }}
-                      style={{
-                        fontSize: 11,
-                        color: 'var(--text-dim)',
-                        opacity: 0.5,
-                        cursor: 'pointer',
-                      }}
-                    >
-                      {fetchingBalance[p.provider] ? '…' : '…'}
-                    </span>
-                  )
+                {/* Balance badge — auto-loaded for supported providers with configured key.
+                    Same squared chip in every state: "..." while loading, "—" (dimmed, tooltip) on error.
+                    Hidden entirely when the provider has no balance API for the account (permanent). */}
+                {p.configured && ['deepseek','openrouter','glm'].includes(p.provider) && !balances[p.provider]?.unsupported && (
+                  <button
+                    type="button"
+                    title={balances[p.provider]?.error || balances[p.provider]?.label || ''}
+                    onClick={(e) => { e.stopPropagation(); fetchBalance(p.provider); }}
+                    style={{
+                      fontSize: 11, fontWeight: 600,
+                      color: 'var(--green)',
+                      background: 'rgba(var(--green-rgb,34,197,94),0.1)',
+                      padding: '2px 8px', borderRadius: 0,
+                      border: '1px solid rgba(var(--green-rgb,34,197,94),0.2)',
+                      cursor: 'pointer',
+                      opacity: balances[p.provider]?.error ? 0.5 : 1,
+                    }}
+                  >
+                    {balances[p.provider] && !balances[p.provider]?.error ? balances[p.provider]!.balance : balances[p.provider]?.error ? '—' : '...'}
+                  </button>
                 )}
               </div>
 
               {/* Accordion body — expandable */}
               {isExpanded && (
                 <div style={{ padding: '0 18px 16px 18px', display: 'grid', gap: 14, borderTop: '1px solid var(--border)', paddingTop: 14 }}>
-                  {/* API Key input con show/hide integrato */}
+                  {/* API Key input with an inline show/hide toggle */}
                   <div style={{ display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap' }}>
                     <PasswordInput
                       value={apiKeyInputs[p.provider] ?? ''}

package/bin/rev4a.js

@@ -41,8 +41,8 @@ const DATA_DIR = join(CONFIG_DIR, 'data');
 const ENV_SOURCE = join(CONFIG_DIR, '.env');
 const ENV_LINK = join(ROOT, '.env');
 const DOCKERFILE = join(ROOT, 'agent-templates', 'base-image', 'Dockerfile');
-const AGENT_IMAGE = 'openclaw-agent-base:latest';
-const AGENT_IMAGE_REGISTRY = 'ghcr.io/flame0510/rev4a/openclaw-agent-base:latest';
+// Supported OpenClaw versions and image repositories, shared with the server.
+const AGENT_VERSIONS = require(join(ROOT, 'lib', 'agent-versions.json'));
 const DOCKER_NETWORK = 'rev4a-network';
 // How long `serve` waits for the Docker daemon before starting without it. Like
 // REV4A_DATA_DIR it is read from the real process environment (a systemd
@@ -204,55 +204,57 @@ function ensureDocker() {
 function ensureAgentImage() {
   if (!hasCmd('docker')) return; // Docker not available — skip, warn later
 
-  // Check if image already exists locally
+  // The newest OpenClaw version this release supports, kept under its version tag.
+  // `:latest` is never used: an agent's version decides its data schema.
+  const version = AGENT_VERSIONS.supported[0].version;
+  const localRef = `${AGENT_VERSIONS.localRepository}:${version}`;
+  const registry = (process.env.REV4A_AGENT_IMAGE_REGISTRY || '').trim() || AGENT_VERSIONS.registryRepository;
+  const remoteRef = `${registry}:${version}`;
+
   try {
-    const r = execSync(
-      `docker image inspect ${AGENT_IMAGE} --format '{{.Id}}'`,
-      { stdio: 'pipe', timeout: 10_000 },
-    );
+    const r = execSync(`docker image inspect ${localRef} --format '{{.Id}}'`, { stdio: 'pipe', timeout: 10_000 });
     if (r.toString().trim()) {
-      log('IMAGE', `Agent base image ${AGENT_IMAGE} already exists`);
+      log('IMAGE', `Agent base image ${localRef} already exists`);
       return;
     }
   } catch {
-    // Image doesn't exist locally
+    // Not downloaded yet
   }
 
-  log('IMAGE', `Pulling agent base image from ${AGENT_IMAGE_REGISTRY}…`);
-
+  log('IMAGE', `Pulling agent base image ${remoteRef}…`);
   try {
-    execSync(`docker pull ${AGENT_IMAGE_REGISTRY}`, {
-      stdio: 'inherit',
-      timeout: 300_000, // 5 min timeout
-    });
-    // Tag locally for Rev4a internal use
-    execSync(`docker tag ${AGENT_IMAGE_REGISTRY} ${AGENT_IMAGE}`, {
-      stdio: 'inherit',
-      timeout: 10_000,
-    });
-    log('IMAGE', `Agent base image pulled and tagged as ${AGENT_IMAGE}`);
+    execSync(`docker pull ${remoteRef}`, { stdio: 'inherit', timeout: 1_800_000 });
+    execSync(`docker tag ${remoteRef} ${localRef}`, { stdio: 'inherit', timeout: 10_000 });
+    try {
+      execSync(`docker rmi ${remoteRef}`, { stdio: 'pipe', timeout: 30_000 }); // untag; the layers stay
+    } catch { /* keeping the registry reference is harmless */ }
+    log('IMAGE', `Agent base image pulled and tagged as ${localRef}`);
+    return;
   } catch {
-    log('IMAGE', `⚠ Pull from registry failed — attempting local build as fallback…`);
-
-    if (!existsSync(DOCKERFILE)) {
-      log('IMAGE', `⚠ Agent base image Dockerfile not found at ${DOCKERFILE}`);
-      log('IMAGE', '  Agent creation will be unavailable until the image is available.');
-      return;
-    }
+    log('IMAGE', '⚠ Pull from registry failed');
+  }
 
-    log('IMAGE', `Building agent base image ${AGENT_IMAGE} (this will take a few minutes)…`);
-    log('IMAGE', '  → pulling node:24-bookworm-slim + installing OpenClaw + tooling');
+  // A local build is only the same image when this Dockerfile builds that version.
+  const dockerfileVersion = existsSync(DOCKERFILE)
+    ? (/^ARG OPENCLAW_VERSION=(\S+)/m.exec(readFileSync(DOCKERFILE, 'utf-8')) || [])[1] || null
+    : null;
+  if (dockerfileVersion !== version) {
+    log('IMAGE', `  The Dockerfile here builds ${dockerfileVersion || 'no version'}, not ${version}: no local build.`);
+    log('IMAGE', '  Agent creation will be unavailable until the image is downloaded from the Agents page.');
+    return;
+  }
 
-    try {
-      execSync(`docker build -t ${AGENT_IMAGE} -f "${DOCKERFILE}" "${join(DOCKERFILE, '..')}"`, {
-        stdio: 'inherit',
-        timeout: 600_000, // 10 min timeout
-      });
-      log('IMAGE', `Agent base image built successfully`);
-    } catch {
-      log('IMAGE', '⚠ Agent base image build failed. Agent creation will be unavailable.');
-      log('IMAGE', '  Pull the image manually: docker pull ' + AGENT_IMAGE_REGISTRY);
-    }
+  log('IMAGE', `Building agent base image ${localRef} (this will take a few minutes)…`);
+  log('IMAGE', '  → pulling node:24-bookworm-slim + installing OpenClaw + tooling');
+  try {
+    execSync(
+      `docker build --build-arg OPENCLAW_VERSION=${version} -t ${localRef} -f "${DOCKERFILE}" "${join(DOCKERFILE, '..')}"`,
+      { stdio: 'inherit', timeout: 3_600_000 },
+    );
+    log('IMAGE', 'Agent base image built successfully');
+  } catch {
+    log('IMAGE', '⚠ Agent base image build failed. Agent creation will be unavailable.');
+    log('IMAGE', `  Pull it manually: docker pull ${remoteRef} && docker tag ${remoteRef} ${localRef}`);
   }
 }
 
@@ -639,7 +641,7 @@ EXAMPLES:
 On first run, rev4a serve automatically:
   • Generates .env (JWT secret + API token)
   • Installs Docker if missing (requires root)
-  • Builds the agent base image (openclaw-agent-base:latest)
+  • Downloads the agent base image for the newest supported OpenClaw version
   • Builds the Next.js app if no build is found
   • Starts Next.js, daemon, and terminal WebSocket as a single process group
   • Cleanly stops all services on Ctrl+C / SIGTERM

package/daemon.js

@@ -668,12 +668,12 @@ function pollSessions() {
   // ── Timeout Detection ────────────────────────────────────────────────────
   // Find sub-agents that were 'working' in the last snapshot but are no longer
   // present in the current output and have been missing for more than 10 minutes.
-  // Questi vengono marcati come 'timeout' nella tabella events.
-  const TIMEOUT_THRESHOLD_MS = 10 * 60 * 1000; // 10 minuti
+  // These are recorded as 'timeout' in the events table.
+  const TIMEOUT_THRESHOLD_MS = 10 * 60 * 1000; // 10 minutes
   for (const [session_id, snap] of knownSessions) {
     // Only sub-agents (contain 'subagent' in the key)
     if (!session_id.includes('subagent')) continue;
-    // Solo se erano working nell'ultimo poll
+    // Only if they were working in the last poll
     if (snap.status !== 'working') continue;
     // Only if not present in the current poll
     if (currentIds.has(session_id)) continue;
@@ -694,10 +694,10 @@ function pollSessions() {
       data: JSON.stringify({
         missing_for_ms: missingFor,
         last_status: snap.status,
-        message: `Subagente missing dopo ${Math.round(missingFor / 60000)}min senza completare`,
+        message: `Subagent missing for ${Math.round(missingFor / 60000)} min without completing`,
       }),
     });
-    log(`[TIMEOUT] ${session_id} missing da ${Math.round(missingFor / 60000)}min`);
+    log(`[TIMEOUT] ${session_id} missing for ${Math.round(missingFor / 60000)} min`);
 
     // Notify Michele via openclaw message (only if openclaw is available)
     try {
@@ -708,7 +708,7 @@ function pollSessions() {
         'message', 'send',
         '--account', 'ops',
         '--target', '297086793',
-        '--text', `⚠️ Rev4a: agent timeout\n\`${session_id.slice(-36)}\`\nMissing for ${Math.round(missingFor / 60000)} min senza completare.`,
+        '--text', `⚠️ Rev4a: agent timeout\n\`${session_id.slice(-36)}\`\nMissing for ${Math.round(missingFor / 60000)} min without completing.`,
       ], { encoding: 'utf8', timeout: 10_000, killSignal: 'SIGKILL' });
     } catch (e) {
       log(`[TIMEOUT] Telegram notification failed: ${e.message}`);