mixdog 0.9.3 → 0.9.5

package/src/runtime/agent/orchestrator/tools/builtin/diagnostics-tool.mjs

@@ -1,285 +0,0 @@
-// Server-less diagnostics tool.
-//
-// Mixdog has no resident LSP server. Instead this tool detects the project
-// marker(s) under the target path, runs the matching project CLI ONCE via the
-// same exec path bash-tool uses (execShellCommand + resolveShell), then PARSES
-// the checker's stdout/stderr into structured findings. No watch, no daemon.
-//
-// Graceful contract: a missing marker or a missing checker binary returns a
-// clear "no checker available for X" message — it never throws.
-import { existsSync, readFileSync, statSync } from 'fs';
-import { dirname, isAbsolute, resolve as pathResolve } from 'path';
-import { execShellCommand, stripAnsi } from '../shell-command.mjs';
-import { resolveShell } from './shell-runtime.mjs';
-
-const DIAGNOSTICS_TIMEOUT_MS = 120_000;
-
-// Probe whether a CLI binary is resolvable on PATH without running real work.
-// Uses the platform command-resolver so an absent checker degrades gracefully
-// into a "no checker available" message instead of a spawn error.
-async function _commandExists(bin, cwd, env) {
-    const { shell, shellArg, shellArgs, shellType } = resolveShell();
-    const probe = shellType === 'powershell'
-        ? `Get-Command ${bin} -ErrorAction SilentlyContinue | Select-Object -First 1`
-        : `command -v ${bin}`;
-    try {
-        const r = await execShellCommand({
-            shell, shellArg, shellArgs, command: probe,
-            env, cwd, timeoutMs: 10_000, abortSignal: null,
-        });
-        const out = `${r.stdout || ''}`.trim();
-        if (shellType === 'powershell') return out.length > 0;
-        return r.exitCode === 0 && out.length > 0;
-    } catch {
-        return false;
-    }
-}
-
-async function _runChecker(command, cwd, env) {
-    const { shell, shellArg, shellArgs } = resolveShell();
-    const r = await execShellCommand({
-        shell, shellArg, shellArgs, command,
-        env, cwd, timeoutMs: DIAGNOSTICS_TIMEOUT_MS, abortSignal: null,
-    });
-    return {
-        stdout: stripAnsi(r.stdout || ''),
-        stderr: stripAnsi(r.stderr || ''),
-        exitCode: r.timedOut ? null : r.exitCode,
-        timedOut: !!r.timedOut,
-    };
-}
-
-// ---- per-checker output parsers -> [{file,line,col,severity,code,message}] ----
-
-function _parseTsc(text) {
-    const findings = [];
-    const re = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: +m[3], severity: m[4], code: m[5], message: m[6] });
-    }
-    return findings;
-}
-
-function _parseRuff(text) {
-    const findings = [];
-    // ruff default text: path:line:col: CODE message
-    const re = /^(.+?):(\d+):(\d+):\s+([A-Z]+\d+)\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (!m) continue;
-        const code = m[4];
-        const severity = (/^(E9|F)/.test(code)) ? 'error' : 'warning';
-        findings.push({ file: m[1], line: +m[2], col: +m[3], severity, code, message: m[5] });
-    }
-    return findings;
-}
-
-function _parsePyflakes(text) {
-    const findings = [];
-    // pyflakes: path:line: message  (no column)
-    const re = /^(.+?):(\d+):\s*(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed) continue;
-        const m = re.exec(trimmed);
-        if (m) findings.push({ file: m[1], line: +m[2], col: null, severity: 'warning', code: null, message: m[3] });
-    }
-    return findings;
-}
-
-function _parseGoVet(text) {
-    const findings = [];
-    // go vet: path:line:col: message   OR   path:line: message
-    const re = /^(.+?\.go):(\d+):(?:(\d+):)?\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: m[3] ? +m[3] : null, severity: 'error', code: 'vet', message: m[4] });
-    }
-    return findings;
-}
-
-function _parseCargo(text) {
-    const findings = [];
-    // cargo check --message-format=short: path:line:col: severity[CODE]: message
-    const re = /^(.+?):(\d+):(\d+):\s+(warning|error)(?:\[([A-Za-z0-9]+)\])?:\s+(.*)$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: +m[3], severity: m[4], code: m[5] || null, message: m[6] });
-    }
-    return findings;
-}
-
-// node --check failure shape: "<abs file>:<line>" on its own line, followed
-// by the offending source + caret, then "SyntaxError: <message>".
-function _parseNodeCheck(text) {
-    const findings = [];
-    const head = /^(.+?):(\d+)\s*$/m.exec(text);
-    const err = /^([A-Za-z]*Error):\s+(.*)$/m.exec(text);
-    if (head && err) {
-        findings.push({ file: head[1], line: +head[2], col: null, severity: 'error', code: err[1], message: err[2] });
-    }
-    return findings;
-}
-
-function _parseEslintCompact(text) {
-    const findings = [];
-    // eslint --format compact: path: line N, col M, Severity - message (rule)
-    const re = /^(.+?):\s+line\s+(\d+),\s+col\s+(\d+),\s+(Error|Warning)\s+-\s+(.*?)(?:\s+\(([^)]+)\))?$/;
-    for (const line of text.split(/\r?\n/)) {
-        const m = re.exec(line.trim());
-        if (m) findings.push({ file: m[1], line: +m[2], col: +m[3], severity: m[4].toLowerCase(), code: m[6] || null, message: m[5] });
-    }
-    return findings;
-}
-
-// Detect the project marker under projectDir and return the checker plan.
-// Order is deterministic; the first matching marker wins.
-function _detectChecker(projectDir) {
-    const has = (f) => existsSync(pathResolve(projectDir, f));
-    if (has('tsconfig.json')) {
-        return { kind: 'tsc', bin: 'tsc', command: 'tsc --noEmit', parse: _parseTsc, marker: 'tsconfig.json' };
-    }
-    if (has('pyproject.toml') || has('setup.py')) {
-        return { kind: 'python', marker: has('pyproject.toml') ? 'pyproject.toml' : 'setup.py' };
-    }
-    if (has('go.mod')) {
-        return { kind: 'go', bin: 'go', command: 'go vet ./...', parse: _parseGoVet, marker: 'go.mod' };
-    }
-    if (has('Cargo.toml')) {
-        return { kind: 'cargo', bin: 'cargo', command: 'cargo check --message-format=short', parse: _parseCargo, marker: 'Cargo.toml' };
-    }
-    if (has('package.json')) {
-        let usesEslint = false;
-        try {
-            const pkg = JSON.parse(readFileSync(pathResolve(projectDir, 'package.json'), 'utf8'));
-            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
-            usesEslint = Object.prototype.hasOwnProperty.call(deps, 'eslint');
-        } catch { /* unreadable/invalid package.json */ }
-        const hasEslintConfig = ['.eslintrc', '.eslintrc.js', '.eslintrc.cjs', '.eslintrc.json', '.eslintrc.yml', '.eslintrc.yaml', 'eslint.config.js', 'eslint.config.mjs', 'eslint.config.cjs']
-            .some((f) => has(f));
-        if (usesEslint || hasEslintConfig) {
-            return { kind: 'eslint', bin: 'eslint', command: 'eslint . --format compact', parse: _parseEslintCompact, marker: 'package.json (eslint)' };
-        }
-        return { kind: 'none', reason: 'package.json present but no eslint dependency/config detected' };
-    }
-    return { kind: 'none', reason: 'no recognized project marker (tsconfig.json / pyproject.toml / setup.py / go.mod / Cargo.toml / package.json)' };
-}
-
-function _formatResult({ marker, checker, findings, raw, note }) {
-    return JSON.stringify({
-        ok: true,
-        marker: marker || null,
-        checker: checker || null,
-        note: note || null,
-        count: findings.length,
-        findings,
-        raw: raw ? raw.slice(0, 4000) : undefined,
-    }, null, 2);
-}
-
-export async function executeDiagnosticsTool(args, workDir, options = {}) {
-    const result = await _executeDiagnosticsImpl(args, workDir);
-    // ② completion progress (claude "Found N" parity). Best-effort, no-op
-    // when onProgress is absent (no progressToken). Never throws — the tool
-    // result is returned regardless.
-    if (typeof options?.onProgress === 'function') {
-        try {
-            let _n = null;
-            try { _n = JSON.parse(result)?.count; } catch { /* non-JSON envelope */ }
-            if (Number.isFinite(_n)) {
-                options.onProgress(_n === 0 ? 'no issues' : `${_n} issue${_n === 1 ? '' : 's'}`);
-            }
-        } catch { /* best-effort */ }
-    }
-    return result;
-}
-
-async function _executeDiagnosticsImpl(args, workDir) {
-    try {
-        // Resolve the target path (file or dir). Default: cwd.
-        const rawPath = (args && typeof args.path === 'string' && args.path.trim()) ? args.path.trim() : '';
-        const absTarget = rawPath
-            ? (isAbsolute(rawPath) ? rawPath : pathResolve(workDir, rawPath))
-            : workDir;
-        if (rawPath && !existsSync(absTarget)) {
-            return _formatResult({ note: `path not found: ${rawPath}`, findings: [] });
-        }
-        let projectDir = absTarget;
-        try {
-            if (statSync(absTarget).isFile()) projectDir = dirname(absTarget);
-        } catch { /* fall through with absTarget */ }
-
-        let plan = _detectChecker(projectDir);
-        // A file deep in the tree (src/search/lib/foo.mjs) has its project
-        // marker at the repo ROOT — walk parent directories until a marker is
-        // found instead of reporting "no recognized project marker" from the
-        // file's immediate dirname. Stops at the first directory that yields
-        // any non-"no marker" answer (including "package.json present but no
-        // eslint"), or at the filesystem root.
-        {
-            const _noMarker = (p) => p.kind === 'none' && String(p.reason || '').startsWith('no recognized project marker');
-            let walk = projectDir;
-            while (_noMarker(plan)) {
-                const parent = dirname(walk);
-                if (!parent || parent === walk) break;
-                walk = parent;
-                plan = _detectChecker(walk);
-            }
-            if (!_noMarker(plan)) projectDir = walk;
-        }
-        if (plan.kind === 'none') {
-            // Syntax-check fallback: a JS file target can still be validated
-            // with `node --check` even when the project has no lint setup —
-            // catch the dominant failure class (parse errors) instead of
-            // going dark with "no checker".
-            let isJsFile = false;
-            try { isJsFile = /\.(mjs|cjs|js)$/i.test(absTarget) && statSync(absTarget).isFile(); } catch { /* keep false */ }
-            if (isJsFile) {
-                const env = { ...process.env, LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' };
-                if (await _commandExists('node', projectDir, env)) {
-                    const r = await _runChecker(`node --check "${absTarget}"`, projectDir, env);
-                    const combined = `${r.stdout}\n${r.stderr}`;
-                    const findings = _parseNodeCheck(combined);
-                    return _formatResult({ checker: 'node --check (no-lint fallback)', findings, raw: combined, note: `${plan.reason} — fell back to syntax check only` });
-                }
-            }
-            return _formatResult({ note: `no checker available for this path — ${plan.reason}`, findings: [] });
-        }
-
-        const env = { ...process.env, LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' };
-
-        // Python is special: prefer ruff, fall back to pyflakes.
-        if (plan.kind === 'python') {
-            if (await _commandExists('ruff', projectDir, env)) {
-                const r = await _runChecker('ruff check .', projectDir, env);
-                const findings = _parseRuff(`${r.stdout}\n${r.stderr}`);
-                return _formatResult({ marker: plan.marker, checker: 'ruff check', findings, raw: `${r.stdout}\n${r.stderr}` });
-            }
-            if (await _commandExists('python', projectDir, env)) {
-                const r = await _runChecker('python -m pyflakes .', projectDir, env);
-                const out = `${r.stdout}\n${r.stderr}`;
-                if (/No module named pyflakes/i.test(out)) {
-                    return _formatResult({ marker: plan.marker, note: 'no checker available for Python — ruff absent and pyflakes module not installed', findings: [] });
-                }
-                const findings = _parsePyflakes(out);
-                return _formatResult({ marker: plan.marker, checker: 'python -m pyflakes (ruff fallback)', findings, raw: out });
-            }
-            return _formatResult({ marker: plan.marker, note: 'no checker available for Python — neither ruff nor python found on PATH', findings: [] });
-        }
-
-        if (!(await _commandExists(plan.bin, projectDir, env))) {
-            return _formatResult({ marker: plan.marker, note: `no checker available for ${plan.kind} — "${plan.bin}" not found on PATH`, findings: [] });
-        }
-        const r = await _runChecker(plan.command, projectDir, env);
-        const combined = `${r.stdout}\n${r.stderr}`;
-        const findings = plan.parse(combined);
-        const note = r.timedOut ? `checker timed out after ${DIAGNOSTICS_TIMEOUT_MS}ms` : null;
-        return _formatResult({ marker: plan.marker, checker: plan.command, findings, raw: combined, note });
-    } catch (err) {
-        // Never throw — surface a graceful diagnostic envelope.
-        return JSON.stringify({ ok: false, error: `diagnostics failed: ${err && err.message ? err.message : String(err)}`, findings: [] }, null, 2);
-    }
-}
-
-export default executeDiagnosticsTool;

package/src/runtime/agent/orchestrator/tools/builtin/external-tool-adapters.test.mjs

@@ -1,162 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { tryExecuteExternalToolAdapter, isExternalAdapterTool } from './external-tool-adapters.mjs';
-
-function makeDir() {
-    return mkdtempSync(join(tmpdir(), 'ext-adapter-test-'));
-}
-
-test('isExternalAdapterTool recognizes adapted names only', () => {
-    assert.equal(isExternalAdapterTool('StrReplace'), true);
-    assert.equal(isExternalAdapterTool('str_replace'), true);
-    assert.equal(isExternalAdapterTool('str_replace_editor'), true);
-    assert.equal(isExternalAdapterTool('search_replace'), true);
-    assert.equal(isExternalAdapterTool('Write'), true);
-    assert.equal(isExternalAdapterTool('create_file'), true);
-    assert.equal(isExternalAdapterTool('Bash'), true);
-    assert.equal(isExternalAdapterTool('run_terminal_cmd'), true);
-    // Destructive / different-shape names stay on the redirect path.
-    assert.equal(isExternalAdapterTool('Delete'), false);
-    assert.equal(isExternalAdapterTool('delete_file'), false);
-    assert.equal(isExternalAdapterTool('edit'), false);
-    assert.equal(isExternalAdapterTool('multiedit'), false);
-    assert.equal(isExternalAdapterTool(''), false);
-    assert.equal(isExternalAdapterTool(null), false);
-});
-
-test('StrReplace: unique match replaces content', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'alpha\nbeta\ngamma\n');
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: file, old_string: 'beta', new_string: 'BETA',
-    }, dir, {});
-    assert.match(out, /^Updated .*\(1 replacement\)$/);
-    assert.equal(readFileSync(file, 'utf8'), 'alpha\nBETA\ngamma\n');
-});
-
-test('StrReplace: zero matches errors without writing', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'alpha\n');
-    const out = await tryExecuteExternalToolAdapter('str_replace', {
-        path: file, old_string: 'missing', new_string: 'x',
-    }, dir, {});
-    assert.match(out, /old_string not found/);
-    assert.equal(readFileSync(file, 'utf8'), 'alpha\n');
-});
-
-test('StrReplace: ambiguous matches error with count', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'dup\ndup\n');
-    const out = await tryExecuteExternalToolAdapter('search_replace', {
-        path: file, old_string: 'dup', new_string: 'x',
-    }, dir, {});
-    assert.match(out, /ambiguous: 2 matches/);
-    assert.equal(readFileSync(file, 'utf8'), 'dup\ndup\n');
-});
-
-test('StrReplace: missing old_string falls back (null)', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: join(dir, 'a.txt'), new_string: 'x',
-    }, dir, {});
-    assert.equal(out, null);
-});
-
-test('StrReplace: unreadable target is a concrete error', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: join(dir, 'nope.txt'), old_string: 'a', new_string: 'b',
-    }, dir, {});
-    assert.match(out, /^Error: cannot read /);
-});
-
-test('Write: creates a new file with contents', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'new', 'nested.txt');
-    const out = await tryExecuteExternalToolAdapter('Write', {
-        path: file, contents: 'created body',
-    }, dir, {});
-    assert.match(out, /^Created .*nested\.txt \(12 bytes\)$/);
-    assert.equal(readFileSync(file, 'utf8'), 'created body');
-});
-
-test('Write: overwrites an existing file and says Updated', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'exists.txt');
-    writeFileSync(file, 'old');
-    const out = await tryExecuteExternalToolAdapter('write', {
-        file_path: file, content: 'new body',
-    }, dir, {});
-    assert.match(out, /^Updated /);
-    assert.equal(readFileSync(file, 'utf8'), 'new body');
-});
-
-test('Write: missing contents falls back to redirect (null)', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('Write', {
-        path: join(dir, 'x.txt'),
-    }, dir, {});
-    assert.equal(out, null);
-    assert.equal(existsSync(join(dir, 'x.txt')), false);
-});
-
-test('StrReplace: missing old_string/new_string falls back (null)', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'body');
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: file, old_string: 'body',
-    }, dir, {});
-    assert.equal(out, null);
-});
-
-test('StrReplace: empty old_string is a concrete error (no hang)', async () => {
-    const dir = makeDir();
-    const file = join(dir, 'a.txt');
-    writeFileSync(file, 'body');
-    const out = await tryExecuteExternalToolAdapter('StrReplace', {
-        path: file, old_string: '', new_string: 'x',
-    }, dir, {});
-    assert.match(out, /old_string must be a non-empty string/);
-    assert.equal(readFileSync(file, 'utf8'), 'body');
-});
-
-test('bash family: missing command falls back (null)', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('Bash', {}, dir, {});
-    assert.equal(out, null);
-});
-
-test('Write: target outside workDir is refused (base containment)', async () => {
-    const workDir = makeDir();
-    const outsideDir = makeDir();
-    const outside = join(outsideDir, 'escape.txt');
-    const out = await tryExecuteExternalToolAdapter('Write', {
-        path: outside, contents: 'should not land',
-    }, workDir, {});
-    assert.match(out, /cannot write outside the working directory/);
-    assert.equal(existsSync(outside), false);
-});
-
-test('non-adapted names return null without touching fs', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('Delete', {
-        path: join(dir, 'x.txt'),
-    }, dir, {});
-    assert.equal(out, null);
-});
-
-test('bash family: executes a command via the shell runner', async () => {
-    const dir = makeDir();
-    const out = await tryExecuteExternalToolAdapter('run_terminal_cmd', {
-        command: 'node -e "console.log(\'adapter-ok\')"',
-    }, dir, {});
-    assert.equal(typeof out, 'string');
-    assert.match(out, /adapter-ok/);
-});

package/src/runtime/agent/orchestrator/tools/builtin/open-config-tool.mjs

@@ -1,26 +0,0 @@
-// open_config builtin tool.
-//
-// Lives in the always-on `builtin` module (not the gated `agent` module) so
-// the config UI stays reachable even when modules.agent.enabled === false —
-// otherwise a user who disabled the agent module would lose every way to open
-// the settings UI (the old `bun launch.mjs` slash shell-out is gone).
-//
-// Launches the config UI through the resident MCP server. Because this server
-// is a long-lived background process, its spawn of setup-server
-// (windowsHide:true inside launch-core) creates NO console window — unlike the
-// old `!bun launch.mjs` slash-command shell-out, which flashed a conhost. The
-// launch-core import is lazy so its child_process/http deps stay off the hot
-// builtin path until the tool is actually called.
-
-export async function executeOpenConfigTool() {
-    const { launchConfigUi, LaunchError } = await import(
-        new URL('../../../../../setup/launch-core.mjs', import.meta.url).href
-    );
-    try {
-        const url = await launchConfigUi();
-        return `Config UI opened at ${url}`;
-    } catch (err) {
-        if (err instanceof LaunchError) return `Error: ${err.message.trim()}`;
-        throw err;
-    }
-}

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
-};

package/src/runtime/shared/channel-notification-routing.test.mjs

@@ -1,45 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import {
-  channelNotificationModelContent,
-  shouldMirrorChannelNotificationToPending,
-} from './channel-notification-routing.mjs';
-
-test('channel schedule notification uses instruction as model content', () => {
-  const content = channelNotificationModelContent({
-    content: ' ',
-    meta: {
-      type: 'schedule',
-      instruction: 'scheduled prompt body',
-    },
-  });
-  assert.equal(content, 'scheduled prompt body');
-});
-
-test('silent channel notification has no model content', () => {
-  const content = channelNotificationModelContent({
-    content: 'hidden',
-    meta: {
-      type: 'schedule',
-      silent_to_agent: true,
-    },
-  });
-  assert.equal(content, '');
-});
-
-test('non-schedule notification preserves instruction-first routing', () => {
-  const content = channelNotificationModelContent({
-    content: 'worker result body',
-    meta: {
-      type: 'webhook',
-      instruction: 'relay instruction',
-    },
-  });
-  assert.equal(content, 'relay instruction');
-});
-
-test('only schedule channel notifications are mirrored to pending fallback', () => {
-  assert.equal(shouldMirrorChannelNotificationToPending({ type: 'schedule' }), true);
-  assert.equal(shouldMirrorChannelNotificationToPending({ type: 'webhook' }), false);
-  assert.equal(shouldMirrorChannelNotificationToPending({}), false);
-});