droid-patch 0.8.1 → 0.8.2

package/dist/cli.mjs

@@ -706,19 +706,31 @@ function extractSessionIdFromLine(line) {
   return m ? m[1] : null;
 }
 
+function parseLineTimestampMs(line) {
+  const s = String(line || '');
+  if (!s || s[0] !== '[') return null;
+  const end = s.indexOf(']');
+  if (end <= 1) return null;
+  const raw = s.slice(1, end);
+  const ms = Date.parse(raw);
+  return Number.isFinite(ms) ? ms : null;
+}
+
+function safeStatMtimeMs(p) {
+  try {
+    const stat = fs.statSync(p);
+    const ms = Number(stat?.mtimeMs ?? 0);
+    return Number.isFinite(ms) ? ms : 0;
+  } catch {
+    return 0;
+  }
+}
+
 function nextCompactionState(line, current) {
   if (!line) return current;
   if (line.includes('[Compaction] Start')) return true;
-  if (
-    line.includes('[Compaction] End') ||
-    line.includes('[Compaction] Done') ||
-    line.includes('[Compaction] Finish') ||
-    line.includes('[Compaction] Finished') ||
-    line.includes('[Compaction] Complete') ||
-    line.includes('[Compaction] Completed')
-  ) {
-    return false;
-  }
+  const endMarkers = ['End', 'Done', 'Finish', 'Finished', 'Complete', 'Completed'];
+  if (endMarkers.some(m => line.includes('[Compaction] ' + m))) return false;
   return current;
 }
 
@@ -1184,7 +1196,7 @@ function buildLine(params) {
 }
 
 async function main() {
-  const factoryConfig = readJsonFile(CONFIG_PATH) || {};
+  let factoryConfig = readJsonFile(CONFIG_PATH) || {};
 
   const cwd = process.cwd();
   const cwdBase = path.basename(cwd) || cwd;
@@ -1231,22 +1243,68 @@ async function main() {
   }
 
   if (!sessionId || !workspaceDir) return;
-  const sessionIdLower = String(sessionId).toLowerCase();
-
-  const { settingsPath, settings } = resolveSessionSettings(workspaceDir, sessionId);
-  const modelId =
-    (settings && typeof settings.model === 'string' ? settings.model : null) || resolveGlobalSettingsModel();
+  let sessionIdLower = String(sessionId).toLowerCase();
+
+  let settingsPath = '';
+  let sessionSettings = {};
+  ({ settingsPath, settings: sessionSettings } = resolveSessionSettings(workspaceDir, sessionId));
+
+  let configMtimeMs = safeStatMtimeMs(CONFIG_PATH);
+  let globalSettingsMtimeMs = safeStatMtimeMs(GLOBAL_SETTINGS_PATH);
+  let globalSettingsModel = resolveGlobalSettingsModel();
+
+  let modelId =
+    (sessionSettings && typeof sessionSettings.model === 'string' ? sessionSettings.model : null) ||
+    globalSettingsModel ||
+    null;
+
+  let provider =
+    sessionSettings && typeof sessionSettings.providerLock === 'string'
+      ? sessionSettings.providerLock
+      : resolveProvider(modelId, factoryConfig);
+  let underlyingModel = resolveUnderlyingModelId(modelId, factoryConfig) || modelId || 'unknown';
+
+  function refreshModel() {
+    const nextModelId =
+      (sessionSettings && typeof sessionSettings.model === 'string' ? sessionSettings.model : null) ||
+      globalSettingsModel ||
+      null;
+
+    // Use providerLock if set, otherwise resolve from model/config (same logic as initialization)
+    const nextProvider =
+      sessionSettings && typeof sessionSettings.providerLock === 'string'
+        ? sessionSettings.providerLock
+        : resolveProvider(nextModelId, factoryConfig);
+    const nextUnderlying = resolveUnderlyingModelId(nextModelId, factoryConfig) || nextModelId || 'unknown';
+
+    let changed = false;
+    if (nextModelId !== modelId) {
+      modelId = nextModelId;
+      changed = true;
+    }
+    if (nextProvider !== provider) {
+      provider = nextProvider;
+      changed = true;
+    }
+    if (nextUnderlying !== underlyingModel) {
+      underlyingModel = nextUnderlying;
+      changed = true;
+    }
 
-  const provider = resolveProvider(modelId, factoryConfig);
-  const underlyingModel = resolveUnderlyingModelId(modelId, factoryConfig) || modelId || 'unknown';
+    if (changed) renderNow();
+  }
 
   let last = { cacheReadInputTokens: 0, contextCount: 0, outputTokens: 0 };
-  let sessionUsage = settings && typeof settings.tokenUsage === 'object' && settings.tokenUsage ? settings.tokenUsage : {};
+  let sessionUsage =
+    sessionSettings && typeof sessionSettings.tokenUsage === 'object' && sessionSettings.tokenUsage
+      ? sessionSettings.tokenUsage
+      : {};
   let compacting = false;
   let lastRenderAt = 0;
   let lastRenderedLine = '';
   let gitBranch = '';
   let gitDiff = '';
+  let lastContextMs = 0;
 
   function renderNow() {
     const usedTokens = (last.cacheReadInputTokens || 0) + (last.contextCount || 0);
@@ -1284,19 +1342,25 @@ async function main() {
   let reseedInProgress = false;
   let reseedQueued = false;
 
-  function updateLastFromContext(ctx, updateOutputTokens) {
+  function updateLastFromContext(ctx, updateOutputTokens, tsMs) {
+    const ts = Number.isFinite(tsMs) ? tsMs : null;
+    if (ts != null && lastContextMs && ts < lastContextMs) return false;
     const cacheRead = Number(ctx?.cacheReadInputTokens);
     const contextCount = Number(ctx?.contextCount);
     const out = Number(ctx?.outputTokens);
     if (Number.isFinite(cacheRead)) last.cacheReadInputTokens = cacheRead;
     if (Number.isFinite(contextCount)) last.contextCount = contextCount;
     if (updateOutputTokens && Number.isFinite(out)) last.outputTokens = out;
+    if (ts != null) lastContextMs = ts;
+    return true;
   }
 
   function seedLastContextFromLog(options) {
     const opts = options || {};
     const maxScanBytes = Number.isFinite(opts.maxScanBytes) ? opts.maxScanBytes : 64 * 1024 * 1024;
     const preferStreaming = !!opts.preferStreaming;
+    const minTimestampMs = Number.isFinite(lastContextMs) && lastContextMs > 0 ? lastContextMs : 0;
+    const earlyStopAfterBestBytes = Math.min(2 * 1024 * 1024, Math.max(256 * 1024, maxScanBytes));
 
     if (reseedInProgress) {
       reseedQueued = true;
@@ -1318,15 +1382,20 @@ async function main() {
           let pos = size;
           let scanned = 0;
           let remainder = '';
-          let seeded = false;
+          let bestCtx = null;
+          let bestIsStreaming = false;
+          let bestTs = null;
+          let bestHasTs = false;
+          let bytesSinceBest = 0;
 
-          while (pos > 0 && scanned < maxScanBytes && !seeded) {
+          while (pos > 0 && scanned < maxScanBytes && (!bestHasTs || bytesSinceBest < earlyStopAfterBestBytes)) {
             const readSize = Math.min(CHUNK_BYTES, pos);
             const start = pos - readSize;
             const buf = Buffer.alloc(readSize);
             fs.readSync(fd, buf, 0, readSize, start);
             pos = start;
             scanned += readSize;
+            bytesSinceBest += readSize;
 
             let text = buf.toString('utf8') + remainder;
             let lines = String(text).split('\\n');
@@ -1361,13 +1430,34 @@ async function main() {
               const hasUsage = Number.isFinite(cacheRead) || Number.isFinite(contextCount);
               if (!hasUsage) continue;
 
-              updateLastFromContext(ctx, isStreaming);
-              seeded = true;
-              break;
+              const ts = parseLineTimestampMs(line);
+              if (ts != null && minTimestampMs && ts < minTimestampMs) {
+                continue;
+              }
+
+              if (ts != null) {
+                if (!bestHasTs || ts > bestTs) {
+                  bestCtx = ctx;
+                  bestIsStreaming = isStreaming;
+                  bestTs = ts;
+                  bestHasTs = true;
+                  bytesSinceBest = 0;
+                }
+              } else if (!bestHasTs && !bestCtx) {
+                // No timestamps available yet: the first match when scanning backward
+                // is the most recent in file order.
+                bestCtx = ctx;
+                bestIsStreaming = isStreaming;
+                bestTs = null;
+              }
             }
 
             if (remainder.length > 8192) remainder = remainder.slice(-8192);
           }
+
+          if (bestCtx) {
+            updateLastFromContext(bestCtx, bestIsStreaming, bestTs);
+          }
         } finally {
           try {
             fs.closeSync(fd);
@@ -1399,17 +1489,36 @@ async function main() {
   let settingsMtimeMs = 0;
   let lastCtxPollMs = 0;
   setInterval(() => {
+    // Refresh config/global settings if they changed (model display depends on these).
+    const configMtime = safeStatMtimeMs(CONFIG_PATH);
+    if (configMtime && configMtime !== configMtimeMs) {
+      configMtimeMs = configMtime;
+      factoryConfig = readJsonFile(CONFIG_PATH) || {};
+      refreshModel();
+    }
+
+    const globalMtime = safeStatMtimeMs(GLOBAL_SETTINGS_PATH);
+    if (globalMtime && globalMtime !== globalSettingsMtimeMs) {
+      globalSettingsMtimeMs = globalMtime;
+      globalSettingsModel = resolveGlobalSettingsModel();
+      refreshModel();
+    }
+
     try {
       const stat = fs.statSync(settingsPath);
       if (stat.mtimeMs === settingsMtimeMs) return;
       settingsMtimeMs = stat.mtimeMs;
       const next = readJsonFile(settingsPath) || {};
+      sessionSettings = next;
 
       // Keep session token usage in sync (used by /status).
       if (next && typeof next.tokenUsage === 'object' && next.tokenUsage) {
         sessionUsage = next.tokenUsage;
       }
 
+      // Keep model/provider in sync (model can change during a running session).
+      refreshModel();
+
       const now = Date.now();
       if (now - lastRenderAt >= MIN_RENDER_INTERVAL_MS) {
         lastRenderAt = now;
@@ -1431,6 +1540,37 @@ async function main() {
     seedLastContextFromLog({ maxScanBytes: 4 * 1024 * 1024, preferStreaming: false });
   }, 2000).unref();
 
+  function switchToSession(nextSessionId) {
+    if (!nextSessionId || !isUuid(nextSessionId)) return;
+    const nextLower = String(nextSessionId).toLowerCase();
+    if (nextLower === sessionIdLower) return;
+
+    sessionId = nextSessionId;
+    sessionIdLower = nextLower;
+
+    const resolved = resolveSessionSettings(workspaceDir, nextSessionId);
+    settingsPath = resolved.settingsPath;
+    sessionSettings = resolved.settings || {};
+
+    sessionUsage =
+      sessionSettings && typeof sessionSettings.tokenUsage === 'object' && sessionSettings.tokenUsage
+        ? sessionSettings.tokenUsage
+        : {};
+
+    // Reset cached state for the new session.
+    last = { cacheReadInputTokens: 0, contextCount: 0, outputTokens: 0 };
+    lastContextMs = 0;
+    compacting = false;
+    settingsMtimeMs = 0;
+    lastCtxPollMs = 0;
+
+    refreshModel();
+    renderNow();
+
+    // Best-effort: if the new session already has Context lines in the log, seed quickly.
+    seedLastContextFromLog({ maxScanBytes: 8 * 1024 * 1024, preferStreaming: false });
+  }
+
   // Follow the Factory log and update based on session-scoped events.
   const tail = spawn('tail', ['-n', '0', '-F', LOG_PATH], {
     stdio: ['ignore', 'pipe', 'ignore'],
@@ -1445,10 +1585,35 @@ async function main() {
       const line = buffer.slice(0, idx).trimEnd();
       buffer = buffer.slice(idx + 1);
 
+      const tsMs = parseLineTimestampMs(line);
       const lineSessionId = extractSessionIdFromLine(line);
       const isSessionLine =
         lineSessionId && String(lineSessionId).toLowerCase() === sessionIdLower;
 
+      // /compress (aka /compact) can create a new session ID. Follow it so ctx/model keep updating.
+      if (line.includes('oldSessionId') && line.includes('newSessionId') && line.includes('Context:')) {
+        const ctxIndex = line.indexOf('Context: ');
+        if (ctxIndex !== -1) {
+          const jsonStr = line.slice(ctxIndex + 'Context: '.length).trim();
+          try {
+            const meta = JSON.parse(jsonStr);
+            const oldId = meta?.oldSessionId;
+            const newId = meta?.newSessionId;
+            if (
+              isUuid(oldId) &&
+              isUuid(newId) &&
+              String(oldId).toLowerCase() === sessionIdLower &&
+              String(newId).toLowerCase() !== sessionIdLower
+            ) {
+              switchToSession(String(newId));
+              continue;
+            }
+          } catch {
+            // ignore
+          }
+        }
+      }
+
       let compactionChanged = false;
       let compactionEnded = false;
       if (line.includes('[Compaction]')) {
@@ -1464,6 +1629,20 @@ async function main() {
         }
       }
 
+      if (compactionChanged && compacting) {
+        // Compaction can start after a context-limit error. Ensure we display the latest
+        // pre-compaction ctx by reseeding from log (tail can miss bursts).
+        seedLastContextFromLog({ maxScanBytes: 8 * 1024 * 1024, preferStreaming: true });
+      }
+
+      if (compactionEnded) {
+        // ctx usage changes dramatically after compaction, but the next Context line
+        // can be delayed. Clear displayed ctx immediately to avoid showing stale numbers.
+        last.cacheReadInputTokens = 0;
+        last.contextCount = 0;
+        if (tsMs != null) lastContextMs = tsMs;
+      }
+
       if (!line.includes('Context:')) {
         if (compactionChanged) {
           lastRenderAt = Date.now();
@@ -1507,7 +1686,7 @@ async function main() {
 
       // Context usage can appear on multiple session-scoped log lines; update whenever present.
       // (Streaming is still the best source for outputTokens / LastOut.)
-      updateLastFromContext(ctx, false);
+      updateLastFromContext(ctx, false, tsMs);
 
       // For new sessions: if this is the first valid Context line and ctx is still 0,
       // trigger a reseed to catch any earlier log entries we might have missed.
@@ -1519,7 +1698,7 @@ async function main() {
       }
 
       if (line.includes('[Agent] Streaming result')) {
-        updateLastFromContext(ctx, true);
+        updateLastFromContext(ctx, true, tsMs);
       }
 
       const now = Date.now();
@@ -2276,12 +2455,7 @@ async function main() {
   }
 
   function includesScrollRegionCSI() {
-    // Equivalent to Python: re.search(b"\\x1b\\\\[[0-9]*;?[0-9]*r", detect_buf)
-    try {
-      return /\\x1b\\[[0-9]*;?[0-9]*r/.test(detectStr);
-    } catch {
-      return false;
-    }
+    return /\\x1b\\[[0-9]*;?[0-9]*r/.test(detectStr);
   }
 
   function updateCursorVisibility() {