token-goat 2.9.30 → 2.9.31

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

@@ -0,0 +1,606 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildCommandManifest,
+  buildReminder,
+  checkSymbolBodySize,
+  flattenCommandNames
+} from "./token-goat-chunk-2XBMMDBD.mjs";
+import {
+  DEFAULT_RECONCILE_BUDGET_MS,
+  isReconcileClean,
+  reconcileProject
+} from "./token-goat-chunk-PFWIMH2E.mjs";
+import {
+  projectNotesFor
+} from "./token-goat-chunk-GWFLAUMQ.mjs";
+import {
+  dropsPreCompactContext,
+  dropsPromptSubmitContext,
+  resumesCompactionOnPrompt,
+  sessionStartMayBeDeferred
+} from "./token-goat-chunk-PJZXIS3G.mjs";
+import {
+  buildDeltaCapsule
+} from "./token-goat-chunk-NOSS5VWY.mjs";
+import {
+  sessionSidecarPath
+} from "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  accumulateResidentLines,
+  lineMayCarryResidentSignal,
+  readTranscriptTail,
+  repeatedSkillBodyHint,
+  summarizeResidentContext,
+  taskListPruneHint
+} from "./token-goat-chunk-WDH44VAU.mjs";
+import {
+  registerHook,
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  contextOutput,
+  getCwd,
+  passOutput
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  markHintShown,
+  recordScheduledPrompt,
+  wasHintShown
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  claimFirstSavingsReceipt,
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  getDb
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  detectHarness,
+  getHarnessName
+} from "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  envBool,
+  envInt
+} from "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  countNoun,
+  ensureDirSync,
+  extractErrorMessage,
+  runGit
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  stripUnsafeSuggestions
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  ENV_KEYS,
+  VERSION,
+  globalDbPath
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/pending_context.ts
+init_define_import_meta_env();
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var PENDING_SUFFIX = ".pending-context.txt";
+var MAX_PENDING_CONTEXT_BYTES = 4096;
+function queuePendingContext(stateKey, text) {
+  const trimmed = text.trim();
+  if (trimmed === "") return;
+  const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
+  if (target === null) return;
+  try {
+    const capped = fitPending(readPending(target), trimmed);
+    ensureDirSync(dirname(target));
+    writeFileSync(target, capped, "utf8");
+  } catch {
+  }
+}
+function replacePendingContextBlock(stateKey, text, blockStart) {
+  const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
+  if (target === null) return;
+  try {
+    const existing = readPending(target);
+    const at = existing === null ? -1 : existing.indexOf(blockStart);
+    if (existing !== null && at >= 0) {
+      const kept = existing.slice(0, at).trim();
+      if (kept === "") rmSync(target, { force: true });
+      else writeFileSync(target, kept, "utf8");
+    }
+  } catch {
+  }
+  queuePendingContext(stateKey, text);
+}
+function peekPendingContext(stateKey) {
+  const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
+  return target === null ? null : readPending(target);
+}
+function peekPendingContextWith(stateKey, carried) {
+  const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
+  const existing = target === null ? null : readPending(target);
+  const text = fitPending(existing, carried.trim());
+  if (target !== null && existing !== null && !text.includes(existing)) {
+    try {
+      rmSync(target, { force: true });
+    } catch {
+    }
+  }
+  return text;
+}
+function commitPendingContext(stateKey, delivered) {
+  if (delivered === null || delivered === "") return;
+  const target = sessionSidecarPath(stateKey, PENDING_SUFFIX);
+  if (target === null) return;
+  const queued = readPending(target);
+  if (queued === null) return;
+  if (!delivered.includes(queued) && !delivered.includes(stripUnsafeSuggestions(queued))) return;
+  try {
+    rmSync(target, { force: true });
+  } catch {
+  }
+}
+function fitPending(existing, text) {
+  if (existing !== null) {
+    const merged = `${existing}
+${text}`;
+    if (merged.length <= MAX_PENDING_CONTEXT_BYTES) return merged;
+  }
+  if (text.length <= MAX_PENDING_CONTEXT_BYTES) return text;
+  const head = text.slice(0, MAX_PENDING_CONTEXT_BYTES);
+  const lineEnd = head.lastIndexOf("\n");
+  if (lineEnd > 0) return head.slice(0, lineEnd).trimEnd();
+  return /[\uD800-\uDBFF]$/.test(head) ? head.slice(0, -1) : head;
+}
+function readPending(target) {
+  try {
+    const raw = readFileSync(target, "utf8").trim();
+    return raw === "" ? null : raw;
+  } catch {
+    return null;
+  }
+}
+
+// src/session_start_owed.ts
+init_define_import_meta_env();
+import { readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var SETTLED_SUFFIX = ".session-start";
+var OWED_CLAIM_SUFFIX = ".session-start-owed";
+var OWED_RESERVE_MS = 1e3;
+function parseMarker(raw) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const { finishedAtMs, deadlineEpoch } = raw;
+  if (typeof finishedAtMs !== "number" || !Number.isFinite(finishedAtMs)) return null;
+  if (deadlineEpoch === null) return { finishedAtMs, deadlineEpoch: null };
+  if (typeof deadlineEpoch !== "number" || !Number.isFinite(deadlineEpoch)) return null;
+  return { finishedAtMs, deadlineEpoch };
+}
+function recordSessionStartSettled(event, marker) {
+  const target = sessionSidecarPath(sessionStateKey(event), SETTLED_SUFFIX);
+  if (target === null) return;
+  try {
+    ensureDirSync(dirname2(target));
+    writeFileSync2(target, JSON.stringify(marker), "utf8");
+  } catch {
+  }
+}
+function removeSidecar(event, suffix) {
+  const target = sessionSidecarPath(sessionStateKey(event), suffix);
+  if (target === null) return;
+  try {
+    rmSync2(target, { force: true });
+  } catch {
+  }
+}
+function recordSessionStartBegun(event) {
+  const target = sessionSidecarPath(sessionStateKey(event), SETTLED_SUFFIX);
+  if (target === null) return;
+  try {
+    ensureDirSync(dirname2(target));
+    writeFileSync2(target, JSON.stringify({ begunAtMs: Date.now() }), "utf8");
+  } catch {
+  }
+}
+function releaseOwedSessionStart(event) {
+  removeSidecar(event, OWED_CLAIM_SUFFIX);
+}
+function readSessionStartRecord(event) {
+  const target = sessionSidecarPath(sessionStateKey(event), SETTLED_SUFFIX);
+  if (target === null) return null;
+  let raw;
+  try {
+    raw = readFileSync2(target, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return parseMarker(JSON.parse(raw)) ?? "begun";
+  } catch {
+    return "begun";
+  }
+}
+function sessionStartOwed(record, _now) {
+  if (record === null) return false;
+  if (record === "begun") return true;
+  if (record.deadlineEpoch === null) return false;
+  return record.finishedAtMs > record.deadlineEpoch - OWED_RESERVE_MS;
+}
+function claimOwedSessionStart(event) {
+  const target = sessionSidecarPath(sessionStateKey(event), OWED_CLAIM_SUFFIX);
+  if (target === null) return false;
+  try {
+    ensureDirSync(dirname2(target));
+    writeFileSync2(target, JSON.stringify({ claimedAtMs: Date.now() }), { encoding: "utf8", flag: "wx" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var carriedOwed = /* @__PURE__ */ new WeakMap();
+var offeredOwed = /* @__PURE__ */ new WeakMap();
+function carryOwedSessionStart(event, text) {
+  carriedOwed.set(event, text.trim());
+}
+function offerOwedSessionStart(event, offered) {
+  offeredOwed.set(event, offered);
+}
+function carriedOwedSessionStart(event) {
+  return carriedOwed.get(event);
+}
+function requeueUndeliveredOwedSessionStart(event, delivered) {
+  const carried = carriedOwed.get(event);
+  if (carried === void 0) return;
+  carriedOwed.delete(event);
+  const offered = offeredOwed.get(event) ?? carried;
+  offeredOwed.delete(event);
+  if (carried === "") return;
+  try {
+    if (delivered !== null && (delivered.includes(offered) || delivered.includes(stripUnsafeSuggestions(offered)))) return;
+    queuePendingContext(sessionStateKey(event), carried);
+  } catch {
+  }
+}
+
+// src/hooks_session_start.ts
+init_define_import_meta_env();
+function reconcileNote(cwd, indexed) {
+  if (!indexed) return null;
+  if (!envBool(ENV_KEYS.RECONCILE, true)) return null;
+  try {
+    const budgetMs = envInt(ENV_KEYS.RECONCILE_BUDGET_MS, DEFAULT_RECONCILE_BUDGET_MS, 0, 6e4);
+    const result = reconcileProject({ cwd, budgetMs });
+    if (isReconcileClean(result) && !result.budgetExhausted) return null;
+    const upgraded = result.parserStale + result.embedStale;
+    const edited = result.changed.length - upgraded;
+    const parts = [];
+    if (edited > 0) parts.push(`${edited} changed`);
+    if (result.added.length > 0) parts.push(`${result.added.length} new`);
+    if (result.removed.length > 0) parts.push(`${result.removed.length} removed`);
+    const breakdown = parts.length > 1 ? ` (${parts.join(", ")})` : "";
+    const truncated = result.budgetExhausted ? ` (sweep stopped at its time budget with ${countNoun(result.unscanned, "file")} unchecked, so there may be more)` : "";
+    const total = result.changed.length + result.added.length + result.removed.length;
+    if (total === 0) {
+      return `token-goat: index drift check${truncated} found nothing in the part it had time to scan. Symbol lookups may be briefly stale.`;
+    }
+    const drifted = total - upgraded;
+    const clauses = [];
+    if (drifted > 0) clauses.push(`${countNoun(drifted, "file")} that changed outside this session${breakdown}`);
+    if (upgraded > 0) clauses.push(`${countNoun(upgraded, "file")} unchanged on disk but indexed by an older version of token-goat`);
+    const unqueued = total - result.enqueued;
+    if (unqueued > 0) {
+      const refused = unqueued < total ? `${unqueued} of them` : total === 1 ? "it" : "they";
+      return `token-goat: found ${clauses.join(" and ")}${truncated}, but ${refused} could not be queued for reindexing, so symbol lookups may stay stale until token-goat index runs here.`;
+    }
+    return `token-goat: reindexing ${clauses.join(" and ")}${truncated}. Symbol lookups may be briefly stale.`;
+  } catch (e) {
+    recordStat("reconcile_note_failed", 0, 0, void 0, extractErrorMessage(e));
+    return null;
+  }
+}
+async function postCompactRecovery(event) {
+  if (event.raw["source"] !== "compact" || event.sessionId === void 0) return null;
+  if (!loadConfig().compact_assist.enabled) return null;
+  try {
+    const { buildResumePacket } = await import("./token-goat-chunk-T5YGG4V3.mjs");
+    return await buildResumePacket(event.sessionId);
+  } catch {
+    return null;
+  }
+}
+async function sessionStartHandler(event) {
+  recordSessionStartBegun(event);
+  const output = withSavingsReceipt(await sessionStartOutput(event));
+  recordSessionStartSettled(event, { finishedAtMs: Date.now(), deadlineEpoch: shimDeadlineEpoch() });
+  return output;
+}
+function shimDeadlineEpoch() {
+  const raw = process.env["TG_SESSION_START_DEADLINE_EPOCH"];
+  if (raw === void 0 || raw.trim() === "") return null;
+  const value = Number(raw);
+  return Number.isFinite(value) && value > 0 ? value : null;
+}
+function savingsReceiptText(tokens) {
+  return `token-goat has saved about ${tokens.toLocaleString("en-US")} tokens so far. Run \`token-goat stats\` for the detail.`;
+}
+function withSavingsReceipt(output, homeDir) {
+  if (output.hookType !== "pass" && output.hookType !== "context") return output;
+  if (detectHarness() !== "claudecode") return output;
+  const saved = claimFirstSavingsReceipt(void 0, homeDir);
+  return saved === null ? output : { ...output, notice: savingsReceiptText(saved) };
+}
+async function sessionStartOutput(event, options = {}) {
+  const recovery = options.skipRecovery === true ? null : await postCompactRecovery(event);
+  const cwd = getCwd(event);
+  const { anchorStatus } = await import("./token-goat-chunk-TWUKBOMP.mjs");
+  const tail = [projectNotesFor(cwd, anchorStatus), recovery].filter((part) => part !== null).join("\n\n");
+  const tailOnly = () => tail === "" ? passOutput() : contextOutput(tail);
+  try {
+    if (!loadConfig().hints.session_start_reminder) return tailOnly();
+    const { isIndexedRoot } = await import("./token-goat-chunk-VTJLAA7P.mjs");
+    const indexed = isIndexedRoot(cwd);
+    let context = buildReminder(indexed);
+    if (cwd !== void 0) {
+      const drift = reconcileNote(cwd, indexed);
+      if (drift !== null) context += `
+
+${drift}`;
+      const capsule = buildDeltaCapsule(cwd);
+      if (capsule !== null) context += `
+
+${capsule}`;
+    }
+    try {
+      const dbHealth = checkSymbolBodySize(globalDbPath());
+      if (dbHealth.status === "warn") {
+        context += ` token-goat: ${dbHealth.message}`;
+      }
+    } catch {
+    }
+    try {
+      const { currentUpgradeDecision, getCachedUpdateStatus, updateAdvice } = await import("./token-goat-chunk-U2KSB4SG.mjs");
+      const update = getCachedUpdateStatus();
+      const advice = update === null ? null : updateAdvice(currentUpgradeDecision(update));
+      if (update?.latest && advice !== null) {
+        context += `
+[token-goat update available: v${update.current} -> v${update.latest}. ${advice}]`;
+      }
+    } catch {
+    }
+    if (tail !== "") context += `
+
+${tail}`;
+    return contextOutput(context);
+  } catch {
+    return tailOnly();
+  }
+}
+registerHook("session_start", sessionStartHandler);
+
+// src/hooks_session.ts
+init_define_import_meta_env();
+import crypto from "node:crypto";
+
+// src/skill_version_drift.ts
+init_define_import_meta_env();
+var TRACKED_SKILL = "token-goat";
+var MAX_COMMANDS_SHOWN = 8;
+async function currentCommandNames() {
+  const { buildProgram } = await import("./token-goat-chunk-YY6AVUFL.mjs");
+  return flattenCommandNames(buildCommandManifest(buildProgram()));
+}
+async function recordSkillVersionSnapshot(sessionId, skillName) {
+  if (skillName !== TRACKED_SKILL || !sessionId) return;
+  try {
+    const db = getDb(globalDbPath());
+    const commands = JSON.stringify(await currentCommandNames());
+    db.prepare(
+      `INSERT INTO skill_version_snapshots (session_id, skill_name, loaded_version, loaded_commands_json, notified_at)
+       VALUES (@sessionId, @skillName, @version, @commands, NULL)
+       ON CONFLICT(session_id) DO UPDATE SET
+         skill_name = @skillName, loaded_version = @version, loaded_commands_json = @commands, notified_at = NULL`
+    ).run({ sessionId, skillName, version: VERSION, commands });
+  } catch {
+  }
+}
+async function checkSkillVersionDrift(sessionId) {
+  if (!sessionId) return null;
+  try {
+    const db = getDb(globalDbPath());
+    const row = db.prepare(
+      `SELECT skill_name, loaded_version, loaded_commands_json, notified_at
+         FROM skill_version_snapshots WHERE session_id = ?`
+    ).get(sessionId);
+    if (!row || row.skill_name !== TRACKED_SKILL) return null;
+    if (row.notified_at !== null) return null;
+    if (row.loaded_version === VERSION) return null;
+    db.prepare(`UPDATE skill_version_snapshots SET notified_at = @now WHERE session_id = @sessionId`).run({
+      now: Date.now() / 1e3,
+      sessionId
+    });
+    let loadedCommands = [];
+    try {
+      const parsed = JSON.parse(row.loaded_commands_json);
+      if (Array.isArray(parsed)) loadedCommands = parsed;
+    } catch {
+      loadedCommands = [];
+    }
+    const loadedSet = new Set(loadedCommands);
+    const newCommands = (await currentCommandNames()).filter((c) => !loadedSet.has(c));
+    if (newCommands.length === 0) {
+      return `[token-goat: upgraded v${row.loaded_version} -> v${VERSION} since you loaded this skill -- run \`token-goat commands\` if anything seems missing]`;
+    }
+    const shown = newCommands.slice(0, MAX_COMMANDS_SHOWN);
+    const more = newCommands.length > shown.length ? ` (+${newCommands.length - shown.length} more)` : "";
+    return `[token-goat: upgraded v${row.loaded_version} -> v${VERSION} since you loaded this skill -- ${countNoun(newCommands.length, "new command")} available: ${shown.join(", ")}${more}. Run \`token-goat commands\` for full details.]`;
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks_session.ts
+async function deliverOwedSessionStart(event) {
+  try {
+    if (event.agentId !== void 0 || !sessionStartMayBeDeferred(getHarnessName())) return;
+    if (!sessionStartOwed(readSessionStartRecord(event), Date.now()) || !claimOwedSessionStart(event)) return;
+    try {
+      const owed = await sessionStartOutput(event, { skipRecovery: true });
+      if (owed.hookType === "context") carryOwedSessionStart(event, owed.context);
+    } catch (error) {
+      releaseOwedSessionStart(event);
+      throw error;
+    }
+    recordStat("session_start_deferred", 0, 0);
+  } catch {
+  }
+}
+async function pendingContextHandler(event) {
+  try {
+    if (event.sessionId) await deliverOwedSessionStart(event);
+    if (!event.sessionId || !dropsPromptSubmitContext() && !dropsPreCompactContext() && !sessionStartMayBeDeferred(getHarnessName())) return passOutput();
+    const carried = carriedOwedSessionStart(event);
+    if (carried !== void 0) {
+      const offered = peekPendingContextWith(sessionStateKey(event), carried);
+      offerOwedSessionStart(event, offered);
+      return contextOutput(offered);
+    }
+    const pending = peekPendingContext(sessionStateKey(event));
+    return pending === null ? passOutput() : contextOutput(pending);
+  } catch {
+    return passOutput();
+  }
+}
+var EMBEDDED_SKILL_CONTEXT_RE = /^\s*<skill-context\b/i;
+var CONTINUATION_PROMPT_RE = /^(?:continue|resume|next|go on)$/i;
+var SCHEDULED_PROMPT_RE = /^\[Scheduled prompt #(\d+)\]/i;
+var SCHEDULED_PROMPT_PRESSURE_THRESHOLDS = /* @__PURE__ */ new Set([25, 100, 250]);
+function promptFingerprint(prompt) {
+  return crypto.createHash("sha256").update(prompt).digest("hex").slice(0, 16);
+}
+function residentContextHints(event) {
+  const transcriptPath = event.raw["transcript_path"];
+  if (typeof transcriptPath !== "string" || transcriptPath === "") return [];
+  const taskKey = `resident-task-list:${event.sessionId}`;
+  const skillKey = `resident-skill-body:${event.sessionId}`;
+  const wantTask = !wasHintShown(taskKey);
+  const wantSkill = !wasHintShown(skillKey);
+  if (!wantTask && !wantSkill) return [];
+  const lines = readTranscriptTail(transcriptPath).filter(lineMayCarryResidentSignal);
+  if (lines.length === 0) return [];
+  const summary = summarizeResidentContext(accumulateResidentLines(lines));
+  const hints = [];
+  if (wantTask) {
+    const hint = taskListPruneHint(summary.latestTaskList);
+    if (hint !== null) {
+      markHintShown(taskKey);
+      hints.push(hint);
+    }
+  }
+  if (wantSkill) {
+    const hint = repeatedSkillBodyHint(summary.repeatedSkillBodies);
+    if (hint !== null) {
+      markHintShown(skillKey);
+      hints.push(hint);
+    }
+  }
+  if (hints.length > 0) recordStat("session_hint", 0, 0);
+  return hints;
+}
+async function userPromptSubmitHandler(event) {
+  try {
+    const rawPrompt = event.raw["prompt"] || "";
+    if (!event.sessionId) {
+      return passOutput();
+    }
+    const parts = [];
+    const prompt = rawPrompt.trim();
+    if (EMBEDDED_SKILL_CONTEXT_RE.test(prompt)) {
+      const key = `embedded-skill:${event.sessionId}:${promptFingerprint(prompt)}`;
+      if (wasHintShown(key)) {
+        parts.push("This identical embedded skill payload was already provided in this session; treat it as loaded and do not re-read its full body.");
+      } else {
+        markHintShown(key);
+      }
+    }
+    if (CONTINUATION_PROMPT_RE.test(prompt)) {
+      const key = `continuation-checkpoint:${event.sessionId}`;
+      if (!wasHintShown(key)) {
+        markHintShown(key);
+        parts.push("Before a long continuation loop, checkpoint the current goal and evidence; start a fresh session when earlier context is no longer needed.");
+      }
+    }
+    const scheduledPrompt = SCHEDULED_PROMPT_RE.exec(prompt);
+    if (scheduledPrompt !== null) {
+      const occurrence = recordScheduledPrompt(event.sessionId);
+      if (SCHEDULED_PROMPT_PRESSURE_THRESHOLDS.has(occurrence)) {
+        const key = `scheduled-prompt-pressure:${event.sessionId}:${occurrence}`;
+        if (!wasHintShown(key)) {
+          markHintShown(key);
+          parts.push(`This is scheduled prompt delivery #${occurrence} (schedule #${scheduledPrompt[1]}). Checkpoint the current objective and start a fresh session before continuing if earlier context is no longer needed; this cannot reclaim tokens already injected.`);
+        }
+      }
+    }
+    if (prompt.length >= 8) {
+      const cwd = getCwd(event);
+      if (cwd) {
+        try {
+          const result = runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd, timeoutMs: loadConfig().hints.git_hint_max_ms });
+          if (result.exitCode === 0 && result.stdout) {
+            const branch = result.stdout.trim();
+            if (branch) {
+              parts.push(`branch: ${branch}`);
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    const driftNudge = await checkSkillVersionDrift(event.sessionId);
+    const residentHints = residentContextHints(event);
+    const resumed = resumesCompactionOnPrompt() ? peekPendingContext(sessionStateKey(event)) : null;
+    if (parts.length === 0 && !driftNudge && residentHints.length === 0 && resumed === null) {
+      return passOutput();
+    }
+    const lines = [];
+    if (resumed !== null) {
+      lines.push(resumed);
+    }
+    if (parts.length > 0) {
+      lines.push("[" + parts.join(" | ") + "]");
+    }
+    if (driftNudge) {
+      lines.push(driftNudge);
+    }
+    for (const hint of residentHints) {
+      lines.push(hint);
+    }
+    const text = lines.join("\n");
+    if (dropsPromptSubmitContext()) {
+      queuePendingContext(sessionStateKey(event), text);
+      return passOutput();
+    }
+    return contextOutput(text);
+  } catch {
+    return passOutput();
+  }
+}
+var CLAIMED_COMMIT_VERBS_RE = /\b(commit(?:ted|s|ting)?|push(?:ed|es|ing)?)\b/i;
+function claimsCommittedChange(message) {
+  return CLAIMED_COMMIT_VERBS_RE.test(message);
+}
+registerHook("user_prompt_submit", userPromptSubmitHandler);
+registerHook("post_tool_use", pendingContextHandler, { advisory: true, followsMatcher: true });
+
+export {
+  MAX_PENDING_CONTEXT_BYTES,
+  replacePendingContextBlock,
+  commitPendingContext,
+  requeueUndeliveredOwedSessionStart,
+  recordSkillVersionSnapshot,
+  claimsCommittedChange
+};