token-goat 2.9.29 → 2.9.31

package/dist/{token-goat-chunk-67BNIKKO.mjs → token-goat-chunk-P6HQSWQ3.mjs}

@@ -3,35 +3,61 @@ const require = __cjsRequire(import.meta.url);
 import {
   MCP_DISABLE_NOTE,
   buildCopilotWasteReport,
+  buildWasteReport,
   findProjectSession,
   isCopilotTranscript,
+  noSessionTranscriptMessage,
   unusedMcpServers
-} from "./token-goat-chunk-C5YPNZKQ.mjs";
+} from "./token-goat-chunk-EELTBKDM.mjs";
+import "./token-goat-chunk-ODBT2USM.mjs";
+import "./token-goat-chunk-DGS2LVNA.mjs";
+import "./token-goat-chunk-INNPTRUX.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 "./token-goat-chunk-C75NA7PL.mjs";
 import {
-  buildWasteReport
-} from "./token-goat-chunk-44BM7DDQ.mjs";
-import "./token-goat-chunk-EUSDXRXU.mjs";
-import "./token-goat-chunk-ONXH6NZ5.mjs";
-import "./token-goat-chunk-O6I2XU4P.mjs";
-import "./token-goat-chunk-D4ETHJD6.mjs";
-import "./token-goat-chunk-52NSDWYY.mjs";
-import "./token-goat-chunk-2WOUYWLM.mjs";
-import "./token-goat-chunk-CIQ2FTY3.mjs";
-import "./token-goat-chunk-435UQTKD.mjs";
-import "./token-goat-chunk-7CPMDFGB.mjs";
+  writeCommandFailure
+} from "./token-goat-chunk-CBIQ7WTD.mjs";
+import "./token-goat-chunk-P6VGNTQT.mjs";
+import "./token-goat-chunk-76FGDLRO.mjs";
+import "./token-goat-chunk-GL3ETKSC.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import "./token-goat-chunk-4NAPX7BA.mjs";
+import "./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 "./token-goat-chunk-T5P5ACNQ.mjs";
+import "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
 import {
   resolveProjectRoot
-} from "./token-goat-chunk-TGOXNAHW.mjs";
-import "./token-goat-chunk-XB5KKOCG.mjs";
+} from "./token-goat-chunk-4GBVPH3D.mjs";
 import "./token-goat-chunk-YZAAZU2S.mjs";
 import "./token-goat-chunk-IVE6U7KV.mjs";
-import "./token-goat-chunk-XYWPOSCN.mjs";
-import "./token-goat-chunk-TCQANXYC.mjs";
+import {
+  countNoun
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  echoedValue
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
 import {
   displaySafeJson
-} from "./token-goat-chunk-NMTKNYGF.mjs";
-import "./token-goat-chunk-MELOKFDJ.mjs";
-import "./token-goat-chunk-JTKCQMQA.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -45,11 +71,11 @@ function buildFeedbackCardFromClaude(report) {
   const fixes = [];
   if (report.neverTouchedAgain.length > 0) {
     const files = report.neverTouchedAgain.map((f) => path.basename(f.filePath)).join(", ");
-    preAudit.push(`Whole-file reads without reuse: ${files} (${report.neverTouchedAgain.length} file(s) read once via Read)`);
+    preAudit.push(`Whole-file reads without reuse: ${files} (${countNoun(report.neverTouchedAgain.length, "file")} read once via Read)`);
     fixes.push('Prefer `token-goat symbol` or `read "file::symbol"` instead of reading whole files.');
   }
   if (report.repeatedUncompressedBash.length > 0) {
-    const cmds = report.repeatedUncompressedBash.map((b) => `"${b.normalized.slice(0, 40)}" (${b.count}x)`).join(", ");
+    const cmds = report.repeatedUncompressedBash.map((b) => `${echoedValue(b.normalized.slice(0, 40))} (${b.count}x)`).join(", ");
     preAudit.push(`Repeated uncompressed terminal commands: ${cmds}`);
     fixes.push("Use token-goat bash-output cache or compress flags for repetitive terminal invocations.");
   }
@@ -79,21 +105,21 @@ function buildFeedbackCardFromCopilot(report) {
     const totalMcpTokens = report.mcpTools.servers.reduce((sum, s) => sum + s.estimatedTokens, 0);
     const heavy = report.mcpTools.servers.filter((s) => s.estimatedTokens > 1e3);
     if (heavy.length > 0 || totalMcpTokens > 1500) {
-      const details = report.mcpTools.servers.map((s) => `${s.serverName} (${s.toolCount} tool(s), ~${s.estimatedTokens.toLocaleString()} tok/turn)`).join(", ");
+      const details = report.mcpTools.servers.map((s) => `${s.serverName} (${countNoun(s.toolCount, "tool")}, ~${s.estimatedTokens.toLocaleString()} tok/turn)`).join(", ");
       const turns = Math.max(1, report.turns);
       const cumulative = totalMcpTokens * turns;
       preAudit.push(
-        `High fixed MCP tool definition overhead: ${details}; total ~${totalMcpTokens.toLocaleString()} tok/turn re-sent across ${turns} turn(s) (~${cumulative.toLocaleString()} cumulative tokens).`
+        `High fixed MCP tool definition overhead: ${details}; total ~${totalMcpTokens.toLocaleString()} tok/turn re-sent across ${countNoun(turns, "turn")} (~${cumulative.toLocaleString()} cumulative tokens).`
       );
       const unused = unusedMcpServers(report);
       if (unused === null) {
         const heavyNames = (heavy.length > 0 ? heavy : report.mcpTools.servers).map((s) => s.serverName).join(", ");
         fixes.push(
-          `Disable the MCP server(s) you do not use among ${heavyNames} with 'copilot mcp disable <name>', or exclude individual tools with '--excluded-tools'. This session's log records no tool calls, so it cannot say which went unused.`
+          `Disable any MCP server you do not use among ${heavyNames} with 'copilot mcp disable <name>', or exclude individual tools with '--excluded-tools'. This session's log records no tool calls, so it cannot say which went unused.`
         );
       } else if (unused.length > 0) {
         const commands = unused.map((s) => `'copilot mcp disable ${s.serverName}' (~${s.estimatedTokens.toLocaleString()} tok/turn)`).join(", ");
-        fixes.push(`Disable the MCP server(s) this session never called: ${commands}. ${MCP_DISABLE_NOTE}`);
+        fixes.push(`Disable ${unused.length === 1 ? "the MCP server" : "the MCP servers"} this session never called: ${commands}. ${MCP_DISABLE_NOTE}`);
       }
     }
   }
@@ -104,7 +130,7 @@ function buildFeedbackCardFromCopilot(report) {
     fixes.push("Maintain current token-efficient tooling and MCP server configuration.");
   }
   return {
-    taskSummary: `Copilot CLI session (${report.turns} turn(s) recorded in ${report.sessionId}).`,
+    taskSummary: `Copilot CLI session (${countNoun(report.turns, "turn")} recorded in ${report.sessionId}).`,
     preAuditFindings: preAudit,
     auditExecutionFindings: [],
     recommendedFix: fixes
@@ -136,15 +162,8 @@ async function runAuditCommand(opts = {}) {
   if (opts.transcript !== void 0) {
     const resolved = path.resolve(opts.transcript);
     if (!fs.existsSync(resolved)) {
-      const err = `transcript not found: ${resolved}`;
-      if (opts.json === true) {
-        process.stdout.write(`${displaySafeJson({ error: err }, 0)}
-`);
-      } else {
-        process.stderr.write(`token-goat: ${err}
-`);
-      }
-      process.exitCode = 1;
+      const err = `transcript not found: ${echoedValue(resolved)}`;
+      writeCommandFailure(opts.json === true, { error: err }, err);
       return;
     }
     if (isCopilotTranscript(resolved)) {
@@ -170,18 +189,7 @@ async function runAuditCommand(opts = {}) {
   }
   const detected = findProjectSession(projectRoot);
   if (detected === null) {
-    const err = "no session transcript found for project";
-    if (opts.json === true) {
-      process.stdout.write(`${displaySafeJson({ error: err, project: projectRoot }, 0)}
-`);
-    } else {
-      process.stdout.write(`
-# token-goat audit
-Project: ${projectRoot}
-No session transcript found. Pass --transcript <path> to specify one explicitly.
-`);
-    }
-    process.exitCode = 1;
+    writeCommandFailure(opts.json === true, { error: "no session transcript found for project", project: projectRoot }, noSessionTranscriptMessage(projectRoot));
     return;
   }
   if (detected.kind === "copilot") {

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

@@ -0,0 +1,71 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  VSCODE_TOOL_NAME_KEY,
+  getCwd
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  escapesOntoNetworkThroughLinks,
+  foldPathForContainment,
+  isInsideRoot
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  isUncOrDevicePath,
+  resolveIndexPath,
+  wslMountOfIndexKey
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/vscode_path_gate.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+function resolvesToUncPath(target, cwd) {
+  try {
+    return isUncOrDevicePath(path.resolve(cwd ?? process.cwd(), target));
+  } catch {
+    return false;
+  }
+}
+function vscodePathAllowed(filePath, workspace) {
+  if (isUncOrDevicePath(filePath)) return false;
+  if (workspace === void 0 || isUncOrDevicePath(workspace)) return false;
+  const resolvedRoot = path.resolve(workspace);
+  const resolvedTarget = path.resolve(workspace, filePath);
+  const root = foldPathForContainment(resolvedRoot.replace(/\\/g, "/"));
+  const target = foldPathForContainment(resolvedTarget.replace(/\\/g, "/"));
+  if (target !== root && !target.startsWith(root.endsWith("/") ? root : root + "/")) return false;
+  return isInsideRoot(resolvedTarget, resolvedRoot);
+}
+function isVscodeEvent(event) {
+  return event.raw["_tg_harness"] === "vscode" || event.raw[VSCODE_TOOL_NAME_KEY] !== void 0;
+}
+function preToolPathDeclined(event, target) {
+  if (target === void 0) return false;
+  const cwd = getCwd(event);
+  if (spellingDeclined(event, target, cwd)) return true;
+  const mount = secondSpellingAtMount(target, cwd);
+  return mount !== null && spellingDeclined(event, mount, cwd);
+}
+function spellingDeclined(event, target, cwd) {
+  if (isUncOrDevicePath(target) || resolvesToUncPath(target, cwd)) return true;
+  if (isVscodeEvent(event)) return !vscodePathAllowed(target, cwd);
+  return escapesOntoNetworkThroughLinks(target, cwd);
+}
+function secondSpellingAtMount(target, cwd) {
+  if (process.platform === "win32") return null;
+  const base = cwd ?? "/";
+  const mount = wslMountOfIndexKey(resolveIndexPath(target, base));
+  return mount !== null && mount !== path.resolve(base, target) ? mount : null;
+}
+function commandPathIsTouchable(filePath, event) {
+  if (event === void 0) return !escapesOntoNetworkThroughLinks(filePath);
+  return !preToolPathDeclined(event, filePath);
+}
+
+export {
+  vscodePathAllowed,
+  preToolPathDeclined,
+  commandPathIsTouchable
+};

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

@@ -0,0 +1,261 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  getTrackedFiles
+} from "./token-goat-chunk-OBOFIHKN.mjs";
+import {
+  enqueueDirtyPathsSafe
+} from "./token-goat-chunk-CIMQ2BB3.mjs";
+import {
+  indexedPathSpellingIsStale,
+  parserFingerprintForLanguage
+} from "./token-goat-chunk-NISNMD7T.mjs";
+import {
+  getProjectFileEntries
+} from "./token-goat-chunk-IK2DRMFX.mjs";
+import {
+  getDb,
+  projectScopeClause
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  fingerprintFile,
+  getDisplayRoot,
+  statIndexedFile
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  countNoun
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  foldPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  displaySafeJson,
+  normalizePath,
+  resolveIndexPath,
+  toDisplayPath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/reconcile.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+var DEFAULT_RECONCILE_BUDGET_MS = 1500;
+function readReconcileCursor(dbPath, root) {
+  try {
+    const row = getDb(dbPath).prepare("SELECT last_scanned_path FROM reconcile_cursor WHERE root = ?").get(root);
+    return row?.last_scanned_path ?? null;
+  } catch {
+    return null;
+  }
+}
+function writeReconcileCursor(dbPath, root, lastScannedPath) {
+  try {
+    getDb(dbPath).prepare(
+      "INSERT INTO reconcile_cursor (root, last_scanned_path, updated_at) VALUES (?, ?, ?) ON CONFLICT(root) DO UPDATE SET last_scanned_path = excluded.last_scanned_path, updated_at = excluded.updated_at"
+    ).run(root, lastScannedPath, Date.now());
+  } catch {
+  }
+}
+function clearReconcileCursor(dbPath, root) {
+  try {
+    getDb(dbPath).prepare("DELETE FROM reconcile_cursor WHERE root = ?").run(root);
+  } catch {
+  }
+}
+function runReconcile(opts = {}) {
+  const raw = reconcileProject(opts);
+  const root = getDisplayRoot(opts.cwd ?? process.cwd());
+  const display = (paths) => paths.map((p) => toDisplayPath(root, p)).sort();
+  const result = {
+    ...raw,
+    changed: display(raw.changed),
+    added: display(raw.added),
+    removed: display(raw.removed)
+  };
+  if (opts.json === true) {
+    process.stdout.write(`${displaySafeJson(result)}
+`);
+    return 0;
+  }
+  const unqueued = opts.dryRun === true ? 0 : result.changed.length + result.added.length + result.removed.length - result.enqueued;
+  const noneQueued = unqueued > 0 && result.enqueued === 0;
+  const lines = [];
+  if (isReconcileClean(result)) {
+    if (!result.trackedUnavailable) {
+      lines.push(`Index matches disk: ${countNoun(result.scanned, "file")} checked in ${result.elapsedMs}ms.`);
+    }
+  } else {
+    const verb = opts.dryRun === true ? "would reindex" : noneQueued ? "not queued" : "queued for reindexing";
+    const dropVerb = opts.dryRun === true ? "would drop from the index" : noneQueued ? "not queued" : "queued for removal";
+    if (result.changed.length > 0) lines.push(`${countNoun(result.changed.length, "file")} changed since indexing (${verb}):`);
+    for (const f of result.changed) lines.push(`  ~ ${f}`);
+    if (result.added.length > 0) lines.push(`${countNoun(result.added.length, "file")} not in the index (${verb}):`);
+    for (const f of result.added) lines.push(`  + ${f}`);
+    if (result.removed.length > 0) lines.push(`${countNoun(result.removed.length, "file")} indexed but gone from disk (${dropVerb}):`);
+    for (const f of result.removed) lines.push(`  - ${f}`);
+    lines.push(`Checked ${countNoun(result.scanned, "file")} in ${result.elapsedMs}ms.`);
+  }
+  if (result.mtimeOnly > 0) {
+    lines.push(`${countNoun(result.mtimeOnly, "file")} had a newer timestamp but identical content, so ${result.mtimeOnly === 1 ? "it was" : "they were"} left alone.`);
+  }
+  if (result.parserStale > 0) {
+    const reparseVerb = opts.dryRun === true ? "would reparse" : noneQueued ? "not queued" : "queued for reparse";
+    lines.push(`${countNoun(result.parserStale, "file")} of the above ${result.parserStale === 1 ? "was" : "were"} unchanged on disk but indexed by an older parser (${reparseVerb}).`);
+  }
+  if (result.embedStale > 0) {
+    const reembedVerb = opts.dryRun === true ? "would re-embed" : noneQueued ? "not queued" : "queued for re-embedding";
+    lines.push(`${countNoun(result.embedStale, "file")} of the above ${result.embedStale === 1 ? "was" : "were"} unchanged on disk but held out-of-date embeddings (${reembedVerb}).`);
+  }
+  if (unqueued > 0) {
+    lines.push(`${countNoun(unqueued, "file")} of the above could not be queued for reindexing: the queue takes nothing under the OS temp dir, and nothing at all when it cannot be written. Run token-goat index here to bring the index up to date.`);
+  }
+  if (result.trackedUnavailable) {
+    lines.push("This project has an index but git listed no files in it, so new files could not be found. Indexed files that changed or are gone from disk were still detected. Run token-goat inside the repository, or reindex with --walk if this directory is deliberately not under git.");
+  }
+  if (result.budgetExhausted) {
+    lines.push(`Stopped at the ${result.elapsedMs}ms budget with ${countNoun(result.unscanned, "file")} unchecked, so there may be more drift; deletions were not computed at all, because an unchecked file is indistinguishable from a deleted one. Raise --budget-ms for a complete sweep.`);
+  }
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return 0;
+}
+function isReconcileClean(r) {
+  return r.changed.length === 0 && r.added.length === 0 && r.removed.length === 0;
+}
+function reconcileProject(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const budgetMs = opts.budgetMs ?? DEFAULT_RECONCILE_BUDGET_MS;
+  const calledAt = Date.now();
+  const dbPath = opts.dbPath ?? globalDbPath();
+  const tracked = getTrackedFiles(cwd);
+  const projectRoot = resolveIndexPath(".", cwd);
+  const indexed = getProjectFileEntries(projectRoot, dbPath);
+  const chunkScope = projectScopeClause("file_path");
+  const chunked = new Set(
+    getDb(dbPath).prepare(`SELECT DISTINCT file_path FROM chunks WHERE ${chunkScope.clause}`).pluck().all(...chunkScope.params(projectRoot)).map((p) => foldPath(normalizePath(p)))
+  );
+  const startedAt = Date.now();
+  let scanOrder = tracked;
+  const cursorPath = tracked.length > 0 ? readReconcileCursor(dbPath, projectRoot) : null;
+  if (cursorPath !== null) {
+    const cursorFolded = foldPath(normalizePath(cursorPath));
+    const cursorIdx = tracked.findIndex((f) => foldPath(normalizePath(f)) === cursorFolded);
+    if (cursorIdx !== -1) {
+      scanOrder = [...tracked.slice(cursorIdx + 1), ...tracked.slice(0, cursorIdx + 1)];
+    }
+  }
+  const changed = [];
+  const added = [];
+  const seenOnDisk = /* @__PURE__ */ new Set();
+  let mtimeOnly = 0;
+  let parserStale = 0;
+  let embedStale = 0;
+  let scanned = 0;
+  let budgetExhausted = false;
+  let lastScanned = null;
+  for (const file of scanOrder) {
+    if (Date.now() - startedAt >= budgetMs) {
+      budgetExhausted = true;
+      break;
+    }
+    scanned++;
+    lastScanned = file;
+    const normalized = normalizePath(file);
+    const folded = foldPath(normalized);
+    seenOnDisk.add(folded);
+    const entry = indexed.get(folded);
+    if (entry === void 0) {
+      added.push(file);
+      continue;
+    }
+    if (entry.parserSha !== parserFingerprintForLanguage(entry.language)) {
+      changed.push(file);
+      parserStale++;
+      continue;
+    }
+    if (entry.embedSha === "" && chunked.has(folded)) {
+      changed.push(file);
+      embedStale++;
+      continue;
+    }
+    if (normalizePath(entry.filePath).slice(projectRoot.length) !== normalized.slice(projectRoot.length) && indexedPathSpellingIsStale(entry.filePath, file)) {
+      changed.push(file);
+      continue;
+    }
+    let mtimeMs;
+    try {
+      mtimeMs = fs.statSync(file).mtimeMs;
+    } catch {
+      changed.push(file);
+      continue;
+    }
+    if (entry.mtime !== 0 && mtimeMs / 1e3 === entry.mtime) continue;
+    const diskSha = fingerprintFile(file);
+    if (diskSha === null) {
+      changed.push(file);
+      continue;
+    }
+    if (diskSha === entry.sha) {
+      mtimeOnly++;
+      continue;
+    }
+    changed.push(file);
+  }
+  const trackedUnavailable = tracked.length === 0 && indexed.size > 0;
+  const removed = [];
+  if (!budgetExhausted) {
+    for (const [folded, entry] of indexed) {
+      if (seenOnDisk.has(folded)) continue;
+      if (Date.now() - startedAt >= budgetMs) {
+        budgetExhausted = true;
+        removed.length = 0;
+        break;
+      }
+      const st = statIndexedFile(entry.filePath);
+      if (st === "gone") {
+        removed.push(entry.filePath);
+        continue;
+      }
+      if (st === null || entry.mtime !== 0 && st.mtimeMs / 1e3 === entry.mtime) continue;
+      const diskSha = fingerprintFile(entry.filePath);
+      if (diskSha === entry.sha) mtimeOnly++;
+      else if (diskSha !== null) changed.push(entry.filePath);
+    }
+  }
+  let enqueued = 0;
+  if (opts.dryRun !== true) {
+    const toEnqueue = [...changed, ...added, ...removed].map((p) => resolveIndexPath(p, cwd));
+    enqueued = enqueueDirtyPathsSafe(toEnqueue, { alreadyResolved: true, ...opts.queueDir !== void 0 ? { dir: opts.queueDir } : {} });
+    if (budgetExhausted) {
+      if (lastScanned !== null) writeReconcileCursor(dbPath, projectRoot, lastScanned);
+    } else if (tracked.length > 0) {
+      clearReconcileCursor(dbPath, projectRoot);
+    }
+  }
+  return {
+    scanned,
+    changed,
+    added,
+    removed,
+    mtimeOnly,
+    parserStale,
+    embedStale,
+    budgetExhausted,
+    trackedUnavailable,
+    unscanned: Math.max(0, tracked.length - scanned),
+    enqueued,
+    elapsedMs: Date.now() - calledAt
+  };
+}
+
+export {
+  DEFAULT_RECONCILE_BUDGET_MS,
+  runReconcile,
+  isReconcileClean,
+  reconcileProject
+};

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

@@ -0,0 +1,39 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  getHarnessName
+} from "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/harness_channels.ts
+init_define_import_meta_env();
+var PROMPT_SUBMIT_CONTEXT_DROPPED = /* @__PURE__ */ new Set([]);
+function dropsPromptSubmitContext() {
+  return PROMPT_SUBMIT_CONTEXT_DROPPED.has(getHarnessName());
+}
+var PRE_COMPACT_CONTEXT_DROPPED = /* @__PURE__ */ new Set(["copilot_cli", "codex"]);
+function dropsPreCompactContext() {
+  return PRE_COMPACT_CONTEXT_DROPPED.has(getHarnessName());
+}
+var STOP_CONTEXT_DROPPED = /* @__PURE__ */ new Set(["copilot_cli", "vscode"]);
+function dropsStopContext() {
+  return STOP_CONTEXT_DROPPED.has(getHarnessName());
+}
+var PRE_COMPACT_RESUMES_ON_PROMPT = /* @__PURE__ */ new Set(["copilot_cli"]);
+function resumesCompactionOnPrompt() {
+  return PRE_COMPACT_RESUMES_ON_PROMPT.has(getHarnessName()) && !dropsPromptSubmitContext();
+}
+var SESSION_START_MAY_BE_DEFERRED = /* @__PURE__ */ new Set(["copilot_cli", "vscode"]);
+function sessionStartMayBeDeferred(host) {
+  return SESSION_START_MAY_BE_DEFERRED.has(host);
+}
+
+export {
+  dropsPromptSubmitContext,
+  dropsPreCompactContext,
+  dropsStopContext,
+  resumesCompactionOnPrompt,
+  sessionStartMayBeDeferred
+};