mixdog 0.9.4 → 0.9.6

package/src/tui/engine.mjs

@@ -173,8 +173,12 @@ export async function createEngineSession({
     if (!status) return;
     const displayWindow = Number(status.contextWindow || 0);
     const compactBoundary = Number(status.compaction?.boundaryTokens || 0);
+    // Prefer the resolved trigger (boundary - buffer): the statusline uses it
+    // as the display denominator so context % reads 100% exactly when
+    // auto-compact fires, instead of stalling at ~90% of the boundary.
     const autoCompact = Number(
-      status.compaction?.autoCompactTokenLimit
+      status.compaction?.triggerTokens
+      || status.compaction?.autoCompactTokenLimit
       || runtime.session?.autoCompactTokenLimit
       || 0,
     );
@@ -655,7 +659,13 @@ export async function createEngineSession({
     // cards are pushed alongside the result-bearing one before their own delay
     // elapses and would otherwise paint an empty reserved band.
     // Mirrors components/ToolExecution.jsx TOOL_PENDING_SHOW_DELAY_MS.
-    const TOOL_CARD_PUSH_DELAY_MS = 1000;
+    // [jitter fix] Reserve the tool-card row immediately instead of after a
+    // 1000ms delay. Delayed insertion made rows appear late and shove the body
+    // vertically; pushing now (with the real 'Running' header height via
+    // deferredDisplayReady) keeps the layout stable. The timer path is kept as a
+    // 0ms microtask fallback for entries that are registered but not explicitly
+    // surfaced, preserving call-order flush semantics.
+    const TOOL_CARD_PUSH_DELAY_MS = 0;
     let deferredSeqCounter = 0;
     const deferredEntries = []; // creation-order list; each is pushed at most once
     // Push this entry AND every earlier-created still-deferred entry, in order,
@@ -927,7 +937,7 @@ export async function createEngineSession({
     // never held back waiting for the next Ink frame. 16ms (~60fps) left every
     // other Ink frame idle, which made fast provider streams visibly land in
     // coarse chunks ("10 chars at a time").
-    const STREAM_BATCH_INTERVAL_MS = 8;
+    const STREAM_BATCH_INTERVAL_MS = 16;
     let _batchTimer = null;
     let _pendingTextFlush = false;   // true when a text/spinner update is queued
     let _pendingThinkFlush = false;  // true when a thinking update is queued
@@ -1155,6 +1165,10 @@ export async function createEngineSession({
           }
 
           const touchedAggregates = new Set();
+          // [jitter fix] Last standalone (Agent) card in this batch to reserve a
+          // row for. Flushed AFTER the syncAggregateHeader loop so any earlier-seq
+          // aggregate it would flush-through already has its pendingSpec built.
+          let standaloneReserve = null;
           for (let i = 0; i < batchCalls.length; i++) {
             const c = batchCalls[i];
             const name = toolCallName(c);
@@ -1207,6 +1221,13 @@ export async function createEngineSession({
                 cardByCallId.set(callId, card);
               }
               toolCards.push(card);
+              // [jitter fix] Immediate row-reserve is deferred to after the
+              // syncAggregateHeader loop below (see standaloneReserve): calling
+              // ensureVisible() here would flushDeferredUpTo() every earlier-seq
+              // entry — including an aggregate whose pendingSpec syncAggregateHeader
+              // hasn't built yet — marking it pushed without inserting (lost/
+              // out-of-order card). Record it and flush once headers exist.
+              standaloneReserve = card;
               // A standalone card (Agent) breaks the consecutive run too: a
               // later same-bucket call must open a fresh card BELOW it, not
               // merge into an aggregate above it.
@@ -1234,6 +1255,11 @@ export async function createEngineSession({
           for (const aggregateCard of touchedAggregates) {
             syncAggregateHeader(aggregateCard);
           }
+          // [jitter fix] Now that every touched aggregate has its pendingSpec,
+          // reserve the standalone (Agent) card's row immediately. Its
+          // ensureVisible() flushes earlier-seq entries too, but those aggregates
+          // are now push-ready so none is marked pushed without inserting.
+          standaloneReserve?.ensureVisible?.();
           if (committedAssistantSegment) {
             // A pre-tool assistant preamble has already had one render frame to
             // settle. Do not let the first grouped tool card sit off-screen until
@@ -1280,7 +1306,7 @@ export async function createEngineSession({
             detail: compactEventDetail(event),
           });
         },
-        onStageChange: (stage) => {
+        onStageChange: async (stage) => {
           if (!state.spinner) return;
           const value = String(stage || '');
           if (value === 'compacting') {
@@ -1299,6 +1325,7 @@ export async function createEngineSession({
                 mode: 'compacting',
               },
             });
+            await yieldToRenderer();
             return;
           }
           if (value === 'requesting' || value === 'streaming') compactingActive = false;
@@ -2225,6 +2252,11 @@ export async function createEngineSession({
       const startedAt = Date.now();
       set({ commandBusy: true, commandStatus: { active: true, verb: 'Compacting conversation', startedAt, mode: 'compacting' } });
       try {
+        // Give Ink one event-loop turn to paint the compacting spinner before
+        // runtime.compact() starts synchronous session/transcript work (same
+        // yield as the auto-clear path; without it /compact looks frozen with
+        // no spinner until the compact already finished).
+        await new Promise((resolve) => setTimeout(resolve, 0));
         const result = await runtime.compact({ recoverAgent: true });
         syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...state.stats } });
@@ -2248,6 +2280,15 @@ export async function createEngineSession({
               error: result.error,
             }),
           });
+        } else {
+          // null = session missing/closed: still surface a done row so
+          // /compact never ends silently without a completion marker.
+          pushItem({
+            kind: 'statusdone',
+            id: nextId(),
+            label: 'Compact failed',
+            detail: 'no active session',
+          });
         }
         return result;
       } finally {
@@ -2556,14 +2597,9 @@ export async function createEngineSession({
       pushNotice('webhook/ngrok authtoken forgotten', 'info');
       return result;
     },
-    saveChannel: (entry) => {
-      const result = runtime.saveChannel(entry);
-      pushNotice(`channel saved: ${entry.name}`, 'info');
-      return result;
-    },
-    deleteChannel: (name) => {
-      const result = runtime.deleteChannel(name);
-      pushNotice(`channel deleted: ${name}`, 'info');
+    setChannel: (entry) => {
+      const result = runtime.setChannel(entry);
+      pushNotice('channel saved', 'info');
       return result;
     },
     setWebhookConfig: (patch) => {

package/src/tui/index.jsx

@@ -16,6 +16,7 @@ import { installProcessSignalCleanup } from '../runtime/shared/process-shutdown.
 import { touchUiHeartbeat } from '../runtime/channels/lib/runtime-paths.mjs';
 import { emitTerminalBackground, loadThemeSettingFromConfig, theme } from './theme.mjs';
 import { POP_KITTY, DISABLE_MODIFY_OTHER_KEYS } from './keyboard-protocol.mjs';
+import { displayWidth } from './display-width.mjs';
 
 const TERMINAL_MODE_RESET = '\x1b[?1006l\x1b[?1005l\x1b[?1015l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?2004l\x1b[?25h';
 const TERMINAL_OSC_RESET_BG = '\x1b]111\x07';
@@ -152,16 +153,18 @@ function ansiFg(rgb) {
  * the seconds between alt-screen entry and the first ink frame are not a blank
  * void. The logo is drawn at the SAME rows/columns as App.jsx's welcome banner
  * (marginTop 3 + 5 logo rows + blank + subtitle), so ink's first real frame
- * overprints it in place with no visible jump. The bottom panel silhouette
- * carries an animated "Loading projects…" spinner so the boot reads as an
- * explicit loading state instead of an empty box that later fills with the
- * list. Returns { stop } — call it right before ink mounts.
+ * overprints it in place with no visible jump. Do NOT pre-paint the bottom
+ * picker/prompt frame here: the first ink frame may hide or move those rows
+ * while the initial project picker settles, and stale raw borders look like a
+ * broken frame. Returns { stop } — call it right before ink mounts.
  */
 function paintBootSplash() {
   try {
     const cols = Math.max(1, Number(process.stdout.columns) || 80);
     const rows = Math.max(1, Number(process.stdout.rows) || 24);
-    const center = (s) => `${' '.repeat(Math.max(0, Math.floor((cols - s.length) / 2)))}${s}`;
+    const windowsLikeTerminal = process.platform === 'win32' || Boolean(process.env.WT_SESSION);
+    const frameCols = Math.max(1, cols - (windowsLikeTerminal ? 1 : 0));
+    const center = (s) => `${' '.repeat(Math.max(0, Math.floor((frameCols - displayWidth(s)) / 2)))}${s}`;
     const logo = [
       '███╗   ███╗██╗██╗  ██╗██████╗  ██████╗  ██████╗ ',
       '████╗ ████║██║╚██╗██╔╝██╔══██╗██╔═══██╗██╔════╝ ',
@@ -181,56 +184,12 @@ function paintBootSplash() {
     }
     out += '\r\n';
     out += `${subtleFg}${center(`mixdog coding agent · ${process.cwd()}`)}${reset}`;
-    // Bottom placeholder: the first REAL screen is the project picker — a tall
-    // floating panel sitting directly above the 3-row statusline — not the
-    // 3-row prompt box. Painting a short prompt silhouette here made the panel
-    // look like it "unfolded" from 3 rows to full height on the first ink
-    // frame. Mirror App.jsx's startup math instead:
-    //   floatingPanelRows = min(17, rows - 15), bottom row = rows - 3.
-    const floating = Math.min(17, rows - 15);
-    let spinnerRow = 0;
-    let spinnerFg = '';
-    if (floating >= 3) {
-      const borderFg = ansiFg(theme.promptBorder) || subtleFg;
-      // Leave the last COLUMN untouched: writing the bottom-right cell makes
-      // Windows Terminal/conhost scroll the alt screen one row (same reason
-      // App.jsx reserves rightSafetyColumns), which made the whole splash jump
-      // when the box was painted at full width on the final row.
-      const boxW = Math.max(4, cols - 1);
-      const innerW = boxW - 2;
-      const topRow = rows - 3 - floating + 1;
-      out += `\x1b[${topRow};1H${borderFg}╭${'─'.repeat(innerW)}╮`;
-      for (let i = 1; i < floating - 1; i++) {
-        out += `\x1b[${topRow + i};1H│${' '.repeat(innerW)}│`;
-      }
-      out += `\x1b[${rows - 3};1H╰${'─'.repeat(innerW)}╯${reset}`;
-      // "Loading projects…" line inside the panel silhouette. Picker.jsx
-      // renders border, then (paddingX=1, no paddingY) title/help row as its
-      // very first interior row — not vertically centered. Match that rhythm
-      // (topRow + 1) instead of centering, so ink's first frame doesn't jump
-      // the text down/up when it overprints this splash.
-      spinnerRow = topRow + 1;
-      spinnerFg = subtleFg;
-      out += `\x1b[${spinnerRow};3H${subtleFg}  Loading projects…${reset}`;
-    }
+
     // Park the cursor at home so ink's first frame paints top-down over the
     // splash instead of starting at the bottom row and scrolling the screen.
     out += '\x1b[H';
     process.stdout.write(out);
-    // Animate only the single spinner glyph cell — never reflow anything else,
-    // so stopping mid-frame can't leave torn output for ink to overwrite.
-    if (spinnerRow > 0) {
-      const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-      let tick = 0;
-      const timer = setInterval(() => {
-        try {
-          process.stdout.write(`\x1b[${spinnerRow};3H${spinnerFg}${frames[tick % frames.length]}${reset}\x1b[H`);
-          tick += 1;
-        } catch { /* ignore */ }
-      }, 80);
-      timer.unref?.();
-      return { stop: () => clearInterval(timer) };
-    }
+
     return { stop: () => {} };
   } catch { /* cosmetic only — never block boot */ }
   return { stop: () => {} };
@@ -472,7 +431,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
   // does not exit abruptly. Explicit exits go through /exit or /quit so teardown
   // still restores the cursor, mouse mode, and alternate screen cleanly.
   try {
-    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 120, onRender: makeRenderProfiler() });
+    const instance = render(<App store={store} forceOnboarding={forceOnboarding === true} />, { exitOnCtrlC: false, maxFps: 60, onRender: makeRenderProfiler() });
     bootProfile('render:mounted', { ms: (performance.now() - startedAt).toFixed(1) });
     const { waitUntilExit } = instance;
     // [mixdog fork] Hand the ink renderer's drag-selection setter to the store so

package/src/ui/statusline.mjs

@@ -173,6 +173,16 @@ function resolveContextUsedPct({
     autoCompactTokenLimit,
     compact,
   });
+  // Trigger-as-denominator: when a sub-boundary compaction trigger
+  // (boundary - buffer) is known, context % is measured against IT so the
+  // gauge reads 100% exactly when auto-compact fires instead of stalling at
+  // ~90% of the boundary window. The gateway's own pct is computed against
+  // the boundary denominator, so it is bypassed in that case.
+  const trigger = num(autoCompactTokenLimit);
+  const triggerDenominator = trigger > 0 && (!(boundary > 0) || trigger < boundary);
+  if (triggerDenominator && numerator > 0) {
+    return (numerator / trigger) * 100;
+  }
   const gatewayRawPct = gatewayStatus?.contextUsedPct;
   if (
     gatewayStatus

package/src/workflows/default/WORKFLOW.md

@@ -16,16 +16,15 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
 - Debugger: deploy for very high complexity, or when root-causing has already
   failed at least once.
 
-1. Plan — discuss the request with the user, form a plan, and wait for approval.
+1. Plan — discuss the request with the user, form a plan, wait for approval.
 2. Delegate — split into the maximum number of independent scopes.
    - PARALLEL across independent scopes by default (implementation, analysis,
-     review, debugging split alike). Spawn every scope in the SAME turn. Shared
-     or cross-cutting code does NOT justify merging: split per path and verify
-     the shared parts yourself. The only single scope is a genuinely
-     inseparable dependency — then state it.
-   - SEQUENTIAL within a single complex scope — split it into ordered steps
-     rather than handing it off in one shot, with a build/test-green gate
-     between steps.
+     review, debugging alike). Spawn every scope in the SAME turn. Shared or
+     cross-cutting code does NOT justify merging: split per path and verify the
+     shared parts yourself. The only single scope is a genuinely inseparable
+     dependency — then state it.
+   - SEQUENTIAL within a single complex scope — split into ordered steps rather
+     than one shot, with a build/test-green gate between steps.
    - Write briefs per the Lead brief contract (token-optimized labeled
      fragments).
    - After spawning async agent(s), END THE TURN — do not poll, guess, or start
@@ -34,15 +33,14 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
 3. Review — pair one reviewer 1:1 with each implementation scope, spawned in the
    same turn; never defer or batch the reviewer call — wait for its result.
    Fact-check the agent response and cross-check implementation and review
-   results yourself before acting on them. Send fixes back to the original
-   scope and loop verify -> fix -> re-verify until clean. Skip review only for
-   simple, low-risk tasks. If the user asks for debugging, or a bug survives
-   2+ fix cycles, have the debugger investigate first instead of another fix
-   round.
-4. Report — deliver the final report: synthesize results (outcome + key
-   evidence; never forward raw agent output), state the final state, and ask the
-   user whether to ship/deploy when relevant. Only after user feedback with no
-   issues prepare deploy/build/commit.
+   results yourself before acting. Send fixes back to the original scope and
+   loop verify -> fix -> re-verify until clean. Skip review only for simple,
+   low-risk tasks. If the user asks for debugging, or a bug survives 2+ fix
+   cycles, have the debugger investigate first instead of another fix round.
+4. Report — synthesize results (outcome + key evidence; never forward raw agent
+   output), state the final state, and ask whether to ship/deploy when
+   relevant. Only after user feedback with no issues prepare
+   deploy/build/commit.
 
 On any major change or direction shift mid-work, pause and re-consult the user
 before continuing.

package/src/workflows/sequential/WORKFLOW.md

@@ -20,15 +20,13 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
 - Debugger: deploy for very high complexity, or when root-causing has already
   failed at least once.
 
-1. Plan — discuss the request with the user, form a plan, and wait for approval.
-2. Delegate — split into ordered scopes and hand them off ONE AT A TIME.
+1. Plan — discuss the request with the user, form a plan, wait for approval.
+2. Delegate — split into ordered scopes and hand off ONE AT A TIME.
    - NO PARALLEL, NO FAN-OUT. Even when scopes are independent, spawn exactly
-     one agent per turn; never spawn multiple agents in the same turn. Wait for
-     the current scope's completion notification before spawning the next scope
-     (1:1 sequential).
-   - SEQUENTIAL within a single complex scope — split it into ordered steps
-     rather than handing it off in one shot, with a build/test-green gate
-     between steps.
+     one agent per turn; never multiple in the same turn. Wait for the current
+     scope's completion notification before spawning the next (1:1 sequential).
+   - SEQUENTIAL within a single complex scope — split into ordered steps rather
+     than one shot, with a build/test-green gate between steps.
    - Write briefs per the Lead brief contract (token-optimized labeled
      fragments).
    - After spawning an async agent, END THE TURN — do not poll, guess, or start
@@ -37,15 +35,15 @@ Lead supervises: delegates, coordinates, judges, decides. Route by complexity:
 3. Review — after each implementation scope completes, pair one reviewer 1:1
    with that scope (spawned on its own turn, not batched); never defer the
    reviewer call — wait for its result. Fact-check the agent response and
-   cross-check implementation and review results yourself before acting on
-   them. Send fixes back to the original scope and loop verify -> fix ->
-   re-verify until clean. Skip review only for simple, low-risk tasks. If the
-   user asks for debugging, or a bug survives 2+ fix cycles, have the debugger
-   investigate first instead of another fix round.
-4. Report — deliver the final report: synthesize results (outcome + key
-   evidence; never forward raw agent output), state the final state, and ask the
-   user whether to ship/deploy when relevant. Only after user feedback with no
-   issues prepare deploy/build/commit.
+   cross-check implementation and review results yourself before acting. Send
+   fixes back to the original scope and loop verify -> fix -> re-verify until
+   clean. Skip review only for simple, low-risk tasks. If the user asks for
+   debugging, or a bug survives 2+ fix cycles, have the debugger investigate
+   first instead of another fix round.
+4. Report — synthesize results (outcome + key evidence; never forward raw agent
+   output), state the final state, and ask whether to ship/deploy when
+   relevant. Only after user feedback with no issues prepare
+   deploy/build/commit.
 
 On any major change or direction shift mid-work, pause and re-consult the user
 before continuing.

package/vendor/ink/build/ink.js

@@ -106,7 +106,15 @@ const shouldClearTerminalForFrame = ({ isTty, viewportRows, previousViewportRows
         nextOutputHeight < previousOutputHeight &&
         (wasFullscreen || isFullscreen || wasOverflowing || isOverflowing);
     const shouldClearOnUnmount = isUnmounting && wasFullscreen;
-    if (isWindowsConsole && (wasFullscreen || isFullscreen)) {
+    // [jitter fix] Do not full-clear EVERY fullscreen frame on Windows consoles:
+    // that repaint-from-scratch caused visible vertical jitter. A full clear is
+    // only needed when the geometry actually changes — the viewport was resized
+    // (viewportRows differs from the previous frame) or the output height
+    // shrank at/over the viewport (stale wrapped rows possible). Otherwise
+    // repaint in place via the incremental erase path.
+    const viewportResized = previousViewportRows != null && previousViewportRows !== viewportRows;
+    if (isWindowsConsole && (wasFullscreen || isFullscreen) &&
+        (viewportResized || isShrinkingAtViewport || isLeavingFullscreen)) {
         return true;
     }
     return (

package/scripts/recall-usecase-probe.json

@@ -1,6 +0,0 @@
-[
-  { "id": "t1", "label": "topic ko-en mixed", "args": { "query": "recall period last 개선", "limit": 8 }, "expect": "results" },
-  { "id": "t2", "label": "topic ko only", "args": { "query": "recall 개선", "limit": 8 }, "expect": "results" },
-  { "id": "t3", "label": "topic en only", "args": { "query": "recall period last improvement", "limit": 8 }, "expect": "results" },
-  { "id": "t4", "label": "category no-raw", "args": { "period": "7d", "category": "decision", "limit": 10, "includeRaw": false }, "expect": "browse" }
-]

package/src/runtime/channels/lib/holidays.mjs

@@ -1,138 +0,0 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { homedir } from "os";
-import { DATA_DIR } from "./config.mjs";
-// Computed lazily (not at module top) so this module can be imported in a
-// cycle with config.mjs without touching DATA_DIR before config.mjs has
-// finished evaluating it (ESM temporal-dead-zone safety).
-function cacheFile() {
-  return join(DATA_DIR, "holidays-cache.json");
-}
-const FALLBACK_FILE = join(homedir(), ".mixdog", "schedules", "holidays.json");
-const CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-// In-memory, pre-warmed holiday cache for SYNC reads (isHolidaySync).
-// Keyed by `${year}:${countryCode}` -> Set<dateStr>. Absent key == cold
-// (not yet warmed); callers fall back to their documented cold-cache
-// behavior until a warm completes.
-const memCache = /* @__PURE__ */ new Map();
-const warming = /* @__PURE__ */ new Set();
-function cacheKey(year, countryCode) {
-  return `${year}:${countryCode}`;
-}
-function holidaySet(holidays) {
-  return new Set((holidays || []).map((h) => h.date));
-}
-async function fetchHolidays(year, countryCode) {
-  const url = `https://date.nager.at/api/v3/publicholidays/${year}/${countryCode}`;
-  const res = await fetch(url, { signal: AbortSignal.timeout(10_000) });
-  if (!res.ok) throw new Error(`Nager API ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-function loadCache(year, countryCode) {
-  try {
-    const file = cacheFile();
-    if (!existsSync(file)) return null;
-    const cache = JSON.parse(readFileSync(file, "utf8"));
-    if (cache.year !== year || cache.countryCode !== countryCode) return null;
-    if (Date.now() - cache.fetchedAt > CACHE_MAX_AGE_MS) return null;
-    return cache.holidays;
-  } catch {
-    return null;
-  }
-}
-function saveCache(year, countryCode, holidays) {
-  const cache = { year, countryCode, fetchedAt: Date.now(), holidays };
-  try {
-    const file = cacheFile();
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(cache, null, 2));
-  } catch {
-  }
-}
-function loadFallback() {
-  try {
-    if (!existsSync(FALLBACK_FILE)) return /* @__PURE__ */ new Set();
-    const data = JSON.parse(readFileSync(FALLBACK_FILE, "utf8"));
-    const dates = data.holidays ?? [];
-    return new Set(dates);
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-async function isHoliday(date, countryCode) {
-  const year = date.getFullYear();
-  const dateStr = `${year}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
-  let holidays = loadCache(year, countryCode);
-  if (!holidays) {
-    try {
-      holidays = await fetchHolidays(year, countryCode);
-      saveCache(year, countryCode, holidays);
-    } catch (err) {
-      process.stderr.write(`mixdog holidays: API fetch failed: ${err}
-`);
-      holidays = null;
-    }
-  }
-  if (holidays) {
-    return holidays.some((h) => h.date === dateStr);
-  }
-  const fallback = loadFallback();
-  return fallback.has(dateStr);
-}
-// Synchronous, non-blocking holiday lookup backed by the pre-warmed
-// in-memory cache. `dateStr` is a plain 'YYYY-MM-DD' string (the same
-// representation warmHolidays stores), so there is no Date round-trip to
-// shift the day across host offsets. Returns:
-//   true  — date is a recognized public holiday (cache warm),
-//   false — date is NOT a holiday (cache warm),
-//   null  — cache is cold (not warmed yet); the async warm is kicked off
-//           and the caller should apply its documented cold-cache
-//           fallback. Never performs network OR blocking disk I/O — the
-//           cold path consults the in-memory cache only.
-function isHolidaySync(dateStr, countryCode) {
-  if (!countryCode) return false;
-  const year = Number(dateStr.slice(0, 4));
-  const key = cacheKey(year, countryCode);
-  const set = memCache.get(key);
-  if (set === void 0) {
-    // Cold: no synchronous disk probe here. Kick off the async warm
-    // (which does any on-disk/network lookup off the sync path) and
-    // report cold so the caller applies its documented fallback.
-    warmHolidays(dateStr, countryCode);
-    return null;
-  }
-  return set.has(dateStr);
-}
-// Asynchronously populate the in-memory sync cache for the given
-// dateStr's year/country (from the on-disk cache when fresh, else Nager).
-// `dateStr` is a plain 'YYYY-MM-DD' string. Idempotent and
-// self-deduplicating; failures leave the entry cold so the next sync
-// read retries.
-async function warmHolidays(dateStr, countryCode) {
-  if (!countryCode) return;
-  const year = Number(dateStr.slice(0, 4));
-  const key = cacheKey(year, countryCode);
-  if (memCache.has(key) || warming.has(key)) return;
-  warming.add(key);
-  try {
-    // Yield once before touching disk so the cold sync caller that
-    // triggered this warm is never blocked by the loadCache file read.
-    await Promise.resolve();
-    let holidays = loadCache(year, countryCode);
-    if (!holidays) {
-      holidays = await fetchHolidays(year, countryCode);
-      saveCache(year, countryCode, holidays);
-    }
-    memCache.set(key, holidaySet(holidays));
-  } catch (err) {
-    process.stderr.write(`mixdog holidays: warm failed: ${err}
-`);
-  } finally {
-    warming.delete(key);
-  }
-}
-export {
-  isHoliday,
-  isHolidaySync,
-  warmHolidays
-};