@vibedeckx/linux-x64 0.3.26 → 0.3.28

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",
@@ -207169,7 +207173,7 @@ function sessionMilestoneForTurnEnd(opts) {
     workflow_run_id: null,
     created_at: opts.createdAt
   };
-  if (opts.outcome === "completed") {
+  if (opts.outcome === "completed" || opts.outcome === "completed_with_pending_tasks") {
     return {
       ...base,
       id: sessionResultReadyId(opts.sessionId, opts.entryIndex),
@@ -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;
@@ -207306,6 +207312,25 @@ var ClaudeCodeProvider = class {
   formatUserInput(content, _sessionId) {
     return serializeUserInput(content);
   }
+  /**
+   * `stop_task` control_request — the documented Agent SDK primitive for
+   * killing one background task, verified live against claude 2.1.238: the CLI
+   * answers `control_response { subtype: "success" }`, empties its task list
+   * and the process really dies.
+   *
+   * `request_id` is namespaced by task id so a response could be correlated;
+   * nothing reads control_response today, and it does not need to — the
+   * authoritative `background_tasks_changed` snapshot that follows is what
+   * updates the ledger. An older CLI that does not know the subtype answers an
+   * error and simply changes nothing.
+   */
+  formatStopBackgroundTask(taskId, _sessionId) {
+    return JSON.stringify({
+      type: "control_request",
+      request_id: `stop_task-${taskId}`,
+      request: { subtype: "stop_task", task_id: taskId }
+    }) + "\n";
+  }
   // Lifecycle hooks are no-ops for Claude (stateless per-session)
   onSessionCreated(_sessionId, _permissionMode) {
   }
@@ -229421,7 +229446,7 @@ function isResidentProcessInScope(candidate, scope) {
   return candidate.projectId === scope.projectId && candidate.branch === scope.branch;
 }
 function isIdleResidentProcess(candidate) {
-  return candidate.processAlive && !candidate.dormant && candidate.status !== "running" && candidate.backgroundTaskCount === 0;
+  return candidate.processAlive && !candidate.dormant && candidate.status !== "running" && !candidate.backgroundTasksProtect;
 }
 function pickIdleResidentEvictionCandidate(candidates, scope) {
   return candidates.filter((candidate) => !scope || isResidentProcessInScope(candidate, scope)).filter(isIdleResidentProcess).sort((a, b2) => a.lastActiveAt - b2.lastActiveAt)[0] ?? null;
@@ -229443,9 +229468,14 @@ var ResidentProcessLimitError = class extends Error {
 
 // src/turn-completion.ts
 var COMPLETION_GRACE_MS = 1500;
+var PARK_TIMEOUT_MS = 20 * 60 * 1e3;
 var TurnCompletionLedger = class {
+  constructor(parkTimeoutMs = PARK_TIMEOUT_MS) {
+    this.parkTimeoutMs = parkTimeoutMs;
+  }
+  parkTimeoutMs;
   /** 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. */
@@ -229456,27 +229486,99 @@ var TurnCompletionLedger = class {
    * grace delay (the common case).
    */
   sawBackgroundActivity = false;
+  /**
+   * When the held candidate was parked behind live background tasks — the
+   * moment the agent stopped working and only tasks kept the turn open. The
+   * park deadline counts from here, not from when a task started: the number
+   * that matters to the user is "how long since the agent answered".
+   */
+  parkedSince = null;
+  /** Task ids the user vouched for; they stop counting toward the deadline. */
+  sanctioned = /* @__PURE__ */ new Set();
+  /**
+   * Whether a park deadline already expired and closed the turn. Live tasks
+   * normally shield the session from being reclaimed — hibernating would kill
+   * a real build and the auto-resume that reads it — but that shield must not
+   * outlast the deadline, or one stuck task pins a resident process slot
+   * forever and new sessions on the branch get turned away.
+   */
+  parkDeadlineExpired = false;
   get pendingTaskCount() {
     return this.tasks.size;
   }
   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()].map(
+      (task) => this.sanctioned.has(task.taskId) ? { ...task, sanctioned: true } : task
+    );
+  }
+  /**
+   * When the parked turn will be committed anyway, or null if nothing is
+   * parked or every live task has been vouched for. Timer-free by design: the
+   * caller re-reads this after each mutation and syncs its own timer, so the
+   * ledger stays a pure state machine.
+   */
+  get parkDeadlineAt() {
+    if (this.pending === null || this.parkedSince === null) return null;
+    const allVouchedFor = [...this.tasks.keys()].every((id) => this.sanctioned.has(id));
+    return allVouchedFor ? null : this.parkedSince + this.parkTimeoutMs;
+  }
+  /**
+   * The user vouched for a task: stop counting it toward the deadline. This
+   * restores the original behavior for that task — wait for it, let the
+   * auto-resume close the turn — but now as an explicit choice.
+   */
+  sanction(taskId) {
+    if (this.tasks.has(taskId)) this.sanctioned.add(taskId);
+  }
+  /**
+   * The deadline expired: commit the parked candidate. Deliberately uses the
+   * ORIGINAL payload — its duration/cost/tokens describe the turn the agent
+   * actually ran, not the time spent waiting on a stuck task.
+   */
+  parkDeadlineElapsed() {
+    if (this.pending === null) return { kind: "none" };
+    this.parkDeadlineExpired = true;
+    return this.commitHeld();
+  }
+  /**
+   * Whether live background tasks should still shield this session from
+   * resident-process reclamation. True while they are plausibly doing real
+   * work; false once the deadline judged them anomalous — unless the user
+   * vouched for every one of them, which restores the shield along with the
+   * waiting behavior it protects.
+   */
+  get backgroundTasksProtectSession() {
+    if (this.tasks.size === 0) return false;
+    if (!this.parkDeadlineExpired) return true;
+    return [...this.tasks.keys()].every((id) => this.sanctioned.has(id));
+  }
+  taskStarted(task, now3) {
+    this.upsert(task, this.tasks.get(task.taskId), now3);
     this.sawBackgroundActivity = true;
-    return this.rearmIfHeld();
+    return this.rearmIfHeld(now3);
   }
-  taskFinished(taskId) {
+  taskFinished(taskId, now3) {
     this.tasks.delete(taskId);
+    this.sanctioned.delete(taskId);
     this.sawBackgroundActivity = true;
-    return this.rearmIfHeld();
+    return this.rearmIfHeld(now3);
   }
   /** Authoritative snapshot from `system/background_tasks_changed`. */
-  taskListChanged(taskIds) {
-    this.tasks = new Set(taskIds);
-    if (taskIds.length > 0) this.sawBackgroundActivity = true;
-    return this.rearmIfHeld();
+  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);
+    }
+    for (const id of this.sanctioned) {
+      if (!this.tasks.has(id)) this.sanctioned.delete(id);
+    }
+    if (tasks.length > 0) this.sawBackgroundActivity = true;
+    return this.rearmIfHeld(now3);
   }
   /**
    * The process emitted turn activity: if a completion was held, it was an
@@ -229488,8 +229590,10 @@ var TurnCompletionLedger = class {
    * the race against the grace window.
    */
   noteTurnActivity() {
+    this.parkDeadlineExpired = false;
     if (this.pending === null) return { kind: "none" };
     this.pending = null;
+    this.parkedSince = null;
     this.generation++;
     return { kind: "cancel" };
   }
@@ -229505,9 +229609,11 @@ var TurnCompletionLedger = class {
     this.sawBackgroundActivity = false;
     return this.noteTurnActivity();
   }
-  successResult(payload) {
+  successResult(payload, now3) {
     this.generation++;
     if (this.tasks.size > 0) {
+      this.parkedSince = now3;
+      this.parkDeadlineExpired = false;
       this.pending = payload;
       return { kind: "cancel" };
     }
@@ -229521,6 +229627,7 @@ var TurnCompletionLedger = class {
   errorResult() {
     if (this.pending === null) return { kind: "none" };
     this.pending = null;
+    this.parkedSince = null;
     this.generation++;
     return { kind: "cancel" };
   }
@@ -229546,7 +229653,10 @@ var TurnCompletionLedger = class {
   /** Full reset (fresh spawn / stop / hibernate / agent switch). */
   reset() {
     this.tasks.clear();
+    this.sanctioned.clear();
     this.pending = null;
+    this.parkedSince = null;
+    this.parkDeadlineExpired = false;
     this.generation++;
     this.sawBackgroundActivity = false;
   }
@@ -229555,15 +229665,34 @@ var TurnCompletionLedger = class {
    * have no resume behind it), so they delay the commit rather than cancel
    * it — and while tasks are still live the candidate stays parked with no
    * timer at all (only an empty set can complete a turn). */
-  rearmIfHeld() {
+  rearmIfHeld(now3) {
     if (this.pending === null) return { kind: "none" };
     this.generation++;
-    if (this.tasks.size > 0) return { kind: "cancel" };
+    if (this.tasks.size > 0) {
+      this.parkedSince ??= now3;
+      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;
+    this.parkedSince = null;
     this.generation++;
     return { kind: "commit", payload };
   }
@@ -229644,10 +229773,13 @@ var AgentSessionManager = class {
   retentionDeleting = /* @__PURE__ */ new Set();
   /** Grace window before committing a held completion (injectable for tests). */
   completionGraceMs;
+  /** Bound on a parked completion (injectable for tests). */
+  parkTimeoutMs;
   workflowSuppressionCheck = null;
   constructor(storage2, opts) {
     this.storage = storage2;
     this.completionGraceMs = opts?.completionGraceMs ?? COMPLETION_GRACE_MS;
+    this.parkTimeoutMs = opts?.parkTimeoutMs ?? PARK_TIMEOUT_MS;
   }
   async resolveSessionWorktreePath(session, legacyProjectPath) {
     if (!session.workspaceCheckoutId) {
@@ -229922,7 +230054,7 @@ var AgentSessionManager = class {
           processAlive: this.isProcessAlive(session),
           status: session.status,
           dormant: session.dormant,
-          backgroundTaskCount: session.completion.pendingTaskCount,
+          backgroundTasksProtect: session.completion.backgroundTasksProtectSession,
           lastActiveAt: session.lastActiveAt,
           projectId: session.projectId,
           branch: session.branch
@@ -230070,8 +230202,9 @@ var AgentSessionManager = class {
       crossRemoteMcp: opts.crossRemoteMcp,
       agentType,
       model,
-      completion: new TurnCompletionLedger(),
+      completion: new TurnCompletionLedger(this.parkTimeoutMs),
       graceTimer: null,
+      parkTimer: null,
       eventChain: Promise.resolve(),
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
@@ -230226,6 +230359,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, {
@@ -230327,25 +230461,119 @@ var AgentSessionManager = class {
     } else if (action.kind === "schedule") {
       this.armGraceTimer(session, action.generation);
     }
+    this.syncParkTimer(session);
+  }
+  /**
+   * Keep the park timer in step with the ledger's deadline.
+   *
+   * Driven by ledger STATE rather than by an action kind, because the deadline
+   * survives across many actions (every task event returns `cancel` while a
+   * completion stays parked) and can also be lifted without any action at all
+   * when the user vouches for the last unvouched task. Re-reading the state
+   * after each mutation is the only way the two can't drift.
+   */
+  syncParkTimer(session) {
+    const deadlineAt = session.completion.parkDeadlineAt;
+    if (deadlineAt === null) {
+      if (session.parkTimer) {
+        clearTimeout(session.parkTimer);
+        session.parkTimer = null;
+      }
+      return;
+    }
+    if (session.parkTimer) return;
+    const timer = setTimeout(() => {
+      session.parkTimer = null;
+      this.enqueueSessionWork(session, async () => {
+        const action = session.completion.parkDeadlineElapsed();
+        if (action.kind !== "commit") return;
+        console.log(
+          `[AgentSession] parked completion exceeded ${this.parkTimeoutMs}ms with ${session.completion.pendingTaskCount} background task(s) still running \u2014 committing the turn anyway (session=${session.id})`
+        );
+        await this.commitCompletion(session, action.payload, "completed_with_pending_tasks");
+        this.broadcastBackgroundTasks(session);
+      }, "completion-park-deadline");
+    }, Math.max(0, deadlineAt - Date.now()));
+    timer.unref?.();
+    session.parkTimer = timer;
+  }
+  /**
+   * The user vouched for a background task: it stops counting toward the park
+   * deadline, restoring the original wait-for-auto-resume behavior for that
+   * task alone — now as an explicit choice rather than a silent assumption.
+   */
+  /**
+   * Ask the agent to stop one background task.
+   *
+   * Returns "unsupported" for agents with no such primitive (Codex), so the
+   * caller can say "stop the session instead" rather than showing a dead
+   * button. On success nothing is updated here: the CLI's own
+   * `background_tasks_changed` snapshot drains the ledger, which then commits
+   * the parked turn through the normal path.
+   */
+  stopBackgroundTask(sessionId, taskId) {
+    const session = this.sessions.get(sessionId);
+    if (!session?.process?.stdin) return "not_found";
+    const frame = getProvider(session.agentType).formatStopBackgroundTask?.(taskId, sessionId);
+    if (!frame) return "unsupported";
+    session.process.stdin.write(frame);
+    console.log(`[AgentSession] stop_task sent for ${taskId} (session=${sessionId})`);
+    return "ok";
+  }
+  sanctionBackgroundTask(sessionId, taskId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return false;
+    session.completion.sanction(taskId);
+    this.syncParkTimer(session);
+    this.broadcastBackgroundTasks(session);
+    return true;
   }
   /** Discard all turn-completion state (fresh spawn / stop / hibernate / agent switch). */
   resetCompletion(session) {
     this.clearGraceTimer(session);
     session.completion.reset();
+    this.syncParkTimer(session);
+    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.
    */
-  async commitCompletion(session, payload) {
+  /**
+   * 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, this.backgroundTasksMessage(session));
+  }
+  /**
+   * Reported rather than inferred client-side: whether a single task can be
+   * stopped is a property of the agent (Claude Code has `stop_task`, Codex has
+   * nothing equivalent), and the server is the only side that knows. A client
+   * guessing from the agent type would drift the day Codex gains one.
+   */
+  backgroundTasksMessage(session) {
+    return {
+      backgroundTasks: {
+        tasks: session.completion.backgroundTasks,
+        turnParked: session.completion.hasPendingCompletion,
+        parkDeadlineAt: session.completion.parkDeadlineAt,
+        canStopTasks: !!getProvider(session.agentType).formatStopBackgroundTask
+      }
+    };
+  }
+  async commitCompletion(session, payload, outcome = "completed") {
     const sessionId = session.id;
     console.log(`[AgentSession] taskCompleted: sessionId=${sessionId}, eventBus=${!!this.eventBus}, projectId=${session.projectId}, branch=${session.branch}`);
     const completedAt = Date.now();
     if (!session.skipDb) {
       await this.storage.agentSessions.markCompleted(sessionId, completedAt);
     }
-    const turnEndEntryIndex = await this.endActiveTurn(session, "completed");
+    const turnEndEntryIndex = await this.endActiveTurn(session, outcome);
+    this.broadcastBackgroundTasks(session);
     const summaryText = extractLastAssistantText(session.store.entries);
     this.broadcastRaw(sessionId, {
       taskCompleted: {
@@ -230526,19 +230754,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.applyCompletionTimerAction(session, session.completion.taskFinished(event.taskId, timestamp));
+        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":
@@ -230599,7 +230834,7 @@ var AgentSessionManager = class {
             cost_usd: event.cost_usd,
             input_tokens: event.input_tokens,
             output_tokens: event.output_tokens
-          });
+          }, timestamp);
           if (action.kind === "commit") {
             await this.commitCompletion(session, action.payload);
           } else {
@@ -230609,6 +230844,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 +231177,8 @@ 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 = this.backgroundTasksMessage(session);
+    ws.send(JSON.stringify(tasksMsg));
     return () => {
       session.subscribers.delete(ws);
     };
@@ -231228,6 +231466,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);
@@ -231738,8 +231977,9 @@ var AgentSessionManager = class {
         permissionMode,
         agentType: dbSession.agent_type || "claude-code",
         model: dbSession.model ?? null,
-        completion: new TurnCompletionLedger(),
+        completion: new TurnCompletionLedger(this.parkTimeoutMs),
         graceTimer: null,
+        parkTimer: null,
         eventChain: Promise.resolve(),
         bgSpawnHintsThisTurn: 0,
         taskStartedThisTurn: 0,
@@ -231930,8 +232170,9 @@ var AgentSessionManager = class {
       permissionMode,
       agentType,
       model,
-      completion: new TurnCompletionLedger(),
+      completion: new TurnCompletionLedger(this.parkTimeoutMs),
       graceTimer: null,
+      parkTimer: null,
       eventChain: Promise.resolve(),
       bgSpawnHintsThisTurn: 0,
       taskStartedThisTurn: 0,
@@ -233597,6 +233838,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 +239658,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 +240347,8 @@ var RemotePatchCache = class {
         latestEntryIndex: null,
         lastTurnEndEntryIndex: null,
         coverage: null,
-        sessionStatus: null
+        sessionStatus: null,
+        backgroundTasks: null
       };
       this.cache.set(sessionId, entry);
     }
@@ -240149,6 +240396,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 +240412,8 @@ var RemotePatchCache = class {
       latestEntryIndex,
       lastTurnEndEntryIndex,
       coverage,
-      sessionStatus
+      sessionStatus,
+      backgroundTasks
     });
   }
   /**
@@ -240229,6 +240478,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 +240487,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 +243519,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);
@@ -248671,6 +248932,68 @@ var routes11 = async (fastify2) => {
       });
     }
   );
+  fastify2.post(
+    "/api/agent-sessions/:sessionId/background-tasks/:taskId/keep",
+    async (req, reply) => {
+      const userId = requireUserFacingUserId(req, reply);
+      if (userId === null) return;
+      const { sessionId, taskId } = req.params;
+      if (sessionId.startsWith("remote-")) {
+        const remoteInfo = await getAuthorizedRemoteSessionInfo(sessionId, userId);
+        if (!remoteInfo) {
+          return reply.code(404).send({ error: "Remote session not found" });
+        }
+        const result = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "POST",
+          `/api/agent-sessions/${remoteInfo.remoteSessionId}/background-tasks/${encodeURIComponent(taskId)}/keep`,
+          {}
+        );
+        return reply.code(proxyStatus(result)).send(result.data);
+      }
+      const row = await fastify2.storage.agentSessions.getById(sessionId);
+      if (!row || !await fastify2.storage.projects.getById(row.project_id, userId)) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      if (!fastify2.agentSessionManager.sanctionBackgroundTask(sessionId, taskId)) {
+        return reply.code(404).send({ error: "Session not running" });
+      }
+      return reply.code(200).send({ success: true });
+    }
+  );
+  fastify2.post(
+    "/api/agent-sessions/:sessionId/background-tasks/:taskId/stop",
+    async (req, reply) => {
+      const userId = requireUserFacingUserId(req, reply);
+      if (userId === null) return;
+      const { sessionId, taskId } = req.params;
+      if (sessionId.startsWith("remote-")) {
+        const remoteInfo = await getAuthorizedRemoteSessionInfo(sessionId, userId);
+        if (!remoteInfo) {
+          return reply.code(404).send({ error: "Remote session not found" });
+        }
+        const result = await proxyAuto(
+          remoteInfo.remoteServerId,
+          "POST",
+          `/api/agent-sessions/${remoteInfo.remoteSessionId}/background-tasks/${encodeURIComponent(taskId)}/stop`,
+          {}
+        );
+        return reply.code(proxyStatus(result)).send(result.data);
+      }
+      const row = await fastify2.storage.agentSessions.getById(sessionId);
+      if (!row || !await fastify2.storage.projects.getById(row.project_id, userId)) {
+        return reply.code(404).send({ error: "Session not found" });
+      }
+      const outcome = fastify2.agentSessionManager.stopBackgroundTask(sessionId, taskId);
+      if (outcome === "not_found") {
+        return reply.code(404).send({ error: "Session not running" });
+      }
+      if (outcome === "unsupported") {
+        return reply.code(501).send({ error: "This agent cannot stop a single background task \u2014 stop the session instead" });
+      }
+      return reply.code(200).send({ success: true });
+    }
+  );
   fastify2.post(
     "/api/agent-sessions/:sessionId/branch",
     async (req, reply) => {
@@ -251688,6 +252011,11 @@ var routes23 = async (fastify2) => {
           try {
             const message = JSON.parse(data.toString());
             if (message.type === "input" || message.type === "resize") {
+              if (message.type === "resize") {
+                console.log(
+                  `[WebSocket] resize ${processId} \u2192 ${message.cols}x${message.rows} ip=${req.ip} ua=${req.headers["user-agent"] ?? "?"}`
+                );
+              }
               handle.handleInput(message);
             }
           } catch (error48) {
@@ -251763,6 +252091,9 @@ var routes23 = async (fastify2) => {
             } else if (msg.type === "input") {
               handleInputMap.get(msg.processId)?.({ type: "input", data: msg.data });
             } else if (msg.type === "resize") {
+              console.log(
+                `[ExecutorMux] resize ${msg.processId} \u2192 ${msg.cols}x${msg.rows} ip=${req.ip} ua=${req.headers["user-agent"] ?? "?"}`
+              );
               handleInputMap.get(msg.processId)?.({ type: "resize", cols: msg.cols, rows: msg.rows });
             }
           } catch (error48) {
@@ -251877,6 +252208,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 +252601,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 +258975,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 +258987,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 +260340,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 +260395,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 +260429,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 +260544,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) => {
@@ -260415,6 +260781,12 @@ var WORKER_CAPABILITIES = {
   "http:POST /api/agent-sessions/:param/restart": { since: "0.2.0", summary: "\u91CD\u542F\u4F1A\u8BDD\u8FDB\u7A0B" },
   "http:POST /api/agent-sessions/:param/agent-type": { since: "0.2.0", summary: "\u5207\u6362 agent \u7C7B\u578B" },
   "http:POST /api/agent-sessions/:param/model": { since: "0.2.0", summary: "\u5207\u6362\u4F1A\u8BDD\u6A21\u578B" },
+  // Additive: an older worker 404s it, and the UI degrades by hiding the
+  // "keep running" button — that worker has no park deadline to defuse.
+  "http:POST /api/agent-sessions/:param/background-tasks/:param/keep": { since: "0.3.28", summary: "\u4E3A\u540E\u53F0\u4EFB\u52A1\u80CC\u4E66,\u514D\u4E8E\u8D85\u65F6\u6536\u5C3E" },
+  // Additive alongside /keep, and degrades the same way: an older worker 404s
+  // and the UI hides the button.
+  "http:POST /api/agent-sessions/:param/background-tasks/:param/stop": { since: "0.3.28", summary: "\u505C\u6B62\u5355\u4E2A\u540E\u53F0\u4EFB\u52A1" },
   "http:POST /api/path/agent-sessions/:param/branch": { since: "0.2.0", summary: "\u4ECE\u5386\u53F2\u5206\u53C9\u4F1A\u8BDD" },
   "http:POST /api/agent-sessions/:param/switch-mode": { since: "0.2.0", summary: "\u6743\u9650\u6A21\u5F0F\u5207\u6362" },
   "http:POST /api/agent-sessions/:param/accept-plan": { since: "0.2.0", summary: "\u63A5\u53D7\u8BA1\u5212(\u9000\u51FA plan \u6A21\u5F0F)" },

package/package.json

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