@link-assistant/hive-mind 2.13.4 → 2.14.0

package/src/codex.lib.mjs

@@ -7,7 +7,11 @@ import { ensureUseM } from './use-m-bootstrap.lib.mjs';
 if (typeof globalThis.use === 'undefined') {
   await ensureUseM();
 }
-const { $ } = await use('command-stream');
+const { $: __rawDollar$ } = await use('command-stream');
+// Issue #2168: retry transient git network failures (push/fetch/pull) the same
+// way `gh` calls are retried, for every command run through this module's `$`.
+const { wrapDollarWithGitRetry } = await import('./git-retry.lib.mjs');
+const $ = wrapDollarWithGitRetry(__rawDollar$);
 const fs = (await use('fs')).promises;
 const path = (await use('path')).default;
 const os = (await use('os')).default;
@@ -44,127 +48,10 @@ import Decimal from 'decimal.js-light';
 import { ensureAiToolScratchIgnored, filterAiToolScratchFromStatus } from './ai-tool-scratch.lib.mjs';
 import { CODEX_CACHE_READ_USAGE_PATHS, CODEX_CACHE_WRITE_USAGE_PATHS, CODEX_MODEL_DIAGNOSTIC_PATHS, CODEX_REASONING_USAGE_PATHS, CODEX_USAGE_FIELD_NAMES, createCodexTokenFieldAvailability, getFirstObservedNumber, hasAnyObservedPath, hasOwnPath } from './codex.usage-fields.lib.mjs';
 const CODEX_LONG_CONTEXT_PRICE_THRESHOLD = 272000;
-const CODEX_COMPACT_API_ENDPOINT = '/responses/compact';
 const getCodexExecEnv = (verbose = false) => (verbose ? { ...process.env, RUST_LOG: 'debug' } : { ...process.env });
-
-const escapeRegExp = value => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const getCodexDiagnosticValue = (line, key) => {
-  const match = line.match(new RegExp(`${escapeRegExp(key)}=(?:"([^"]*)"|([^\\s")]+))`));
-  return match?.[1] ?? match?.[2] ?? null;
-};
-const getCodexDiagnosticInteger = (line, key) => {
-  const value = getCodexDiagnosticValue(line, key);
-  if (value === null) return null;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) ? parsed : null;
-};
-const getCodexDiagnosticTimestamp = line => {
-  const eventTimestamp = getCodexDiagnosticValue(line, 'event.timestamp');
-  if (eventTimestamp) return eventTimestamp;
-  const logPrefixMatch = line.match(/^\[(\d{4}-\d{2}-\d{2}T[^\]]+Z)\]/u);
-  return logPrefixMatch?.[1] ?? null;
-};
-const isSuccessfulCodexCompactRequestLine = line => {
-  if (!line.includes('codex_otel.log_only:')) return false;
-  if (!line.includes('event.name="codex.api_request"')) return false;
-  if (!line.includes(`endpoint="${CODEX_COMPACT_API_ENDPOINT}"`)) return false;
-  const statusCode = getCodexDiagnosticInteger(line, 'http.response.status_code');
-  return statusCode === null || (statusCode >= 200 && statusCode < 300);
-};
-
-const splitTokenCountEvenly = (total, partCount) => {
-  const safeTotal = Math.max(0, Math.round(total || 0));
-  const safePartCount = Math.max(1, Math.round(partCount || 1));
-  const base = Math.floor(safeTotal / safePartCount);
-  let remainder = safeTotal % safePartCount;
-  return Array.from({ length: safePartCount }, () => {
-    const value = base + (remainder > 0 ? 1 : 0);
-    if (remainder > 0) remainder--;
-    return value;
-  });
-};
-const splitCodexSubSessionInputTokens = (total, partCount, autoCompactTokenLimit = null) => {
-  const safeTotal = Math.max(0, Math.round(total || 0));
-  const safePartCount = Math.max(1, Math.round(partCount || 1));
-  const safeLimit = Number.isFinite(autoCompactTokenLimit) && autoCompactTokenLimit > 0 ? Math.round(autoCompactTokenLimit) : null;
-  if (safePartCount <= 1) return [safeTotal];
-  if (safeLimit && safeTotal > safeLimit * (safePartCount - 1)) {
-    const chunks = [];
-    let remaining = safeTotal;
-    for (let i = 0; i < safePartCount - 1; i++) {
-      const chunk = Math.min(safeLimit, remaining);
-      chunks.push(chunk);
-      remaining -= chunk;
-    }
-    chunks.push(Math.max(0, remaining));
-    return chunks;
-  }
-  return splitTokenCountEvenly(safeTotal, safePartCount);
-};
-const splitTokenCountByWeights = (total, weights) => {
-  const safeTotal = Math.max(0, Math.round(total || 0));
-  const safeWeights = Array.isArray(weights) && weights.length > 0 ? weights.map(weight => Math.max(0, weight || 0)) : [1];
-  const weightTotal = safeWeights.reduce((sum, weight) => sum + weight, 0);
-  if (weightTotal <= 0) return splitTokenCountEvenly(safeTotal, safeWeights.length);
-  let allocated = 0;
-  return safeWeights.map((weight, index) => {
-    if (index === safeWeights.length - 1) return Math.max(0, safeTotal - allocated);
-    const value = Math.floor((safeTotal * weight) / weightTotal);
-    allocated += value;
-    return value;
-  });
-};
-const rebuildCodexSubSessionsFromCompactifications = tokenUsage => {
-  const compactifications = Array.isArray(tokenUsage.compactifications) ? tokenUsage.compactifications : [];
-  if (compactifications.length === 0 || (tokenUsage.stepCount || 0) === 0) {
-    tokenUsage.subSessions = Array.isArray(tokenUsage.subSessions) ? tokenUsage.subSessions : [];
-    return;
-  }
-
-  const subSessionCount = compactifications.length + 1;
-  const inputChunks = splitCodexSubSessionInputTokens(tokenUsage.inputTokens || 0, subSessionCount, tokenUsage.autoCompactTokenLimit);
-  const cacheWriteChunks = splitTokenCountByWeights(tokenUsage.cacheWriteTokens || 0, inputChunks);
-  const cacheReadChunks = splitTokenCountByWeights(tokenUsage.cacheReadTokens || 0, inputChunks);
-  const outputChunks = splitTokenCountByWeights(tokenUsage.outputTokens || 0, inputChunks);
-  tokenUsage.subSessions = inputChunks.map((inputTokens, index) => {
-    const cacheCreationTokens = cacheWriteChunks[index] || 0;
-    const outputTokens = outputChunks[index] || 0;
-    return {
-      inputTokens,
-      cacheCreationTokens,
-      cacheReadTokens: cacheReadChunks[index] || 0,
-      outputTokens,
-      messageCount: null,
-      peakContextUsage: getCumulativeContextInputTokens({ inputTokens, cacheCreationTokens }),
-      peakOutputUsage: outputTokens,
-      estimated: true,
-      source: 'codex.compact-diagnostics',
-      compactBoundaryBefore: index === 0 ? null : compactifications[index - 1] || null,
-    };
-  });
-};
-const recordCodexCompactification = (line, tokenUsage) => {
-  if (!isSuccessfulCodexCompactRequestLine(line)) return;
-  const timestamp = getCodexDiagnosticTimestamp(line);
-  const conversationId = getCodexDiagnosticValue(line, 'conversation.id');
-  const existing = tokenUsage.compactifications.find(compact => compact.timestamp === timestamp && compact.conversationId === conversationId);
-  if (existing) return;
-  tokenUsage.compactifications.push({
-    timestamp,
-    preTokens: null,
-    trigger: 'auto',
-    source: 'codex.responses.compact',
-    conversationId: conversationId || null,
-  });
-};
-const parseCodexDiagnosticLine = (line, tokenUsage) => {
-  const contextLimit = getCodexDiagnosticInteger(line, 'context_window') ?? getCodexDiagnosticInteger(line, 'model_context_window');
-  if (contextLimit !== null) tokenUsage.contextLimit = contextLimit;
-
-  const autoCompactTokenLimit = getCodexDiagnosticInteger(line, 'auto_compact_token_limit') ?? getCodexDiagnosticInteger(line, 'model_auto_compact_token_limit');
-  if (autoCompactTokenLimit !== null) tokenUsage.autoCompactTokenLimit = autoCompactTokenLimit;
-  recordCodexCompactification(line, tokenUsage);
-};
+// Issue #2175: diagnostic-line parsing lives in its own module to keep this file
+// under the 1350-line warning threshold.
+import { parseCodexDiagnosticLine, rebuildCodexSubSessionsFromCompactifications } from './codex.diagnostics.lib.mjs';
 export const createCodexTokenUsage = requestedModelId => ({
   inputTokens: 0,
   outputTokens: 0,

package/src/config.lib.mjs

@@ -115,6 +115,15 @@ export const retryLimits = {
   maxForkRetries: parseIntWithDefault('HIVE_MIND_MAX_FORK_RETRIES', 5),
   maxVerifyRetries: parseIntWithDefault('HIVE_MIND_MAX_VERIFY_RETRIES', 5),
   maxApiRetries: parseIntWithDefault('HIVE_MIND_MAX_API_RETRIES', 3),
+  // Issue #2168: GitHub's own 5xx / GraphQL-internal failures ("Something went
+  // wrong while executing your query") are usually over within seconds, but 3
+  // attempts at 1s+2s was too tight to ride one out. These budgets are used by
+  // `ghWithRateLimitRetry` for the transient (non-rate-limit) branch.
+  maxGitHubTransientRetries: parseIntWithDefault('HIVE_MIND_MAX_GITHUB_TRANSIENT_RETRIES', 6),
+  initialGitHubTransientDelayMs: parseIntWithDefault('HIVE_MIND_INITIAL_GITHUB_TRANSIENT_DELAY_MS', 2000),
+  // Issue #2168: network-facing git operations (push/fetch/clone) get the same
+  // treatment via `gitCmdRetry` in src/lib.mjs.
+  maxGitRetries: parseIntWithDefault('HIVE_MIND_MAX_GIT_RETRIES', 5),
   retryBackoffMultiplier: parseFloatWithDefault('HIVE_MIND_RETRY_BACKOFF_MULTIPLIER', 2),
   // Unified retry config for all transient API errors (Overloaded, 503, Internal Server Error)
   // Issue #2169: count backstop only. With the defaults below (3 min → 30 min backoff) the 12-hour

package/src/docker-sidecar.lib.mjs

@@ -0,0 +1,276 @@
+/**
+ * Mechanics shared by every on-demand Docker sidecar Hive Mind runs.
+ *
+ * The Formal AI sidecar (issue #2146) and the router sidecar (issue #2164) are
+ * different services with different reasons to exist, but their *mechanics* are
+ * the same problem solved twice: one container shared by concurrent tasks, a
+ * lease per task, a durable JSON record that is only ever a cache of what
+ * Docker actually reports, and an exclusive lock so a launch and an update can
+ * never interleave.
+ *
+ * Those mechanics live here so the two lifecycles stay in step — a fix to lease
+ * reconciliation or to the network guard applies to both — and so each sidecar
+ * module is left holding only the part that is genuinely its own: which image,
+ * which mounts, which readiness check, and what the task is handed.
+ *
+ * @see https://github.com/link-assistant/hive-mind/issues/2146
+ * @see https://github.com/link-assistant/hive-mind/issues/2164
+ */
+
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+
+import { resolveBotStateDir } from './session-store.lib.mjs';
+
+const execFileAsync = promisify(execFile);
+
+export const DEFAULT_DOCKER_TIMEOUT_MS = 120_000;
+// Pulling a sidecar image is the one Docker call that legitimately takes many
+// minutes, so it gets its own budget instead of the general command timeout.
+export const DEFAULT_IMAGE_TIMEOUT_MS = 600_000;
+
+export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+/** Run `docker …` and return trimmed stdout. Throws on a non-zero exit. */
+export const dockerText = async (run, args, { timeoutMs = DEFAULT_DOCKER_TIMEOUT_MS } = {}) => {
+  const result = await run('docker', args, { encoding: 'utf8', timeout: timeoutMs });
+  return String(result?.stdout ?? '').trim();
+};
+
+/** Run `docker …` for its effect only, reporting success as a boolean. */
+export const dockerOk = async (run, args, options) => {
+  try {
+    await dockerText(run, args, options);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** The message a failed `docker` invocation should be reported with. */
+export const dockerErrorMessage = error => error?.stderr?.toString?.().trim() || error?.message || String(error);
+
+/**
+ * Inspect a container without treating "absent" as an error.
+ *
+ * @returns {Promise<{exists: boolean, running: boolean, image: string|null, imageDigest: string|null}>}
+ */
+export const inspectDockerContainer = async (name, { run = execFileAsync, timeoutMs } = {}) => {
+  try {
+    const raw = await dockerText(run, ['inspect', name, '--format', '{{.State.Running}}|{{.Config.Image}}|{{.Image}}'], { timeoutMs });
+    const [running, image, imageDigest] = raw.split('|');
+    return { exists: true, running: running === 'true', image: image || null, imageDigest: imageDigest || null };
+  } catch {
+    return { exists: false, running: false, image: null, imageDigest: null };
+  }
+};
+
+/** Resolve the local content digest of an image reference, or null when it is absent. */
+export const readDockerImageDigest = async (image, { run = execFileAsync, timeoutMs } = {}) => {
+  try {
+    return (await dockerText(run, ['image', 'inspect', image, '--format', '{{.Id}}'], { timeoutMs })) || null;
+  } catch {
+    return null;
+  }
+};
+
+/** A container's IPv4 address on one named network, or null when it has none. */
+export const readDockerContainerAddress = async (containerName, network, { run = execFileAsync, timeoutMs } = {}) => {
+  try {
+    return (await dockerText(run, ['inspect', containerName, '--format', `{{with index .NetworkSettings.Networks "${network}"}}{{.IPAddress}}{{end}}`], { timeoutMs })) || null;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Create the private network a sidecar and its tasks share.
+ *
+ * `--internal` is the security requirement: the sidecar endpoint must not be
+ * published to the host and must not be reachable from any other network. An
+ * existing network that is *not* internal is a stale artifact from an older
+ * deployment and is replaced — but only while nothing is attached to it, since
+ * removing a network out from under a running container would break it.
+ */
+export const ensureInternalDockerNetwork = async ({ name, label, run = execFileAsync, timeoutMs, log = null, verbose = false, logPrefix = 'docker-sidecar' } = {}) => {
+  // `null` means "absent", which is different from "present but not internal".
+  let internal = null;
+  let containers = 0;
+  try {
+    const raw = await dockerText(run, ['network', 'inspect', name, '--format', '{{.Internal}}|{{len .Containers}}'], { timeoutMs });
+    const [internalFlag, containerCount] = raw.split('|');
+    internal = internalFlag === 'true';
+    containers = Number(containerCount) || 0;
+  } catch {
+    // Absent; fall through to creation.
+  }
+
+  if (internal === true) return { created: false, internal: true };
+
+  if (internal === false) {
+    if (containers > 0) {
+      if (log) await log(`⚠️ Network '${name}' is not internal but still has ${containers} attached container(s); leaving it in place`);
+      return { created: false, internal: false };
+    }
+    if (verbose && log) await log(`[VERBOSE] ${logPrefix}: replacing non-internal network '${name}'`);
+    await dockerOk(run, ['network', 'rm', name], { timeoutMs });
+  }
+
+  await dockerText(run, ['network', 'create', '--internal', '--label', `${label}=network`, name], { timeoutMs });
+  if (verbose && log) await log(`[VERBOSE] ${logPrefix}: created internal network '${name}'`);
+  return { created: true, internal: true };
+};
+
+/**
+ * Add a network to an already-created container.
+ *
+ * A single `docker run --network` *replaces* the container's default bridge, so
+ * an `--internal` network passed that way would also cut the container off from
+ * GitHub and the package registries. Attaching afterwards is additive, which is
+ * what both sidecars need — for the task container, and for the router sidecar
+ * itself, which must keep its outbound route to the vendor APIs.
+ */
+export const attachDockerNetwork = async ({ network, container, alias = null, run = execFileAsync, timeoutMs, log = null, verbose = false, logPrefix = 'docker-sidecar' } = {}) => {
+  if (!container) return { attached: false, error: 'no container' };
+  const args = ['network', 'connect'];
+  if (alias) args.push('--alias', alias);
+  args.push(network, container);
+  try {
+    await dockerText(run, args, { timeoutMs });
+    if (verbose && log) await log(`[VERBOSE] ${logPrefix}: attached '${container}' to '${network}'${alias ? ` as '${alias}'` : ''}`);
+    return { attached: true, error: null };
+  } catch (error) {
+    const message = dockerErrorMessage(error);
+    // Docker reports an already-attached container as an error; that is success.
+    if (/already exists in network/i.test(message)) return { attached: true, error: null };
+    if (log) await log(`⚠️ Could not attach '${container}' to network '${network}': ${message}`);
+    return { attached: false, error: message };
+  }
+};
+
+/** Create a named volume if it is missing. Never removed by any caller: it holds the data the sidecar exists to keep. */
+export const ensureDockerVolume = async ({ name, label, role = 'data', run = execFileAsync, timeoutMs, log = null, verbose = false, logPrefix = 'docker-sidecar' } = {}) => {
+  if (await dockerOk(run, ['volume', 'inspect', name], { timeoutMs })) return { created: false };
+  await dockerText(run, ['volume', 'create', '--label', `${label}=${role}`, name], { timeoutMs });
+  if (verbose && log) await log(`[VERBOSE] ${logPrefix}: created volume '${name}'`);
+  return { created: true };
+};
+
+/** Path of a sidecar's durable record inside the bot state directory. */
+export const resolveSidecarStatePath = (fileName, env = process.env) => path.join(resolveBotStateDir(env), fileName);
+
+/** Read a durable sidecar record. A missing or corrupt file is an empty record, never a throw. */
+export const readSidecarState = ({ fileName, emptyState, env = process.env, fsImpl = fs } = {}) => {
+  try {
+    const parsed = JSON.parse(fsImpl.readFileSync(resolveSidecarStatePath(fileName, env), 'utf8'));
+    return { ...emptyState, ...parsed, leases: Array.isArray(parsed?.leases) ? parsed.leases : [] };
+  } catch {
+    return { ...emptyState, leases: [] };
+  }
+};
+
+/**
+ * Persist a sidecar record atomically so a crash mid-write cannot corrupt it.
+ *
+ * `mode` exists because the router's record holds its JWT signing secret, which
+ * mints subscription access: that file must not be world-readable (issue #2164).
+ */
+export const writeSidecarState = (state, { fileName, env = process.env, fsImpl = fs, mode = 0o600 } = {}) => {
+  const target = resolveSidecarStatePath(fileName, env);
+  fsImpl.mkdirSync(path.dirname(target), { recursive: true });
+  const temporary = `${target}.tmp`;
+  fsImpl.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { encoding: 'utf8', mode });
+  fsImpl.renameSync(temporary, target);
+  return state;
+};
+
+/**
+ * How long a lease whose container has never been seen running is kept.
+ *
+ * A lease is taken *before* start-command creates the task container, because
+ * the endpoint and the token have to be known when the task's environment is
+ * built. During that window the container legitimately does not exist yet — and
+ * creating it can take a long time when the isolation image still has to be
+ * pulled.
+ */
+export const LEASE_START_GRACE_MS = 60 * 60 * 1000;
+
+/**
+ * Drop leases whose task container no longer runs, so a crashed run cannot pin
+ * a sidecar up forever.
+ *
+ * Liveness is re-derived from Docker on every call rather than trusted from the
+ * store, which is what lets a restarted bot converge instead of orphaning.
+ *
+ * @param {Array<object>} leases
+ * @param {{onDropped?: (lease: object) => Promise<void>|void}} options
+ *   `onDropped` lets a sidecar clean up what the lease owned — the router
+ *   revokes the task's token there.
+ */
+export const reconcileSidecarLeases = async (leases, { run = execFileAsync, timeoutMs, log = null, verbose = false, now = () => Date.now(), onDropped = null, logPrefix = 'docker-sidecar' } = {}) => {
+  const live = [];
+  for (const lease of leases) {
+    if (!lease?.sessionId) continue;
+    const container = await inspectDockerContainer(lease.sessionId, { run, timeoutMs });
+    if (container.exists && container.running) {
+      live.push(lease.containerSeen ? lease : { ...lease, containerSeen: true });
+      continue;
+    }
+    if (!lease.containerSeen) {
+      const age = now() - (Date.parse(lease.acquiredAt ?? '') || 0);
+      if (age < LEASE_START_GRACE_MS) {
+        if (verbose && log) await log(`[VERBOSE] ${logPrefix}: keeping lease '${lease.sessionId}' whose container has not appeared yet (${Math.round(age / 1000)}s into the ${Math.round(LEASE_START_GRACE_MS / 1000)}s launch grace)`);
+        live.push(lease);
+        continue;
+      }
+    }
+    if (verbose && log) await log(`[VERBOSE] ${logPrefix}: dropping stale lease '${lease.sessionId}' (container exists=${container.exists} running=${container.running})`);
+    if (onDropped) await onDropped(lease);
+  }
+  return live;
+};
+
+/**
+ * Periodic best-effort maintenance timer shared by the sidecar lifecycles.
+ *
+ * Both the Formal AI and the router sidecar need the same thing: a tick that
+ * runs immediately, repeats on an interval, never keeps the process alive on
+ * shutdown, and never rejects into the bot's event loop. Keeping one
+ * implementation means a fix to that shape applies to both.
+ *
+ * @returns {{stop: () => void}}
+ */
+export const startSidecarMaintenance = ({ runTick, logPrefix = 'sidecar-maintenance', env = process.env, log = null, verbose = false, intervalMs, setIntervalImpl = setInterval, clearIntervalImpl = clearInterval } = {}) => {
+  const tick = () => {
+    runTick({ env, log, verbose }).catch(error => {
+      console.error(`[${logPrefix}] tick failed: ${error?.message || error}`);
+    });
+  };
+
+  const timer = setIntervalImpl(tick, intervalMs);
+  timer?.unref?.();
+  tick();
+  return {
+    stop: () => clearIntervalImpl(timer),
+  };
+};
+
+export default {
+  attachDockerNetwork,
+  dockerErrorMessage,
+  dockerOk,
+  dockerText,
+  ensureDockerVolume,
+  ensureInternalDockerNetwork,
+  inspectDockerContainer,
+  readDockerContainerAddress,
+  readDockerImageDigest,
+  readSidecarState,
+  reconcileSidecarLeases,
+  resolveSidecarStatePath,
+  sleep,
+  startSidecarMaintenance,
+  writeSidecarState,
+};

package/src/formal-ai-maintenance.lib.mjs

@@ -21,6 +21,7 @@
  */
 
 import { updateAgenticClisWhenIdle } from './agentic-cli-updater.lib.mjs';
+import { startSidecarMaintenance } from './docker-sidecar.lib.mjs';
 import { reconcileFormalAiSidecar, stopFormalAiSidecar, withFormalAiSidecarLock } from './formal-ai-sidecar.lib.mjs';
 import { updateFormalAiSidecarWhenIdle } from './formal-ai-updater.lib.mjs';
 
@@ -88,19 +89,6 @@ export const runFormalAiMaintenanceTick = async ({ env = process.env, run, log =
  *
  * @returns {{stop: () => void}}
  */
-export const startFormalAiMaintenance = ({ env = process.env, log = null, verbose = false, intervalMs = DEFAULT_FORMAL_AI_MAINTENANCE_INTERVAL_MS, setIntervalImpl = setInterval, clearIntervalImpl = clearInterval, runTick = runFormalAiMaintenanceTick } = {}) => {
-  const tick = () => {
-    runTick({ env, log, verbose }).catch(error => {
-      console.error(`[formal-ai-maintenance] tick failed: ${error?.message || error}`);
-    });
-  };
-
-  const timer = setIntervalImpl(tick, intervalMs);
-  timer?.unref?.();
-  tick();
-  return {
-    stop: () => clearIntervalImpl(timer),
-  };
-};
+export const startFormalAiMaintenance = ({ env = process.env, log = null, verbose = false, intervalMs = DEFAULT_FORMAL_AI_MAINTENANCE_INTERVAL_MS, setIntervalImpl = setInterval, clearIntervalImpl = clearInterval, runTick = runFormalAiMaintenanceTick } = {}) => startSidecarMaintenance({ runTick, logPrefix: 'formal-ai-maintenance', env, log, verbose, intervalMs, setIntervalImpl, clearIntervalImpl });
 
 export default { DEFAULT_FORMAL_AI_MAINTENANCE_INTERVAL_MS, runFormalAiMaintenanceTick, startFormalAiMaintenance, stopIdleFormalAiSidecar };