tide-commander 1.131.0 → 1.133.0

package/dist/assets/{web-SdWeOa6A.js → web-C--hoJ1w.js}

@@ -1 +1 @@
-import{cO as t}from"./main-DffU4pm2.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};
+import{cO as t}from"./main-D5m1NJ8q.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class o extends t{constructor(){super(),this.handleVisibilityChange=()=>{const e={isActive:document.hidden!==!0};this.notifyListeners("appStateChange",e),document.hidden?this.notifyListeners("pause",null):this.notifyListeners("resume",null)},document.addEventListener("visibilitychange",this.handleVisibilityChange,!1)}exitApp(){throw this.unimplemented("Not implemented on web.")}async getInfo(){throw this.unimplemented("Not implemented on web.")}async getLaunchUrl(){return{url:""}}async getState(){return{isActive:document.hidden!==!0}}async minimizeApp(){throw this.unimplemented("Not implemented on web.")}async toggleBackButtonHandler(){throw this.unimplemented("Not implemented on web.")}async getAppLanguage(){return{value:navigator.language.split("-")[0].toLowerCase()}}}export{o as AppWeb};

package/dist/assets/{web-CNVP9dOO.js → web-CbFuYEMc.js}

@@ -1 +1 @@
-import{cO as s}from"./main-DffU4pm2.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};
+import{cO as s}from"./main-D5m1NJ8q.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class l extends s{constructor(){super(...arguments),this.pending=[],this.deliveredNotifications=[],this.hasNotificationSupport=()=>{if(!("Notification"in window)||!Notification.requestPermission)return!1;if(Notification.permission!=="granted")try{new Notification("")}catch(i){if(i instanceof Error&&i.name==="TypeError")return!1}return!0}}async getDeliveredNotifications(){const i=[];for(const t of this.deliveredNotifications){const e={title:t.title,id:parseInt(t.tag),body:t.body};i.push(e)}return{notifications:i}}async removeDeliveredNotifications(i){for(const t of i.notifications){const e=this.deliveredNotifications.find(n=>n.tag===String(t.id));e==null||e.close(),this.deliveredNotifications=this.deliveredNotifications.filter(()=>!e)}}async removeAllDeliveredNotifications(){for(const i of this.deliveredNotifications)i.close();this.deliveredNotifications=[]}async createChannel(){throw this.unimplemented("Not implemented on web.")}async deleteChannel(){throw this.unimplemented("Not implemented on web.")}async listChannels(){throw this.unimplemented("Not implemented on web.")}async schedule(i){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");for(const t of i.notifications)this.sendNotification(t);return{notifications:i.notifications.map(t=>({id:t.id}))}}async getPending(){return{notifications:this.pending}}async registerActionTypes(){throw this.unimplemented("Not implemented on web.")}async cancel(i){this.pending=this.pending.filter(t=>!i.notifications.find(e=>e.id===t.id))}async areEnabled(){const{display:i}=await this.checkPermissions();return{value:i==="granted"}}async changeExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async checkExactNotificationSetting(){throw this.unimplemented("Not implemented on web.")}async requestPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(await Notification.requestPermission())}}async checkPermissions(){if(!this.hasNotificationSupport())throw this.unavailable("Notifications not supported in this browser.");return{display:this.transformNotificationPermission(Notification.permission)}}transformNotificationPermission(i){switch(i){case"granted":return"granted";case"denied":return"denied";default:return"prompt"}}sendPending(){var i;const t=[],e=new Date().getTime();for(const n of this.pending)!((i=n.schedule)===null||i===void 0)&&i.at&&n.schedule.at.getTime()<=e&&(this.buildNotification(n),t.push(n));this.pending=this.pending.filter(n=>!t.find(o=>o===n))}sendNotification(i){var t;if(!((t=i.schedule)===null||t===void 0)&&t.at){const e=i.schedule.at.getTime()-new Date().getTime();this.pending.push(i),setTimeout(()=>{this.sendPending()},e);return}this.buildNotification(i)}buildNotification(i){const t=new Notification(i.title,{body:i.body,tag:String(i.id)});return t.addEventListener("click",this.onClick.bind(this,i),!1),t.addEventListener("show",this.onShow.bind(this,i),!1),t.addEventListener("close",()=>{this.deliveredNotifications=this.deliveredNotifications.filter(()=>!this)},!1),this.deliveredNotifications.push(t),t}onClick(i){const t={actionId:"tap",notification:i};this.notifyListeners("localNotificationActionPerformed",t)}onShow(i){this.notifyListeners("localNotificationReceived",i)}}export{l as LocalNotificationsWeb};

package/dist/assets/{web-BzTFbp-p.js → web-Dh2cBvOj.js}

@@ -1 +1 @@
-import{cO as a}from"./main-DffU4pm2.js";import{ImpactStyle as i,NotificationType as r}from"./index-SaaO8V1I.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};
+import{cO as a}from"./main-D5m1NJ8q.js";import{ImpactStyle as i,NotificationType as r}from"./index-Cs3R3S9l.js";import"./vendor-react--Eh9ivFN.js";import"./vendor-three-Chj50gSY.js";class h extends a{constructor(){super(...arguments),this.selectionStarted=!1}async impact(t){const e=this.patternForImpact(t==null?void 0:t.style);this.vibrateWithPattern(e)}async notification(t){const e=this.patternForNotification(t==null?void 0:t.type);this.vibrateWithPattern(e)}async vibrate(t){const e=(t==null?void 0:t.duration)||300;this.vibrateWithPattern([e])}async selectionStart(){this.selectionStarted=!0}async selectionChanged(){this.selectionStarted&&this.vibrateWithPattern([70])}async selectionEnd(){this.selectionStarted=!1}patternForImpact(t=i.Heavy){return t===i.Medium?[43]:t===i.Light?[20]:[61]}patternForNotification(t=r.Success){return t===r.Warning?[30,40,30,50,60]:t===r.Error?[27,45,50]:[35,65,21]}vibrateWithPattern(t){if(navigator.vibrate)navigator.vibrate(t);else throw this.unavailable("Browser does not support the vibrate API")}}export{h as HapticsWeb};

package/dist/index.html

@@ -22,10 +22,10 @@
     <link rel="icon" type="image/png" sizes="16x16" href="/assets/icons/favicon-16x16.png" />
     <link rel="apple-touch-icon" sizes="180x180" href="/assets/icons/apple-touch-icon.png" />
     <title>Tide Commander</title>
-    <script type="module" crossorigin src="/assets/main-DffU4pm2.js"></script>
+    <script type="module" crossorigin src="/assets/main-D5m1NJ8q.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-react--Eh9ivFN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-three-Chj50gSY.js">
-    <link rel="stylesheet" crossorigin href="/assets/main-BPim_cvM.css">
+    <link rel="stylesheet" crossorigin href="/assets/main-BUUWICEe.css">
   </head>
   <body>
     <div id="app"></div>

package/dist/src/packages/server/routes/perf.js

@@ -23,6 +23,9 @@ export function incrementWsReceived() {
 export function setWsClientsCount(count) {
     wsClientsCount = count;
 }
+export function getWsClientsCount() {
+    return wsClientsCount;
+}
 const recentRequests = [];
 const MAX_RECENT_REQUESTS = 100;
 export function recordRequestTiming(method, path, duration) {

package/dist/src/packages/server/services/agent-service.js

@@ -29,6 +29,15 @@ function getDefaultContextLimit(provider, model) {
 // In-memory agent storage
 const agents = new Map();
 const listeners = new Set();
+// Fields that change constantly while an agent works (several times per tool
+// call). When an update changes nothing outside this set, the 'updated' event
+// is emitted as quiet.
+const QUIET_UPDATE_FIELDS = new Set([
+    'currentTool',
+    'contextUsed',
+    'contextLimit',
+    'contextStats',
+]);
 const pendingPropertyUpdates = new Map();
 export function sanitizeModelForProvider(provider, model) {
     if (provider !== 'claude')
@@ -257,8 +266,8 @@ export function subscribe(listener) {
     listeners.add(listener);
     return () => listeners.delete(listener);
 }
-function emit(event, data) {
-    listeners.forEach((listener) => listener(event, data));
+function emit(event, data, meta) {
+    listeners.forEach((listener) => listener(event, data, meta));
 }
 // ============================================================================
 // Agent CRUD
@@ -474,6 +483,16 @@ export function updateAgent(id, updates, updateActivity = true) {
         normalizedUpdates.trackingStatusDetail = undefined;
         normalizedUpdates.trackingStatusTimestamp = undefined;
     }
+    // Determine which fields actually change value (shallow — replaced objects
+    // like contextStats/position always count as changed). Drives the `quiet`
+    // flag on the 'updated' event below.
+    const changedKeys = [];
+    for (const key of Object.keys(normalizedUpdates)) {
+        const before = agent[key];
+        const after = normalizedUpdates[key];
+        if (before !== after)
+            changedKeys.push(key);
+    }
     // Only update lastActivity for real activity (not position changes, etc.)
     if (updateActivity) {
         Object.assign(agent, normalizedUpdates, { lastActivity: Date.now() });
@@ -491,7 +510,13 @@ export function updateAgent(id, updates, updateActivity = true) {
     if (sessionIdBefore !== agent.sessionId) {
         log.warn(`🔑 [SESSION CHANGE] Agent ${agent.name} (${id}): sessionId changed from "${sessionIdBefore}" to "${agent.sessionId}". Updates had sessionId: ${hasSessionIdInUpdates}, updates keys: ${Object.keys(normalizedUpdates).join(', ')}`);
     }
-    emit('updated', agent);
+    // Quiet when nothing changed, or everything that changed is a high-churn
+    // metric field. During streaming this is ~3 updates per tool call
+    // (status:'working' no-op, currentTool set/clear, context tokens) — without
+    // the flag each one broadcast the FULL agent (contextStats, todos, config)
+    // to every connected client.
+    const quiet = changedKeys.every((key) => QUIET_UPDATE_FIELDS.has(key));
+    emit('updated', agent, { quiet });
     if (statusBefore !== agent.status) {
         void publishNotification('statusChanges', `${agentNameBefore}: status changed`, `${statusBefore ?? 'unknown'} → ${agent.status ?? 'unknown'}`).catch(() => { });
     }

package/dist/src/packages/server/services/building-service.js

@@ -6,6 +6,7 @@
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { loadBuildings, saveBuildings } from '../data/index.js';
+import { getWsClientsCount } from '../routes/perf.js';
 import { createLogger, generateId } from '../utils/index.js';
 import * as pm2Service from './pm2-service.js';
 import * as dockerService from './docker-service.js';
@@ -573,20 +574,49 @@ export function getSubordinateBuildings(buildingId) {
 // PM2 Status Polling
 // ============================================================================
 let pollInterval = null;
+let pollBroadcast = null;
+let pollInFlight = false;
 /**
  * Start polling PM2 for status updates
  * Syncs PM2 process status with building status
+ *
+ * Each cycle spawns `pm2 jlist` (a full Node process), so cycles are skipped
+ * while no WebSocket client is connected — nobody is looking at the status
+ * badges, and a fresh poll runs on the next client connect
+ * (triggerPM2StatusPoll from the WS connection handler).
  */
-export function startPM2StatusPolling(broadcast, intervalMs = 10000) {
+export function startPM2StatusPolling(broadcast, intervalMs = 30000) {
     if (pollInterval) {
         log.log('PM2 status polling already running');
         return;
     }
-    log.log(`Starting PM2 status polling (interval: ${intervalMs}ms)`);
+    pollBroadcast = broadcast;
+    log.log(`Starting PM2 status polling (interval: ${intervalMs}ms, paused while no clients)`);
     // Initial poll
-    pollPM2Status(broadcast);
+    void guardedPoll(broadcast);
     // Set up interval
-    pollInterval = setInterval(() => pollPM2Status(broadcast), intervalMs);
+    pollInterval = setInterval(() => {
+        if (getWsClientsCount() === 0)
+            return;
+        void guardedPoll(broadcast);
+    }, intervalMs);
+}
+/** Run one poll immediately (used when a client connects mid-idle). */
+export function triggerPM2StatusPoll() {
+    if (pollBroadcast)
+        void guardedPoll(pollBroadcast);
+}
+// Prevents overlapping polls if `pm2 jlist` is slower than the interval.
+async function guardedPoll(broadcast) {
+    if (pollInFlight)
+        return;
+    pollInFlight = true;
+    try {
+        await pollPM2Status(broadcast);
+    }
+    finally {
+        pollInFlight = false;
+    }
 }
 /**
  * Stop PM2 status polling

package/dist/src/packages/server/services/git-watch-service.js

@@ -0,0 +1,270 @@
+/**
+ * Git Watch Service — server-side git status polling pushed over WebSocket.
+ *
+ * Replaces per-client HTTP polling of GET /api/files/git-status and
+ * /api/files/git-branch. Each client declares the directories it cares about
+ * via the `git_watch` message; this service polls the UNION of all watched
+ * directories once (shared across every connected client), and pushes a
+ * `git_status_update` only when a directory's status actually changed.
+ *
+ * Net effect vs polling: one async git run per directory per cycle regardless
+ * of client count, zero network traffic while nothing changes, and no
+ * event-loop blocking (the HTTP routes use execSync; this service uses
+ * execFile). Polling stops entirely when no client watches anything —
+ * e.g. when the mobile app parks its socket in the background.
+ */
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import * as fs from 'fs';
+import * as path from 'path';
+import { logger } from '../utils/index.js';
+const execFileAsync = promisify(execFile);
+const log = logger.files;
+const POLL_INTERVAL_MS = 10_000;
+const GIT_TIMEOUT_MS = 8_000;
+// Safety cap per socket — far above any real area/building configuration.
+const MAX_WATCHED_PATHS = 200;
+const subscriptions = new Map();
+const cache = new Map();
+let pollTimer = null;
+let pollInFlight = false;
+async function git(args, cwd) {
+    const { stdout } = await execFileAsync('git', args, {
+        cwd,
+        timeout: GIT_TIMEOUT_MS,
+        maxBuffer: 10 * 1024 * 1024,
+        encoding: 'utf-8',
+    });
+    return stdout;
+}
+function toPosixSeparators(p) {
+    return p.split(path.sep).join('/');
+}
+/** Parse `git status --porcelain -uall` output into absolute-path file entries. */
+function parsePorcelain(gitRoot, output) {
+    const files = [];
+    const lines = output.replace(/\n$/, '').split('\n').filter(Boolean);
+    for (const line of lines) {
+        // Porcelain v1: "XY PATH" or "XY ORIG -> NEW" for renames. Paths are
+        // relative to the git root.
+        const indexStatus = line[0];
+        const workTreeStatus = line[1];
+        const filePart = line.substring(3);
+        let filePath;
+        let oldPath;
+        if (filePart.includes(' -> ')) {
+            const [old, newPath] = filePart.split(' -> ');
+            filePath = toPosixSeparators(path.join(gitRoot, newPath));
+            oldPath = toPosixSeparators(path.join(gitRoot, old));
+        }
+        else {
+            filePath = toPosixSeparators(path.join(gitRoot, filePart));
+        }
+        let status;
+        if ((indexStatus === 'U' || workTreeStatus === 'U') ||
+            (indexStatus === 'D' && workTreeStatus === 'D') ||
+            (indexStatus === 'A' && workTreeStatus === 'A')) {
+            status = 'conflict';
+        }
+        else if (indexStatus === 'A' && workTreeStatus === 'D') {
+            // Orphaned staged-add (file deleted from disk) — the git-status HTTP
+            // route auto-unstages these; the read-only watcher just skips them.
+            continue;
+        }
+        else if (indexStatus === '?' || workTreeStatus === '?') {
+            status = 'untracked';
+        }
+        else if (indexStatus === 'A' || workTreeStatus === 'A') {
+            status = 'added';
+        }
+        else if (indexStatus === 'D' || workTreeStatus === 'D') {
+            status = 'deleted';
+        }
+        else if (indexStatus === 'R' || workTreeStatus === 'R') {
+            status = 'renamed';
+        }
+        else {
+            status = 'modified';
+        }
+        files.push({ path: filePath, name: path.basename(filePath), status, oldPath });
+    }
+    return files;
+}
+async function computeStatus(dirPath) {
+    const empty = {
+        path: dirPath,
+        isGitRepo: false,
+        branch: null,
+        ahead: 0,
+        behind: 0,
+        mergeInProgress: false,
+        files: [],
+    };
+    if (!path.isAbsolute(dirPath) || !fs.existsSync(dirPath))
+        return empty;
+    let gitRoot;
+    try {
+        gitRoot = (await git(['rev-parse', '--show-toplevel'], dirPath)).trim();
+    }
+    catch {
+        return empty;
+    }
+    let files = [];
+    try {
+        files = parsePorcelain(gitRoot, await git(['status', '--porcelain', '-uall'], dirPath));
+    }
+    catch (err) {
+        log.error(`[GitWatch] git status failed for ${dirPath}:`, err);
+    }
+    let branch = null;
+    try {
+        branch = (await git(['branch', '--show-current'], gitRoot)).trim() || 'HEAD';
+    }
+    catch {
+        branch = 'HEAD';
+    }
+    let ahead = 0;
+    let behind = 0;
+    if (branch && branch !== 'HEAD') {
+        try {
+            const revList = (await git(['rev-list', '--left-right', '--count', `${branch}...@{upstream}`], gitRoot)).trim();
+            const parts = revList.split(/\s+/);
+            if (parts.length === 2) {
+                ahead = parseInt(parts[0], 10) || 0;
+                behind = parseInt(parts[1], 10) || 0;
+            }
+        }
+        catch {
+            // No upstream configured — leave at 0
+        }
+    }
+    return {
+        path: dirPath,
+        isGitRepo: true,
+        branch,
+        ahead,
+        behind,
+        mergeInProgress: fs.existsSync(path.join(gitRoot, '.git', 'MERGE_HEAD')),
+        files,
+    };
+}
+function sendStatus(ws, payload) {
+    if (ws.readyState !== ws.OPEN)
+        return;
+    try {
+        ws.send(JSON.stringify({ type: 'git_status_update', payload }));
+    }
+    catch (err) {
+        log.error('[GitWatch] Failed to send git_status_update:', err);
+    }
+}
+function watchedUnion() {
+    const union = new Set();
+    for (const paths of subscriptions.values()) {
+        for (const p of paths)
+            union.add(p);
+    }
+    return union;
+}
+function pushToSubscribers(payload) {
+    for (const [ws, paths] of subscriptions) {
+        if (paths.has(payload.path))
+            sendStatus(ws, payload);
+    }
+}
+/** Compute a dir, update the cache, and push to subscribers if it changed. */
+async function refreshOne(dirPath, forcePushTo) {
+    const payload = await computeStatus(dirPath);
+    const fingerprint = JSON.stringify(payload);
+    const prev = cache.get(dirPath);
+    cache.set(dirPath, { fingerprint, payload });
+    if (!prev || prev.fingerprint !== fingerprint) {
+        pushToSubscribers(payload);
+    }
+    else if (forcePushTo) {
+        // Unchanged, but an explicit refresh/subscribe asked for it.
+        sendStatus(forcePushTo, payload);
+    }
+}
+async function pollOnce() {
+    if (pollInFlight)
+        return;
+    pollInFlight = true;
+    try {
+        const union = watchedUnion();
+        // Drop cache entries nobody watches anymore.
+        for (const key of cache.keys()) {
+            if (!union.has(key))
+                cache.delete(key);
+        }
+        // Sequential on purpose: keeps the git subprocess load flat no matter how
+        // many directories are watched. Local git status is fast (~tens of ms).
+        for (const dirPath of union) {
+            if (!watchedUnion().has(dirPath))
+                continue; // unsubscribed mid-cycle
+            await refreshOne(dirPath);
+        }
+    }
+    catch (err) {
+        log.error('[GitWatch] Poll cycle failed:', err);
+    }
+    finally {
+        pollInFlight = false;
+    }
+}
+function ensurePolling() {
+    if (pollTimer || subscriptions.size === 0)
+        return;
+    pollTimer = setInterval(() => void pollOnce(), POLL_INTERVAL_MS);
+}
+function stopPollingIfIdle() {
+    if (subscriptions.size === 0 && pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+        cache.clear();
+    }
+}
+export const gitWatchService = {
+    /**
+     * Replace a socket's watched directory set. Immediately sends the current
+     * status for every requested path (cached, or freshly computed) so the
+     * client renders without waiting for the next poll cycle.
+     */
+    setWatchList(ws, paths) {
+        const cleaned = [...new Set((paths || [])
+                .filter((p) => typeof p === 'string' && path.isAbsolute(p))
+                .slice(0, MAX_WATCHED_PATHS))];
+        if (cleaned.length === 0) {
+            subscriptions.delete(ws);
+            stopPollingIfIdle();
+            return;
+        }
+        subscriptions.set(ws, new Set(cleaned));
+        ensurePolling();
+        void (async () => {
+            for (const dirPath of cleaned) {
+                const cached = cache.get(dirPath);
+                if (cached) {
+                    sendStatus(ws, cached.payload);
+                }
+                else {
+                    await refreshOne(dirPath, ws);
+                }
+            }
+        })();
+    },
+    /** Recompute the given (watched) paths now and push results. */
+    async refreshPaths(paths, requester) {
+        const union = watchedUnion();
+        for (const dirPath of paths || []) {
+            if (typeof dirPath !== 'string' || !union.has(dirPath))
+                continue;
+            await refreshOne(dirPath, requester);
+        }
+    },
+    /** Forget a socket (call on WS close). */
+    removeSocket(ws) {
+        subscriptions.delete(ws);
+        stopPollingIfIdle();
+    },
+};

package/dist/src/packages/server/websocket/handler.js

@@ -4,7 +4,7 @@
  */
 import { hostname } from 'node:os';
 import { WebSocketServer, WebSocket } from 'ws';
-import { agentService, bossMessageService, customClassService, permissionService, runtimeService, skillService, triggerService, workflowService, } from '../services/index.js';
+import { agentService, bossMessageService, buildingService, customClassService, permissionService, runtimeService, skillService, triggerService, workflowService, } from '../services/index.js';
 import { loadAreas, loadBuildings } from '../data/index.js';
 import { logger } from '../utils/index.js';
 import { setNotificationBroadcast, setExecBroadcast, setTestsBroadcast, setFocusAgentBroadcast, setAgentsBroadcast, setTriggerBroadcast, setBuildingsBroadcast, setSkillsBroadcast } from '../routes/index.js';
@@ -16,6 +16,8 @@ import { handleSpawnBossAgent, handleAssignSubordinates, handleRemoveSubordinate
 import { handleCreateCustomAgentClass, handleUpdateCustomAgentClass, handleDeleteCustomAgentClass, } from './handlers/custom-class-handler.js';
 import { handleBuildingCommand, handlePM2LogsStart, handlePM2LogsStop, handleDockerLogsStart, handleDockerLogsStop, handleDockerListContainers, handleBossBuildingCommand, handleAssignBuildings, handleBossBuildingLogsStart, handleBossBuildingLogsStop, } from './handlers/building-handler.js';
 import { handleSendCommand } from './handlers/command-handler.js';
+import { handleGitWatch, handleGitRefresh } from './handlers/git-handler.js';
+import { gitWatchService } from '../services/git-watch-service.js';
 import { handleCreateSecret, handleUpdateSecret, handleDeleteSecret, } from './handlers/secrets-handler.js';
 import { secretsService } from '../services/secrets-service.js';
 import { handleTestDatabaseConnection, handleTestDatabaseConnectionTransient, handleListDatabases, handleListTables, handleGetTableSchema, handleExecuteQuery, handleRequestQueryHistory, handleToggleQueryFavorite, handleDeleteQueryHistory, handleClearQueryHistory, } from './handlers/database-handler.js';
@@ -65,13 +67,21 @@ function messageReplacer(_key, value) {
 function serializeMessage(message) {
     return JSON.stringify(message, messageReplacer);
 }
+// Notification-only clients (connected with /ws?mode=notify, e.g. the Android
+// foreground service) subscribe exclusively to these types. Everything else —
+// output streams, activity, state syncs — is skipped so a backgrounded phone's
+// radio/CPU stay idle unless a real notification arrives.
+const NOTIFY_ONLY_TYPES = new Set(['agent_notification']);
+function wantsMessage(client, messageType) {
+    return !client.__tcNotifyOnly || NOTIFY_ONLY_TYPES.has(messageType);
+}
 export function broadcast(message) {
     try {
         const data = serializeMessage(message);
         let sentCount = 0;
         let errorCount = 0;
         for (const client of clients) {
-            if (client.readyState === WebSocket.OPEN) {
+            if (client.readyState === WebSocket.OPEN && wantsMessage(client, message.type)) {
                 try {
                     client.send(data);
                     sentCount++;
@@ -94,7 +104,7 @@ export function broadcast(message) {
 function broadcastToOthers(sender, message) {
     const data = serializeMessage(message);
     for (const client of clients) {
-        if (client !== sender && client.readyState === WebSocket.OPEN) {
+        if (client !== sender && client.readyState === WebSocket.OPEN && wantsMessage(client, message.type)) {
             client.send(data);
         }
     }
@@ -155,6 +165,8 @@ const messageHandlers = {
     building_command: handleBuildingCommand,
     pm2_logs_start: handlePM2LogsStart,
     pm2_logs_stop: handlePM2LogsStop,
+    git_watch: handleGitWatch,
+    git_refresh: handleGitRefresh,
     docker_logs_start: handleDockerLogsStart,
     docker_logs_stop: handleDockerLogsStop,
     docker_list_containers: (ctx) => handleDockerListContainers(ctx),
@@ -268,32 +280,45 @@ export function init(server) {
         catch {
             /* best-effort — client info is diagnostic only */
         }
-        log.log(`Client connected (total: ${clients.size})`);
-        // Send initial state immediately – status sync runs in background
-        const customClasses = customClassService.getAllCustomClasses();
-        ws.send(JSON.stringify({ type: 'custom_agent_classes_update', payload: customClasses }));
-        const agents = agentService.getAllAgents();
-        ws.send(JSON.stringify({ type: 'agents_update', payload: agents }));
-        const areas = loadAreas();
-        ws.send(JSON.stringify({ type: 'areas_update', payload: areas }));
-        const buildings = loadBuildings();
-        ws.send(JSON.stringify({ type: 'buildings_update', payload: buildings }));
-        const skills = skillService.getAllSkills();
-        ws.send(JSON.stringify({ type: 'skills_update', payload: skills }));
-        const secrets = secretsService.getAllSecrets();
-        ws.send(JSON.stringify({ type: 'secrets_update', payload: secrets }));
-        const triggers = triggerService.getAllTriggers();
-        ws.send(JSON.stringify({ type: 'triggers_update', payload: triggers }));
-        const workflowDefs = workflowService.listDefinitions();
-        ws.send(JSON.stringify({ type: 'workflow_definitions_update', payload: workflowDefs }));
-        const pendingPermissions = permissionService.getPendingRequests();
-        if (pendingPermissions.length > 0) {
-            log.log(`Sending ${pendingPermissions.length} pending permission requests`);
-            for (const request of pendingPermissions) {
-                ws.send(JSON.stringify({
-                    type: 'permission_request',
-                    payload: request,
-                }));
+        // Notification-only subscribers (the Android foreground service) get no
+        // broadcast firehose and no initial state — just agent_notification.
+        const notifyOnly = (request.url || '').includes('mode=notify');
+        if (notifyOnly) {
+            ws.__tcNotifyOnly = true;
+        }
+        log.log(`${notifyOnly ? 'Notification-only client' : 'Client'} connected (total: ${clients.size})`);
+        if (!notifyOnly) {
+            // Send initial state immediately – status sync runs in background
+            // server_time goes FIRST: clients use it to align their clock with the
+            // server before any output arrives, so optimistic client-stamped items
+            // sort correctly against server-stamped outputs even on devices with a
+            // skewed clock (mobile).
+            ws.send(JSON.stringify({ type: 'server_time', payload: { timestamp: Date.now() } }));
+            const customClasses = customClassService.getAllCustomClasses();
+            ws.send(JSON.stringify({ type: 'custom_agent_classes_update', payload: customClasses }));
+            const agents = agentService.getAllAgents();
+            ws.send(JSON.stringify({ type: 'agents_update', payload: agents }));
+            const areas = loadAreas();
+            ws.send(JSON.stringify({ type: 'areas_update', payload: areas }));
+            const buildings = loadBuildings();
+            ws.send(JSON.stringify({ type: 'buildings_update', payload: buildings }));
+            const skills = skillService.getAllSkills();
+            ws.send(JSON.stringify({ type: 'skills_update', payload: skills }));
+            const secrets = secretsService.getAllSecrets();
+            ws.send(JSON.stringify({ type: 'secrets_update', payload: secrets }));
+            const triggers = triggerService.getAllTriggers();
+            ws.send(JSON.stringify({ type: 'triggers_update', payload: triggers }));
+            const workflowDefs = workflowService.listDefinitions();
+            ws.send(JSON.stringify({ type: 'workflow_definitions_update', payload: workflowDefs }));
+            const pendingPermissions = permissionService.getPendingRequests();
+            if (pendingPermissions.length > 0) {
+                log.log(`Sending ${pendingPermissions.length} pending permission requests`);
+                for (const request of pendingPermissions) {
+                    ws.send(JSON.stringify({
+                        type: 'permission_request',
+                        payload: request,
+                    }));
+                }
             }
         }
         ws.on('message', (data) => {
@@ -309,14 +334,20 @@ export function init(server) {
         ws.on('close', () => {
             clients.delete(ws);
             setWsClientsCount(clients.size);
+            gitWatchService.removeSocket(ws);
             log.log(`Client disconnected (remaining: ${clients.size})`);
         });
         // Background sync – refreshes agent status after initial data is sent
-        runtimeService.syncAllAgentStatus().then(() => {
-            if (ws.readyState === WebSocket.OPEN) {
-                ws.send(JSON.stringify({ type: 'agents_update', payload: agentService.getAllAgents() }));
-            }
-        }).catch(() => { });
+        if (!notifyOnly) {
+            runtimeService.syncAllAgentStatus().then(() => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.send(JSON.stringify({ type: 'agents_update', payload: agentService.getAllAgents() }));
+                }
+            }).catch(() => { });
+            // PM2 polling pauses while no clients are connected — run one poll now
+            // so building status badges are fresh for this client.
+            buildingService.triggerPM2StatusPoll();
+        }
     });
     setupServiceListeners({
         broadcast,

package/dist/src/packages/server/websocket/handlers/git-handler.js

@@ -0,0 +1,11 @@
+/**
+ * Git watch message handlers — subscribe a socket to server-side git status
+ * polling (git_watch) and force an immediate recompute (git_refresh).
+ */
+import { gitWatchService } from '../../services/git-watch-service.js';
+export function handleGitWatch(ctx, payload) {
+    gitWatchService.setWatchList(ctx.ws, payload?.paths || []);
+}
+export function handleGitRefresh(ctx, payload) {
+    void gitWatchService.refreshPaths(payload?.paths || [], ctx.ws);
+}

package/dist/src/packages/server/websocket/listeners/index.js

@@ -5,11 +5,17 @@ import { setupAgentPromptListeners } from './agent-prompt-listeners.js';
 import { setupRuntimeListeners } from './runtime-listeners.js';
 import { setupSkillListeners } from './skill-listeners.js';
 export function setupServiceListeners(ctx) {
-    agentService.subscribe((event, data) => {
+    agentService.subscribe((event, data, meta) => {
         switch (event) {
             case 'created':
                 break;
             case 'updated':
+                // Quiet updates only changed high-churn metric fields (currentTool,
+                // context tokens) — clients already get those through the lightweight
+                // `context_update` and `event` messages, so skip the full-Agent
+                // broadcast (fires several times per tool call during streaming).
+                if (meta?.quiet)
+                    break;
                 ctx.broadcast({
                     type: 'agent_updated',
                     payload: data,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.131.0",
+  "version": "1.133.0",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",