token-goat 2.9.30 → 2.9.31

package/dist/token-goat-chunk-NMD42SFQ.mjs

@@ -0,0 +1,434 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  AGENT_SALT_MARKER,
+  readSessionStateFile,
+  sessionFileStem
+} from "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  readTranscriptTail
+} from "./token-goat-chunk-WDH44VAU.mjs";
+import {
+  isAutoTriggerMultiplierExplicit,
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  detectHarness
+} from "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  atomicWriteText,
+  ensureDirSync,
+  normalizePathForwardSlash
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  dataDir,
+  tokenGoatHome
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/compact.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var CONTEXT_AUTOCOMPACT_TOKENS = 66e4;
+var CATALOG_TOKENS = 10800;
+var CONTEXT_TIER_WARM = 0.5;
+var CONTEXT_TIER_HOT = 0.7;
+var CONTEXT_TIER_CRITICAL = 0.85;
+var NOISE_EXTS = /* @__PURE__ */ new Set([
+  ".pyc",
+  ".pyo",
+  ".pyd",
+  ".class",
+  ".o",
+  ".obj",
+  ".a",
+  ".lib",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".log",
+  ".jsonl",
+  ".tmp",
+  ".temp",
+  ".swp",
+  ".swo",
+  ".bak",
+  ".pid",
+  ".lock",
+  ".map",
+  ".wasm",
+  ".gz",
+  ".zip",
+  ".tar",
+  ".tgz",
+  ".db",
+  ".sqlite",
+  ".sqlite3",
+  ".db3",
+  ".d.ts",
+  ".snap",
+  ".eot",
+  ".ttf",
+  ".woff",
+  ".woff2",
+  ".ico",
+  ".pdb",
+  ".exe",
+  ".bin"
+]);
+var NOISE_BASENAMES = /* @__PURE__ */ new Set([
+  ".ds_store",
+  "thumbs.db",
+  "desktop.ini",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "poetry.lock",
+  "uv.lock",
+  "pdm.lock",
+  "cargo.lock",
+  "composer.lock",
+  "gemfile.lock",
+  "coverage.xml",
+  ".coverage",
+  "lcov.info"
+]);
+var NOISE_SEGMENTS = [
+  "/__pycache__/",
+  "/.git/",
+  "/node_modules/",
+  "/.venv/",
+  "/venv/",
+  "/dist/",
+  "/build/",
+  "/.mypy_cache/",
+  "/.pytest_cache/",
+  "/.ruff_cache/",
+  "/appdata/local/temp/",
+  "/appdata/roaming/",
+  "/tmp/",
+  "/.next/",
+  "/.nuxt/",
+  "/.svelte-kit/",
+  "/.turbo/",
+  "/.parcel-cache/",
+  "/.cache/",
+  "/.tox/",
+  "/coverage/",
+  "/.nyc_output/",
+  "/site-packages/",
+  ".egg-info/",
+  "/target/",
+  "/__snapshots__/"
+];
+var HARNESS_MULTIPLIER_DEFAULTS = {
+  claudecode: 2,
+  codex: 1.5,
+  opencode: 2.5,
+  gemini: 3,
+  openclaw: 1,
+  pi: 1,
+  hermes: 1,
+  generic: 1
+};
+function tierForFraction(fill) {
+  if (fill >= CONTEXT_TIER_CRITICAL) return "critical";
+  if (fill >= CONTEXT_TIER_HOT) return "hot";
+  if (fill >= CONTEXT_TIER_WARM) return "warm";
+  return "cool";
+}
+function pressureRawTotal(cache) {
+  const skillTokens = cache.loadedSkillTotalTokens ?? 0;
+  const bashCount = (cache.bashOutputs ?? []).length;
+  const webCount = (cache.webFetches ?? []).length;
+  const files = cache.files ?? [];
+  const readCount = files.length;
+  return skillTokens + CATALOG_TOKENS + bashCount * 500 + webCount * 1e3 + readCount * 200;
+}
+var PROMPT_MEASURE_TAIL_BYTES = 1048576;
+function extractUsageTotal(record) {
+  if (record === null || typeof record !== "object") return null;
+  if (record["type"] !== "assistant") return null;
+  const message = record["message"];
+  if (message === null || typeof message !== "object") return null;
+  const usage = message["usage"];
+  if (usage === null || typeof usage !== "object") return null;
+  const u = usage;
+  const input = u["input_tokens"];
+  const cacheCreation = u["cache_creation_input_tokens"];
+  const cacheRead = u["cache_read_input_tokens"];
+  const output = u["output_tokens"];
+  if (typeof input !== "number" || typeof cacheCreation !== "number" || typeof cacheRead !== "number" || typeof output !== "number") {
+    return null;
+  }
+  return input + cacheCreation + cacheRead + output;
+}
+function measurePromptTokens(transcriptPath) {
+  try {
+    const lines = readTranscriptTail(transcriptPath, PROMPT_MEASURE_TAIL_BYTES);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (line === void 0) continue;
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      const total = extractUsageTotal(parsed);
+      if (total !== null) return total;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function getEffectiveAutoTriggerWindow() {
+  const ca = loadConfig().compact_assist;
+  const isConfigDefault = !isAutoTriggerMultiplierExplicit();
+  const multiplier = getAutoTriggerMultiplier(
+    ca.harness === "auto" ? { configExplicitMultiplier: ca.auto_trigger_multiplier, isConfigDefault } : { configExplicitMultiplier: ca.auto_trigger_multiplier, harness: ca.harness, isConfigDefault }
+  );
+  return CONTEXT_AUTOCOMPACT_TOKENS * multiplier;
+}
+function getContextPressure(cache, transcriptPath) {
+  try {
+    const window = getEffectiveAutoTriggerWindow();
+    if (transcriptPath) {
+      const measured = measurePromptTokens(transcriptPath);
+      if (measured !== null) {
+        const fill2 = measured / window;
+        return { fillFraction: fill2, tier: tierForFraction(fill2) };
+      }
+    }
+    if (!cache) {
+      return { fillFraction: 0, tier: "cool" };
+    }
+    const total = pressureRawTotal(cache);
+    const fill = total / window;
+    return {
+      fillFraction: fill,
+      tier: tierForFraction(fill)
+    };
+  } catch {
+    return { fillFraction: 0, tier: "cool" };
+  }
+}
+function getAutoTriggerMultiplier(opts) {
+  const config = opts?.configExplicitMultiplier ?? 2;
+  let isDefault = opts?.isConfigDefault;
+  if (isDefault === void 0) {
+    isDefault = config === 2;
+  }
+  if (!isDefault && opts?.configExplicitMultiplier !== void 0) {
+    return Math.max(1, Math.min(10, opts.configExplicitMultiplier));
+  }
+  const harness = opts?.harness ?? detectHarness();
+  return Math.max(1, Math.min(10, HARNESS_MULTIPLIER_DEFAULTS[harness] ?? 1));
+}
+function isNoisePath(inputPath) {
+  if (!inputPath) {
+    return false;
+  }
+  const p = normalizePathForwardSlash(inputPath, true);
+  for (const segment of NOISE_SEGMENTS) {
+    if (p.includes(segment)) {
+      return true;
+    }
+  }
+  const slashIdx = p.lastIndexOf("/");
+  const basename = slashIdx >= 0 ? p.slice(slashIdx + 1) : p;
+  if (NOISE_BASENAMES.has(basename)) {
+    return true;
+  }
+  if (basename.startsWith(".improve-state-") || basename.startsWith("improve_commit_msg_")) {
+    return true;
+  }
+  const dotIdx = basename.lastIndexOf(".");
+  if (dotIdx >= 0) {
+    const ext = basename.slice(dotIdx);
+    if (NOISE_EXTS.has(ext)) {
+      return true;
+    }
+  }
+  for (const ext of NOISE_EXTS) {
+    if (ext.includes(".") && ext.split(".").length > 2) {
+      if (basename.endsWith(ext)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function findLatestSessionId() {
+  try {
+    const sessionsDir = path.join(tokenGoatHome(), "sessions");
+    if (!fs.existsSync(sessionsDir)) {
+      return null;
+    }
+    const files = fs.readdirSync(sessionsDir);
+    const jsonFiles = files.filter((f) => f.endsWith(".json") && !f.includes(AGENT_SALT_MARKER));
+    if (jsonFiles.length === 0) {
+      return null;
+    }
+    const firstFile = jsonFiles[0];
+    if (!firstFile) {
+      return null;
+    }
+    let latestFile = firstFile;
+    let latestMtime = fs.statSync(path.join(sessionsDir, firstFile)).mtimeMs;
+    for (const file of jsonFiles) {
+      const mtime = fs.statSync(path.join(sessionsDir, file)).mtimeMs;
+      if (mtime > latestMtime) {
+        latestFile = file;
+        latestMtime = mtime;
+      }
+    }
+    return latestFile.replace(/\.json$/, "");
+  } catch {
+    return null;
+  }
+}
+function eventCount(cache) {
+  const files = cache.files ?? [];
+  const editedCount = files.filter((f) => f.wasEdited).length;
+  const bashCount = (cache.bashOutputs ?? []).length;
+  const webCount = (cache.webFetches ?? []).length;
+  const skillHistory = cache.skillHistory ?? {};
+  return files.length + editedCount + bashCount + webCount + Object.keys(skillHistory).length;
+}
+function writeSessionManifest(projectHash, sessionId, manifestJson) {
+  const safeSessionId = sessionFileStem(sessionId);
+  if (!safeSessionId) return;
+  const sessionsDir = path.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs.existsSync(sessionsDir)) {
+    ensureDirSync(sessionsDir);
+  }
+  const dest = path.join(sessionsDir, `${safeSessionId}.json`);
+  atomicWriteText(dest, JSON.stringify(manifestJson));
+}
+function readAllSessionManifests(projectHash, maxAgeSecs = 3600) {
+  const sessionsDir = path.join(dataDir(), "projects", projectHash, "sessions");
+  if (!fs.existsSync(sessionsDir)) {
+    return [];
+  }
+  const now = Date.now() / 1e3;
+  const results = [];
+  try {
+    const files = fs.readdirSync(sessionsDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      try {
+        const fullPath = path.join(sessionsDir, file);
+        const stat = fs.statSync(fullPath);
+        if (now - stat.mtimeMs / 1e3 > maxAgeSecs) {
+          try {
+            fs.unlinkSync(fullPath);
+          } catch {
+          }
+          continue;
+        }
+        const text = fs.readFileSync(fullPath, "utf8");
+        const data = JSON.parse(text);
+        if (typeof data === "object" && data !== null && "files" in data) {
+          results.push(data);
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function _editedFileCount(cache) {
+  return (cache.files ?? []).filter((f) => f.wasEdited).length;
+}
+function _computeActivityMultiplier(ageSecs, editedCount) {
+  const TEN_MIN_SECS = 600;
+  const SIXTY_MIN_SECS = 3600;
+  const EDITS_PER_MIN_DENSITY_THRESHOLD = 0.3;
+  let tier;
+  if (ageSecs < TEN_MIN_SECS) {
+    tier = "young";
+  } else if (ageSecs < SIXTY_MIN_SECS) {
+    tier = "active";
+  } else {
+    tier = "mature";
+  }
+  const baseFactor = {
+    young: 0.6,
+    active: 1,
+    mature: 1.4
+  };
+  let factor = baseFactor[tier];
+  if (ageSecs >= TEN_MIN_SECS) {
+    const editsPerMin = ageSecs > 0 ? editedCount / (ageSecs / 60) : 0;
+    if (editsPerMin < EDITS_PER_MIN_DENSITY_THRESHOLD) {
+      factor = Math.min(factor, 1);
+    }
+  }
+  return factor;
+}
+function loadSessionCache(sessionId) {
+  const disk = readSessionStateFile(sessionId);
+  if (!disk) {
+    return null;
+  }
+  return {
+    files: disk.files,
+    webFetches: disk.webFetches,
+    bashOutputs: disk.bashOutputs,
+    ...disk.created_ts !== void 0 ? { created_ts: disk.created_ts } : {}
+  };
+}
+function computeAdaptiveBudget(cache, ageSecs = 0, opts) {
+  const base = 200;
+  const maxTotal = 800;
+  const minTotal = 200;
+  const editedCount = _editedFileCount(cache);
+  const editedBonus = Math.min(200, editedCount * 50);
+  const files = cache.files ?? [];
+  const symbolFiles = files.filter((f) => {
+    const entry = f;
+    return (entry["symbols_read"] ?? []).length > 0;
+  }).length;
+  const symbolsBonus = Math.min(150, symbolFiles * 30);
+  const bashCount = (cache.bashOutputs ?? []).length;
+  const bashBonus = bashCount > 0 ? Math.min(100, Math.max(20, bashCount * 5)) : 0;
+  const webBonus = (cache.webFetches ?? []).length > 0 ? 15 : 0;
+  const diffBonus = opts?.hasPendingDiff ? 50 : 0;
+  const uncommittedBonus = opts?.hasUncommittedChanges ? 10 : 0;
+  const staleFrac = Math.max(0, Math.min(1, opts?.staleCompactFraction ?? 0));
+  const staleBonus = Math.min(60, Math.round(staleFrac * 60));
+  const rawTotal = base + editedBonus + symbolsBonus + bashBonus + webBonus + diffBonus + uncommittedBonus + staleBonus;
+  const factor = _computeActivityMultiplier(ageSecs, editedCount);
+  const total = Math.round(rawTotal * factor);
+  let capMax = maxTotal;
+  if (opts?.contextPressure) {
+    if (opts.contextPressure.tier === "critical") {
+      capMax = Math.min(capMax, 300);
+    } else if (opts.contextPressure.tier === "hot") {
+      capMax = Math.min(capMax, 500);
+    }
+  }
+  return Math.max(minTotal, Math.min(capMax, total));
+}
+
+export {
+  CONTEXT_AUTOCOMPACT_TOKENS,
+  getContextPressure,
+  isNoisePath,
+  findLatestSessionId,
+  eventCount,
+  writeSessionManifest,
+  readAllSessionManifests,
+  loadSessionCache,
+  computeAdaptiveBudget
+};

package/dist/token-goat-chunk-NOSS5VWY.mjs

@@ -0,0 +1,174 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  embedTexts,
+  isAvailable
+} from "./token-goat-chunk-NISNMD7T.mjs";
+import {
+  redactIfDotenv
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  decodeSource,
+  ensureDirSync,
+  statSize
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  displaySafePath,
+  hostPathOfIndexKey,
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/evidence_cache.ts
+init_define_import_meta_env();
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+var MAX_ENTRIES = 500;
+var MAX_TEXT_BYTES = 128 * 1024;
+var MAX_FILE_BYTES = 4 * MAX_TEXT_BYTES + 7;
+var CACHE_FILE = "workspace-evidence.json";
+function cachePath() {
+  return path.join(dataDir(), CACHE_FILE);
+}
+function hash(text) {
+  return crypto.createHash("sha256").update(text).digest("hex");
+}
+function load() {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(cachePath(), "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.projectRoot === "string" && typeof entry.source === "string" && (entry.representation === "file" || entry.representation === "tool-output") && typeof entry.contentHash === "string" && typeof entry.text === "string" && typeof entry.createdAt === "number" && (entry.embedding === void 0 || typeof entry.embedding === "string")
+    );
+  } catch {
+    return [];
+  }
+}
+function save(entries) {
+  try {
+    ensureDirSync(dataDir());
+    fs.writeFileSync(cachePath(), JSON.stringify(entries.slice(0, MAX_ENTRIES)), "utf8");
+  } catch {
+  }
+}
+function readEvidenceFileText(filePath) {
+  const onDisk = hostPathOfIndexKey(filePath);
+  const size = statSize(onDisk);
+  if (size === null || size > MAX_FILE_BYTES) return null;
+  const text = decodeSource(fs.readFileSync(onDisk));
+  return Buffer.byteLength(text, "utf8") > MAX_TEXT_BYTES ? null : text;
+}
+function recordEvidence(input) {
+  if (Buffer.byteLength(input.text, "utf8") > MAX_TEXT_BYTES) return null;
+  const contentHash = hash(input.text);
+  const text = redactSecrets(redactIfDotenv(input.source, input.text)).text;
+  const projectRoot = normalizePath(input.projectRoot);
+  const source = input.representation === "file" ? normalizePath(input.source) : input.source;
+  const id = hash(`${projectRoot}\0${source}\0${input.representation}\0${contentHash}`).slice(0, 24);
+  const entry = {
+    id,
+    projectRoot,
+    source,
+    representation: input.representation,
+    contentHash,
+    text,
+    createdAt: Date.now()
+  };
+  const entries = load().filter(
+    (candidate) => candidate.projectRoot !== projectRoot || candidate.source !== source || candidate.representation !== input.representation
+  );
+  entries.unshift(entry);
+  save(entries);
+  return entry;
+}
+function findVerifiedFileEvidence(projectRoot, source, currentText) {
+  const normalizedRoot = normalizePath(projectRoot);
+  const normalizedSource = normalizePath(source);
+  const currentHash = hash(currentText);
+  return load().find(
+    (entry) => entry.projectRoot === normalizedRoot && entry.source === normalizedSource && entry.representation === "file" && entry.contentHash === currentHash
+  ) ?? null;
+}
+function decodeEmbedding(encoded) {
+  if (encoded === void 0) return null;
+  try {
+    const bytes = Buffer.from(encoded, "base64");
+    if (bytes.length === 0 || bytes.length % Float32Array.BYTES_PER_ELEMENT !== 0) return null;
+    return new Float32Array(bytes.buffer, bytes.byteOffset, bytes.length / Float32Array.BYTES_PER_ELEMENT);
+  } catch {
+    return null;
+  }
+}
+function encodeEmbedding(vector) {
+  const values = Float32Array.from(vector);
+  return Buffer.from(values.buffer, values.byteOffset, values.byteLength).toString("base64");
+}
+function cosineSimilarity(left, right) {
+  if (left.length !== right.length) return Number.NEGATIVE_INFINITY;
+  let dot = 0;
+  let leftMagnitude = 0;
+  let rightMagnitude = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    const a = left[index] ?? 0;
+    const b = right[index] ?? 0;
+    dot += a * b;
+    leftMagnitude += a * a;
+    rightMagnitude += b * b;
+  }
+  return leftMagnitude === 0 || rightMagnitude === 0 ? Number.NEGATIVE_INFINITY : dot / Math.sqrt(leftMagnitude * rightMagnitude);
+}
+async function searchEvidenceSemantically(projectRoot, query, limit = 10) {
+  if (query.trim() === "" || !isAvailable()) return [];
+  const root = normalizePath(projectRoot);
+  const entries = load().filter((entry) => entry.projectRoot === root);
+  if (entries.length === 0) return [];
+  try {
+    const missing = entries.filter((entry) => decodeEmbedding(entry.embedding) === null);
+    const vectors = await embedTexts([query, ...missing.map((entry) => entry.text)]);
+    const queryVector = vectors[0];
+    if (queryVector === void 0) return [];
+    for (let index = 0; index < missing.length; index += 1) {
+      const vector = vectors[index + 1];
+      if (vector !== void 0) missing[index].embedding = encodeEmbedding(vector);
+    }
+    if (missing.length > 0) {
+      const updated = new Map(entries.map((entry) => [entry.id, entry]));
+      save(load().map((entry) => updated.get(entry.id) ?? entry));
+    }
+    const queryValues = Float32Array.from(queryVector);
+    return entries.map((entry) => ({ entry, score: cosineSimilarity(queryValues, decodeEmbedding(entry.embedding) ?? new Float32Array()) })).filter(({ score }) => Number.isFinite(score)).sort((left, right) => right.score - left.score || right.entry.createdAt - left.entry.createdAt).slice(0, limit).map(({ entry }) => entry);
+  } catch {
+    return [];
+  }
+}
+function buildDeltaCapsule(projectRoot, limit = 8) {
+  const root = normalizePath(projectRoot);
+  const changed = load().filter((entry) => entry.projectRoot === root && entry.representation === "file").filter((entry) => {
+    try {
+      const current = readEvidenceFileText(entry.source);
+      return current === null || hash(current) !== entry.contentHash;
+    } catch {
+      return true;
+    }
+  }).slice(0, limit);
+  if (changed.length === 0) return null;
+  return `Cross-session evidence changed since it was cached:
+${changed.map((entry) => `- ${displaySafePath(entry.source)} (use a fresh surgical read)`).join("\n")}`;
+}
+
+export {
+  readEvidenceFileText,
+  recordEvidence,
+  findVerifiedFileEvidence,
+  searchEvidenceSemantically,
+  buildDeltaCapsule
+};

package/dist/{token-goat-chunk-KQNZDCBD.mjs → token-goat-chunk-NSNSPPBG.mjs}

@@ -1,43 +1,65 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  WORKER_STARTUP_GRACE_MS,
   WorkerAlreadyRunningError,
   WorkerDataDirUnwritableError,
   appendWorkerErrorLog,
+  claimCurrentWorker,
   claimWorkerPidFile,
   currentDaemonStamp,
+  daemonEntryScript,
   dataDirWriteRefusal,
+  displacedWorkerPath,
   drainHeartbeatPathFor,
   ensureWorkerAlive,
   isWorkerRunning,
   oneLogLine,
+  pidAlive,
+  readDisplacedPids,
   readPidFile,
   resolvePollIntervalMs,
+  retireDisplacedWorker,
   startDetachedWorker,
   stopWorker,
   workerErrorLogPath,
   workerPidPath,
   workerStampPath,
   writeDrainHeartbeat
-} from "./token-goat-chunk-5KDMCMF2.mjs";
-import "./token-goat-chunk-GOLEOXZP.mjs";
+} from "./token-goat-chunk-F6PAUIEK.mjs";
+import "./token-goat-chunk-65N4RHP4.mjs";
+import "./token-goat-chunk-X2SUP3EI.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
 import "./token-goat-chunk-AM5V6GSX.mjs";
 import "./token-goat-chunk-FNFBKLRD.mjs";
-import "./token-goat-chunk-VES7EL7O.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
 import "./token-goat-chunk-A37V4PBF.mjs";
 export {
+  WORKER_STARTUP_GRACE_MS,
   WorkerAlreadyRunningError,
   WorkerDataDirUnwritableError,
   appendWorkerErrorLog,
+  claimCurrentWorker,
   claimWorkerPidFile,
   currentDaemonStamp,
+  daemonEntryScript,
   dataDirWriteRefusal,
+  displacedWorkerPath,
   drainHeartbeatPathFor,
   ensureWorkerAlive,
   isWorkerRunning,
   oneLogLine,
+  pidAlive,
+  readDisplacedPids,
   readPidFile,
   resolvePollIntervalMs,
+  retireDisplacedWorker,
   startDetachedWorker,
   stopWorker,
   workerErrorLogPath,