token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,307 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  evaluateVerification
+} from "./token-goat-chunk-2WLPWKHV.mjs";
+import {
+  claimsCommittedChange
+} from "./token-goat-chunk-PUO5INXP.mjs";
+import "./token-goat-chunk-2XBMMDBD.mjs";
+import "./token-goat-chunk-PFWIMH2E.mjs";
+import "./token-goat-chunk-GWFLAUMQ.mjs";
+import "./token-goat-chunk-PJZXIS3G.mjs";
+import "./token-goat-chunk-OBOFIHKN.mjs";
+import "./token-goat-chunk-NOSS5VWY.mjs";
+import "./token-goat-chunk-SAMFDIS2.mjs";
+import {
+  sessionSidecarPath
+} from "./token-goat-chunk-WBA5SKT4.mjs";
+import "./token-goat-chunk-CIMQ2BB3.mjs";
+import "./token-goat-chunk-WDH44VAU.mjs";
+import "./token-goat-chunk-BPGCUMR7.mjs";
+import "./token-goat-chunk-KQBLRPBN.mjs";
+import "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  contextOutput,
+  getCwd,
+  passOutput
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import "./token-goat-chunk-GL3ETKSC.mjs";
+import "./token-goat-chunk-NISNMD7T.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import {
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-4GILLLWY.mjs";
+import "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-F6PAUIEK.mjs";
+import "./token-goat-chunk-65N4RHP4.mjs";
+import "./token-goat-chunk-X2SUP3EI.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  getHarnessName
+} from "./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-Y4AFKTHK.mjs";
+import {
+  atomicWriteText,
+  ensureDirSync,
+  isWithinQuietHours,
+  runGit,
+  withFileLock
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedCommand,
+  nameSubject
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/agent_receipt.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+// src/change_claim.ts
+init_define_import_meta_env();
+var CHANGE_VERBS = "fixed|implemented|added|created|wrote|written|refactored|updated|changed|edited|modified|deleted|removed|patched|resolved|replaced|improved|applied|renamed|rewrote|rewritten";
+var OPENER_VERBS = "fixed|implemented|added|created|wrote|refactored|updated|changed|edited|modified|deleted|removed|patched|replaced|renamed|rewrote";
+var NOT_AN_EDIT_OBJECT = "(?![ \\t]+(?:(?:the|a|an|my|our|this|these|some)[ \\t]+)?(?:summary|report|review|analysis|findings?|notes?|plan|mind|understanding|that|following[ \\t]+(?:findings?|notes?|observations?|points?|issues?[ \\t]+(?:I|we)[ \\t]+(?:found|noticed|saw)))\\b)";
+var FENCED_BLOCK_RE = /```[\s\S]*?(?:```|$)|~~~[\s\S]*?(?:~~~|$)/g;
+var QUOTED_LINE_RE = /^(?:[ \t]*>.*|(?: {4}|\t)(?![ \t]*(?:[-*•]|\d+[.)])[ \t]).*)$/gm;
+var DIFF_EVIDENCE_RE = /^[ \t]*(?:@@|diff --git)|^[ \t]*\+[ \t].*\n[ \t]*[+-][ \t]|^[ \t]*-[ \t].*\n[ \t]*\+[ \t]/m;
+var DIFF_LINE_RE = /^[ \t]*(?:[+-][ \t]|@@).*$/gm;
+var FIRST_PERSON_CLAIM_RE = new RegExp(
+  `(?<!\\b(?:if|whether|when|unless|should|would|could)[ \\t]+)\\b(?:I|we)(?:['\u2019]ve|[ \\t]+have)?[ \\t]+(?:(?:also|then|just|now|already|both)[ \\t]+)*(?:(?:${CHANGE_VERBS})\\b(?![ \\t]+up\\b)(?![ \\t]*(?::[ \\t]*)?(?:nothing|none|anything|no|not|neither)\\b)${NOT_AN_EDIT_OBJECT}|made[ \\t]+(?:(?:the|some|several|a[ \\t]+few|these|those|following|minor|small)[ \\t]+)*(?:changes?|edits?|modifications?|fixes|updates?)\\b)`,
+  "i"
+);
+var OPENER_CLAIM_RE = new RegExp(`^[ \\t]{0,3}(?:${OPENER_VERBS})${NOT_AN_EDIT_OBJECT}[ \\t]+(?:(?:the|a|an|this|these|my|our)[ \\t]|\`[^\`\\n]+\`|[\\w./-]+\\.[A-Za-z]{1,5}\\b)`, "im");
+var CHANGES_HEADER_RE = /(?:^|\n)[ \t]*(?:#{1,6}[ \t]*)?[*_]*(?:changes(?: made)?|what (?:I|we) (?:changed|did)|files (?:changed|modified|edited))[*_]*[ \t]*(?::[*_]*[ \t]*|(?=\n))([^\n]*(?:\n[ \t]*(?:[-*•]|\d+[.)])[ \t]+[^\n]*)*)/i;
+var NEGATED_LIST_RE = /^[([]?\s*(?:none|nothing|n\/a|na|no|not|zero|0|[-–—]+)\b|^[-–—]+\s*$/i;
+var NOT_A_REPORT_ITEM_RE = /^(?:recommend|suggest|propos|consider|could|should)|\b(?:only read|read[- ]only|no (?:changes|edits)|made no (?:changes|edits))\b/i;
+function claimsOwnChange(report) {
+  const text = report.replace(FENCED_BLOCK_RE, "").replace(QUOTED_LINE_RE, "").replace(/\n[ \t]*(?=\n)/g, "");
+  const header = CHANGES_HEADER_RE.exec(text);
+  if (header !== null) {
+    const listed = (header[1] ?? "").trim().replace(/^(?:[-*•]|\d+[.)])[ \t]*/, "");
+    const firstItem = listed.split("\n")[0] ?? "";
+    if (listed !== "" && !NEGATED_LIST_RE.test(listed) && !NOT_A_REPORT_ITEM_RE.test(firstItem)) return true;
+  }
+  const prose = DIFF_EVIDENCE_RE.test(text) ? text.replace(DIFF_LINE_RE, "") : text;
+  return FIRST_PERSON_CLAIM_RE.test(prose) || OPENER_CLAIM_RE.test(prose);
+}
+
+// src/agent_receipt.ts
+var RECEIPTS_SUFFIX = ".agent-receipts";
+var MAX_RECEIPTS = 16;
+var MAX_NAMED_FILES = 3;
+var GIT_STATUS_TIMEOUT_MS = 5e3;
+var LINE_PREFIX = "token-goat:";
+var RECEIPT_TTL_MS = 30 * 60 * 1e3;
+var RECEIPTS_LOCK_SUFFIX = ".agent-receipts.lock";
+var RECEIPT_LOCK_WAIT_MS = 2e3;
+function capReceipts(receipts) {
+  let excess = receipts.length - MAX_RECEIPTS;
+  if (excess <= 0) return receipts;
+  const dropped = /* @__PURE__ */ new Set();
+  for (const wantClean of [true, false]) {
+    for (const r of receipts) {
+      if (excess > 0 && r.text === "" === wantClean && !dropped.has(r)) {
+        dropped.add(r);
+        excess--;
+      }
+    }
+  }
+  return receipts.filter((r) => !dropped.has(r));
+}
+function reportHash(trimmedReport) {
+  return createHash("sha256").update(trimmedReport).digest("hex").slice(0, 16);
+}
+function receiptLines(state, claimsChangeWithoutEdit) {
+  const lines = [];
+  if (state.failingUnresolved && state.latestRun !== void 0) {
+    lines.push(`${LINE_PREFIX} this subagent's last check failed: ${echoedCommand(state.latestRun.command)} (exit ${state.latestRun.exitCode}).`);
+  }
+  if (state.editedSinceLastPass.length > 0) {
+    const named = state.editedSinceLastPass.slice(0, MAX_NAMED_FILES).map((name) => nameSubject("file", name)).join(", ");
+    const more = state.editedSinceLastPass.length - MAX_NAMED_FILES;
+    lines.push(`${LINE_PREFIX} this subagent edited after its last passing check: ${named}${more > 0 ? ` (+${more} more)` : ""}.`);
+  }
+  if (claimsChangeWithoutEdit) lines.push(`${LINE_PREFIX} the report claims a change, but this subagent recorded no edit and the working tree is clean.`);
+  return lines;
+}
+function claimsChangeTheTreeLacks(report, cwd) {
+  if (cwd === null || !claimsOwnChange(report) || claimsCommittedChange(report)) return false;
+  const result = runGit(["status", "--porcelain"], { cwd, timeoutMs: GIT_STATUS_TIMEOUT_MS });
+  return result.exitCode === 0 && result.stdout.trim() === "";
+}
+function receiptForStoppedAgent(event, redactedReport) {
+  const config = loadConfig().hints;
+  if (!config.agent_receipt || isWithinQuietHours(config.quiet_hours)) return null;
+  const state = evaluateVerification(sessionStateKey(event));
+  const claimsWithoutEdit = !state.editedAnyFile && claimsChangeTheTreeLacks(redactedReport, getCwd(event) || null);
+  const lines = receiptLines(state, claimsWithoutEdit);
+  return lines.length === 0 ? null : lines.join("\n");
+}
+function readReceipts(target) {
+  try {
+    const parsed = JSON.parse(readFileSync(target, "utf8"));
+    if (!Array.isArray(parsed)) return [];
+    const oldest = Date.now() - RECEIPT_TTL_MS;
+    return parsed.filter(
+      (r) => r !== null && typeof r === "object" && typeof r.hash === "string" && typeof r.length === "number" && typeof r.text === "string" && typeof r.at === "number" && r.at >= oldest
+    );
+  } catch {
+    return [];
+  }
+}
+function withReceipts(sessionId, create, work) {
+  const target = sessionSidecarPath(sessionId, RECEIPTS_SUFFIX);
+  const lockPath = sessionSidecarPath(sessionId, RECEIPTS_LOCK_SUFFIX);
+  if (target === null || lockPath === null) return null;
+  if (!create && (!existsSync(target) || readReceipts(target).length === 0)) return null;
+  try {
+    ensureDirSync(dirname(target));
+    const held = withFileLock(
+      lockPath,
+      () => {
+        const receipts = readReceipts(target);
+        const before = JSON.stringify(receipts);
+        const out = work(receipts);
+        const after = JSON.stringify(capReceipts(receipts));
+        if (after !== before) atomicWriteText(target, after);
+        return { out };
+      },
+      { waitMs: RECEIPT_LOCK_WAIT_MS }
+    );
+    return held === void 0 ? null : held.out;
+  } catch {
+    return null;
+  }
+}
+function parkAgentReceipt(sessionId, redactedReport, text, agentId) {
+  const trimmed = redactedReport.trim();
+  if (trimmed === "") return;
+  const entry = { hash: reportHash(trimmed), length: trimmed.length, text: redactSecrets(text).text, at: Date.now(), ...agentId ? { agentId } : {} };
+  withReceipts(sessionId, true, (receipts) => {
+    receipts.push(entry);
+  });
+}
+var AGENT_ID_TRAILER_RE = /\bagentId:\s*([A-Za-z0-9_-]{6,})/g;
+function trailerAgentId(resultText) {
+  const matches = [...resultText.slice(-600).matchAll(AGENT_ID_TRAILER_RE)];
+  return matches.at(-1)?.[1];
+}
+function takeAgentReceipt(sessionId, resultText, agentId) {
+  const trimmed = resultText.trim();
+  const wantedId = agentId ?? trailerAgentId(trimmed);
+  const endsReport = (r) => r.length === trimmed.length || trimmed[r.length] === "\n" || trimmed[r.length] === "\r";
+  const sameText = (r) => r.length <= trimmed.length && endsReport(r) && reportHash(trimmed.slice(0, r.length)) === r.hash;
+  return withReceipts(sessionId, false, (receipts) => {
+    const byId = wantedId === void 0 ? -1 : receipts.findIndex((r) => r.agentId === wantedId);
+    if (byId >= 0 && (agentId !== void 0 || sameText(receipts[byId]))) return receipts.splice(byId, 1)[0]?.text || null;
+    if (agentId !== void 0) return null;
+    const candidates = receipts.map((r, i) => ({ r, i })).filter(({ r }) => sameText(r) && (wantedId === void 0 || r.agentId === void 0));
+    if (candidates.length === 0 || candidates.some(({ r }) => r.text !== candidates[0].r.text)) return null;
+    return receipts.splice(candidates[0].i, 1)[0]?.text || null;
+  });
+}
+function subagentReceiptHandler(event) {
+  try {
+    const raw = event.raw["last_assistant_message"];
+    if (getHarnessName() === "copilot_cli" || !event.sessionId || typeof raw !== "string" || raw === "" || event.raw["stop_hook_active"] === true) return passOutput();
+    const report = redactSecrets(raw).text;
+    const text = receiptForStoppedAgent(event, report);
+    if (text !== null || loadConfig().hints.agent_receipt) parkAgentReceipt(event.sessionId, report, text ?? "", event.agentId);
+    return passOutput();
+  } catch {
+    return passOutput();
+  }
+}
+function subagentStopHandler(event) {
+  try {
+    const cwd = getCwd(event);
+    if (!event.sessionId || !cwd) return passOutput();
+    const message = typeof event.raw["last_assistant_message"] === "string" ? event.raw["last_assistant_message"] : "";
+    if (!claimsOwnChange(message) || claimsCommittedChange(message)) return passOutput();
+    const result = runGit(["status", "--porcelain"], { cwd, timeoutMs: loadConfig().hints.git_hint_max_ms });
+    if (result.exitCode === 0 && result.stdout.trim() === "") {
+      console.warn(`subagent-stop: possible hallucination \u2014 session=${event.sessionId} but git status is clean`);
+    }
+    return passOutput();
+  } catch {
+    return passOutput();
+  }
+}
+function completedSubagents(toolResponse) {
+  let parsed = toolResponse;
+  if (typeof toolResponse === "string") {
+    try {
+      parsed = JSON.parse(toolResponse);
+    } catch {
+      return [];
+    }
+  }
+  const status = parsed !== null && typeof parsed === "object" ? parsed["status"] : void 0;
+  if (status === null || typeof status !== "object") return [];
+  const out = [];
+  for (const [agentId, value] of Object.entries(status)) {
+    const report = value !== null && typeof value === "object" ? value["completed"] : void 0;
+    if (typeof report === "string" && report !== "") out.push({ agentId, report });
+  }
+  return out;
+}
+function waitAgentReceipts(sessionId, toolResponse) {
+  const finished = completedSubagents(toolResponse);
+  const blocks = [];
+  for (const { agentId, report } of finished) {
+    const text = takeAgentReceipt(sessionId, redactSecrets(report).text, agentId);
+    if (text !== null) blocks.push(finished.length > 1 ? `${LINE_PREFIX} agent ${echoedCommand(agentId)}:
+${text}` : text);
+  }
+  return blocks;
+}
+function waitAgentHandler(event) {
+  try {
+    if (!event.sessionId) return passOutput();
+    const blocks = waitAgentReceipts(event.sessionId, event.raw["tool_response"]);
+    if (blocks.length === 0) return passOutput();
+    recordStat("agent_receipt", 0, 0, void 0, "agent");
+    return contextOutput(blocks.join("\n"));
+  } catch {
+    return passOutput();
+  }
+}
+export {
+  claimsChangeTheTreeLacks,
+  parkAgentReceipt,
+  receiptForStoppedAgent,
+  receiptLines,
+  subagentReceiptHandler,
+  subagentStopHandler,
+  takeAgentReceipt,
+  waitAgentHandler,
+  waitAgentReceipts
+};

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

@@ -0,0 +1,233 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  registerHook
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  passOutput
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  ensureWorkerAlive
+} from "./token-goat-chunk-F6PAUIEK.mjs";
+import {
+  isUnderSystemTemp
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  atomicWriteBytes,
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  normalizePath,
+  resolveIndexPath
+} 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/dirty_queue.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function dirtyQueuePathFor(dir) {
+  return path.join(dir, "queue", "dirty.txt");
+}
+var ENCODED_LINE_MARKER = "!";
+function encodeDirtyQueueLine(absPath) {
+  const needsEncoding = /[\r\n]/.test(absPath) || absPath !== absPath.trim();
+  return needsEncoding ? ENCODED_LINE_MARKER + JSON.stringify(absPath) : absPath;
+}
+function decodeDirtyQueueLine(line) {
+  if (!line.startsWith(ENCODED_LINE_MARKER)) return line;
+  try {
+    const decoded = JSON.parse(line.slice(ENCODED_LINE_MARKER.length));
+    return typeof decoded === "string" ? decoded : line;
+  } catch {
+    return line;
+  }
+}
+function parseDirtyQueueLines(raw) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = decodeDirtyQueueLine(line.trim());
+    if (trimmed === "") continue;
+    const normalized = normalizePath(trimmed);
+    const dedupeKey = foldPath(normalized);
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+    out.push(trimmed);
+  }
+  return out;
+}
+function getDirtyPathsFor(dir) {
+  let raw;
+  try {
+    raw = fs.readFileSync(dirtyQueuePathFor(dir), "utf8");
+  } catch {
+    return [];
+  }
+  return parseDirtyQueueLines(raw);
+}
+function dirtyQueueLeadingNewline(queuePath) {
+  let fd;
+  try {
+    const size = fs.statSync(queuePath).size;
+    if (size === 0) return "";
+    fd = fs.openSync(queuePath, "r");
+    const tail = Buffer.allocUnsafe(1);
+    fs.readSync(fd, tail, 0, 1, size - 1);
+    return tail[0] === 10 ? "" : "\n";
+  } catch {
+    return "";
+  } finally {
+    if (fd !== void 0) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+function appendToLiveQueue(queuePath, data) {
+  const fd = fs.openSync(queuePath, "a");
+  try {
+    fs.writeFileSync(fd, data);
+    return fs.statSync(queuePath, { bigint: true, throwIfNoEntry: false })?.ino === fs.fstatSync(fd, { bigint: true }).ino;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+function renderDirtyQueueLines(absPaths) {
+  return absPaths.map((p) => `${encodeDirtyQueueLine(p)}
+`).join("");
+}
+function appendDirtyQueueFile(filePath, absPaths) {
+  if (absPaths.length === 0) return;
+  fs.appendFileSync(filePath, `${dirtyQueueLeadingNewline(filePath)}${renderDirtyQueueLines(absPaths)}`);
+}
+function appendDirtyQueuePaths(dir, absPaths) {
+  if (absPaths.length === 0) return true;
+  return appendToClaimableFile(dirtyQueuePathFor(dir), renderDirtyQueueLines(absPaths));
+}
+function appendToClaimableFile(queuePath, body) {
+  const queueDir = path.dirname(queuePath);
+  try {
+    ensureDirSync(queueDir);
+  } catch (e) {
+    if (e.code !== "EEXIST" || !fs.existsSync(queueDir)) throw e;
+  }
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (appendToLiveQueue(queuePath, `${dirtyQueueLeadingNewline(queuePath)}${body}`)) return true;
+  }
+  return false;
+}
+function reconcileRequestPathFor(dir) {
+  return path.join(dir, "queue", "reconcile.txt");
+}
+function appendReconcileRequest(dir, projectDir) {
+  return appendToClaimableFile(reconcileRequestPathFor(dir), `${JSON.stringify(projectDir)}
+`);
+}
+function parseReconcileRequests(raw) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    let dir;
+    try {
+      dir = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (typeof dir !== "string" || dir === "") continue;
+    const key = foldPath(normalizePath(dir));
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(dir);
+  }
+  return out;
+}
+
+// src/hooks_index.ts
+init_define_import_meta_env();
+import * as path2 from "node:path";
+function appendDirtyPaths(normalizedPaths) {
+  appendDirtyQueuePaths(dataDir(), normalizedPaths);
+}
+function appendDirtyPath(normalizedPath) {
+  appendDirtyPaths([normalizedPath]);
+}
+function enqueueDirtyPathSafe(filePath, opts) {
+  enqueueDirtyPathsSafe([filePath], opts);
+}
+function enqueueDirtyPathsSafe(filePaths, opts) {
+  const resolved = [];
+  try {
+    for (const filePath of filePaths) {
+      const r = opts?.alreadyResolved === true ? filePath : resolveIndexPath(filePath);
+      if (isUnderSystemTemp(r)) continue;
+      resolved.push(r);
+    }
+    if (resolved.length === 0) return 0;
+    if (opts?.dir !== void 0) appendDirtyQueuePaths(opts.dir, resolved);
+    else appendDirtyPaths(resolved);
+  } catch {
+    return 0;
+  }
+  try {
+    ensureWorkerAlive();
+  } catch {
+  }
+  return resolved.length;
+}
+function requestReconcileSafe(projectDir) {
+  try {
+    if (!appendReconcileRequest(dataDir(), projectDir)) return false;
+  } catch {
+    return false;
+  }
+  try {
+    ensureWorkerAlive();
+  } catch {
+  }
+  return true;
+}
+function getDirtyPaths() {
+  return getDirtyPathsFor(dataDir());
+}
+function preCompactIndexHandler(_event) {
+  const paths = getDirtyPaths();
+  if (paths.length > 0) {
+    const sidecar = path2.join(dataDir(), "queue", "pending.txt");
+    try {
+      ensureDirSync(path2.dirname(sidecar));
+      atomicWriteBytes(sidecar, Buffer.from(`${paths.join("\n")}
+`, "utf8"));
+    } catch {
+    }
+  }
+  return passOutput();
+}
+registerHook("pre_compact", preCompactIndexHandler, { advisory: true });
+
+export {
+  dirtyQueuePathFor,
+  parseDirtyQueueLines,
+  getDirtyPathsFor,
+  appendDirtyQueueFile,
+  appendDirtyQueuePaths,
+  reconcileRequestPathFor,
+  appendReconcileRequest,
+  parseReconcileRequests,
+  appendDirtyPath,
+  enqueueDirtyPathSafe,
+  enqueueDirtyPathsSafe,
+  requestReconcileSafe
+};