mixdog 0.9.86 → 0.9.88

package/src/standalone/agent-watchdog-registry.mjs

@@ -32,6 +32,15 @@ export function createProgressWatchdogRegistry({ mgr }) {
     const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
       ? mgr.getSessionProgressSnapshot(sessionId)
       : null;
+    // Turn boundary: askStartedAt is re-stamped by markSessionAskStart for
+    // EVERY turn of one askSession call, including the follow-up turns drained
+    // from the pending-message queue. The sweep already reads this snapshot, so
+    // observing the change is the cheapest per-turn signal available here.
+    const askStartedAt = Number(snapshot?.askStartedAt || 0);
+    if (askStartedAt > 0 && askStartedAt !== state.lastAskStartedAt) {
+      state.lastAskStartedAt = askStartedAt;
+      try { state.onTurnStart?.(askStartedAt); } catch { /* bookkeeping only */ }
+    }
     const abortErr = snapshot ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy) : null;
     const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
     const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
@@ -79,7 +88,7 @@ export function createProgressWatchdogRegistry({ mgr }) {
   return {
     /** Watch a session until the returned handle is stopped; null when the
      *  policy is off or the manager cannot link an abort signal. */
-    start(sessionId, watchdogPolicy, agent = null) {
+    start(sessionId, watchdogPolicy, agent = null, { onTurnStart = null } = {}) {
       if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
       if (typeof mgr.getSessionProgressSnapshot !== 'function'
         && typeof mgr.getSessionLastProgressAt !== 'function') return null;
@@ -87,7 +96,15 @@ export function createProgressWatchdogRegistry({ mgr }) {
       const controller = new AbortController();
       const anchorTs = Date.now();
       try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
-      const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
+      const state = {
+        sessionId,
+        watchdogPolicy,
+        agent,
+        controller,
+        anchorTs,
+        onTurnStart: typeof onTurnStart === 'function' ? onTurnStart : null,
+        lastAskStartedAt: 0,
+      };
       watched.set(sessionId, state);
       ensureTimer();
       return {

package/src/standalone/channel-daemon.mjs

@@ -15,6 +15,14 @@
 process.env.MIXDOG_CHANNEL_DAEMON = '1';
 process.env.MIXDOG_WORKER_MODE = process.env.MIXDOG_WORKER_MODE || '1';
 
+// V8 compile cache: the daemon is a standalone child entry (not via cli.mjs);
+// caching compiled bytecode across restarts removes the channels+memory
+// runtime parse cost from every daemon boot. Best-effort.
+try {
+  const { enableCompileCache } = await import('node:module');
+  enableCompileCache?.();
+} catch { /* launch-speed optimization only */ }
+
 import os from 'node:os';
 import path from 'node:path';
 import { mkdirSync, appendFileSync } from 'node:fs';

package/src/standalone/memory-runtime-proxy.mjs

@@ -446,13 +446,10 @@ export function createStandaloneMemoryRuntime({
           MIXDOG_OWNER_LEAD_PID: String(process.pid),
           MIXDOG_MEMORY_SECONDARY: '0',
           MIXDOG_PG_ATTACH_ONLY: '0',
-          // seeds.mjs defaults MIXDOG_EMBED_WARMUP to '0' for the HOST process
-          // (TUI boot must not pay the ONNX session-create cost). The daemon is
-          // the long-lived embed owner, so warmup is force-enabled here like the
-          // secondary/attach flags above — otherwise the daemon boots cold and
-          // every recall runs lexical-only until the first fallback flush
-          // lazily loads the model (observed 1.5h '(no results)' windows).
-          MIXDOG_EMBED_WARMUP: '1',
+          // The daemon owns the model, but ownership does not imply eager
+          // residency. A recall starts warmup on demand and immediately uses
+          // lexical search while it loads, keeping desktop/TUI boot lightweight.
+          MIXDOG_EMBED_WARMUP: process.env.MIXDOG_EMBED_WARMUP ?? '0',
           MIXDOG_MEMORY_DISABLE_CYCLES: process.env.MIXDOG_MEMORY_DISABLE_CYCLES ?? '0',
           MIXDOG_MEMORY_DISABLE_LLM_WORKER: process.env.MIXDOG_MEMORY_DISABLE_LLM_WORKER ?? '0',
           MIXDOG_QUIET_SESSION_LOG: process.env.MIXDOG_QUIET_SESSION_LOG ?? '1',

package/src/standalone/projects.mjs

@@ -12,7 +12,9 @@ import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSyn
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 
 const MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
-const PROJECTS_FILE = join(MIXDOG_HOME, 'projects.json');
+const PROJECTS_FILE = process.env.MIXDOG_PROJECTS_FILE
+  ? resolve(process.env.MIXDOG_PROJECTS_FILE)
+  : join(MIXDOG_HOME, 'projects.json');
 
 /** Resolve a raw path to an absolute path against the user's cwd. */
 function toAbsolute(rawPath) {
@@ -76,6 +78,7 @@ function writeStore(store) {
  */
 function ensureProjectIdMarker(absPath, name) {
   try {
+    if (process.env.MIXDOG_DISABLE_PROJECT_MARKERS === '1') return;
     if (!absPath) return;
     // Only when the project folder actually exists as a directory on disk.
     try {

package/src/standalone/usage-dashboard.mjs

@@ -82,6 +82,35 @@ function normaliseWindows(value, source = 'config') {
   }).filter(Boolean);
 }
 
+function normaliseResetCredits(value) {
+  if (!value || typeof value !== 'object') return null;
+  const availableCount = num(value.availableCount ?? value.available_count, null);
+  const offerRevision = clean(value.offerRevision ?? value.offer_revision);
+  if (availableCount === null || !offerRevision) return null;
+  const nextExpiresAt = num(value.nextExpiresAt ?? value.next_expires_at, null);
+  const rawAvailableCredits = value.availableCredits ?? value.available_credits;
+  const availableCredits = (Array.isArray(rawAvailableCredits) ? rawAvailableCredits : [])
+    .map((credit) => {
+      if (!credit || typeof credit !== 'object' || Array.isArray(credit)) return null;
+      const expiresAt = num(credit.expiresAt ?? credit.expires_at, null);
+      const grantedAt = num(credit.grantedAt ?? credit.granted_at, null);
+      return {
+        ...(expiresAt && expiresAt > 0 ? { expiresAt } : {}),
+        ...(grantedAt && grantedAt > 0 ? { grantedAt } : {}),
+      };
+    })
+    .filter(Boolean)
+    .sort((left, right) =>
+      (left.expiresAt ?? Number.POSITIVE_INFINITY)
+      - (right.expiresAt ?? Number.POSITIVE_INFINITY));
+  return {
+    availableCount: Math.max(0, Math.floor(availableCount)),
+    offerRevision,
+    availableCredits,
+    ...(nextExpiresAt && nextExpiresAt > 0 ? { nextExpiresAt } : {}),
+  };
+}
+
 function localBudget(providerCfg = {}) {
   const limitUsd = num(
     providerCfg.limitUsd ?? providerCfg.limit_usd ?? providerCfg.budgetUsd ?? providerCfg.budget_usd
@@ -221,15 +250,28 @@ function rowTone(row) {
 async function oauthSnapshot(providerId, { refresh, getProvider, log }) {
   const cached = readCachedOAuthUsageSnapshot({ provider: providerId, model: '' });
   if (!refresh && cached) return cached;
+  // A rate-limited or failed forced refresh (Anthropic /oauth/usage 429s
+  // aggressively) must not blank a known quota row: fall back to the last
+  // contentful snapshot — a stale meter with its updatedAt beats an empty row.
+  const staleFallback = () => cached
+    || readCachedOAuthUsageSnapshot({ provider: providerId, model: '' }, { allowStale: true });
   if (typeof getProvider === 'function') {
     try {
       const providerObj = getProvider(providerId);
-      if (providerObj) return await fetchOAuthUsageSnapshot({ provider: providerId, model: '' }, providerObj, log);
+      if (providerObj) {
+        const fresh = await fetchOAuthUsageSnapshot(
+          { provider: providerId, model: '' },
+          providerObj,
+          log,
+          { force: refresh === true },
+        );
+        return fresh || staleFallback();
+      }
     } catch {
-      return null;
+      return staleFallback();
     }
   }
-  return cached;
+  return staleFallback();
 }
 
 async function apiSnapshot(providerId, { refresh } = {}) {
@@ -544,7 +586,9 @@ export async function createUsageDashboard(config = {}, options = {}) {
         const snapshot = await oauthSnapshot(item.id, options);
         const known = snapshotRemaining(snapshot);
         const windows = normaliseWindows(snapshot?.quotaWindows, clean(snapshot?.source) || 'provider-api');
+        const resetCredits = normaliseResetCredits(snapshot?.resetCredits);
         row.windows = windows;
+        if (resetCredits) row.resetCredits = resetCredits;
         row.updatedAt = num(snapshot?.cachedAt, null);
         if (known) {
           applyKnownRemaining(row, known, { estimated: false });