@vibedeckx/linux-x64 0.3.26 → 0.3.27

package/dist/bin.js

@@ -186425,6 +186425,10 @@ var createRemoteServerRepos = (kdb, _h) => ({
       ]).where("project_remotes.project_id", "=", projectId).orderBy("project_remotes.sort_order", "asc").orderBy("project_remotes.id", "asc").execute();
       return rows.map(mapProjectRemoteWithServer);
     },
+    listProjectIdsByServer: async (remoteServerId) => {
+      const rows = await kdb.selectFrom("project_remotes").select("project_id").distinct().where("remote_server_id", "=", remoteServerId).execute();
+      return rows.map((r) => r.project_id);
+    },
     getByProjectAndServer: async (projectId, remoteServerId) => {
       const row = await kdb.selectFrom("project_remotes").innerJoin("remote_servers", "remote_servers.id", "project_remotes.remote_server_id").select([
         "project_remotes.id",
@@ -207274,8 +207278,10 @@ var ClaudeCodeProvider = class {
       if (systemMsg.subtype === BACKGROUND_TASKS_CHANGED_SUBTYPE) {
         const tasks = msg.tasks;
         if (!Array.isArray(tasks)) return [];
-        const taskIds = tasks.map((t) => t.task_id).filter((id) => typeof id === "string");
-        return [{ type: "task_list_changed", taskIds }];
+        const parsed = tasks.flatMap(
+          (t) => typeof t.task_id === "string" ? [{ taskId: t.task_id, taskType: t.task_type, description: t.description }] : []
+        );
+        return [{ type: "task_list_changed", tasks: parsed }];
       }
       if (systemMsg.subtype === INIT_SUBTYPE) {
         const nativeId = msg.session_id;
@@ -229445,7 +229451,7 @@ var ResidentProcessLimitError = class extends Error {
 var COMPLETION_GRACE_MS = 1500;
 var TurnCompletionLedger = class {
   /** Live background tasks by harness task_id (same id may restart). */
-  tasks = /* @__PURE__ */ new Set();
+  tasks = /* @__PURE__ */ new Map();
   /** Held completion candidate — the latest success result, if any. */
   pending = null;
   /** Bumped whenever the candidate changes; stale grace timers no-op. */
@@ -229462,8 +229468,12 @@ var TurnCompletionLedger = class {
   get hasPendingCompletion() {
     return this.pending !== null;
   }
-  taskStarted(taskId) {
-    this.tasks.add(taskId);
+  /** Live tasks in first-seen order — the payload the UI renders. */
+  get backgroundTasks() {
+    return [...this.tasks.values()];
+  }
+  taskStarted(task, now3) {
+    this.upsert(task, this.tasks.get(task.taskId), now3);
     this.sawBackgroundActivity = true;
     return this.rearmIfHeld();
   }
@@ -229473,9 +229483,13 @@ var TurnCompletionLedger = class {
     return this.rearmIfHeld();
   }
   /** Authoritative snapshot from `system/background_tasks_changed`. */
-  taskListChanged(taskIds) {
-    this.tasks = new Set(taskIds);
-    if (taskIds.length > 0) this.sawBackgroundActivity = true;
+  taskListChanged(tasks, now3) {
+    const previous = this.tasks;
+    this.tasks = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      this.upsert(task, previous.get(task.taskId), now3);
+    }
+    if (tasks.length > 0) this.sawBackgroundActivity = true;
     return this.rearmIfHeld();
   }
   /**
@@ -229561,6 +229575,21 @@ var TurnCompletionLedger = class {
     if (this.tasks.size > 0) return { kind: "cancel" };
     return { kind: "schedule", generation: this.generation };
   }
+  /**
+   * Merge a descriptor into the live set, keeping the earliest `startedAt` and
+   * any label already known: `task_started` carries a description that the
+   * snapshot for the same task may omit, and the two arrive in either order.
+   * `known` comes from the caller: a snapshot resync rebuilds the map, so the
+   * prior entry is no longer reachable through `this.tasks`.
+   */
+  upsert(task, known, now3) {
+    this.tasks.set(task.taskId, {
+      taskId: task.taskId,
+      taskType: task.taskType ?? known?.taskType,
+      description: task.description ?? known?.description,
+      startedAt: known?.startedAt ?? now3
+    });
+  }
   commitHeld() {
     const payload = this.pending;
     this.pending = null;
@@ -230226,6 +230255,7 @@ var AgentSessionManager = class {
         if (action.kind === "commit") {
           await this.commitCompletion(session, action.payload);
         }
+        this.broadcastBackgroundTasks(session);
         if (code !== 0 && !spawnFailed && !session.producedOutput) {
           try {
             await this.pushEntry(session.id, {
@@ -230332,12 +230362,27 @@ var AgentSessionManager = class {
   resetCompletion(session) {
     this.clearGraceTimer(session);
     session.completion.reset();
+    this.broadcastBackgroundTasks(session);
   }
   /**
    * The single place completion side effects run. Fired by processAgentEvent
    * for turns with no background activity (zero delay), by the grace timer
    * for held candidates, and by the close handler on a clean process exit.
    */
+  /**
+   * Push the live background-task set to every subscriber. Called on each
+   * lifecycle event rather than diffed: the set is tiny and the harness
+   * already only speaks on change, so a plain snapshot keeps the client
+   * stateless (no patch application, no ordering assumptions).
+   */
+  broadcastBackgroundTasks(session) {
+    this.broadcastRaw(session.id, {
+      backgroundTasks: {
+        tasks: session.completion.backgroundTasks,
+        turnParked: session.completion.hasPendingCompletion
+      }
+    });
+  }
   async commitCompletion(session, payload) {
     const sessionId = session.id;
     console.log(`[AgentSession] taskCompleted: sessionId=${sessionId}, eventBus=${!!this.eventBus}, projectId=${session.projectId}, branch=${session.branch}`);
@@ -230346,6 +230391,7 @@ var AgentSessionManager = class {
       await this.storage.agentSessions.markCompleted(sessionId, completedAt);
     }
     const turnEndEntryIndex = await this.endActiveTurn(session, "completed");
+    this.broadcastBackgroundTasks(session);
     const summaryText = extractLastAssistantText(session.store.entries);
     this.broadcastRaw(sessionId, {
       taskCompleted: {
@@ -230526,19 +230572,26 @@ var AgentSessionManager = class {
       // no auto-resume behind it, and cancelling on it would drop the
       // completion entirely.
       case "task_started":
-        this.applyCompletionTimerAction(session, session.completion.taskStarted(event.taskId));
+        this.applyCompletionTimerAction(session, session.completion.taskStarted({
+          taskId: event.taskId,
+          taskType: event.taskType,
+          description: event.description
+        }, timestamp));
         session.taskStartedThisTurn++;
+        this.broadcastBackgroundTasks(session);
         console.log(`[AgentSession] Background task started: ${event.taskId} (${event.taskType ?? "?"}) \u2014 ${session.completion.pendingTaskCount} pending in ${sessionId}`);
         break;
       case "task_finished":
         this.applyCompletionTimerAction(session, session.completion.taskFinished(event.taskId));
+        this.broadcastBackgroundTasks(session);
         console.log(`[AgentSession] Background task finished: ${event.taskId} (${event.status ?? "?"}) \u2014 ${session.completion.pendingTaskCount} pending in ${sessionId}`);
         break;
       // Authoritative running-task snapshot from the CLI — resyncs the ledger
       // so add/delete drift in the started/finished pairs can't accumulate.
       case "task_list_changed":
-        this.applyCompletionTimerAction(session, session.completion.taskListChanged(event.taskIds));
-        console.log(`[AgentSession] Background task snapshot: [${event.taskIds.join(", ")}] in ${sessionId}`);
+        this.applyCompletionTimerAction(session, session.completion.taskListChanged(event.tasks, timestamp));
+        this.broadcastBackgroundTasks(session);
+        console.log(`[AgentSession] Background task snapshot: [${event.tasks.map((t) => t.taskId).join(", ")}] in ${sessionId}`);
         break;
       // Handled above (cancels a grace-held completion); no store entry.
       case "turn_started":
@@ -230609,6 +230662,7 @@ var AgentSessionManager = class {
               console.log(`[AgentSession] result after background-task activity \u2014 holding completion for ${this.completionGraceMs}ms grace (session=${sessionId})`);
             }
             this.applyCompletionTimerAction(session, action);
+            this.broadcastBackgroundTasks(session);
           }
         }
         break;
@@ -230941,6 +230995,13 @@ var AgentSessionManager = class {
     ws.send(JSON.stringify({ Ready: true, historyEpoch: session.historyEpoch }));
     const statusPatch = ConversationPatch.updateStatus(session.status);
     ws.send(JSON.stringify({ JsonPatch: statusPatch }));
+    const tasksMsg = {
+      backgroundTasks: {
+        tasks: session.completion.backgroundTasks,
+        turnParked: session.completion.hasPendingCompletion
+      }
+    };
+    ws.send(JSON.stringify(tasksMsg));
     return () => {
       session.subscribers.delete(ws);
     };
@@ -231228,6 +231289,7 @@ var AgentSessionManager = class {
     session.process = null;
     this.killProcess(proc);
     this.emitProcessAlive(session, false);
+    this.resetCompletion(session);
     if (!session.skipDb) {
       await this.storage.agentSessions.deleteEntries(sessionId);
       session.historyEpoch = await this.storage.agentSessions.incrementHistoryEpoch(sessionId);
@@ -233597,6 +233659,9 @@ function connectPersistentRemoteWs(sessionId, remoteInfo, cache2, reverseConnect
           );
         }
       }
+    } else if ("backgroundTasks" in parsed) {
+      cache2.setBackgroundTasks(sessionId, raw);
+      cache2.broadcast(sessionId, raw);
     } else if ("error" in parsed) {
       cache2.setSessionStatus(sessionId, "error");
       cache2.appendMessage(sessionId, raw, false);
@@ -239414,6 +239479,8 @@ function selfReportSection(report) {
   ].join("\n");
 }
 var VERDICT_INSTRUCTIONS = [
+  "\nThe bar for blocking: a real defect that is worth fixing \u2014 wrong behavior, a case a user or caller will actually hit, a security or data-loss risk, or a missing test for logic that matters. Report those plainly; do not soften a real problem because the fix is inconvenient.",
+  "Not blocking: over-engineering \u2014 speculative hardening, defenses against inputs this code cannot receive, abstractions or configurability for cases nobody has asked for, or a rewrite in your preferred style. When the fix would add more complexity than the problem it prevents is worth, it is a non-blocking note at most.",
   "\nEnd your final message with:",
   "1. Verdict \u2014 exactly one of: ship / needs-changes / cannot-verify. Use cannot-verify when you could not gather enough evidence to judge, rather than guessing.",
   "2. Blocking findings \u2014 what must change before shipping, each specific and actionable (say explicitly when there are none).",
@@ -240101,7 +240168,8 @@ var RemotePatchCache = class {
         latestEntryIndex: null,
         lastTurnEndEntryIndex: null,
         coverage: null,
-        sessionStatus: null
+        sessionStatus: null,
+        backgroundTasks: null
       };
       this.cache.set(sessionId, entry);
     }
@@ -240149,6 +240217,7 @@ var RemotePatchCache = class {
       if (metadata.lastTurnEnd !== null) lastTurnEndEntryIndex = Math.max(lastTurnEndEntryIndex ?? -1, metadata.lastTurnEnd);
     }
     const sessionStatus = existing?.sessionStatus ?? null;
+    const backgroundTasks = existing?.backgroundTasks ?? null;
     const coverage = existing?.coverage ?? null;
     this.cache.set(sessionId, {
       messages,
@@ -240164,7 +240233,8 @@ var RemotePatchCache = class {
       latestEntryIndex,
       lastTurnEndEntryIndex,
       coverage,
-      sessionStatus
+      sessionStatus,
+      backgroundTasks
     });
   }
   /**
@@ -240229,6 +240299,7 @@ var RemotePatchCache = class {
     entry.historyEpoch = epoch;
     entry.latestEntryIndex = null;
     entry.lastTurnEndEntryIndex = null;
+    entry.backgroundTasks = null;
     entry.coverage = { epoch, start: 0 };
   }
   setLastTurnEndEntryIndex(sessionId, index) {
@@ -240237,6 +240308,10 @@ var RemotePatchCache = class {
   setSessionStatus(sessionId, status) {
     this.getOrCreate(sessionId).sessionStatus = status;
   }
+  /** Last-value store for the live background-task snapshot (see CacheEntry). */
+  setBackgroundTasks(sessionId, raw) {
+    this.getOrCreate(sessionId).backgroundTasks = raw;
+  }
   /** Store a persistent remote WebSocket connection. */
   setRemoteWs(sessionId, ws) {
     const entry = this.getOrCreate(sessionId);
@@ -243265,6 +243340,13 @@ var sharedServices = async (fastify2, opts) => {
   reverseConnectManager.setStatusChangeHandler((remoteServerId, status) => {
     void (async () => {
       await opts.storage.remoteServers.updateStatus(remoteServerId, status);
+      try {
+        for (const projectId of await opts.storage.projectRemotes.listProjectIdsByServer(remoteServerId)) {
+          eventBus.emit({ type: "remote-server:status", projectId, remoteServerId, status });
+        }
+      } catch (err) {
+        console.error(`[SharedServices] remote-server:status fan-out failed for ${remoteServerId}:`, err);
+      }
       if (status === "online") {
         const machineId = reverseConnectManager.getMachineId(remoteServerId);
         await restoreRemoteExecutorsForServer(remoteServerId, machineId);
@@ -251877,6 +251959,12 @@ var routes23 = async (fastify2) => {
               socket.send(JSON.stringify({ Ready: true, historyEpoch: cacheEntry.historyEpoch ?? void 0 }));
             } catch {
             }
+            if (cacheEntry.backgroundTasks !== null) {
+              try {
+                socket.send(cacheEntry.backgroundTasks);
+              } catch {
+              }
+            }
             if (cacheEntry.finished) {
               try {
                 socket.send(JSON.stringify({ finished: true }));
@@ -252264,6 +252352,11 @@ var routes25 = async (fastify2) => {
       "Access-Control-Allow-Origin": "*"
     });
     reply.raw.write(":ok\n\n");
+    reply.raw.write(
+      `data: ${JSON.stringify({ type: "hello", ...fastify2.uiBuildId ? { uiBuildId: fastify2.uiBuildId } : {} })}
+
+`
+    );
     const unsubscribe = fastify2.eventBus.subscribe((event) => {
       void (async () => {
         if (userId !== null && !await fastify2.storage.projects.getById(event.projectId, userId)) {
@@ -258633,6 +258726,8 @@ var REMOTE_ID_PROP = {
 };
 var CROSS_REMOTE_MCP_INSTRUCTIONS = [
   "Use these tools when the task requires inspecting or operating another remote machine, or using an MCP server reachable from that remote.",
+  "Treat a machine or host name in the user's request (for example, 'look at the ubuntu machine') as an explicit target signal, not as a request to inspect the current local workspace. Call `list_accessible_remotes` and match the user's wording against the returned remote names and ids before reading files or running local commands.",
+  "If exactly one accessible remote matches the named machine, perform the requested work on that remote. If multiple remotes match, or the wording could reasonably refer to either the local machine or a remote, ask the user which target they mean before operating. If no remote matches, say so instead of silently falling back to local.",
   "Cross-remote can discover accessible machines, inspect files, directories, paths, and processes, run commands on exec-tier remotes, and persistently use MCP servers reachable from those remotes. Available operations depend on the remote's access tier, online state, and worker capabilities.",
   "Call `list_accessible_remotes` first to discover the remote id, access tier, online state, and whether its MCP broker is supported.",
   "For a remote MCP server, call `remote_mcp_open` once, use the returned tool schemas and handle for repeated `remote_mcp_call` calls, then call `remote_mcp_close` when the work is complete. Do not reopen the MCP server for every tool call.",
@@ -258643,7 +258738,7 @@ var CROSS_REMOTE_MCP_INSTRUCTIONS = [
 var TOOLS = [
   {
     name: "list_accessible_remotes",
-    description: "List the remote machines this agent may access, with their access tier and online status.",
+    description: "List remote machines this agent may access, including their names, ids, access tiers, and online status. Call this before acting whenever the user names or otherwise identifies a machine/host, so the request is routed to the intended target instead of the current local machine.",
     inputSchema: { type: "object", properties: {}, additionalProperties: false }
   },
   {
@@ -259996,6 +260091,12 @@ function registerTraceContext(server) {
 
 // src/server.ts
 var API_KEY2 = process.env.VIBEDECKX_API_KEY || void 0;
+function staticCacheControl(filePath) {
+  const p2 = filePath.replace(/\\/g, "/");
+  if (p2.includes("/_next/static/")) return "public, max-age=31536000, immutable";
+  if (p2.endsWith(".html") || p2.endsWith(".txt")) return "no-cache";
+  return "public, max-age=86400";
+}
 function requireAuth(req, reply) {
   const server = req.server;
   if (!server.authEnabled) return void 0;
@@ -260045,6 +260146,14 @@ var createServer = async (opts) => {
     "./ui"
   );
   const UI_ROOT = opts.uiRoot !== void 0 ? opts.uiRoot : fs5.existsSync(bakedUiRoot) ? bakedUiRoot : null;
+  let uiBuildId;
+  if (UI_ROOT) {
+    try {
+      const parsed = JSON.parse(fs5.readFileSync(path19.join(UI_ROOT, "build-id.json"), "utf8"));
+      if (typeof parsed.buildId === "string" && parsed.buildId) uiBuildId = parsed.buildId;
+    } catch {
+    }
+  }
   const server = (0, import_fastify.default)({
     maxParamLength: 500,
     bodyLimit: 16 * 1024 * 1024,
@@ -260071,6 +260180,7 @@ var createServer = async (opts) => {
     console.log(`[WS-RAW] HTTP upgrade event: ${redactUrlForLog(req.url)}`);
   });
   server.decorate("authEnabled", authEnabled);
+  server.decorate("uiBuildId", uiBuildId);
   server.decorate("noLocalProjects", noLocalProjects);
   registerTraceContext(server);
   server.addHook("onRequest", (req, reply, done) => {
@@ -260185,7 +260295,14 @@ var createServer = async (opts) => {
   if (UI_ROOT) {
     server.register(import_static.fastifyStatic, {
       root: UI_ROOT,
-      wildcard: false
+      wildcard: false,
+      // Cache policy is ours, not send's default (`public, max-age=0`): with no
+      // origin Cache-Control, Cloudflare was stamping a 4h TTL on every asset
+      // and every reload re-downloaded ~1.2MB of content-hashed chunks.
+      cacheControl: false,
+      setHeaders: (res, filePath) => {
+        res.setHeader("Cache-Control", staticCacheControl(filePath));
+      }
     });
   }
   server.addHook("onError", (req, _reply, error48, done) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibedeckx/linux-x64",
-  "version": "0.3.26",
+  "version": "0.3.27",
   "description": "Vibedeckx platform binaries for Linux x64",
   "os": [
     "linux"