turnbell 1.0.0

package/dist/index.js

@@ -0,0 +1,4673 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { spawn as spawn2 } from "child_process";
+import { realpathSync } from "fs";
+import { basename as basename4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/adapters/amp.ts
+import { statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/core/events.ts
+import { basename } from "path";
+var TRAILING_SEPARATORS = /[/\\]+$/;
+var WORD_SEPARATORS = /[-_]/g;
+var CODE_BLOCK = /```[\s\S]*?```/g;
+var BACKTICK = /`/g;
+var WHITESPACE_RUN = /\s+/g;
+var CODE_BLOCK_PLACEHOLDER = " code block omitted. ";
+function projectLabel(cwd) {
+  const trimmed = cwd.replace(TRAILING_SEPARATORS, "");
+  const base = basename(trimmed) || cwd;
+  return base.replace(WORD_SEPARATORS, " ");
+}
+function prepareSpeechText(text2, maxChars, stripCode) {
+  let out = text2;
+  if (stripCode) {
+    out = out.replace(CODE_BLOCK, CODE_BLOCK_PLACEHOLDER).replace(BACKTICK, "");
+  }
+  return out.replace(WHITESPACE_RUN, " ").trim().slice(0, maxChars);
+}
+
+// src/adapters/diffwire.ts
+import {
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename as basename2, dirname, join as join2 } from "path";
+
+// src/core/config.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var SCHEMA_VERSION = 2;
+var DEFAULT_RATE_WPM = 190;
+var DEFAULT_MAX_CHARS = 1200;
+var DEFAULTS = {
+  version: SCHEMA_VERSION,
+  activation: "all",
+  events: {
+    done: { mode: "announce" },
+    blocked: { mode: "announce" },
+    error: { mode: "notify" }
+  },
+  voice: { name: null, rateWpm: DEFAULT_RATE_WPM },
+  notify: { desktop: true, sound: null },
+  readaloud: { maxChars: DEFAULT_MAX_CHARS, stripCode: true, openCommand: "" },
+  quietHours: null,
+  quietHoursWebhooks: "fire",
+  webhooks: [],
+  allowHttp: false
+};
+var NESTED_KEYS = /* @__PURE__ */ new Set([
+  "events",
+  "voice",
+  "notify",
+  "readaloud"
+]);
+var NON_ALNUM = /[^A-Za-z0-9]/g;
+var HHMM = /^([01]\d|2[0-3]):([0-5]\d)$/;
+var MINUTES_PER_HOUR = 60;
+var ENABLED_SUFFIX = ".enabled";
+var QUIET_UNTIL_FILE = "quiet-until";
+var QUIET_INDEFINITE = "indefinite";
+var INTEGER_RE = /^-?\d+$/;
+function turnbellHome() {
+  const override = process.env.TURNBELL_HOME ?? process.env.HOLLR_HOME;
+  if (override !== void 0 && override.length > 0) {
+    return override;
+  }
+  return join(homedir(), ".config", "turnbell");
+}
+function migrateLegacyHome() {
+  const override = process.env.TURNBELL_HOME ?? process.env.HOLLR_HOME;
+  if (override !== void 0 && override.length > 0) {
+    return;
+  }
+  const legacy = join(homedir(), ".config", "hollr");
+  const current = join(homedir(), ".config", "turnbell");
+  if (!existsSync(legacy) || existsSync(current)) {
+    return;
+  }
+  try {
+    renameSync(legacy, current);
+  } catch {
+  }
+}
+function encodeCwd(cwd) {
+  return cwd.replace(NON_ALNUM, "-");
+}
+function defaultOpenCommand(platformId = process.platform) {
+  if (platformId === "darwin") {
+    return "open";
+  }
+  if (platformId === "win32") {
+    return "start";
+  }
+  return "xdg-open";
+}
+function globalConfigPath() {
+  return join(turnbellHome(), "config.json");
+}
+function projectConfigPath(cwd) {
+  return join(turnbellHome(), "projects", `${encodeCwd(cwd)}.json`);
+}
+function muteFlagPath(cwd) {
+  return join(turnbellHome(), "projects", `${encodeCwd(cwd)}.muted`);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function readJsonObject(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return isPlainObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function mergeConfig(base, override) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const current = merged[key];
+    if (NESTED_KEYS.has(key) && isPlainObject(value) && isPlainObject(current)) {
+      merged[key] = { ...current, ...value };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+function loadConfig(cwd) {
+  const base = structuredClone(DEFAULTS);
+  const withGlobal = mergeConfig(base, readJsonObject(globalConfigPath()));
+  const merged = mergeConfig(withGlobal, readJsonObject(projectConfigPath(cwd)));
+  return merged;
+}
+function isConfigured(cwd) {
+  return isFile(globalConfigPath()) || isFile(projectConfigPath(cwd));
+}
+function isMuted(cwd) {
+  return isFile(muteFlagPath(cwd));
+}
+function projectEnabledFlagPath(cwd) {
+  return join(turnbellHome(), "projects", `${encodeCwd(cwd)}${ENABLED_SUFFIX}`);
+}
+function isProjectEnabled(cwd) {
+  return isFile(projectEnabledFlagPath(cwd));
+}
+function quietUntilPath() {
+  return join(turnbellHome(), QUIET_UNTIL_FILE);
+}
+function quietActive(now) {
+  let raw;
+  try {
+    raw = readFileSync(quietUntilPath(), "utf8").trim();
+  } catch {
+    return false;
+  }
+  if (raw === QUIET_INDEFINITE) {
+    return true;
+  }
+  if (!INTEGER_RE.test(raw)) {
+    return false;
+  }
+  return now.getTime() < Number.parseInt(raw, 10);
+}
+function toMinutes(part) {
+  const match = HHMM.exec(part);
+  if (match === null) {
+    return null;
+  }
+  const hours = match[1];
+  const minutes = match[2];
+  if (hours === void 0 || minutes === void 0) {
+    return null;
+  }
+  return Number(hours) * MINUTES_PER_HOUR + Number(minutes);
+}
+function inQuietHours(spec, now) {
+  if (spec === null || !spec.includes("-")) {
+    return false;
+  }
+  const separator = spec.indexOf("-");
+  const start = toMinutes(spec.slice(0, separator));
+  const end = toMinutes(spec.slice(separator + 1));
+  if (start === null || end === null) {
+    return false;
+  }
+  const current = now.getHours() * MINUTES_PER_HOUR + now.getMinutes();
+  if (start <= end) {
+    return start <= current && current < end;
+  }
+  return current >= start || current < end;
+}
+var V1_CONFIG_RELATIVE = [".claude", "hollr", "config.json"];
+function v2ConfigExists() {
+  if (isFile(globalConfigPath())) {
+    return true;
+  }
+  try {
+    return readdirSync(join(turnbellHome(), "projects")).some(
+      (entry) => entry.endsWith(".json")
+    );
+  } catch {
+    return false;
+  }
+}
+function isMode(value) {
+  return value === "announce" || value === "readaloud" || value === "notify" || value === "silent";
+}
+function applyEventMode(config, target, source) {
+  if (isPlainObject(source) && isMode(source.mode)) {
+    config.events[target] = { mode: source.mode };
+  }
+}
+function buildV2FromV1(v1) {
+  const config = structuredClone(DEFAULTS);
+  const voice = v1.voice;
+  if (isPlainObject(voice)) {
+    if (typeof voice.name === "string" || voice.name === null) {
+      config.voice.name = voice.name;
+    }
+    if (typeof voice.rate_wpm === "number") {
+      config.voice.rateWpm = voice.rate_wpm;
+    }
+  }
+  const readaloud = v1.readaloud;
+  if (isPlainObject(readaloud)) {
+    if (typeof readaloud.max_chars === "number") {
+      config.readaloud.maxChars = readaloud.max_chars;
+    }
+    if (typeof readaloud.strip_code === "boolean") {
+      config.readaloud.stripCode = readaloud.strip_code;
+    }
+  }
+  if (typeof v1.quiet_hours === "string" || v1.quiet_hours === null) {
+    config.quietHours = v1.quiet_hours;
+  }
+  const events = v1.events;
+  if (isPlainObject(events)) {
+    applyEventMode(config, "done", events.done);
+    applyEventMode(config, "blocked", events.needs_input);
+  }
+  return config;
+}
+function migrateV1() {
+  if (v2ConfigExists()) {
+    return false;
+  }
+  const v1 = readJsonObject(join(homedir(), ...V1_CONFIG_RELATIVE));
+  if (Object.keys(v1).length === 0) {
+    return false;
+  }
+  const home = turnbellHome();
+  try {
+    mkdirSync(home, { recursive: true });
+    writeFileSync(
+      join(home, "config.json"),
+      `${JSON.stringify(buildV2FromV1(v1), null, 2)}
+`,
+      "utf8"
+    );
+  } catch {
+    return false;
+  }
+  return true;
+}
+var HTTP_SCHEME = "http:";
+function urlScheme(url) {
+  try {
+    return new URL(url).protocol;
+  } catch {
+    return null;
+  }
+}
+function migrateHttpOptIn(config) {
+  if (config.allowHttp !== true) {
+    return { config, changed: false };
+  }
+  const next = structuredClone(config);
+  next.allowHttp = false;
+  if (Array.isArray(next.webhooks)) {
+    for (const target of next.webhooks) {
+      if (target.allowHttp === void 0 && urlScheme(target.url) === HTTP_SCHEME) {
+        target.allowHttp = true;
+      }
+    }
+  }
+  return { config: next, changed: true };
+}
+
+// src/adapters/diffwire.ts
+var JSON_INDENT = 2;
+var TRAILING_NEWLINE = "\n";
+var LEDGER_FILE = "wired.json";
+var LEDGER_MODE = 384;
+var DIFF_CONTEXT_LINES = 3;
+var REMOVED_MARK = "-";
+var ADDED_MARK = "+";
+var CONTEXT_MARK = " ";
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return isPlainObject2(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function serializeJson(value) {
+  return `${JSON.stringify(value, null, JSON_INDENT)}${TRAILING_NEWLINE}`;
+}
+function readFileOrNull(path) {
+  try {
+    return readFileSync2(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function writeFileAtomic(path, content, mode) {
+  const dir = dirname(path);
+  mkdirSync2(dir, { recursive: true });
+  const temp = join2(dir, `.${basename2(path)}.${process.pid}.tmp`);
+  writeFileSync2(temp, content, mode === void 0 ? "utf8" : { encoding: "utf8", mode });
+  renameSync2(temp, path);
+}
+function ledgerPath() {
+  return join2(turnbellHome(), LEDGER_FILE);
+}
+function isLedgerEntry(value) {
+  if (!isPlainObject2(value)) {
+    return false;
+  }
+  const kindOk = value.kind === void 0 || value.kind === "file" || value.kind === "marked";
+  const markerOk = value.markerId === void 0 || typeof value.markerId === "string";
+  return typeof value.ledgerKey === "string" && typeof value.path === "string" && (value.before === null || typeof value.before === "string") && typeof value.at === "string" && kindOk && markerOk;
+}
+function readLedger() {
+  const raw = readFileOrNull(ledgerPath());
+  if (raw === null) {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter(isLedgerEntry) : [];
+  } catch {
+    return [];
+  }
+}
+function listWiredKeys() {
+  return readLedger().map((entry) => entry.ledgerKey);
+}
+function writeLedger(entries) {
+  mkdirSync2(turnbellHome(), { recursive: true });
+  writeFileAtomic(
+    ledgerPath(),
+    `${JSON.stringify(entries, null, JSON_INDENT)}${TRAILING_NEWLINE}`,
+    LEDGER_MODE
+  );
+}
+function appendLedgerEntry(entry) {
+  const entries = readLedger();
+  const existing = entries.find((item) => item.ledgerKey === entry.ledgerKey);
+  if (existing !== void 0) {
+    if (existing.path === entry.path && existing.markerId === entry.markerId) {
+      return;
+    }
+    restoreEntry(existing);
+    writeLedger([
+      ...entries.filter((item) => item.ledgerKey !== entry.ledgerKey),
+      entry
+    ]);
+    return;
+  }
+  entries.push(entry);
+  writeLedger(entries);
+}
+function splitLines(text2) {
+  return text2.length === 0 ? [] : text2.split("\n");
+}
+function commonPrefixLength(a, b) {
+  let index = 0;
+  while (index < a.length && index < b.length && a[index] === b[index]) {
+    index += 1;
+  }
+  return index;
+}
+function commonSuffixLength(a, b, prefix) {
+  let count = 0;
+  while (count < a.length - prefix && count < b.length - prefix && a[a.length - 1 - count] === b[b.length - 1 - count]) {
+    count += 1;
+  }
+  return count;
+}
+function renderLineDiff(oldText, newText) {
+  const before = splitLines(oldText);
+  const after = splitLines(newText);
+  const prefix = commonPrefixLength(before, after);
+  const suffix = commonSuffixLength(before, after, prefix);
+  const removed = before.slice(prefix, before.length - suffix);
+  const added = after.slice(prefix, after.length - suffix);
+  if (removed.length === 0 && added.length === 0) {
+    return "";
+  }
+  const leading = before.slice(Math.max(0, prefix - DIFF_CONTEXT_LINES), prefix);
+  const tailStart = before.length - suffix;
+  const trailing = before.slice(tailStart, tailStart + DIFF_CONTEXT_LINES);
+  return [
+    ...leading.map((line) => `${CONTEXT_MARK}${line}`),
+    ...removed.map((line) => `${REMOVED_MARK}${line}`),
+    ...added.map((line) => `${ADDED_MARK}${line}`),
+    ...trailing.map((line) => `${CONTEXT_MARK}${line}`)
+  ].join("\n");
+}
+function buildWireOp(path, original, nextContent, ledgerKey) {
+  const oldContent = original ?? "";
+  const changed = oldContent !== nextContent;
+  return {
+    diff: renderLineDiff(oldContent, nextContent),
+    changed,
+    apply() {
+      if (!changed) {
+        return;
+      }
+      writeFileAtomic(path, nextContent);
+      appendLedgerEntry({
+        ledgerKey,
+        path,
+        before: original,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  };
+}
+function wireJsonFile(path, mutate, ledgerKey) {
+  const original = readFileOrNull(path);
+  const nextContent = serializeJson(mutate(parseJsonObject(original ?? "")));
+  return buildWireOp(path, original, nextContent, ledgerKey);
+}
+function wireTextFile(path, newContent, ledgerKey) {
+  return buildWireOp(path, readFileOrNull(path), newContent, ledgerKey);
+}
+function startMarker(markerId) {
+  return `<!-- ${markerId}:start (managed by turnbell \u2014 \`turnbell uninstall\`, or re-run \`turnbell init\` with read-aloud off, removes this) -->`;
+}
+function endMarker(markerId) {
+  return `<!-- ${markerId}:end -->`;
+}
+function markedBlock(markerId, body) {
+  return `${startMarker(markerId)}
+${body}
+${endMarker(markerId)}`;
+}
+function startMarkerPrefix(markerId) {
+  return `<!-- ${markerId}:start`;
+}
+function stripMarkedSection(content, markerId) {
+  const start = content.indexOf(startMarkerPrefix(markerId));
+  if (start === -1) {
+    return content;
+  }
+  const endToken = endMarker(markerId);
+  const endIdx = content.indexOf(endToken, start);
+  if (endIdx === -1) {
+    return content;
+  }
+  const after = endIdx + endToken.length;
+  const head = content.slice(0, start).replace(/\n?\n$/, "\n");
+  const tail = content.slice(after).replace(/^\n/, "");
+  return `${head}${tail}`;
+}
+function upsertMarkedSection(content, markerId, body) {
+  const block = markedBlock(markerId, body);
+  const start = content.indexOf(startMarkerPrefix(markerId));
+  if (start !== -1) {
+    const stripped = stripMarkedSection(content, markerId);
+    const base2 = stripped.length === 0 || stripped.endsWith("\n") ? stripped : `${stripped}
+`;
+    return `${base2}${base2.length === 0 ? "" : "\n"}${block}
+`;
+  }
+  if (content.length === 0) {
+    return `${block}
+`;
+  }
+  const base = content.endsWith("\n") ? content : `${content}
+`;
+  return `${base}
+${block}
+`;
+}
+function wireMarkedSection(path, markerId, blockBody, ledgerKey, legacyMarkerIds = []) {
+  const original = readFileOrNull(path);
+  const base = legacyMarkerIds.reduce(
+    (text2, legacyId) => stripMarkedSection(text2, legacyId),
+    original ?? ""
+  );
+  const nextContent = upsertMarkedSection(base, markerId, blockBody);
+  const oldContent = original ?? "";
+  const changed = oldContent !== nextContent;
+  return {
+    diff: renderLineDiff(oldContent, nextContent),
+    changed,
+    apply() {
+      if (!changed) {
+        return;
+      }
+      writeFileAtomic(path, nextContent);
+      appendLedgerEntry({
+        ledgerKey,
+        path,
+        before: original,
+        at: (/* @__PURE__ */ new Date()).toISOString(),
+        kind: "marked",
+        markerId
+      });
+    }
+  };
+}
+function restoreEntry(entry) {
+  if (entry.kind === "marked" && typeof entry.markerId === "string") {
+    const current = readFileOrNull(entry.path);
+    if (current === null) {
+      return;
+    }
+    const stripped = stripMarkedSection(current, entry.markerId);
+    if (stripped !== current) {
+      writeFileAtomic(entry.path, stripped);
+    }
+    return;
+  }
+  if (entry.before === null) {
+    try {
+      rmSync(entry.path, { force: true });
+    } catch {
+    }
+    return;
+  }
+  writeFileAtomic(entry.path, entry.before);
+}
+function unwireFromLedger(ledgerKey) {
+  const entries = readLedger();
+  const entry = entries.find((item) => item.ledgerKey === ledgerKey);
+  if (entry === void 0) {
+    return;
+  }
+  restoreEntry(entry);
+  writeLedger(entries.filter((item) => item.ledgerKey !== ledgerKey));
+}
+function dropLedgerKey(ledgerKey) {
+  const entries = readLedger();
+  const kept = entries.filter((entry) => entry.ledgerKey !== ledgerKey);
+  if (kept.length !== entries.length) {
+    writeLedger(kept);
+  }
+}
+function unwireJsonFile(path, removeMutate, ledgerKey) {
+  const original = readFileOrNull(path);
+  if (original !== null) {
+    const next = serializeJson(removeMutate(parseJsonObject(original)));
+    if (next !== original) {
+      writeFileAtomic(path, next);
+    }
+  }
+  dropLedgerKey(ledgerKey);
+}
+function unwireCreatedFile(path, ledgerKey) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+  }
+  dropLedgerKey(ledgerKey);
+}
+function unwireTextFile(path, transform, ledgerKey) {
+  const original = readFileOrNull(path);
+  const next = transform(original);
+  if (next !== null && next !== original) {
+    writeFileAtomic(path, next);
+  }
+  dropLedgerKey(ledgerKey);
+}
+
+// src/adapters/amp.ts
+var ID = "amp";
+var TITLE = "Amp";
+var LEDGER_KEY = "amp";
+var BINARY = "amp";
+var CONFIG_SEGMENTS = [".config", "amp"];
+var FALLBACK_WARNINGS = [
+  "Amp has no declarative hook catalog turnbell can write, so nothing was changed.",
+  `Enable Amp's built-in turn alert: set "amp.notifications.enabled": true in ~/.config/amp/settings.json.`,
+  "For turnbell voice announcements, launch Amp through the wrapper: `turnbell run --agent amp -- amp`."
+];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configDir(deps) {
+  return join3(deps.home, ...CONFIG_SEGMENTS);
+}
+function isDir(path) {
+  try {
+    return statSync2(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function payloadCwd(raw) {
+  return typeof raw.cwd === "string" ? raw.cwd : "";
+}
+var amp = {
+  id: ID,
+  title: TITLE,
+  tagline: "Sourcegraph Amp \u2014 announce-only via amp.notifications + the turnbell run wrapper",
+  capabilities: {
+    done: true,
+    blocked: false,
+    readAloud: false,
+    slashCommand: false,
+    instructionInjection: false
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY) !== null || isDir(configDir(deps));
+    return Promise.resolve({ installed });
+  },
+  wire(_deps) {
+    return Promise.resolve({
+      changed: false,
+      diff: "",
+      warnings: [...FALLBACK_WARNINGS]
+    });
+  },
+  unwire(_deps) {
+    unwireFromLedger(LEDGER_KEY);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord(raw)) {
+      return null;
+    }
+    const cwd = payloadCwd(raw);
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID,
+      agentTitle: TITLE,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: "",
+      lastResponse: null
+    };
+  },
+  readLastResponse(_raw) {
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/antigravity.ts
+import { statSync as statSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/adapters/hooks.ts
+function legacyCommandVariant(command) {
+  return command.replace(/^turnbell(?= )/, "hollr");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function removeTurnbellHooks(json, eventKeys, isTurnbellEntry6) {
+  if (!isRecord2(json.hooks)) {
+    return json;
+  }
+  const hooks = { ...json.hooks };
+  for (const event of eventKeys) {
+    const arr = hooks[event];
+    if (!Array.isArray(arr)) {
+      continue;
+    }
+    const kept = arr.filter((entry) => !isTurnbellEntry6(entry));
+    if (kept.length > 0) {
+      hooks[event] = kept;
+    } else {
+      delete hooks[event];
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    const { hooks: _drop, ...rest } = json;
+    return rest;
+  }
+  return { ...json, hooks };
+}
+
+// src/adapters/antigravity.ts
+var ID2 = "antigravity";
+var TITLE2 = "Antigravity";
+var LEDGER_KEY2 = "antigravity";
+var BINARY2 = "agy";
+var CONFIG_DIR = ".gemini";
+var HOOKS_FILE = "hooks.json";
+var HOOK_NAME = "turnbell";
+var LEGACY_HOOK_NAME = "hollr";
+var HOOK_STOP = "Stop";
+var HOOK_TYPE_COMMAND = "command";
+var TURNBELL_STOP_COMMAND = "turnbell emit --agent antigravity --event done --payload-stdin; printf '{}'";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hooksPath(deps) {
+  return join4(deps.home, CONFIG_DIR, HOOKS_FILE);
+}
+function isDir2(path) {
+  try {
+    return statSync3(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function workspaceCwd(raw) {
+  const paths = raw.workspacePaths;
+  if (!Array.isArray(paths)) {
+    return "";
+  }
+  const first = paths[0];
+  return typeof first === "string" ? first : "";
+}
+function stopHasTurnbell(stop) {
+  if (!Array.isArray(stop)) {
+    return false;
+  }
+  return stop.some(
+    (handler) => isRecord3(handler) && handler.command === TURNBELL_STOP_COMMAND
+  );
+}
+function addStopHook(json) {
+  const existing = isRecord3(json[HOOK_NAME]) ? json[HOOK_NAME] : {};
+  const currentStop = Array.isArray(existing[HOOK_STOP]) ? existing[HOOK_STOP] : [];
+  const nextStop = stopHasTurnbell(currentStop) ? currentStop : [...currentStop, { type: HOOK_TYPE_COMMAND, command: TURNBELL_STOP_COMMAND }];
+  return {
+    ...json,
+    [HOOK_NAME]: {
+      ...existing,
+      [HOOK_STOP]: nextStop
+    }
+  };
+}
+var TURNBELL_STOP_COMMANDS = /* @__PURE__ */ new Set([
+  TURNBELL_STOP_COMMAND,
+  legacyCommandVariant(TURNBELL_STOP_COMMAND)
+]);
+function isTurnbellEntry(entry) {
+  return isRecord3(entry) && typeof entry.command === "string" && TURNBELL_STOP_COMMANDS.has(entry.command);
+}
+function removeHooksFromGroup(json, groupName) {
+  const existing = json[groupName];
+  if (!isRecord3(existing)) {
+    return json;
+  }
+  const stop = Array.isArray(existing[HOOK_STOP]) ? existing[HOOK_STOP] : [];
+  const kept = stop.filter((entry) => !isTurnbellEntry(entry));
+  const nextEntry = { ...existing };
+  if (kept.length > 0) {
+    nextEntry[HOOK_STOP] = kept;
+  } else {
+    delete nextEntry[HOOK_STOP];
+  }
+  if (Object.keys(nextEntry).length === 0) {
+    const { [groupName]: _drop, ...rest } = json;
+    return rest;
+  }
+  return { ...json, [groupName]: nextEntry };
+}
+function removeHooks(json) {
+  return removeHooksFromGroup(
+    removeHooksFromGroup(json, LEGACY_HOOK_NAME),
+    HOOK_NAME
+  );
+}
+var antigravity = {
+  id: ID2,
+  title: TITLE2,
+  tagline: "Google's agentic CLI (agy)",
+  capabilities: {
+    done: true,
+    blocked: false,
+    readAloud: false,
+    slashCommand: false,
+    instructionInjection: false
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY2) !== null || isDir2(join4(deps.home, CONFIG_DIR));
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = hooksPath(deps);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const op = wireJsonFile(hooksPath(deps), (json) => addStopHook(removeHooks(json)), LEDGER_KEY2);
+    const result = {
+      changed: op.changed,
+      diff: op.diff,
+      warnings: []
+    };
+    op.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireJsonFile(hooksPath(deps), removeHooks, LEDGER_KEY2);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord3(raw)) {
+      return null;
+    }
+    const cwd = workspaceCwd(raw);
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID2,
+      agentTitle: TITLE2,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: "",
+      lastResponse: null
+    };
+  },
+  readLastResponse(_raw) {
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/claude-code.ts
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync3, readSync, statSync as statSync4 } from "fs";
+import { join as join5 } from "path";
+var ID3 = "claude-code";
+var TITLE3 = "Claude Code";
+var LEDGER_KEY3 = "claude-code:settings";
+var COMMAND_LEDGER_KEY = "claude-code:command";
+var COMMANDS_DIR = "commands";
+var COMMAND_FILE = "turnbell.md";
+var LEGACY_COMMAND_FILE = "hollr.md";
+var HOOKS_KEY = "hooks";
+var ENABLED_PLUGINS_KEY = "enabledPlugins";
+var COMMAND_TEMPLATE = `---
+description: Control turnbell (pause/resume/stop/status/mute/doctor)
+---
+
+Managed by turnbell \u2014 reversible via \`turnbell uninstall\`. Do not edit by hand.
+
+Run this shell command and relay its output to the user verbatim:
+
+\`\`\`bash
+turnbell $ARGUMENTS
+\`\`\`
+
+Supported actions: pause, resume, stop, status, mute, doctor.
+
+Note: \`turnbell init\` is terminal-only (an interactive wizard) and is not
+available as a slash command \u2014 run it directly in your terminal instead.
+`;
+var MAX_TRANSCRIPT_BYTES = 2e6;
+var HOOK_STOP2 = "Stop";
+var HOOK_NOTIFICATION = "Notification";
+var HOOK_TYPE_COMMAND2 = "command";
+var ASSISTANT_TYPE = "assistant";
+var TEXT_TYPE = "text";
+var BLOCKED_EVENT = "blocked";
+var DONE_EVENT = "done";
+var NOTIFICATION_TYPE_KEY = "notification_type";
+var BACKGROUND_TASKS_KEY = "background_tasks";
+var TASK_TYPE_KEY = "type";
+var BLOCKING_BACKGROUND_TYPES = /* @__PURE__ */ new Set([
+  "subagent",
+  "workflow",
+  "teammate",
+  "cloud session"
+]);
+var SUPPRESSED_NOTIFICATION_TYPES = /* @__PURE__ */ new Set([
+  "idle_prompt",
+  "auth_success",
+  "agent_completed",
+  "elicitation_complete",
+  "elicitation_response"
+]);
+var STOP_COMMAND = "turnbell emit --agent claude-code --event done --payload-stdin";
+var NOTIFICATION_COMMAND = "turnbell emit --agent claude-code --event blocked --payload-stdin";
+var LEGACY_SCRIPT_MARKERS = ["hollr_hook.py", "announce-done.py"];
+var LEGACY_PLUGIN_ID = "hollr@hollr-marketplace";
+var LEGACY_MARKERS = [
+  ...LEGACY_SCRIPT_MARKERS,
+  LEGACY_PLUGIN_ID
+];
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function settingsPath(deps) {
+  return join5(deps.home, ".claude", "settings.json");
+}
+function commandPath(deps) {
+  return join5(deps.home, ".claude", COMMANDS_DIR, COMMAND_FILE);
+}
+function legacyCommandPath(deps) {
+  return join5(deps.home, ".claude", COMMANDS_DIR, LEGACY_COMMAND_FILE);
+}
+function omitKey(obj, key) {
+  const rest = {};
+  for (const [name, value] of Object.entries(obj)) {
+    if (name !== key) {
+      rest[name] = value;
+    }
+  }
+  return rest;
+}
+function isDir3(path) {
+  try {
+    return statSync4(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readFileOrNull2(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readTail(path) {
+  try {
+    const fd = openSync(path, "r");
+    try {
+      const size = fstatSync(fd).size;
+      const start = Math.max(0, size - MAX_TRANSCRIPT_BYTES);
+      const length = size - start;
+      const buffer = Buffer.alloc(length);
+      let offset = 0;
+      while (offset < length) {
+        const read = readSync(fd, buffer, offset, length - offset, start + offset);
+        if (read === 0) {
+          break;
+        }
+        offset += read;
+      }
+      return buffer.subarray(0, offset).toString("utf8");
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function assistantText(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord4(obj) || obj.type !== ASSISTANT_TYPE) {
+    return null;
+  }
+  const message = obj.message;
+  const content = isRecord4(message) ? message.content : null;
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  const joined = content.filter((block) => isRecord4(block) && block.type === TEXT_TYPE).map((block) => typeof block.text === "string" ? block.text : "").filter((text2) => text2.length > 0).join(" ").trim();
+  return joined.length > 0 ? joined : null;
+}
+function entryHasCommand(entry, command) {
+  if (!isRecord4(entry) || !Array.isArray(entry.hooks)) {
+    return false;
+  }
+  return entry.hooks.some((hook) => isRecord4(hook) && hook.command === command);
+}
+function appendTurnbellHook(existing, command) {
+  const list = Array.isArray(existing) ? existing : [];
+  if (list.some((entry) => entryHasCommand(entry, command))) {
+    return list;
+  }
+  return [...list, { hooks: [{ type: HOOK_TYPE_COMMAND2, command }] }];
+}
+function addHooks(json) {
+  const hooks = isRecord4(json.hooks) ? json.hooks : {};
+  return {
+    ...json,
+    hooks: {
+      ...hooks,
+      [HOOK_STOP2]: appendTurnbellHook(hooks[HOOK_STOP2], STOP_COMMAND),
+      [HOOK_NOTIFICATION]: appendTurnbellHook(hooks[HOOK_NOTIFICATION], NOTIFICATION_COMMAND)
+    }
+  };
+}
+var TURNBELL_COMMANDS = /* @__PURE__ */ new Set([
+  STOP_COMMAND,
+  NOTIFICATION_COMMAND,
+  legacyCommandVariant(STOP_COMMAND),
+  legacyCommandVariant(NOTIFICATION_COMMAND)
+]);
+function isTurnbellEntry2(entry) {
+  return isRecord4(entry) && Array.isArray(entry.hooks) && entry.hooks.some(
+    (hook) => isRecord4(hook) && typeof hook.command === "string" && TURNBELL_COMMANDS.has(hook.command)
+  );
+}
+function removeHooks2(json) {
+  return removeTurnbellHooks(json, [HOOK_STOP2, HOOK_NOTIFICATION], isTurnbellEntry2);
+}
+function commandIsLegacy(command) {
+  return typeof command === "string" && LEGACY_SCRIPT_MARKERS.some((marker) => command.includes(marker));
+}
+function isLegacyHookEntry(entry) {
+  if (!isRecord4(entry) || !Array.isArray(entry.hooks)) {
+    return false;
+  }
+  return entry.hooks.some(
+    (hook) => isRecord4(hook) && commandIsLegacy(hook.command)
+  );
+}
+function stripLegacyHooks(hooks) {
+  const cleaned = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) {
+      cleaned[event] = entries;
+      continue;
+    }
+    const kept = entries.filter((entry) => !isLegacyHookEntry(entry));
+    if (kept.length > 0) {
+      cleaned[event] = kept;
+    }
+  }
+  return cleaned;
+}
+function stripLegacyPlugin(json) {
+  const plugins = json[ENABLED_PLUGINS_KEY];
+  if (isRecord4(plugins) && LEGACY_PLUGIN_ID in plugins) {
+    const rest = omitKey(plugins, LEGACY_PLUGIN_ID);
+    return Object.keys(rest).length > 0 ? { ...json, [ENABLED_PLUGINS_KEY]: rest } : omitKey(json, ENABLED_PLUGINS_KEY);
+  }
+  if (Array.isArray(plugins) && plugins.includes(LEGACY_PLUGIN_ID)) {
+    const kept = plugins.filter((item) => item !== LEGACY_PLUGIN_ID);
+    return kept.length > 0 ? { ...json, [ENABLED_PLUGINS_KEY]: kept } : omitKey(json, ENABLED_PLUGINS_KEY);
+  }
+  return json;
+}
+function stripLegacy(json) {
+  const withoutPlugin = stripLegacyPlugin(json);
+  const hooks = withoutPlugin[HOOKS_KEY];
+  if (!isRecord4(hooks)) {
+    return withoutPlugin;
+  }
+  const cleaned = stripLegacyHooks(hooks);
+  return Object.keys(cleaned).length > 0 ? { ...withoutPlugin, [HOOKS_KEY]: cleaned } : omitKey(withoutPlugin, HOOKS_KEY);
+}
+function wireSettings(json) {
+  return addHooks(removeHooks2(stripLegacy(json)));
+}
+function joinDiffs(settingsDiff, commandDiff) {
+  return [settingsDiff, commandDiff].filter((diff) => diff.length > 0).join("\n");
+}
+function legacyMarker(rawText) {
+  if (rawText === null) {
+    return null;
+  }
+  return LEGACY_MARKERS.find((marker) => rawText.includes(marker)) ?? null;
+}
+function legacyMessage(marker) {
+  return `legacy turnbell v1 integration detected in settings (${marker}); \`turnbell init\` removes it as part of wiring (reversible via \`turnbell uninstall\`)`;
+}
+function isSuppressedNotification(raw, eventHint) {
+  if (eventHint !== BLOCKED_EVENT) {
+    return false;
+  }
+  const type = raw[NOTIFICATION_TYPE_KEY];
+  return typeof type === "string" && SUPPRESSED_NOTIFICATION_TYPES.has(type);
+}
+function hasPendingDelegatedWork(raw, eventHint) {
+  if (eventHint !== DONE_EVENT) {
+    return false;
+  }
+  const tasks = raw[BACKGROUND_TASKS_KEY];
+  if (!Array.isArray(tasks)) {
+    return false;
+  }
+  return tasks.some(
+    (task) => isRecord4(task) && typeof task[TASK_TYPE_KEY] === "string" && BLOCKING_BACKGROUND_TYPES.has(task[TASK_TYPE_KEY])
+  );
+}
+var claudeCode = {
+  id: ID3,
+  title: TITLE3,
+  tagline: "Claude Code \u2014 done/blocked hooks and transcript read-aloud",
+  capabilities: {
+    done: true,
+    blocked: true,
+    readAloud: true,
+    slashCommand: true,
+    instructionInjection: true
+  },
+  memoryPath(deps) {
+    return join5(deps.home, ".claude", "CLAUDE.md");
+  },
+  detect(deps) {
+    const path = settingsPath(deps);
+    const installed = isDir3(join5(deps.home, ".claude")) || deps.which("claude") !== null;
+    const marker = legacyMarker(readFileOrNull2(path));
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = path;
+    }
+    if (marker !== null) {
+      detection.degraded = legacyMessage(marker);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const path = settingsPath(deps);
+    const marker = legacyMarker(readFileOrNull2(path));
+    const settingsOp = wireJsonFile(path, wireSettings, LEDGER_KEY3);
+    const commandOp = wireTextFile(
+      commandPath(deps),
+      COMMAND_TEMPLATE,
+      COMMAND_LEDGER_KEY
+    );
+    const result = {
+      changed: settingsOp.changed || commandOp.changed,
+      diff: joinDiffs(settingsOp.diff, commandOp.diff),
+      warnings: marker === null ? [] : [legacyMessage(marker)]
+    };
+    settingsOp.apply();
+    commandOp.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireJsonFile(settingsPath(deps), removeHooks2, LEDGER_KEY3);
+    unwireCreatedFile(legacyCommandPath(deps), COMMAND_LEDGER_KEY);
+    unwireCreatedFile(commandPath(deps), COMMAND_LEDGER_KEY);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord4(raw)) {
+      return null;
+    }
+    if (isSuppressedNotification(raw, eventHint)) {
+      return null;
+    }
+    if (hasPendingDelegatedWork(raw, eventHint)) {
+      return null;
+    }
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID3,
+      agentTitle: TITLE3,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: typeof raw.message === "string" ? raw.message : ""
+    };
+  },
+  readLastResponse(raw) {
+    if (!isRecord4(raw) || typeof raw.transcript_path !== "string") {
+      return Promise.resolve(null);
+    }
+    const data = readTail(raw.transcript_path);
+    if (data === null) {
+      return Promise.resolve(null);
+    }
+    const lines = data.split("\n");
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const text2 = assistantText(lines[index] ?? "");
+      if (text2 !== null) {
+        return Promise.resolve(text2);
+      }
+    }
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/codex.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+var ID4 = "codex";
+var TITLE4 = "Codex";
+var BINARY3 = "codex";
+var CONFIG_DIR2 = ".codex";
+var CONFIG_FILE = "config.toml";
+var HOOKS_FILE2 = "hooks.json";
+var CONFIG_LEDGER_KEY = "codex:config";
+var HOOKS_LEDGER_KEY = "codex:hooks";
+var LAST_MESSAGE_FIELD = "last-assistant-message";
+var NOTIFY_ARGV = [
+  "turnbell",
+  "emit",
+  "--agent",
+  "codex",
+  "--event",
+  "done",
+  "--payload-argv"
+];
+var BLOCKED_COMMAND = "turnbell emit --agent codex --event blocked --payload-stdin";
+var HOOK_EVENT = "PermissionRequest";
+var HOOK_TYPE_COMMAND3 = "command";
+var HOOK_MATCHER = ".*";
+var HOOK_TRUST_WARNING = "codex requires you to review and trust the blocked hook once (run `codex` and approve it) \u2014 it stays inert until then";
+var NOTIFY_KEY_PATTERN = /^\s*notify\s*=/;
+var TABLE_HEADER_PATTERN = /^\s*\[/;
+var NEWLINE = "\n";
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configPath(deps) {
+  return join6(deps.home, CONFIG_DIR2, CONFIG_FILE);
+}
+function hooksPath2(deps) {
+  return join6(deps.home, CONFIG_DIR2, HOOKS_FILE2);
+}
+function isDir4(path) {
+  try {
+    return statSync5(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readFileOrNull3(path) {
+  try {
+    return readFileSync4(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+function notifyLine() {
+  const items = NOTIFY_ARGV.map((item) => `"${item}"`).join(", ");
+  return `notify = [${items}]`;
+}
+function legacyNotifyLine() {
+  const items = NOTIFY_ARGV.map((item, index) => `"${index === 0 ? "hollr" : item}"`).join(", ");
+  return `notify = [${items}]`;
+}
+function bracketDelta(line) {
+  const opens = (line.match(/\[/g) ?? []).length;
+  const closes = (line.match(/\]/g) ?? []).length;
+  return opens - closes;
+}
+function notifyEndIndex(lines, start, limit) {
+  let depth = 0;
+  for (let index = start; index < limit; index += 1) {
+    depth += bracketDelta(lines[index] ?? "");
+    if (depth <= 0) {
+      return index;
+    }
+  }
+  return limit - 1;
+}
+function replaceNotifyRange(lines, start, end, target) {
+  const next = [...lines];
+  next.splice(start, end - start + 1, target);
+  return next.join(NEWLINE);
+}
+function firstTableHeaderIndex(lines) {
+  const index = lines.findIndex((line) => TABLE_HEADER_PATTERN.test(line));
+  return index === -1 ? lines.length : index;
+}
+function topLevelNotifyIndex(lines, limit) {
+  for (let index = 0; index < limit; index += 1) {
+    if (NOTIFY_KEY_PATTERN.test(lines[index] ?? "")) {
+      return index;
+    }
+  }
+  return -1;
+}
+function insertNotifyLine(original, lines, target) {
+  const headerIndex = lines.findIndex((line) => TABLE_HEADER_PATTERN.test(line));
+  if (headerIndex === -1) {
+    const base = original.endsWith(NEWLINE) ? original : `${original}${NEWLINE}`;
+    return `${base}${target}${NEWLINE}`;
+  }
+  const next = [...lines];
+  next.splice(headerIndex, 0, target);
+  return next.join(NEWLINE);
+}
+function patchNotify(original) {
+  const target = notifyLine();
+  if (original === null || original.trim().length === 0) {
+    return `${target}${NEWLINE}`;
+  }
+  const lines = original.split(NEWLINE);
+  const limit = firstTableHeaderIndex(lines);
+  const start = topLevelNotifyIndex(lines, limit);
+  if (start !== -1) {
+    return replaceNotifyRange(lines, start, notifyEndIndex(lines, start, limit), target);
+  }
+  return insertNotifyLine(original, lines, target);
+}
+function removeNotify(original) {
+  if (original === null) {
+    return null;
+  }
+  const lines = original.split(NEWLINE);
+  const limit = firstTableHeaderIndex(lines);
+  const start = topLevelNotifyIndex(lines, limit);
+  if (start === -1) {
+    return original;
+  }
+  const end = notifyEndIndex(lines, start, limit);
+  const next = [...lines];
+  next.splice(start, end - start + 1);
+  return next.join(NEWLINE);
+}
+var NOTIFY_BACKUP_FILE = "codex-notify.bak";
+function codexNotifyBackupPath() {
+  return join6(turnbellHome(), NOTIFY_BACKUP_FILE);
+}
+function readNotifyBackup() {
+  return readFileOrNull3(codexNotifyBackupPath());
+}
+function writeNotifyBackup(content) {
+  try {
+    const path = codexNotifyBackupPath();
+    mkdirSync3(dirname2(path), { recursive: true });
+    writeFileSync3(path, content, "utf8");
+  } catch {
+  }
+}
+function deleteNotifyBackup() {
+  try {
+    rmSync2(codexNotifyBackupPath(), { force: true });
+  } catch {
+  }
+}
+function extractNotify(original) {
+  if (original === null) {
+    return null;
+  }
+  const lines = original.split(NEWLINE);
+  const limit = firstTableHeaderIndex(lines);
+  const start = topLevelNotifyIndex(lines, limit);
+  if (start === -1) {
+    return null;
+  }
+  const end = notifyEndIndex(lines, start, limit);
+  return lines.slice(start, end + 1).join(NEWLINE);
+}
+function archiveExistingNotify(original) {
+  const existing = extractNotify(original);
+  if (existing !== null && existing !== notifyLine() && existing !== legacyNotifyLine()) {
+    writeNotifyBackup(existing);
+    return;
+  }
+  deleteNotifyBackup();
+}
+function restoreNotifyRange(current, backup) {
+  const lines = current.split(NEWLINE);
+  const limit = firstTableHeaderIndex(lines);
+  const start = topLevelNotifyIndex(lines, limit);
+  if (start === -1) {
+    return current;
+  }
+  const end = notifyEndIndex(lines, start, limit);
+  return replaceNotifyRange(lines, start, end, backup);
+}
+function restoreOrRemoveNotify(current) {
+  const backup = readNotifyBackup();
+  if (backup === null) {
+    return removeNotify(current);
+  }
+  const restored = current === null ? null : restoreNotifyRange(current, backup);
+  deleteNotifyBackup();
+  return restored;
+}
+var BLOCKED_COMMANDS = /* @__PURE__ */ new Set([
+  BLOCKED_COMMAND,
+  legacyCommandVariant(BLOCKED_COMMAND)
+]);
+function entryHasCommand2(entry) {
+  if (!isRecord5(entry) || !Array.isArray(entry.hooks)) {
+    return false;
+  }
+  return entry.hooks.some(
+    (hook) => isRecord5(hook) && typeof hook.command === "string" && BLOCKED_COMMANDS.has(hook.command)
+  );
+}
+function appendPermissionEntry(existing) {
+  const list = Array.isArray(existing) ? existing : [];
+  if (list.some(entryHasCommand2)) {
+    return list;
+  }
+  return [
+    ...list,
+    {
+      matcher: HOOK_MATCHER,
+      hooks: [{ type: HOOK_TYPE_COMMAND3, command: BLOCKED_COMMAND }]
+    }
+  ];
+}
+function addPermissionHook(json) {
+  const hooks = isRecord5(json.hooks) ? json.hooks : {};
+  return {
+    ...json,
+    hooks: {
+      ...hooks,
+      [HOOK_EVENT]: appendPermissionEntry(hooks[HOOK_EVENT])
+    }
+  };
+}
+function removeHooks3(json) {
+  return removeTurnbellHooks(json, [HOOK_EVENT], entryHasCommand2);
+}
+function joinDiffs2(configDiff, hooksDiff) {
+  return [configDiff, hooksDiff].filter((diff) => diff.length > 0).join(NEWLINE);
+}
+var codex = {
+  id: ID4,
+  title: TITLE4,
+  tagline: "OpenAI Codex \u2014 notify done/read-aloud and PermissionRequest blocked",
+  capabilities: {
+    done: true,
+    blocked: true,
+    readAloud: true,
+    slashCommand: false,
+    instructionInjection: true
+  },
+  memoryPath(deps) {
+    return join6(deps.home, CONFIG_DIR2, "AGENTS.md");
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY3) !== null || isDir4(join6(deps.home, CONFIG_DIR2));
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = configPath(deps);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const cfgPath = configPath(deps);
+    const originalConfig = readFileOrNull3(cfgPath);
+    archiveExistingNotify(originalConfig);
+    const configOp = wireTextFile(cfgPath, patchNotify(originalConfig), CONFIG_LEDGER_KEY);
+    const hooksOp = wireJsonFile(
+      hooksPath2(deps),
+      (json) => addPermissionHook(removeHooks3(json)),
+      HOOKS_LEDGER_KEY
+    );
+    const result = {
+      changed: configOp.changed || hooksOp.changed,
+      diff: joinDiffs2(configOp.diff, hooksOp.diff),
+      warnings: [HOOK_TRUST_WARNING]
+    };
+    configOp.apply();
+    hooksOp.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireTextFile(configPath(deps), restoreOrRemoveNotify, CONFIG_LEDGER_KEY);
+    unwireJsonFile(hooksPath2(deps), removeHooks3, HOOKS_LEDGER_KEY);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord5(raw)) {
+      return null;
+    }
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID4,
+      agentTitle: TITLE4,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: "",
+      lastResponse: null
+    };
+  },
+  readLastResponse(raw) {
+    if (!isRecord5(raw)) {
+      return Promise.resolve(null);
+    }
+    const message = raw[LAST_MESSAGE_FIELD];
+    return Promise.resolve(typeof message === "string" ? message : null);
+  }
+};
+
+// src/adapters/copilot.ts
+import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readSync as readSync2, statSync as statSync6 } from "fs";
+import { join as join7 } from "path";
+var ID5 = "copilot";
+var TITLE5 = "GitHub Copilot";
+var BINARY4 = "copilot";
+var CONFIG_DIR3 = ".copilot";
+var HOOKS_DIR = "hooks";
+var HOOKS_FILE3 = "turnbell.json";
+var LEGACY_HOOKS_FILE = "hollr.json";
+var LEDGER_KEY4 = "copilot:hooks";
+var MAX_TRANSCRIPT_BYTES2 = 2e6;
+var HOOKS_VERSION = 1;
+var HOOK_AGENT_STOP = "agentStop";
+var HOOK_NOTIFICATION2 = "notification";
+var HOOK_TYPE_COMMAND4 = "command";
+var ASSISTANT_EVENT = "assistant.message";
+var BLOCKED_MATCHER = "agent_idle|permission_prompt|elicitation_dialog";
+var DONE_COMMAND = "turnbell emit --agent copilot --event done --payload-stdin";
+var BLOCKED_COMMAND2 = "turnbell emit --agent copilot --event blocked --payload-stdin";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hooksPath3(deps) {
+  return join7(deps.home, CONFIG_DIR3, HOOKS_DIR, HOOKS_FILE3);
+}
+function isDir5(path) {
+  try {
+    return statSync6(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function readTail2(path) {
+  try {
+    const fd = openSync2(path, "r");
+    try {
+      const size = fstatSync2(fd).size;
+      const start = Math.max(0, size - MAX_TRANSCRIPT_BYTES2);
+      const length = size - start;
+      const buffer = Buffer.alloc(length);
+      readSync2(fd, buffer, 0, length, start);
+      return buffer.toString("utf8");
+    } finally {
+      closeSync2(fd);
+    }
+  } catch {
+    return null;
+  }
+}
+function joinTextBlocks(content) {
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content.filter((block) => isRecord6(block)).map((block) => typeof block.text === "string" ? block.text : "").filter((text2) => text2.length > 0).join(" ");
+}
+function textFromData(data) {
+  if (typeof data.text === "string") {
+    return data.text;
+  }
+  if (typeof data.content === "string") {
+    return data.content;
+  }
+  if (typeof data.message === "string") {
+    return data.message;
+  }
+  return joinTextBlocks(data.content);
+}
+function assistantText2(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord6(obj) || obj.type !== ASSISTANT_EVENT || !isRecord6(obj.data)) {
+    return null;
+  }
+  const text2 = textFromData(obj.data).trim();
+  return text2.length > 0 ? text2 : null;
+}
+function commandHandler(command, matcher) {
+  const handler = { type: HOOK_TYPE_COMMAND4, command };
+  if (matcher !== void 0) {
+    handler.matcher = matcher;
+  }
+  return handler;
+}
+function appendHandler(existing, command, matcher) {
+  const list = Array.isArray(existing) ? existing : [];
+  if (list.some((entry) => isRecord6(entry) && entry.command === command)) {
+    return list;
+  }
+  return [...list, commandHandler(command, matcher)];
+}
+function addHooks2(json) {
+  const hooks = isRecord6(json.hooks) ? json.hooks : {};
+  return {
+    ...json,
+    version: typeof json.version === "number" ? json.version : HOOKS_VERSION,
+    hooks: {
+      ...hooks,
+      [HOOK_AGENT_STOP]: appendHandler(hooks[HOOK_AGENT_STOP], DONE_COMMAND),
+      [HOOK_NOTIFICATION2]: appendHandler(
+        hooks[HOOK_NOTIFICATION2],
+        BLOCKED_COMMAND2,
+        BLOCKED_MATCHER
+      )
+    }
+  };
+}
+var TURNBELL_COMMANDS2 = /* @__PURE__ */ new Set([
+  DONE_COMMAND,
+  BLOCKED_COMMAND2,
+  legacyCommandVariant(DONE_COMMAND),
+  legacyCommandVariant(BLOCKED_COMMAND2)
+]);
+function isTurnbellEntry3(entry) {
+  return isRecord6(entry) && typeof entry.command === "string" && TURNBELL_COMMANDS2.has(entry.command);
+}
+function removeHooks4(json) {
+  return removeTurnbellHooks(json, [HOOK_AGENT_STOP, HOOK_NOTIFICATION2], isTurnbellEntry3);
+}
+var copilot = {
+  id: ID5,
+  title: TITLE5,
+  tagline: "GitHub Copilot CLI \u2014 agentStop/notification hooks and read-aloud",
+  capabilities: {
+    done: true,
+    blocked: true,
+    readAloud: true,
+    slashCommand: false,
+    instructionInjection: false
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY4) !== null || isDir5(join7(deps.home, CONFIG_DIR3));
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = hooksPath3(deps);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const op = wireJsonFile(hooksPath3(deps), addHooks2, LEDGER_KEY4);
+    const result = {
+      changed: op.changed,
+      diff: op.diff,
+      warnings: []
+    };
+    op.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireJsonFile(hooksPath3(deps), removeHooks4, LEDGER_KEY4);
+    unwireCreatedFile(join7(deps.home, CONFIG_DIR3, HOOKS_DIR, LEGACY_HOOKS_FILE), LEDGER_KEY4);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord6(raw)) {
+      return null;
+    }
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID5,
+      agentTitle: TITLE5,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: typeof raw.message === "string" ? raw.message : ""
+    };
+  },
+  readLastResponse(raw) {
+    if (!isRecord6(raw) || typeof raw.transcriptPath !== "string") {
+      return Promise.resolve(null);
+    }
+    const data = readTail2(raw.transcriptPath);
+    if (data === null) {
+      return Promise.resolve(null);
+    }
+    const lines = data.split("\n");
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const text2 = assistantText2(lines[index] ?? "");
+      if (text2 !== null) {
+        return Promise.resolve(text2);
+      }
+    }
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/cursor.ts
+import { statSync as statSync7 } from "fs";
+import { join as join8 } from "path";
+var ID6 = "cursor";
+var TITLE6 = "Cursor";
+var LEDGER_KEY5 = "cursor";
+var BINARY5 = "cursor-agent";
+var CONFIG_DIR4 = ".cursor";
+var HOOKS_FILE4 = "hooks.json";
+var HOOKS_VERSION2 = 1;
+var HOOK_STOP3 = "stop";
+var HOOK_TYPE_COMMAND5 = "command";
+var STOP_COMMAND2 = "turnbell emit --agent cursor --event done --payload-stdin";
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hooksPath4(deps) {
+  return join8(deps.home, CONFIG_DIR4, HOOKS_FILE4);
+}
+function isDir6(path) {
+  try {
+    return statSync7(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function firstWorkspaceRoot(raw) {
+  const roots = raw.workspace_roots;
+  if (!Array.isArray(roots)) {
+    return "";
+  }
+  const first = roots.find((root) => typeof root === "string" && root.length > 0);
+  return typeof first === "string" ? first : "";
+}
+function resolveCwd(raw) {
+  if (typeof raw.cwd === "string" && raw.cwd.length > 0) {
+    return raw.cwd;
+  }
+  return firstWorkspaceRoot(raw);
+}
+function appendHook(existing, command) {
+  const list = Array.isArray(existing) ? existing : [];
+  if (list.some((entry) => isRecord7(entry) && entry.command === command)) {
+    return list;
+  }
+  return [...list, { type: HOOK_TYPE_COMMAND5, command }];
+}
+function addHooks3(json) {
+  const hooks = isRecord7(json.hooks) ? json.hooks : {};
+  const version = typeof json.version === "number" ? json.version : HOOKS_VERSION2;
+  return {
+    ...json,
+    version,
+    hooks: {
+      ...hooks,
+      [HOOK_STOP3]: appendHook(hooks[HOOK_STOP3], STOP_COMMAND2)
+    }
+  };
+}
+var TURNBELL_COMMANDS3 = /* @__PURE__ */ new Set([
+  STOP_COMMAND2,
+  legacyCommandVariant(STOP_COMMAND2)
+]);
+function isTurnbellEntry4(entry) {
+  return isRecord7(entry) && typeof entry.command === "string" && TURNBELL_COMMANDS3.has(entry.command);
+}
+function removeHooks5(json) {
+  return removeTurnbellHooks(json, [HOOK_STOP3], isTurnbellEntry4);
+}
+var cursor = {
+  id: ID6,
+  title: TITLE6,
+  tagline: "Cursor Agent (cursor-agent) \u2014 done via stop hook (read-aloud/blocked come via the wrapper)",
+  capabilities: {
+    done: true,
+    blocked: false,
+    readAloud: false,
+    slashCommand: false,
+    instructionInjection: false
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY5) !== null || isDir6(join8(deps.home, CONFIG_DIR4));
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = hooksPath4(deps);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const op = wireJsonFile(hooksPath4(deps), (json) => addHooks3(removeHooks5(json)), LEDGER_KEY5);
+    const result = {
+      changed: op.changed,
+      diff: op.diff,
+      warnings: []
+    };
+    op.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireJsonFile(hooksPath4(deps), removeHooks5, LEDGER_KEY5);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord7(raw)) {
+      return null;
+    }
+    const cwd = resolveCwd(raw);
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID6,
+      agentTitle: TITLE6,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: "",
+      lastResponse: null
+    };
+  },
+  readLastResponse(_raw) {
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/gemini.ts
+import { join as join9 } from "path";
+var ID7 = "gemini";
+var TITLE7 = "Gemini";
+var BINARY6 = "gemini";
+var CONFIG_DIR5 = ".gemini";
+var SETTINGS_FILE = "settings.json";
+var COMMANDS_DIR2 = "commands";
+var COMMAND_FILE2 = "turnbell.toml";
+var LEGACY_COMMAND_FILE2 = "hollr.toml";
+var SETTINGS_LEDGER_KEY = "gemini:settings";
+var COMMAND_LEDGER_KEY2 = "gemini:command";
+var HOOK_AFTER_AGENT = "AfterAgent";
+var HOOK_NOTIFICATION3 = "Notification";
+var HOOK_TYPE_COMMAND6 = "command";
+var DONE_COMMAND2 = "turnbell emit --agent gemini --event done --payload-stdin";
+var BLOCKED_COMMAND3 = "turnbell emit --agent gemini --event blocked --payload-stdin";
+var LAST_RESPONSE_FIELD = "prompt_response";
+var COMMAND_TEMPLATE2 = `# Managed by turnbell \u2014 reversible via \`turnbell uninstall\`. Do not edit by hand.
+description = "Run the turnbell CLI (voice + desktop notifications) from inside Gemini"
+prompt = """
+Below is the raw output of the turnbell command-line tool. Relay it to the user as-is.
+
+!{turnbell {{args}}}
+"""
+`;
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function settingsPath2(deps) {
+  return join9(deps.home, CONFIG_DIR5, SETTINGS_FILE);
+}
+function commandPath2(deps) {
+  return join9(deps.home, CONFIG_DIR5, COMMANDS_DIR2, COMMAND_FILE2);
+}
+function entryHasCommand3(entry, command) {
+  if (!isRecord8(entry) || !Array.isArray(entry.hooks)) {
+    return false;
+  }
+  return entry.hooks.some((hook) => isRecord8(hook) && hook.command === command);
+}
+function appendTurnbellHook2(existing, command) {
+  const list = Array.isArray(existing) ? existing : [];
+  if (list.some((entry) => entryHasCommand3(entry, command))) {
+    return list;
+  }
+  return [...list, { hooks: [{ type: HOOK_TYPE_COMMAND6, command }] }];
+}
+function addHooks4(json) {
+  const hooks = isRecord8(json.hooks) ? json.hooks : {};
+  return {
+    ...json,
+    hooks: {
+      ...hooks,
+      [HOOK_AFTER_AGENT]: appendTurnbellHook2(hooks[HOOK_AFTER_AGENT], DONE_COMMAND2),
+      [HOOK_NOTIFICATION3]: appendTurnbellHook2(
+        hooks[HOOK_NOTIFICATION3],
+        BLOCKED_COMMAND3
+      )
+    }
+  };
+}
+function joinDiffs3(settingsDiff, commandDiff) {
+  return [settingsDiff, commandDiff].filter((diff) => diff.length > 0).join("\n");
+}
+var TURNBELL_COMMANDS4 = /* @__PURE__ */ new Set([
+  DONE_COMMAND2,
+  BLOCKED_COMMAND3,
+  legacyCommandVariant(DONE_COMMAND2),
+  legacyCommandVariant(BLOCKED_COMMAND3)
+]);
+function isTurnbellEntry5(entry) {
+  return isRecord8(entry) && Array.isArray(entry.hooks) && entry.hooks.some(
+    (hook) => isRecord8(hook) && typeof hook.command === "string" && TURNBELL_COMMANDS4.has(hook.command)
+  );
+}
+function removeHooks6(json) {
+  return removeTurnbellHooks(json, [HOOK_AFTER_AGENT, HOOK_NOTIFICATION3], isTurnbellEntry5);
+}
+var gemini = {
+  id: ID7,
+  title: TITLE7,
+  tagline: "Google Gemini CLI \u2014 AfterAgent done, Notification blocked, /turnbell command",
+  capabilities: {
+    done: true,
+    blocked: true,
+    readAloud: true,
+    slashCommand: true,
+    instructionInjection: true
+  },
+  memoryPath(deps) {
+    return join9(deps.home, CONFIG_DIR5, "GEMINI.md");
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY6) !== null;
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = settingsPath2(deps);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const settingsOp = wireJsonFile(
+      settingsPath2(deps),
+      (json) => addHooks4(removeHooks6(json)),
+      SETTINGS_LEDGER_KEY
+    );
+    const commandOp = wireTextFile(
+      commandPath2(deps),
+      COMMAND_TEMPLATE2,
+      COMMAND_LEDGER_KEY2
+    );
+    const result = {
+      changed: settingsOp.changed || commandOp.changed,
+      diff: joinDiffs3(settingsOp.diff, commandOp.diff),
+      warnings: []
+    };
+    settingsOp.apply();
+    commandOp.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireJsonFile(settingsPath2(deps), removeHooks6, SETTINGS_LEDGER_KEY);
+    unwireCreatedFile(
+      join9(deps.home, CONFIG_DIR5, COMMANDS_DIR2, LEGACY_COMMAND_FILE2),
+      COMMAND_LEDGER_KEY2
+    );
+    unwireCreatedFile(commandPath2(deps), COMMAND_LEDGER_KEY2);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord8(raw)) {
+      return null;
+    }
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID7,
+      agentTitle: TITLE7,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: typeof raw.message === "string" ? raw.message : "",
+      lastResponse: null
+    };
+  },
+  readLastResponse(raw) {
+    if (!isRecord8(raw)) {
+      return Promise.resolve(null);
+    }
+    const response = raw[LAST_RESPONSE_FIELD];
+    return Promise.resolve(typeof response === "string" ? response : null);
+  }
+};
+
+// src/adapters/opencode.ts
+import { statSync as statSync8 } from "fs";
+import { join as join10 } from "path";
+var ID8 = "opencode";
+var TITLE8 = "opencode";
+var BINARY7 = "opencode";
+var LEDGER_KEY6 = "opencode";
+var CONFIG_SEGMENTS2 = [".config", "opencode"];
+var PLUGIN_DIR = "plugin";
+var PLUGIN_FILE = "turnbell.js";
+var LEGACY_PLUGIN_FILE = "hollr.js";
+var EVENT_SESSION_IDLE = "session.idle";
+var EVENT_PERMISSION_ASKED = "permission.asked";
+var EMIT_DONE = "done";
+var EMIT_BLOCKED = "blocked";
+var EMIT_COMMAND_PREFIX = `turnbell emit --agent ${ID8}`;
+var PLUGIN_TEMPLATE = `// Managed by turnbell \u2014 reversible via \`turnbell uninstall\`. Do not edit by hand.
+// Bridges opencode lifecycle events to the turnbell CLI (voice + desktop notifications).
+// opencode auto-loads .js/.ts files under ~/.config/opencode/plugin/ (and .opencode/plugin/).
+export const turnbell = async ({ $, directory }) => {
+  const emit = async (event, properties) => {
+    const payload = JSON.stringify({
+      cwd: directory,
+      sessionID: properties?.sessionID ?? null,
+    });
+    try {
+      await $\`${EMIT_COMMAND_PREFIX} --event \${event} --payload-argv \${payload}\`
+        .quiet()
+        .nothrow();
+    } catch {
+      // A notification failure must never disrupt the coding session.
+    }
+  };
+  return {
+    event: async ({ event }) => {
+      if (event.type === "${EVENT_SESSION_IDLE}") {
+        await emit("${EMIT_DONE}", event.properties);
+        return;
+      }
+      if (event.type === "${EVENT_PERMISSION_ASKED}") {
+        await emit("${EMIT_BLOCKED}", event.properties);
+      }
+    },
+  };
+};
+`;
+function isRecord9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function configDir2(deps) {
+  return join10(deps.home, ...CONFIG_SEGMENTS2);
+}
+function pluginPath(deps) {
+  return join10(configDir2(deps), PLUGIN_DIR, PLUGIN_FILE);
+}
+function isDir7(path) {
+  try {
+    return statSync8(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var opencode = {
+  id: ID8,
+  title: TITLE8,
+  tagline: "sst opencode \u2014 plugin bridges session.idle done and permission.asked blocked",
+  capabilities: {
+    done: true,
+    blocked: true,
+    readAloud: false,
+    slashCommand: false,
+    instructionInjection: false
+  },
+  detect(deps) {
+    const installed = deps.which(BINARY7) !== null || isDir7(configDir2(deps));
+    const detection = { installed };
+    if (installed) {
+      detection.configPath = pluginPath(deps);
+    }
+    return Promise.resolve(detection);
+  },
+  wire(deps) {
+    const op = wireTextFile(pluginPath(deps), PLUGIN_TEMPLATE, LEDGER_KEY6);
+    const result = {
+      changed: op.changed,
+      diff: op.diff,
+      warnings: []
+    };
+    op.apply();
+    return Promise.resolve(result);
+  },
+  unwire(deps) {
+    unwireCreatedFile(join10(configDir2(deps), PLUGIN_DIR, LEGACY_PLUGIN_FILE), LEDGER_KEY6);
+    unwireCreatedFile(pluginPath(deps), LEDGER_KEY6);
+    return Promise.resolve();
+  },
+  normalize(raw, eventHint) {
+    if (!isRecord9(raw)) {
+      return null;
+    }
+    const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
+    return {
+      v: 1,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agent: ID8,
+      agentTitle: TITLE8,
+      event: eventHint,
+      cwd,
+      project: projectLabel(cwd),
+      summary: "",
+      lastResponse: null
+    };
+  },
+  readLastResponse(_raw) {
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/wrapper.ts
+var ID9 = "wrapper";
+var TITLE9 = "Wrapper";
+var USAGE_HINT = "wrap any agent with `turnbell run -- <cmd> [args...]`; add `--announce-stream cursor` before `--` for read-aloud of cursor output";
+var wrapper = {
+  id: ID9,
+  title: TITLE9,
+  tagline: "Universal wrapper \u2014 announce any agent via `turnbell run -- <cmd>`",
+  capabilities: {
+    done: true,
+    blocked: false,
+    readAloud: true,
+    slashCommand: false,
+    instructionInjection: false
+  },
+  detect(_deps) {
+    return Promise.resolve({ installed: true });
+  },
+  wire(_deps) {
+    return Promise.resolve({ changed: false, diff: "", warnings: [USAGE_HINT] });
+  },
+  unwire(_deps) {
+    return Promise.resolve();
+  },
+  normalize(_raw, _eventHint) {
+    return null;
+  },
+  readLastResponse(_raw) {
+    return Promise.resolve(null);
+  }
+};
+
+// src/adapters/registry.ts
+var adapters = [
+  claudeCode,
+  amp,
+  antigravity,
+  codex,
+  copilot,
+  cursor,
+  gemini,
+  opencode,
+  wrapper
+];
+function byId(id) {
+  return adapters.find((adapter) => adapter.id === id);
+}
+
+// src/core/control.ts
+import { readFileSync as readFileSync5, unlinkSync } from "fs";
+import { join as join13 } from "path";
+
+// src/platform/index.ts
+import { spawn } from "child_process";
+import { accessSync, constants } from "fs";
+import { delimiter, join as join12 } from "path";
+
+// src/platform/darwin.ts
+import { existsSync as existsSync2 } from "fs";
+
+// src/platform/rate.ts
+var DEFAULT_RATE_WPM2 = 190;
+var SPD_BASELINE_WPM = DEFAULT_RATE_WPM2;
+var SPD_RATE_MIN = -100;
+var SPD_RATE_MAX = 100;
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function coerceRate(rateWpm) {
+  return Number.isFinite(rateWpm) ? Math.trunc(rateWpm) : DEFAULT_RATE_WPM2;
+}
+function rateToSpd(rateWpm) {
+  if (!Number.isFinite(rateWpm)) {
+    return "0";
+  }
+  const points = Math.round(rateWpm - SPD_BASELINE_WPM);
+  return String(clamp(points, SPD_RATE_MIN, SPD_RATE_MAX));
+}
+
+// src/platform/darwin.ts
+var MAX_SPEECH_CHARS = 2e3;
+var MAX_NOTIFY_BODY = 200;
+var MAX_NOTIFY_TITLE = 60;
+var SOUND_DIR = "/System/Library/Sounds";
+var SOUND_NAME_RE = /^[A-Za-z]+$/;
+var SYSTEM_VOICE_SENTINELS = /* @__PURE__ */ new Set(["", "system", "default"]);
+var LOCALE_TOKEN_RE = /\s+[a-z]{2}_[A-Z]{2}/;
+var COLUMN_GAP_RE = /\s{2,}/;
+function isNamedVoice(voice) {
+  if (voice === null) {
+    return false;
+  }
+  return !SYSTEM_VOICE_SENTINELS.has(voice.trim().toLowerCase());
+}
+function applescriptSafe(text2) {
+  return text2.replace(/\\/g, "").replace(/"/g, "'");
+}
+function parseVoiceLine(line) {
+  if (line.trim().length === 0) {
+    return null;
+  }
+  const boundary = LOCALE_TOKEN_RE.exec(line) ?? COLUMN_GAP_RE.exec(line);
+  if (boundary === null || boundary.index === 0) {
+    return null;
+  }
+  const name = line.slice(0, boundary.index).trim();
+  return name.length > 0 ? name : null;
+}
+var DarwinPlatform = class {
+  id = "darwin";
+  canPauseResume = true;
+  requiredBinaries = [
+    { name: "say", fix: null },
+    { name: "osascript", fix: null },
+    { name: "afplay", fix: null, optional: true }
+  ];
+  #fileExists;
+  constructor(fileExists = existsSync2) {
+    this.#fileExists = fileExists;
+  }
+  voiceArgv(text2, voice, rateWpm) {
+    if (text2.trim().length === 0) {
+      return null;
+    }
+    const voiceArgs = isNamedVoice(voice) ? ["-v", voice] : [];
+    return [
+      "say",
+      ...voiceArgs,
+      "-r",
+      String(coerceRate(rateWpm)),
+      "--",
+      text2.slice(0, MAX_SPEECH_CHARS)
+    ];
+  }
+  notifyArgv(title, body) {
+    const safeBody = applescriptSafe(body).slice(0, MAX_NOTIFY_BODY);
+    const safeTitle = applescriptSafe(title).slice(0, MAX_NOTIFY_TITLE);
+    const script = `display notification "${safeBody}" with title "${safeTitle}"`;
+    return ["osascript", "-e", script];
+  }
+  soundArgv(soundName) {
+    if (!SOUND_NAME_RE.test(soundName)) {
+      return null;
+    }
+    const path = `${SOUND_DIR}/${soundName}.aiff`;
+    return this.#fileExists(path) ? ["afplay", path] : null;
+  }
+  enumerateVoicesArgv() {
+    return ["say", "-v", "?"];
+  }
+  parseVoicesOutput(raw) {
+    const names = [];
+    for (const line of raw.split("\n")) {
+      const name = parseVoiceLine(line);
+      if (name !== null) {
+        names.push(name);
+      }
+    }
+    return names;
+  }
+};
+
+// src/platform/linux.ts
+import { existsSync as existsSync3 } from "fs";
+var MAX_SPEECH_CHARS2 = 2e3;
+var MAX_NOTIFY_TITLE2 = 60;
+var MAX_NOTIFY_BODY2 = 200;
+var SPD_SAY = "spd-say";
+var ESPEAK_NG = "espeak-ng";
+var ESPEAK = "espeak";
+var NOTIFY_SEND = "notify-send";
+var PAPLAY = "paplay";
+var APLAY = "aplay";
+var SOUND_DIR2 = "/usr/share/sounds/freedesktop/stereo";
+var SOUND_NAME_RE2 = /^[A-Za-z][A-Za-z0-9 _-]*$/;
+var ESPEAK_HEADER_PREFIX = "Pty";
+var ESPEAK_NAME_COLUMN = 3;
+var SPD_NAME_COLUMN = 0;
+function hasVoice(voice) {
+  return voice !== null && voice.length > 0;
+}
+var LinuxPlatform = class {
+  id = "linux";
+  canPauseResume = true;
+  requiredBinaries = [
+    { name: SPD_SAY, fix: "sudo apt install speech-dispatcher" },
+    { name: NOTIFY_SEND, fix: "sudo apt install libnotify-bin" },
+    { name: PAPLAY, fix: "sudo apt install pulseaudio-utils", optional: true }
+  ];
+  #which;
+  #fileExists;
+  constructor(which, fileExists = existsSync3) {
+    this.#which = which;
+    this.#fileExists = fileExists;
+  }
+  voiceArgv(text2, voice, rateWpm) {
+    if (text2.trim().length === 0) {
+      return null;
+    }
+    const body = text2.slice(0, MAX_SPEECH_CHARS2);
+    if (this.#which(SPD_SAY) !== null) {
+      const voiceArgs2 = hasVoice(voice) ? ["-y", voice] : [];
+      return [SPD_SAY, ...voiceArgs2, "-r", rateToSpd(rateWpm), "--wait", body];
+    }
+    const espeak = this.#selectEspeak();
+    if (espeak === null) {
+      return null;
+    }
+    const voiceArgs = hasVoice(voice) ? ["-v", voice] : [];
+    return [espeak, ...voiceArgs, "-s", String(coerceRate(rateWpm)), "--", body];
+  }
+  notifyArgv(title, body) {
+    return [
+      NOTIFY_SEND,
+      "--app-name=turnbell",
+      title.slice(0, MAX_NOTIFY_TITLE2),
+      body.slice(0, MAX_NOTIFY_BODY2)
+    ];
+  }
+  soundArgv(soundName) {
+    if (!SOUND_NAME_RE2.test(soundName)) {
+      return null;
+    }
+    const path = `${SOUND_DIR2}/${soundName}.oga`;
+    if (!this.#fileExists(path)) {
+      return null;
+    }
+    if (this.#which(PAPLAY) !== null) {
+      return [PAPLAY, path];
+    }
+    if (this.#which(APLAY) !== null) {
+      return [APLAY, path];
+    }
+    return null;
+  }
+  enumerateVoicesArgv() {
+    if (this.#which(SPD_SAY) !== null) {
+      return [SPD_SAY, "-L"];
+    }
+    if (this.#which(ESPEAK_NG) !== null) {
+      return [ESPEAK_NG, "--voices"];
+    }
+    return null;
+  }
+  parseVoicesOutput(raw) {
+    const lines = raw.split("\n");
+    const header = lines[0] ?? "";
+    const column = header.trimStart().startsWith(ESPEAK_HEADER_PREFIX) ? ESPEAK_NAME_COLUMN : SPD_NAME_COLUMN;
+    const names = [];
+    for (const line of lines.slice(1)) {
+      const name = line.trim().split(/\s+/)[column];
+      if (name !== void 0 && name.length > 0) {
+        names.push(name);
+      }
+    }
+    return names;
+  }
+  /** Pick the available espeak binary (`espeak-ng` preferred), or `null`. */
+  #selectEspeak() {
+    if (this.#which(ESPEAK_NG) !== null) {
+      return ESPEAK_NG;
+    }
+    if (this.#which(ESPEAK) !== null) {
+      return ESPEAK;
+    }
+    return null;
+  }
+};
+
+// src/platform/win32.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
+var POWERSHELL = ["powershell", "-NoProfile", "-Command"];
+var TMP_SUBDIR = "tmp";
+var SPEECH_TMP_PREFIX = "speech";
+var NOTIFY_TITLE_TMP_PREFIX = "notify-title";
+var NOTIFY_BODY_TMP_PREFIX = "notify-body";
+var RATE_MIN = -10;
+var RATE_MAX = 10;
+var RATE_BASE_WPM = 190;
+var RATE_SLOW_ANCHOR_WPM = 150;
+var RATE_SLOW_ANCHOR = -3;
+var RATE_FAST_ANCHOR_WPM = 220;
+var RATE_FAST_ANCHOR = 3;
+var RATE_SLOW_SLOPE = RATE_SLOW_ANCHOR / (RATE_SLOW_ANCHOR_WPM - RATE_BASE_WPM);
+var RATE_FAST_SLOPE = RATE_FAST_ANCHOR / (RATE_FAST_ANCHOR_WPM - RATE_BASE_WPM);
+var VOICE_NAME_RE = /^[A-Za-z0-9 ]+$/;
+var SOUND_DIR3 = "C:\\Windows\\Media";
+var SOUND_NAME_RE3 = /^[A-Za-z][A-Za-z0-9 _-]*$/;
+function toSynthRate(rateWpm) {
+  if (!Number.isFinite(rateWpm)) {
+    return 0;
+  }
+  const delta = rateWpm - RATE_BASE_WPM;
+  const slope = delta < 0 ? RATE_SLOW_SLOPE : RATE_FAST_SLOPE;
+  const rate = Math.round(delta * slope);
+  return Math.max(RATE_MIN, Math.min(RATE_MAX, rate));
+}
+var Win32Platform = class {
+  id = "win32";
+  canPauseResume = false;
+  requiredBinaries = [{ name: "powershell", fix: null }];
+  #fileExists;
+  // `which` is injected for construction symmetry with the other engines, but
+  // win32 depends only on the built-in `powershell`, so it is not retained.
+  constructor(_which, fileExists = existsSync4) {
+    this.#fileExists = fileExists;
+  }
+  voiceArgv(text2, voice, rateWpm) {
+    if (text2.trim().length === 0) {
+      return null;
+    }
+    const tmp = this.#writeTmp(SPEECH_TMP_PREFIX, text2);
+    const voiceLine = voice !== null && VOICE_NAME_RE.test(voice) ? `$s.SelectVoice('${voice}')` : null;
+    const script = [
+      "Add-Type -AssemblyName System.Speech",
+      "$s=New-Object System.Speech.Synthesis.SpeechSynthesizer",
+      `$s.Rate=${toSynthRate(rateWpm)}`,
+      ...voiceLine === null ? [] : [voiceLine],
+      `$s.Speak([IO.File]::ReadAllText('${tmp}'))`,
+      removeItem(tmp)
+    ].join("; ");
+    return [...POWERSHELL, script];
+  }
+  notifyArgv(title, body) {
+    const titleTmp = this.#writeTmp(NOTIFY_TITLE_TMP_PREFIX, title);
+    const bodyTmp = this.#writeTmp(NOTIFY_BODY_TMP_PREFIX, body);
+    const script = [
+      "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType=WindowsRuntime] > $null",
+      "$t=[Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)",
+      "$n=$t.GetElementsByTagName('text')",
+      `$n.Item(0).AppendChild($t.CreateTextNode([IO.File]::ReadAllText('${titleTmp}'))) > $null`,
+      `$n.Item(1).AppendChild($t.CreateTextNode([IO.File]::ReadAllText('${bodyTmp}'))) > $null`,
+      "$toast=[Windows.UI.Notifications.ToastNotification]::new($t)",
+      "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('turnbell').Show($toast)",
+      removeItem(titleTmp),
+      removeItem(bodyTmp)
+    ].join("; ");
+    return [...POWERSHELL, script];
+  }
+  soundArgv(soundName) {
+    if (!SOUND_NAME_RE3.test(soundName)) {
+      return null;
+    }
+    const path = `${SOUND_DIR3}\\${soundName}.wav`;
+    if (!this.#fileExists(path)) {
+      return null;
+    }
+    return [...POWERSHELL, `(New-Object Media.SoundPlayer '${path}').PlaySync()`];
+  }
+  enumerateVoicesArgv() {
+    const script = "Add-Type -AssemblyName System.Speech; (New-Object System.Speech.Synthesis.SpeechSynthesizer).GetInstalledVoices() | ForEach-Object { $_.VoiceInfo.Name }";
+    return [...POWERSHELL, script];
+  }
+  parseVoicesOutput(raw) {
+    const names = [];
+    for (const line of raw.split("\n")) {
+      const name = line.trim();
+      if (name.length > 0) {
+        names.push(name);
+      }
+    }
+    return names;
+  }
+  /** Write `text` to `<TURNBELL_HOME>/tmp/<prefix>-<pid>.txt` and return its path. */
+  #writeTmp(prefix, text2) {
+    const dir = join11(turnbellHome(), TMP_SUBDIR);
+    mkdirSync4(dir, { recursive: true });
+    const path = join11(dir, `${prefix}-${process.pid}.txt`);
+    writeFileSync4(path, text2, "utf8");
+    return path;
+  }
+};
+function removeItem(path) {
+  return `Remove-Item '${path}' -ErrorAction SilentlyContinue`;
+}
+
+// src/platform/index.ts
+function whichOnPath(bin) {
+  const pathEnv = process.env.PATH;
+  if (pathEnv === void 0 || pathEnv.length === 0) {
+    return null;
+  }
+  const isWindows = process.platform === "win32";
+  const mode = isWindows ? constants.F_OK : constants.X_OK;
+  const extensions = isWindows ? (process.env.PATHEXT ?? ".EXE").split(delimiter) : [""];
+  for (const dir of pathEnv.split(delimiter)) {
+    if (dir.length === 0) {
+      continue;
+    }
+    for (const extension of extensions) {
+      const candidate = join12(dir, `${bin}${extension}`);
+      try {
+        accessSync(candidate, mode);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function selectPlatform(id = process.platform) {
+  switch (id) {
+    case "darwin":
+      return new DarwinPlatform();
+    case "linux":
+      return new LinuxPlatform(whichOnPath);
+    case "win32":
+      return new Win32Platform(whichOnPath);
+    default:
+      throw new Error(`unsupported platform: ${id}`);
+  }
+}
+function spawnDetached(argv) {
+  const command = argv[0];
+  if (command === void 0) {
+    return;
+  }
+  const child = spawn(command, argv.slice(1), {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+
+// src/core/control.ts
+var READING_PIDFILE_NAME = "reading.pid";
+var SIGNAL_STOP = "SIGSTOP";
+var SIGNAL_CONT = "SIGCONT";
+var SIGNAL_TERM = "SIGTERM";
+var MSG_PAUSED = "turnbell: reading paused";
+var MSG_RESUMED = "turnbell: reading resumed";
+var MSG_STOPPED = "turnbell: reading stopped";
+var MSG_NOTHING = "turnbell: nothing is being read";
+var MSG_PAUSE_UNSUPPORTED = "turnbell: pause is not supported on Windows \u2014 use turnbell stop";
+var INTEGER_RE2 = /^-?\d+$/;
+function defaultDeps() {
+  return {
+    platform: selectPlatform(),
+    kill: process.kill.bind(process),
+    pidPath: join13(turnbellHome(), READING_PIDFILE_NAME)
+  };
+}
+function readPid(pidPath) {
+  let raw;
+  try {
+    raw = readFileSync5(pidPath, "utf8").trim();
+  } catch {
+    return null;
+  }
+  if (!INTEGER_RE2.test(raw)) {
+    return null;
+  }
+  return Number.parseInt(raw, 10);
+}
+function clearPid(pidPath) {
+  try {
+    unlinkSync(pidPath);
+  } catch {
+  }
+}
+function signalReader(deps, signal, successMessage) {
+  const pid = readPid(deps.pidPath);
+  if (pid === null) {
+    return MSG_NOTHING;
+  }
+  try {
+    if (signal === void 0) {
+      deps.kill(pid);
+    } else {
+      deps.kill(pid, signal);
+    }
+  } catch {
+    clearPid(deps.pidPath);
+    return MSG_NOTHING;
+  }
+  return successMessage;
+}
+function pauseReading(deps = defaultDeps()) {
+  if (!deps.platform.canPauseResume) {
+    return MSG_PAUSE_UNSUPPORTED;
+  }
+  return signalReader(deps, SIGNAL_STOP, MSG_PAUSED);
+}
+function resumeReading(deps = defaultDeps()) {
+  if (!deps.platform.canPauseResume) {
+    return MSG_PAUSE_UNSUPPORTED;
+  }
+  return signalReader(deps, SIGNAL_CONT, MSG_RESUMED);
+}
+function stopReading(deps = defaultDeps()) {
+  const signal = deps.platform.canPauseResume ? SIGNAL_TERM : void 0;
+  const message = signalReader(deps, signal, MSG_STOPPED);
+  if (message === MSG_STOPPED) {
+    clearPid(deps.pidPath);
+  }
+  return message;
+}
+
+// src/core/doctor.ts
+import { homedir as homedir2 } from "os";
+var MIN_NODE_MAJOR = 20;
+var NODE_KEY = "node";
+var NODE_LABEL = "Node.js";
+var NODE_FIX = `upgrade Node to >= ${MIN_NODE_MAJOR}`;
+var BETA_NOTES = {
+  linux: "Linux support is beta \u2014 engines are mock-tested, not yet live-verified.",
+  win32: "Windows support is beta \u2014 engines are mock-tested, not yet live-verified."
+};
+function stripVersionPrefix(version) {
+  return version.startsWith("v") ? version.slice(1) : version;
+}
+function parseMajor(version) {
+  const major = Number.parseInt(stripVersionPrefix(version).split(".")[0] ?? "", 10);
+  return Number.isNaN(major) ? null : major;
+}
+function checkNode(nodeVersion) {
+  const major = parseMajor(nodeVersion);
+  const ok = major !== null && major >= MIN_NODE_MAJOR;
+  const version = `v${stripVersionPrefix(nodeVersion)}`;
+  const detail = ok ? `${version} (>= ${MIN_NODE_MAJOR} required)` : `${version} is too old (>= ${MIN_NODE_MAJOR} required)`;
+  return {
+    key: NODE_KEY,
+    label: NODE_LABEL,
+    ok,
+    required: true,
+    detail,
+    fix: ok ? null : NODE_FIX
+  };
+}
+function checkBinaries(platform, which) {
+  const betaNote = BETA_NOTES[platform.id];
+  return platform.requiredBinaries.map((entry) => {
+    const resolved = which(entry.name);
+    const ok = resolved !== null;
+    let detail = ok ? `found at ${resolved}` : "not found on PATH";
+    if (betaNote !== void 0) {
+      detail = `${detail} \u2014 ${betaNote}`;
+    }
+    return {
+      key: entry.name,
+      label: entry.name,
+      ok,
+      required: entry.optional !== true,
+      detail,
+      fix: entry.fix
+    };
+  });
+}
+async function checkAdapter(agent, deps) {
+  let ok = false;
+  let detail = "not installed";
+  try {
+    const result = await agent.detect(deps);
+    ok = result.installed;
+    if (result.installed) {
+      detail = result.degraded === void 0 ? "installed" : `installed (degraded: ${result.degraded})`;
+    }
+  } catch {
+    detail = "not installed (detection failed)";
+  }
+  return { key: agent.id, label: agent.title, ok, required: false, detail, fix: null };
+}
+async function checkAll(deps) {
+  const nodeVersion = deps.nodeVersion ?? process.versions.node;
+  const adapterDeps2 = {
+    home: deps.home ?? homedir2(),
+    which: deps.which
+  };
+  const adapterChecks = await Promise.all(
+    (deps.adapters ?? []).map((agent) => checkAdapter(agent, adapterDeps2))
+  );
+  return [
+    checkNode(nodeVersion),
+    ...checkBinaries(deps.platform, deps.which),
+    ...adapterChecks
+  ];
+}
+function allRequiredOk(checks) {
+  return checks.every((check) => !check.required || check.ok);
+}
+
+// src/adapters/instruction.ts
+import { join as join14 } from "path";
+var READALOUD_MARKER = "turnbell:readaloud";
+var LEGACY_READALOUD_MARKER = "hollr:readaloud";
+function readaloudTempDir() {
+  return join14(turnbellHome(), "readaloud");
+}
+function readaloudLedgerKey(adapterId) {
+  return `${adapterId}:readaloud`;
+}
+function buildReadaloudBlock(openCommand) {
+  const dir = readaloudTempDir();
+  return [
+    "Your responses are being read aloud (text-to-speech). For the FINAL message each turn:",
+    "- Write plain, speakable sentences. No headers, tables, bullet lists, or inline backticks in the spoken part.",
+    `- When the answer needs code, long output, or dense technical detail, DON'T speak it: write it to a temp .md file under ${dir} and open it with \`${openCommand} <file>\`, then say one sentence pointing the user there.`,
+    "- Keep file-dumps INTENTIONAL and rare \u2014 only when detail truly won't read aloud well. Never create files for short or conversational answers.",
+    "This shapes only how you present the final message; it does not change the work you do."
+  ].join("\n");
+}
+function injectReadaloud(memoryPath, openCommand, adapterId) {
+  return wireMarkedSection(
+    memoryPath,
+    READALOUD_MARKER,
+    buildReadaloudBlock(openCommand),
+    readaloudLedgerKey(adapterId),
+    [LEGACY_READALOUD_MARKER]
+  );
+}
+
+// src/core/prune.ts
+import { readdirSync as readdirSync2, statSync as statSync9, unlinkSync as unlinkSync2 } from "fs";
+import { join as join15 } from "path";
+var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
+function pruneReadaloudDir(dir, now, ttlMs = DEFAULT_TTL_MS) {
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const path = join15(dir, entry);
+    try {
+      const stat = statSync9(path);
+      if (stat.isFile() && now.getTime() - stat.mtimeMs > ttlMs) {
+        unlinkSync2(path);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/core/router.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join16 } from "path";
+var NOTIFY_TITLE = "turnbell";
+var HINT_MESSAGE = "turnbell: not configured \u2014 run turnbell init\n";
+var HINT_MARKER = "hint-shown";
+var EVENTS_LOG = "events.log";
+var EVENTS_LOG_CAP = 50;
+var SUPPRESS = "suppress";
+var LINE_BUILDERS = {
+  done: (agentTitle, project) => `${agentTitle} response is ready in ${project}`,
+  blocked: (agentTitle, project) => `${agentTitle} needs your input in ${project}`,
+  error: (agentTitle, project) => `${agentTitle} hit an error in ${project}`
+};
+var EXIT_OK = 0;
+var EXIT_HINT = 1;
+function route(ev, cfg, deps, now) {
+  try {
+    if (quietActive(now)) {
+      return EXIT_OK;
+    }
+    if (isMuted(ev.cwd)) {
+      return EXIT_OK;
+    }
+    if (!isConfigured(ev.cwd)) {
+      return showHintOnce();
+    }
+    if (isProjectEnabled(ev.cwd)) {
+      dispatchRouted(ev, cfg, deps, now);
+      return EXIT_OK;
+    }
+    if (cfg.activation === "opt-in") {
+      return EXIT_OK;
+    }
+    dispatchRouted(ev, cfg, deps, now);
+    return EXIT_OK;
+  } catch {
+    return EXIT_OK;
+  }
+}
+function showHintOnce() {
+  const marker = join16(turnbellHome(), HINT_MARKER);
+  if (existsSync5(marker)) {
+    return EXIT_OK;
+  }
+  try {
+    mkdirSync5(turnbellHome(), { recursive: true });
+    writeFileSync5(marker, "");
+  } catch {
+    return EXIT_OK;
+  }
+  process.stderr.write(HINT_MESSAGE);
+  return EXIT_HINT;
+}
+function dispatchRouted(ev, cfg, deps, now) {
+  const quiet = inQuietHours(cfg.quietHours, now);
+  fireWebhooks(ev, cfg, deps, quiet);
+  fireSinks(ev, cfg, deps, effectiveMode(cfg, ev.event), quiet);
+  appendEventLog(ev);
+}
+function fireWebhooks(ev, cfg, deps, quiet) {
+  if (quiet && cfg.quietHoursWebhooks === SUPPRESS) {
+    return;
+  }
+  deps.webhooks(ev);
+}
+function fireSinks(ev, cfg, deps, mode, quiet) {
+  const line = LINE_BUILDERS[ev.event](ev.agentTitle, ev.project);
+  if (mode === "announce" || mode === "readaloud") {
+    const spoken = mode === "readaloud" ? readaloudSpeech(ev, cfg, line) : line;
+    if (!quiet) {
+      speak(deps, cfg, spoken);
+    }
+    if (cfg.notify.desktop) {
+      desktopNotify(deps, line);
+    }
+  } else if (mode === "notify") {
+    if (!quiet && cfg.notify.sound !== null) {
+      speak(deps, cfg, "");
+    }
+    desktopNotify(deps, line);
+  }
+}
+function readaloudSpeech(ev, cfg, line) {
+  const raw = ev.lastResponse;
+  if (raw === null || raw === void 0 || raw.length === 0) {
+    return line;
+  }
+  const prepared = prepareSpeechText(raw, cfg.readaloud.maxChars, cfg.readaloud.stripCode);
+  return prepared.length > 0 ? prepared : line;
+}
+function speak(deps, cfg, text2) {
+  deps.speak({
+    text: text2,
+    voice: cfg.voice.name,
+    rateWpm: cfg.voice.rateWpm,
+    sound: cfg.notify.sound,
+    platform: deps.platform
+  });
+}
+function desktopNotify(deps, line) {
+  const argv = deps.platform.notifyArgv(NOTIFY_TITLE, line);
+  if (argv !== null) {
+    deps.notify(argv);
+  }
+}
+function effectiveMode(cfg, event) {
+  const mode = readMode(cfg, event);
+  if (mode === "readaloud" && event !== "done") {
+    return "announce";
+  }
+  return mode;
+}
+function readMode(cfg, event) {
+  const events = cfg.events;
+  if (!isRecord10(events)) {
+    return void 0;
+  }
+  const entry = events[event];
+  if (!isRecord10(entry)) {
+    return void 0;
+  }
+  return typeof entry.mode === "string" ? entry.mode : void 0;
+}
+function isRecord10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function appendEventLog(ev) {
+  try {
+    const home = turnbellHome();
+    const path = join16(home, EVENTS_LOG);
+    const line = `${ev.ts} ${ev.agent} ${ev.event} ${ev.project}`;
+    mkdirSync5(home, { recursive: true });
+    const lines = [...readLogLines(path), line].slice(-EVENTS_LOG_CAP);
+    writeFileSync5(path, `${lines.join("\n")}
+`);
+  } catch {
+  }
+}
+function readLogLines(path) {
+  try {
+    return readFileSync6(path, "utf8").split("\n").filter((entry) => entry.length > 0);
+  } catch {
+    return [];
+  }
+}
+
+// src/sinks/webhook.ts
+import { chmodSync, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname3, join as join17 } from "path";
+var PAYLOAD_VERSION = 1;
+var TIMEOUT_MS = 5e3;
+var LOG_CAP = 100;
+var LOG_FILE = "webhook.log";
+var CONFIG_FILE2 = "config.json";
+var CONFIG_MODE = 384;
+var HTTP_SCHEME2 = "http:";
+var HTTPS_SCHEME = "https:";
+var PRIORITY_DONE = "default";
+var PRIORITY_OTHER = "high";
+var CONTENT_TYPE_JSON = "application/json";
+var CONTENT_TYPE_FORM = "application/x-www-form-urlencoded";
+var PUSHOVER_TOKEN = "token";
+var PUSHOVER_USER = "user";
+var DONE_EVENT2 = "done";
+var OUTCOME_OK = "ok";
+var OUTCOME_NETWORK_ERROR = "error";
+var OUTCOME_SKIP = "skip";
+var SKIP_REASON_HTTP = "http-not-allowed";
+var SKIP_REASON_UNKNOWN_PROVIDER = "unknown-provider";
+var SKIP_REASON_DELIVERY_ERROR = "delivery-error";
+function webhookPayload(ev) {
+  return {
+    v: PAYLOAD_VERSION,
+    ts: ev.ts,
+    agent: ev.agent,
+    event: ev.event,
+    project: ev.project,
+    summary: ev.summary
+  };
+}
+function titleLine(ev) {
+  return `turnbell: ${ev.agentTitle} ${ev.event} in ${ev.project}`;
+}
+function withoutKeys(headers, drop) {
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (!drop.includes(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function formatNtfy(ev, headers) {
+  return {
+    headers: {
+      ...headers,
+      Title: titleLine(ev),
+      Priority: ev.event === DONE_EVENT2 ? PRIORITY_DONE : PRIORITY_OTHER
+    },
+    body: ev.summary
+  };
+}
+function formatPushover(ev, headers) {
+  const form = new URLSearchParams();
+  const token = headers[PUSHOVER_TOKEN];
+  const user = headers[PUSHOVER_USER];
+  if (token !== void 0) {
+    form.set(PUSHOVER_TOKEN, token);
+  }
+  if (user !== void 0) {
+    form.set(PUSHOVER_USER, user);
+  }
+  form.set("title", titleLine(ev));
+  form.set("message", ev.summary);
+  return {
+    headers: {
+      ...withoutKeys(headers, [PUSHOVER_TOKEN, PUSHOVER_USER]),
+      "content-type": CONTENT_TYPE_FORM
+    },
+    body: form.toString()
+  };
+}
+function formatSlack(ev, headers) {
+  return {
+    headers: { ...headers, "content-type": CONTENT_TYPE_JSON },
+    body: JSON.stringify({ text: `${titleLine(ev)} \u2014 ${ev.summary}` })
+  };
+}
+function formatGeneric(ev, headers) {
+  return {
+    headers: { ...headers, "content-type": CONTENT_TYPE_JSON },
+    body: JSON.stringify(webhookPayload(ev))
+  };
+}
+var FORMATTERS = {
+  ntfy: formatNtfy,
+  pushover: formatPushover,
+  slack: formatSlack,
+  generic: formatGeneric
+};
+function urlAllowed(url, allowHttp) {
+  try {
+    const scheme = new URL(url).protocol;
+    if (scheme === HTTPS_SCHEME) {
+      return true;
+    }
+    if (scheme === HTTP_SCHEME2) {
+      return allowHttp;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function tryOnce(url, req, fetchFn) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, TIMEOUT_MS);
+  try {
+    const res = await fetchFn(url, {
+      method: "POST",
+      headers: req.headers,
+      body: req.body,
+      signal: controller.signal
+    });
+    return res.ok ? { kind: "ok" } : { kind: "http", status: res.status };
+  } catch {
+    return { kind: "network" };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function attemptDelivery(ev, target, req, fetchFn) {
+  const maxRetries = 1;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    const result = await tryOnce(target.url, req, fetchFn);
+    if (result.kind === "ok") {
+      return logLine(ev, OUTCOME_OK, target.name);
+    }
+    if (result.kind === "http") {
+      return logLine(ev, String(result.status), target.name);
+    }
+  }
+  return logLine(ev, OUTCOME_NETWORK_ERROR, target.name);
+}
+async function deliverTarget(ev, target, allowHttp, fetchFn) {
+  const httpAllowed = target.allowHttp ?? allowHttp;
+  if (!urlAllowed(target.url, httpAllowed)) {
+    return logLine(ev, OUTCOME_SKIP, target.name, SKIP_REASON_HTTP);
+  }
+  const formatter = FORMATTERS[target.provider];
+  if (formatter === void 0) {
+    return logLine(ev, OUTCOME_SKIP, target.name, SKIP_REASON_UNKNOWN_PROVIDER);
+  }
+  const req = formatter(ev, target.headers ?? {});
+  return attemptDelivery(ev, target, req, fetchFn);
+}
+async function deliverTargetSafe(ev, target, allowHttp, fetchFn) {
+  try {
+    return await deliverTarget(ev, target, allowHttp, fetchFn);
+  } catch {
+    return logLine(ev, OUTCOME_SKIP, target.name, SKIP_REASON_DELIVERY_ERROR);
+  }
+}
+function targetMatches(target, event) {
+  return Array.isArray(target.events) && target.events.includes(event);
+}
+function logLine(ev, status, name, reason) {
+  const base = `${ev.ts} ${status} ${name}`;
+  return reason === void 0 ? base : `${base} ${reason}`;
+}
+function readLogLines2(path) {
+  try {
+    return readFileSync7(path, "utf8").split("\n").filter((entry) => entry.length > 0);
+  } catch {
+    return [];
+  }
+}
+function appendLog(path, lines) {
+  if (lines.length === 0) {
+    return;
+  }
+  try {
+    mkdirSync6(dirname3(path), { recursive: true });
+    const all = [...readLogLines2(path), ...lines].slice(-LOG_CAP);
+    writeFileSync6(path, `${all.join("\n")}
+`);
+  } catch {
+  }
+}
+async function fireWebhooks2(ev, targets, opts) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const logPath = opts.logPath ?? join17(turnbellHome(), LOG_FILE);
+  const matched = targets.filter((target) => targetMatches(target, ev.event));
+  const lines = await Promise.all(
+    matched.map((target) => deliverTargetSafe(ev, target, opts.allowHttp, fetchFn))
+  );
+  appendLog(logPath, lines);
+}
+function hardenConfig(targets) {
+  const hasSecrets = targets.some(
+    (target) => target.headers !== void 0 && Object.keys(target.headers).length > 0
+  );
+  if (!hasSecrets) {
+    return;
+  }
+  try {
+    chmodSync(join17(turnbellHome(), CONFIG_FILE2), CONFIG_MODE);
+  } catch {
+  }
+}
+
+// src/cli/emit.ts
+var MAX_STDIN_BYTES = 1024 * 1024;
+var WEBHOOK_CAP_MS = 6e3;
+function capTimer(ms) {
+  let timer;
+  const promise = new Promise((resolve) => {
+    timer = setTimeout(resolve, ms);
+  });
+  return {
+    promise,
+    cancel: () => {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+async function settleWebhooks(pending) {
+  const cap = capTimer(WEBHOOK_CAP_MS);
+  try {
+    await Promise.race([pending, cap.promise]);
+  } catch {
+  } finally {
+    cap.cancel();
+  }
+}
+var EMPTY_PAYLOAD = "{}";
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject2(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return isRecord11(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseEmitFlags(args) {
+  const flags = {
+    agent: "",
+    event: "",
+    summary: null,
+    payloadStdin: false,
+    payloadArgv: null
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--payload-stdin") {
+      flags.payloadStdin = true;
+      continue;
+    }
+    index += consumeValueFlag(flags, arg, args[index + 1]);
+  }
+  return flags;
+}
+function consumeValueFlag(flags, flag, value) {
+  switch (flag) {
+    case "--agent":
+      flags.agent = value ?? "";
+      return 1;
+    case "--event":
+      flags.event = value ?? "";
+      return 1;
+    case "--summary":
+      flags.summary = value ?? null;
+      return 1;
+    case "--payload-argv":
+      flags.payloadArgv = value ?? null;
+      return 1;
+    default:
+      return 0;
+  }
+}
+async function resolvePayloadRaw(flags, deps) {
+  if (flags.payloadStdin) {
+    const raw = await deps.readStdin();
+    return Buffer.byteLength(raw, "utf8") > MAX_STDIN_BYTES ? EMPTY_PAYLOAD : raw;
+  }
+  if (flags.payloadArgv !== null) {
+    return flags.payloadArgv;
+  }
+  return EMPTY_PAYLOAD;
+}
+function stringField(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function buildEmitEvent(flags, payload, now) {
+  const cwd = stringField(payload.cwd, process.cwd());
+  const lastResponse = typeof payload.lastResponse === "string" ? payload.lastResponse : null;
+  return {
+    v: 1,
+    ts: now.toISOString(),
+    agent: flags.agent,
+    agentTitle: flags.agent,
+    event: flags.event,
+    cwd,
+    project: projectLabel(cwd),
+    summary: flags.summary ?? stringField(payload.summary, ""),
+    lastResponse
+  };
+}
+function normalizeEmit(flags, payload, now) {
+  const adapter = byId(flags.agent);
+  if (adapter === void 0) {
+    return buildEmitEvent(flags, payload, now);
+  }
+  return adapter.normalize(payload, flags.event);
+}
+var EXIT_NO_EVENT = 0;
+var READALOUD_MODE = "readaloud";
+var READALOUD_EVENT = "done";
+function isReadaloudEvent(cfg, event) {
+  if (event !== READALOUD_EVENT) {
+    return false;
+  }
+  const entry = cfg.events[event];
+  return isRecord11(entry) && entry.mode === READALOUD_MODE;
+}
+async function hydrateLastResponse(flags, event, payload, cfg) {
+  if (!isReadaloudEvent(cfg, event.event)) {
+    return;
+  }
+  const adapter = byId(flags.agent);
+  if (adapter === void 0) {
+    return;
+  }
+  event.lastResponse = await adapter.readLastResponse(payload);
+}
+async function runEmit(args, deps) {
+  const flags = parseEmitFlags(args);
+  const payload = parseJsonObject2(await resolvePayloadRaw(flags, deps));
+  const event = normalizeEmit(flags, payload, /* @__PURE__ */ new Date());
+  if (event === null) {
+    return EXIT_NO_EVENT;
+  }
+  const cfg = loadConfig(event.cwd);
+  hardenConfig(cfg.webhooks);
+  await hydrateLastResponse(flags, event, payload, cfg);
+  const code = route(
+    event,
+    cfg,
+    {
+      platform: deps.platform,
+      speak: deps.speak,
+      notify: deps.notify,
+      webhooks: (ev) => {
+        deps.webhooks(ev, cfg.webhooks, cfg.allowHttp);
+      }
+    },
+    /* @__PURE__ */ new Date()
+  );
+  await settleWebhooks(deps.awaitWebhooks());
+  try {
+    pruneReadaloudDir(readaloudTempDir(), /* @__PURE__ */ new Date());
+  } catch {
+  }
+  return code;
+}
+
+// src/cli/init.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join19 } from "path";
+import * as clack from "@clack/prompts";
+
+// src/cli/init-steps.ts
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
+import { join as join18 } from "path";
+
+// src/cli/init-sinks.ts
+var OS_DEFAULT_VOICE = "__os_default__";
+var MAX_PROMPT_ATTEMPTS = 5;
+var HTTPS_SCHEME2 = "https:";
+var HTTP_SCHEME3 = "http:";
+var PUSHOVER_PROVIDER = "pushover";
+var EVENT_NAMES = ["done", "blocked", "error"];
+var MODES = ["announce", "readaloud", "notify", "silent"];
+var PROVIDERS = ["ntfy", "pushover", "slack", "generic"];
+var QUIET_HOURS_OPTIONS = ["fire", "suppress"];
+var QUIET_HOURS_RE = /^([01]\d|2[0-3]):[0-5]\d-([01]\d|2[0-3]):[0-5]\d$/;
+async function collectOpenCommand(io, events, existing, defaultOpen) {
+  if (events.done.mode !== "readaloud") {
+    return existing.readaloud.openCommand;
+  }
+  io.note(
+    "Read-aloud keeps responses suitable for listening; code and extra detail open in your markdown viewer instead of being spoken."
+  );
+  const seed = existing.readaloud.openCommand.length > 0 ? existing.readaloud.openCommand : defaultOpen;
+  const raw = (await io.text({ message: "Command to open a markdown file", initialValue: seed })).trim();
+  return raw.length === 0 ? seed : raw;
+}
+async function collectModes(io, existing) {
+  const events = structuredClone(existing.events);
+  for (const event of EVENT_NAMES) {
+    const mode = await io.select({
+      message: `How should "${event}" events be announced?`,
+      options: MODES.map((value) => ({ value, label: value })),
+      initialValue: existing.events[event].mode
+    });
+    events[event] = { mode };
+  }
+  return events;
+}
+async function collectVoice(io, enumerate, existing) {
+  const voice = structuredClone(existing.voice);
+  const pickInstalled = await io.confirm({
+    message: "Choose from installed voices? (otherwise the OS default voice is used)",
+    initialValue: existing.voice.name !== null
+  });
+  if (!pickInstalled) {
+    voice.name = null;
+    return voice;
+  }
+  const names = enumerate();
+  if (names.length === 0) {
+    io.note("No installed voices found; using the OS default voice.");
+    return voice;
+  }
+  const chosen = await io.select({
+    message: "Voice",
+    options: [
+      { value: OS_DEFAULT_VOICE, label: "OS default" },
+      ...names.map((name) => ({ value: name, label: name }))
+    ],
+    initialValue: existing.voice.name ?? OS_DEFAULT_VOICE
+  });
+  voice.name = chosen === OS_DEFAULT_VOICE ? null : chosen;
+  return voice;
+}
+async function collectSound(io, existing) {
+  const name = (await io.text({
+    message: "Notification sound name (leave blank for none)",
+    initialValue: existing.notify.sound ?? ""
+  })).trim();
+  return name.length === 0 ? null : name;
+}
+async function promptQuietHours(io, existing) {
+  const seed = existing.quietHours ?? "";
+  for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt += 1) {
+    const raw = (await io.text({
+      message: "Quiet hours as HH:MM-HH:MM (leave blank for none)",
+      initialValue: seed
+    })).trim();
+    if (raw.length === 0) {
+      return null;
+    }
+    if (QUIET_HOURS_RE.test(raw)) {
+      return raw;
+    }
+    io.note("Invalid format; expected HH:MM-HH:MM (e.g. 22:00-08:00).");
+  }
+  return null;
+}
+async function collectQuietHours(io, existing) {
+  const spec = await promptQuietHours(io, existing);
+  if (spec === null) {
+    return { spec: null, webhooks: existing.quietHoursWebhooks };
+  }
+  const webhooks = await io.select({
+    message: "During quiet hours, webhooks should",
+    options: QUIET_HOURS_OPTIONS.map((value) => ({ value, label: value })),
+    initialValue: existing.quietHoursWebhooks
+  });
+  return { spec, webhooks };
+}
+function urlScheme2(url) {
+  try {
+    return new URL(url).protocol;
+  } catch {
+    return null;
+  }
+}
+async function promptWebhookUrl(io) {
+  for (let attempt = 0; attempt < MAX_PROMPT_ATTEMPTS; attempt += 1) {
+    const url = (await io.text({ message: "Webhook URL (https)" })).trim();
+    const scheme = urlScheme2(url);
+    if (scheme === HTTPS_SCHEME2) {
+      return { url, allowHttp: false };
+    }
+    if (scheme === HTTP_SCHEME3) {
+      const allow = await io.confirm({
+        message: "That URL is insecure http \u2014 send events over http anyway?",
+        initialValue: false
+      });
+      if (allow) {
+        return { url, allowHttp: true };
+      }
+      io.note("Enter an https:// URL instead.");
+      continue;
+    }
+    io.note("Invalid URL; it must start with https:// (or http:// if you opt in).");
+  }
+  return null;
+}
+async function collectHeaders(io) {
+  const headers = {};
+  let more = await io.confirm({ message: "Add request headers?", initialValue: false });
+  while (more) {
+    const key = (await io.text({ message: "Header name (blank to finish)" })).trim();
+    if (key.length === 0) {
+      break;
+    }
+    headers[key] = await io.text({ message: `Value for "${key}"` });
+    more = await io.confirm({ message: "Add another header?", initialValue: false });
+  }
+  return headers;
+}
+async function collectOneWebhook(io) {
+  const provider = await io.select({
+    message: "Webhook provider",
+    options: PROVIDERS.map((value) => ({ value, label: value })),
+    initialValue: "ntfy"
+  });
+  const name = (await io.text({ message: "A name for this webhook", initialValue: provider })).trim();
+  const resolved = await promptWebhookUrl(io);
+  if (resolved === null) {
+    io.note("No valid URL provided; skipping this webhook.");
+    return null;
+  }
+  const events = await io.multiselect({
+    message: "Which events fire this webhook?",
+    options: EVENT_NAMES.map((value) => ({ value, label: value })),
+    initialValues: [...EVENT_NAMES],
+    required: true
+  });
+  if (provider === PUSHOVER_PROVIDER) {
+    io.note('Pushover: put your app "token" and "user" key in headers.');
+  }
+  const headers = await collectHeaders(io);
+  const target = {
+    name: name.length === 0 ? provider : name,
+    provider,
+    url: resolved.url,
+    events
+  };
+  if (Object.keys(headers).length > 0) {
+    target.headers = headers;
+  }
+  if (resolved.allowHttp) {
+    target.allowHttp = true;
+  }
+  return target;
+}
+async function collectWebhooks(io, existing) {
+  const targets = existing.webhooks.map((target) => structuredClone(target));
+  let add = await io.confirm({ message: "Add a webhook?", initialValue: false });
+  while (add) {
+    const built = await collectOneWebhook(io);
+    if (built !== null) {
+      targets.push(built);
+    }
+    add = await io.confirm({ message: "Add another webhook?", initialValue: false });
+  }
+  return targets;
+}
+async function collectSinkConfig(io, enumerate, existing, defaultOpen) {
+  const config = structuredClone(existing);
+  config.events = await collectModes(io, existing);
+  config.readaloud = {
+    ...config.readaloud,
+    openCommand: await collectOpenCommand(io, config.events, existing, defaultOpen)
+  };
+  config.voice = await collectVoice(io, enumerate, existing);
+  config.notify = { ...config.notify, sound: await collectSound(io, existing) };
+  const quiet = await collectQuietHours(io, existing);
+  config.quietHours = quiet.spec;
+  config.quietHoursWebhooks = quiet.webhooks;
+  config.webhooks = await collectWebhooks(io, existing);
+  return config;
+}
+
+// src/cli/init-steps.ts
+var CONFIG_FILE3 = "config.json";
+var JSON_INDENT2 = 2;
+var XCODE_SELECT_FIX = "xcode-select --install";
+var CHECK_MARK = "\u2713";
+var CROSS_MARK = "\u2717";
+function adapterDeps(deps) {
+  return { home: deps.home, which: deps.which };
+}
+function isWired(wiredKeys, id) {
+  return wiredKeys.some(
+    (key) => key !== readaloudLedgerKey(id) && (key.split(":")[0] ?? key) === id
+  );
+}
+function capabilityBadges(caps) {
+  const badge = (ok, label) => `${ok ? CHECK_MARK : CROSS_MARK}${label}`;
+  return [
+    badge(caps.done, "done"),
+    badge(caps.blocked, "blocked"),
+    badge(caps.readAloud, "read-aloud"),
+    badge(caps.slashCommand, "slash")
+  ].join(" ");
+}
+function agentOption(adapter, detection) {
+  const flags = [];
+  if (!detection.installed) {
+    flags.push("not detected");
+  }
+  if (detection.degraded !== void 0) {
+    flags.push("degraded");
+  }
+  const badges = capabilityBadges(adapter.capabilities);
+  const hint = flags.length === 0 ? badges : `${badges} \xB7 ${flags.join(", ")}`;
+  return { value: adapter.id, label: `${adapter.title} \u2014 ${adapter.tagline}`, hint };
+}
+var CONFIG_MODE2 = 384;
+function writeGlobalConfig(config) {
+  const home = turnbellHome();
+  mkdirSync7(home, { recursive: true });
+  const path = join18(home, CONFIG_FILE3);
+  writeFileSync7(path, `${JSON.stringify(config, null, JSON_INDENT2)}
+`, {
+    encoding: "utf8",
+    mode: CONFIG_MODE2
+  });
+  hardenConfig(config.webhooks);
+  return path;
+}
+function noteBetaPlatform(deps) {
+  if (deps.platform.id === "linux" || deps.platform.id === "win32") {
+    deps.io.note(
+      `${deps.platform.id} support is beta \u2014 engines are mock-tested, not yet live-verified.`,
+      "Beta platform"
+    );
+  }
+}
+async function stepMigrate(deps) {
+  if (!deps.detectV1()) {
+    return;
+  }
+  const doImport = await deps.io.confirm({
+    message: "A turnbell v1 config was found. Import it?",
+    initialValue: true
+  });
+  if (!doImport) {
+    return;
+  }
+  const migrated = deps.migrate();
+  deps.io.note(
+    migrated ? "Imported your v1 config." : "Nothing imported (a v2 config already exists)."
+  );
+}
+function formatFailingCheck(check) {
+  const fix = check.fix === null ? "" : `
+   fix: ${check.fix}`;
+  return `${CROSS_MARK} ${check.label} \u2014 ${check.detail}${fix}`;
+}
+async function stepDoctor(deps) {
+  const checks = await checkAll({
+    which: deps.which,
+    platform: deps.platform,
+    adapters: deps.adapters,
+    home: deps.home
+  });
+  if (allRequiredOk(checks)) {
+    return true;
+  }
+  const failing = checks.filter((check) => check.required && !check.ok);
+  deps.io.note(failing.map(formatFailingCheck).join("\n"), "Missing prerequisites");
+  for (const check of failing) {
+    if (check.fix === XCODE_SELECT_FIX) {
+      const run2 = await deps.io.confirm({
+        message: `Run \`${check.fix}\` now?`,
+        initialValue: false
+      });
+      if (run2) {
+        deps.autoRunFix(check.fix);
+      }
+    }
+  }
+  return deps.io.confirm({ message: "Continue setup anyway?", initialValue: false });
+}
+function wireSummary(adapter) {
+  const caps = adapter.capabilities;
+  const parts = [];
+  const alerts = [];
+  if (caps.done) {
+    alerts.push("done");
+  }
+  if (caps.blocked) {
+    alerts.push("needs-input");
+  }
+  if (alerts.length > 0) {
+    parts.push(`${alerts.join(" + ")} alerts`);
+  }
+  if (caps.readAloud) {
+    parts.push("read-aloud");
+  }
+  if (caps.slashCommand) {
+    parts.push("/turnbell command");
+  }
+  if (parts.length === 0) {
+    return adapter.title;
+  }
+  return `${adapter.title}: ${parts.join(", ")}`;
+}
+async function wireAgent(deps, adapter) {
+  const result = await adapter.wire(adapterDeps(deps));
+  for (const warning of result.warnings) {
+    deps.io.note(warning, "Warning");
+  }
+  if (!result.changed) {
+    deps.io.note(`${adapter.title} is already configured.`);
+    return;
+  }
+  deps.io.note(
+    `${wireSummary(adapter)}
+Silence it here anytime with \`turnbell off\`.`,
+    `${adapter.title} \u2014 set up`
+  );
+  const seeDiff = await deps.io.confirm({
+    message: "Show exactly what changed?",
+    initialValue: false
+  });
+  if (seeDiff) {
+    deps.io.note(result.diff, `${adapter.title} \u2014 changes applied`);
+  }
+  const keep = await deps.io.confirm({
+    message: `Keep these changes to ${adapter.title}?`,
+    initialValue: true
+  });
+  if (!keep) {
+    await adapter.unwire(adapterDeps(deps));
+    deps.io.note(`Reverted ${adapter.title}.`);
+  }
+}
+async function stepAgents(deps) {
+  const detections = await Promise.all(
+    deps.adapters.map((adapter) => adapter.detect(adapterDeps(deps)))
+  );
+  const wiredKeys = listWiredKeys();
+  const options = deps.adapters.map(
+    (adapter, index) => agentOption(adapter, detections[index] ?? { installed: false })
+  );
+  const initialValues = deps.adapters.filter((adapter) => isWired(wiredKeys, adapter.id)).map((adapter) => adapter.id);
+  const selected = await deps.io.multiselect({
+    message: "Select the agents turnbell should wire (space to toggle)",
+    options,
+    initialValues,
+    required: false
+  });
+  const selectedSet = new Set(selected);
+  for (const adapter of deps.adapters) {
+    const wired = isWired(wiredKeys, adapter.id);
+    const picked = selectedSet.has(adapter.id);
+    if (picked && !wired) {
+      await wireAgent(deps, adapter);
+    } else if (!picked && wired) {
+      await adapter.unwire(adapterDeps(deps));
+      deps.io.note(`Unwired ${adapter.title}.`);
+    }
+  }
+}
+async function stepActivation(io, current) {
+  const choice = await io.select({
+    message: "When should turnbell speak up?",
+    options: [
+      { value: "all", label: "In every project \u2014 turn it off where you don't want it" },
+      { value: "opt-in", label: "Only in projects I turn on" }
+    ],
+    initialValue: current
+  });
+  if (choice === "opt-in") {
+    io.note("turnbell will stay quiet until you run `turnbell on` inside a project.");
+  }
+  return choice;
+}
+async function stepInjectInstructions(deps, config, interactive) {
+  const wiredKeys = listWiredKeys();
+  const wantReadaloud = config.events.done.mode === "readaloud";
+  for (const adapter of deps.adapters) {
+    if (!adapter.capabilities.instructionInjection || adapter.memoryPath === void 0) {
+      continue;
+    }
+    if (!wantReadaloud || !isWired(wiredKeys, adapter.id)) {
+      unwireFromLedger(readaloudLedgerKey(adapter.id));
+      continue;
+    }
+    const path = adapter.memoryPath(adapterDeps(deps));
+    const op = injectReadaloud(path, config.readaloud.openCommand, adapter.id);
+    if (!op.changed) {
+      continue;
+    }
+    if (!interactive) {
+      op.apply();
+      continue;
+    }
+    deps.io.note(
+      `${adapter.title}: a read-aloud instruction is ready for ${path} \u2014 kept only if you confirm below (reversible: re-run \`turnbell init\` with read-aloud off, or \`turnbell uninstall\`).`
+    );
+    const seeDiff = await deps.io.confirm({
+      message: "Show exactly what changed?",
+      initialValue: false
+    });
+    if (seeDiff) {
+      deps.io.note(op.diff, `${adapter.title} \u2014 read-aloud instruction`);
+    }
+    const keep = await deps.io.confirm({
+      message: `Keep this for ${adapter.title}?`,
+      initialValue: true
+    });
+    if (keep) {
+      op.apply();
+    }
+  }
+}
+async function stepSummary(io, config) {
+  const lines = [
+    `done: ${config.events.done.mode}`,
+    `blocked: ${config.events.blocked.mode}`,
+    `error: ${config.events.error.mode}`,
+    `voice: ${config.voice.name ?? "OS default"}`,
+    `quiet hours: ${config.quietHours ?? "none"}`,
+    `webhooks: ${config.webhooks.length}`
+  ];
+  io.note(lines.join("\n"), "turnbell is configured");
+  return io.confirm({ message: "Preview it now with `turnbell test`?", initialValue: true });
+}
+async function runInitYes(deps) {
+  if (deps.detectV1()) {
+    deps.migrate();
+  }
+  const detections = await Promise.all(
+    deps.adapters.map((adapter) => adapter.detect(adapterDeps(deps)))
+  );
+  for (const [index, adapter] of deps.adapters.entries()) {
+    if (detections[index]?.installed === true) {
+      await adapter.wire(adapterDeps(deps));
+    }
+  }
+  const cwd = process.cwd();
+  const loaded = isConfigured(cwd) ? loadConfig(cwd) : structuredClone(DEFAULTS);
+  const config = migrateHttpOptIn(loaded).config;
+  if (config.readaloud.openCommand.length === 0) {
+    config.readaloud.openCommand = defaultOpenCommand(deps.platform.id);
+  }
+  await stepInjectInstructions(deps, config, false);
+  const configPath2 = writeGlobalConfig(config);
+  return { runTest: false, configPath: configPath2 };
+}
+async function runInit(deps, opts) {
+  if (opts.yes) {
+    return runInitYes(deps);
+  }
+  noteBetaPlatform(deps);
+  await stepMigrate(deps);
+  const proceed = await stepDoctor(deps);
+  if (!proceed) {
+    return { runTest: false, configPath: null };
+  }
+  await stepAgents(deps);
+  const existing = migrateHttpOptIn(loadConfig(process.cwd())).config;
+  const activation = await stepActivation(deps.io, existing.activation);
+  const config = await collectSinkConfig(
+    deps.io,
+    deps.enumerateVoices,
+    existing,
+    defaultOpenCommand(deps.platform.id)
+  );
+  config.activation = activation;
+  await stepInjectInstructions(deps, config, true);
+  const configPath2 = writeGlobalConfig(config);
+  const runTest2 = await stepSummary(deps.io, config);
+  return { runTest: runTest2, configPath: configPath2 };
+}
+
+// src/cli/uninstall.ts
+import { rmSync as rmSync3 } from "fs";
+var EXIT_OK2 = 0;
+var READALOUD_SUFFIX = ":readaloud";
+function keyLabel(key) {
+  const id = key.split(":")[0] ?? key;
+  return byId(id)?.title ?? key;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runUninstall(io, deps) {
+  const keys = listWiredKeys();
+  if (keys.length === 0) {
+    io.note("No wired integrations found.");
+  } else {
+    io.note(keys.map((key) => `- ${keyLabel(key)} (${key})`).join("\n"), "Will unwire");
+  }
+  const proceed = await io.confirm({
+    message: "Reverse every turnbell integration?",
+    initialValue: false
+  });
+  if (!proceed) {
+    io.note("Nothing changed.");
+    return EXIT_OK2;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    const id = key.split(":")[0] ?? key;
+    const adapter = byId(id);
+    const label = keyLabel(key);
+    if (adapter !== void 0 && !key.endsWith(READALOUD_SUFFIX)) {
+      if (!seen.has(id)) {
+        seen.add(id);
+        try {
+          await adapter.unwire(deps);
+          io.note(`Unwired ${label}.`);
+        } catch (error) {
+          io.note(`Could not fully reverse ${label}: ${errorMessage(error)}`);
+        }
+      }
+    } else {
+      try {
+        unwireFromLedger(key);
+        io.note(`Unwired ${label}.`);
+      } catch (error) {
+        io.note(`Could not fully reverse ${label}: ${errorMessage(error)}`);
+      }
+    }
+  }
+  const deleteHome = await io.confirm({
+    message: "Also delete turnbell's config, logs, and ledger (TURNBELL_HOME)?",
+    initialValue: false
+  });
+  if (deleteHome) {
+    rmSync3(turnbellHome(), { recursive: true, force: true });
+    io.note("Deleted TURNBELL_HOME.");
+  }
+  return EXIT_OK2;
+}
+
+// src/cli/init.ts
+var EXIT_OK3 = 0;
+var CANCEL_MESSAGE = "Setup cancelled.";
+var V1_CONFIG = [".claude", "hollr", "config.json"];
+function unwrap(value) {
+  if (clack.isCancel(value)) {
+    clack.cancel(CANCEL_MESSAGE);
+    throw new Error(CANCEL_MESSAGE);
+  }
+  return value;
+}
+function toClackOptions(options) {
+  return options.map((option) => ({
+    value: option.value,
+    label: option.label,
+    ...option.hint === void 0 ? {} : { hint: option.hint }
+  }));
+}
+function clackIo() {
+  return {
+    async multiselect(opts) {
+      const chosen = unwrap(
+        await clack.multiselect({
+          message: opts.message,
+          options: toClackOptions(opts.options),
+          ...opts.initialValues === void 0 ? {} : { initialValues: opts.initialValues },
+          required: opts.required ?? false
+        })
+      );
+      return chosen;
+    },
+    async select(opts) {
+      const chosen = unwrap(
+        await clack.select({
+          message: opts.message,
+          options: toClackOptions(opts.options),
+          ...opts.initialValue === void 0 ? {} : { initialValue: opts.initialValue }
+        })
+      );
+      return chosen;
+    },
+    async text(opts) {
+      return unwrap(
+        await clack.text({
+          message: opts.message,
+          ...opts.placeholder === void 0 ? {} : { placeholder: opts.placeholder },
+          ...opts.initialValue === void 0 ? {} : { initialValue: opts.initialValue }
+        })
+      );
+    },
+    async confirm(opts) {
+      return unwrap(
+        await clack.confirm({
+          message: opts.message,
+          initialValue: opts.initialValue ?? false
+        })
+      );
+    },
+    note(message, title) {
+      clack.note(message, title);
+    }
+  };
+}
+function enumerateVoices(platform) {
+  const argv = platform.enumerateVoicesArgv();
+  const command = argv?.[0];
+  if (argv === null || command === void 0) {
+    return [];
+  }
+  const result = spawnSync(command, argv.slice(1), { encoding: "utf8" });
+  if (result.status !== 0 || typeof result.stdout !== "string") {
+    return [];
+  }
+  return platform.parseVoicesOutput(result.stdout);
+}
+function autoRunFix(command) {
+  const parts = command.split(" ");
+  const bin = parts[0];
+  if (bin === void 0) {
+    return;
+  }
+  spawnSync(bin, parts.slice(1), { stdio: "inherit" });
+}
+function realInitDeps() {
+  const platform = selectPlatform();
+  return {
+    io: clackIo(),
+    adapters,
+    platform,
+    home: homedir3(),
+    which: whichOnPath,
+    detectV1: () => existsSync6(join19(homedir3(), ...V1_CONFIG)),
+    migrate: migrateV1,
+    enumerateVoices: () => enumerateVoices(platform),
+    autoRunFix
+  };
+}
+async function runInitCli(argv, runTestFn) {
+  const yes = argv.includes("--yes") || argv.includes("-y");
+  clack.intro("turnbell setup");
+  const result = await runInit(realInitDeps(), { yes });
+  if (result.configPath === null) {
+    clack.outro("Setup stopped \u2014 nothing was written.");
+    return EXIT_OK3;
+  }
+  clack.outro(`Wrote ${result.configPath}`);
+  if (result.runTest) {
+    await runTestFn();
+  }
+  return EXIT_OK3;
+}
+function runUninstallCli() {
+  clack.intro("turnbell uninstall");
+  return runUninstall(clackIo(), { home: homedir3(), which: whichOnPath });
+}
+
+// src/cli/mute.ts
+import { mkdirSync as mkdirSync8, unlinkSync as unlinkSync3, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname4, join as join20 } from "path";
+var PROJECTS_DIR = "projects";
+var MUTED_SUFFIX = ".muted";
+var ENABLED_SUFFIX2 = ".enabled";
+var EXIT_OK4 = 0;
+function muteFlagPath2(cwd) {
+  return join20(turnbellHome(), PROJECTS_DIR, `${encodeCwd(cwd)}${MUTED_SUFFIX}`);
+}
+function enabledFlagPath(cwd) {
+  return join20(turnbellHome(), PROJECTS_DIR, `${encodeCwd(cwd)}${ENABLED_SUFFIX2}`);
+}
+function desiredState(sub, cwd) {
+  if (sub === "on") {
+    return true;
+  }
+  if (sub === "off") {
+    return false;
+  }
+  return !isMuted(cwd);
+}
+function createFlag(path) {
+  try {
+    mkdirSync8(dirname4(path), { recursive: true });
+    writeFileSync8(path, "");
+  } catch (cause) {
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(`could not write mute flag at ${path}: ${reason}`);
+  }
+}
+function removeFlag(path) {
+  try {
+    unlinkSync3(path);
+  } catch {
+  }
+}
+function setProjectState(on, cwd) {
+  const mutedPath = muteFlagPath2(cwd);
+  const enabledPath = enabledFlagPath(cwd);
+  if (on) {
+    createFlag(enabledPath);
+    removeFlag(mutedPath);
+  } else {
+    createFlag(mutedPath);
+    removeFlag(enabledPath);
+  }
+  const label = projectLabel(cwd);
+  process.stdout.write(`turnbell: ${on ? "on for" : "off for"} ${label}
+`);
+  return EXIT_OK4;
+}
+function runMute(args, cwd) {
+  const muted = desiredState(args[0], cwd);
+  return setProjectState(!muted, cwd);
+}
+
+// src/cli/run.ts
+import { basename as basename3 } from "path";
+import { StringDecoder } from "string_decoder";
+var SEPARATOR = "--";
+var STREAM_FLAG = "--announce-stream";
+var STREAM_FORMAT_CURSOR = "cursor";
+var RESULT_EVENT_TYPE = "result";
+var RESULT_TEXT_FIELD = "result";
+var LINE_SEPARATOR = "\n";
+var WRAPPER_AGENT = "wrapper";
+var EVENT_DONE = "done";
+var EVENT_ERROR = "error";
+var EXIT_OK5 = 0;
+var EXIT_USAGE = 2;
+var STREAM_DRAIN_GRACE_MS = 2e3;
+var SPAWN_FAILED = 127;
+var SIGNAL_EXIT_CODE = 1;
+var RUN_USAGE = "usage: turnbell run [--announce-stream cursor] -- <cmd> [args...]";
+function isRecord12(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseStreamFlag(pre) {
+  const index = pre.indexOf(STREAM_FLAG);
+  if (index === -1) {
+    return { cursor: false };
+  }
+  const value = pre[index + 1];
+  if (value !== STREAM_FORMAT_CURSOR) {
+    return { cursor: false, error: `unsupported stream format: ${value ?? ""}` };
+  }
+  return { cursor: true };
+}
+function parseRunArgs(args) {
+  const separator = args.indexOf(SEPARATOR);
+  if (separator === -1) {
+    return { error: "missing `--` before the command" };
+  }
+  const child = args.slice(separator + 1);
+  const command = child[0];
+  if (command === void 0) {
+    return { error: "no command given after `--`" };
+  }
+  const stream = parseStreamFlag(args.slice(0, separator));
+  if (stream.error !== void 0) {
+    return { error: stream.error };
+  }
+  return { streamCursor: stream.cursor, command, commandArgs: child.slice(1) };
+}
+function parseCursorResult(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (!isRecord12(parsed) || parsed.type !== RESULT_EVENT_TYPE) {
+    return null;
+  }
+  const text2 = parsed[RESULT_TEXT_FIELD];
+  return typeof text2 === "string" ? text2 : null;
+}
+function createResultParser(out) {
+  let lastResponse = null;
+  let buffer = "";
+  const consume = (line) => {
+    const found = parseCursorResult(line);
+    if (found !== null) {
+      lastResponse = found;
+    }
+  };
+  return {
+    feed(text2) {
+      if (text2.length === 0) {
+        return;
+      }
+      out(text2);
+      buffer += text2;
+      const parts = buffer.split(LINE_SEPARATOR);
+      buffer = parts.pop() ?? "";
+      for (const line of parts) {
+        consume(line);
+      }
+    },
+    flush() {
+      consume(buffer);
+      buffer = "";
+    },
+    read: () => lastResponse
+  };
+}
+function attachStreamCapture(child, deps) {
+  const parser = createResultParser(deps.out);
+  const stdout = child.stdout;
+  if (stdout === null) {
+    return { read: parser.read, drained: Promise.resolve() };
+  }
+  let resolveDrained = null;
+  const drained = new Promise((resolve) => {
+    resolveDrained = resolve;
+  });
+  const decoder = new StringDecoder("utf8");
+  stdout.on("data", (chunk) => {
+    parser.feed(decoder.write(chunk));
+  });
+  stdout.on("end", () => {
+    parser.feed(decoder.end());
+    parser.flush();
+    resolveDrained?.();
+  });
+  return { read: parser.read, drained };
+}
+function buildWrapperEvent(deps, command, exitCode, lastResponse) {
+  const now = deps.now();
+  return {
+    v: 1,
+    ts: now.toISOString(),
+    agent: WRAPPER_AGENT,
+    agentTitle: basename3(command),
+    event: exitCode === EXIT_OK5 ? EVENT_DONE : EVENT_ERROR,
+    cwd: deps.cwd,
+    project: projectLabel(deps.cwd),
+    summary: "",
+    lastResponse
+  };
+}
+async function emitEvent(deps, event) {
+  const cfg = loadConfig(event.cwd);
+  hardenConfig(cfg.webhooks);
+  route(
+    event,
+    cfg,
+    {
+      platform: deps.platform,
+      speak: deps.speak,
+      notify: deps.notify,
+      webhooks: (ev) => {
+        deps.webhooks(ev, cfg.webhooks, cfg.allowHttp);
+      }
+    },
+    deps.now()
+  );
+  await settleWebhooks(deps.awaitWebhooks());
+}
+async function finishExit(deps, command, exitCode, capture) {
+  try {
+    const lastResponse = exitCode === EXIT_OK5 && capture !== null ? capture() : null;
+    await emitEvent(deps, buildWrapperEvent(deps, command, exitCode, lastResponse));
+  } catch {
+  }
+}
+function awaitChild(child, deps, command, capture) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      const read = capture !== null ? capture.read : null;
+      void finishExit(deps, command, code, read).finally(() => {
+        resolve(code);
+      });
+    };
+    child.on("error", () => {
+      finish(SPAWN_FAILED);
+    });
+    child.on("exit", (code) => {
+      const graced = capture === null ? Promise.resolve() : Promise.race([capture.drained, deps.delay(STREAM_DRAIN_GRACE_MS)]);
+      void graced.then(() => {
+        finish(code ?? SIGNAL_EXIT_CODE);
+      });
+    });
+  });
+}
+function runWrapper(args, deps) {
+  const parsed = parseRunArgs(args);
+  if ("error" in parsed) {
+    process.stderr.write(`turnbell run: ${parsed.error}
+${RUN_USAGE}
+`);
+    return Promise.resolve(EXIT_USAGE);
+  }
+  const mode = parsed.streamCursor ? "stream" : "inherit";
+  const child = deps.spawn(parsed.command, parsed.commandArgs, mode);
+  const capture = parsed.streamCursor ? attachStreamCapture(child, deps) : null;
+  return awaitChild(child, deps, parsed.command, capture);
+}
+
+// src/cli/test.ts
+var TEST_AGENT = "turnbell-test";
+var TEST_TITLE = "turnbell";
+var TEST_EVENT = "done";
+var TEST_SUMMARY = "turnbell test";
+var PAYLOAD_INDENT = 2;
+var EXIT_OK6 = 0;
+function parseTestFlags(args) {
+  return {
+    webhook: args.includes("--webhook"),
+    showPayload: args.includes("--show-payload")
+  };
+}
+function buildTestEvent(cwd, now) {
+  return {
+    v: 1,
+    ts: now.toISOString(),
+    agent: TEST_AGENT,
+    agentTitle: TEST_TITLE,
+    event: TEST_EVENT,
+    cwd,
+    project: projectLabel(cwd),
+    summary: TEST_SUMMARY
+  };
+}
+async function runTest(args, deps, now) {
+  const flags = parseTestFlags(args);
+  const event = buildTestEvent(deps.cwd, now);
+  if (flags.showPayload) {
+    deps.out(`${JSON.stringify(webhookPayload(event), null, PAYLOAD_INDENT)}
+`);
+    return EXIT_OK6;
+  }
+  const cfg = loadConfig(deps.cwd);
+  const code = route(
+    event,
+    cfg,
+    {
+      platform: deps.platform,
+      speak: deps.speak,
+      notify: deps.notify,
+      webhooks: (ev) => {
+        if (flags.webhook) {
+          deps.webhooks(ev, cfg.webhooks, cfg.allowHttp);
+        }
+      }
+    },
+    now
+  );
+  await settleWebhooks(deps.awaitWebhooks());
+  return code;
+}
+
+// src/cli/status.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join21 } from "path";
+var LOG_TAIL = 5;
+var WEBHOOK_LOG = "webhook.log";
+var EVENTS_LOG2 = "events.log";
+var EXIT_OK7 = 0;
+var NONE = "none";
+var UNKNOWN_MODE = "unknown";
+var DEFAULT_VOICE = "system default";
+var MS_PER_MINUTE = 6e4;
+var EVENT_NAMES2 = ["done", "blocked", "error"];
+function isRecord13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function wiredLabel(key) {
+  const id = key.split(":")[0] ?? key;
+  return byId(id)?.title ?? key;
+}
+function eventMode(config, event) {
+  const events = config.events;
+  if (isRecord13(events)) {
+    const entry = events[event];
+    if (isRecord13(entry) && typeof entry.mode === "string") {
+      return entry.mode;
+    }
+  }
+  return UNKNOWN_MODE;
+}
+function webhookNames(config) {
+  const targets = config.webhooks;
+  if (!Array.isArray(targets)) {
+    return [];
+  }
+  return targets.map((target) => isRecord13(target) && typeof target.name === "string" ? target.name : "").filter((name) => name.length > 0);
+}
+function section(title, lines) {
+  const body = lines.length === 0 ? [`  ${NONE}`] : lines.map((line) => `  ${line}`);
+  return [`${title}:`, ...body].join("\n");
+}
+function wiredSection(keys) {
+  const labels = [...new Set(keys.map(wiredLabel))];
+  return section("Wired adapters", labels);
+}
+function eventsSection(config) {
+  return section(
+    "Events",
+    EVENT_NAMES2.map((event) => `${event}: ${eventMode(config, event)}`)
+  );
+}
+function configSection(config) {
+  const voice = config.voice.name ?? DEFAULT_VOICE;
+  return [
+    `Voice: ${voice} @ ${config.voice.rateWpm} wpm`,
+    `Quiet hours: ${config.quietHours ?? NONE}`,
+    `Webhooks: ${webhookNames(config).join(", ") || NONE}`
+  ].join("\n");
+}
+function scopeLine(activation) {
+  return activation === "opt-in" ? "Notifications: on only where you turn it on" : "Notifications: on in every project";
+}
+function projectStateLine(model) {
+  if (model.muted) {
+    return "This project: off for this project \u2014 run 'turnbell on' to enable";
+  }
+  if (model.enabled) {
+    return "This project: on for this project";
+  }
+  if (model.activation === "opt-in") {
+    return "This project: not turned on here \u2014 run 'turnbell on' to enable";
+  }
+  return "This project: on for this project";
+}
+function quietLine(quiet) {
+  if (!quiet.active) {
+    return "Quiet: no";
+  }
+  if (quiet.remainingMinutes === null) {
+    return "Quiet: quiet until you run 'turnbell quiet off'";
+  }
+  return `Quiet: quiet for ${quiet.remainingMinutes} more minutes`;
+}
+function projectSection(model) {
+  return [
+    `Project: ${projectLabel(model.cwd)} (${model.cwd})`,
+    scopeLine(model.activation),
+    projectStateLine(model),
+    quietLine(model.quiet),
+    `Pause/resume: ${model.canPauseResume ? "supported" : "unsupported"}`
+  ].join("\n");
+}
+function formatStatus(model) {
+  return [
+    "turnbell status",
+    wiredSection(model.wiredKeys),
+    eventsSection(model.config),
+    configSection(model.config),
+    projectSection(model),
+    section("Recent webhook deliveries", model.webhookLog),
+    section("Recent events", model.eventsLog),
+    ""
+  ].join("\n\n");
+}
+function readLogTail(path) {
+  try {
+    return readFileSync8(path, "utf8").split("\n").filter((line) => line.length > 0).slice(-LOG_TAIL);
+  } catch {
+    return [];
+  }
+}
+function readQuietRemaining(now) {
+  try {
+    const raw = readFileSync8(quietUntilPath(), "utf8").trim();
+    if (!/^-?\d+$/.test(raw)) {
+      return null;
+    }
+    const remaining = Number.parseInt(raw, 10) - now.getTime();
+    return remaining > 0 ? remaining : null;
+  } catch {
+    return null;
+  }
+}
+function runStatus(io) {
+  const home = turnbellHome();
+  const config = loadConfig(io.cwd);
+  const now = /* @__PURE__ */ new Date();
+  const quietMs = readQuietRemaining(now);
+  const model = {
+    cwd: io.cwd,
+    config,
+    muted: isMuted(io.cwd),
+    enabled: isProjectEnabled(io.cwd),
+    activation: config.activation,
+    quiet: {
+      active: quietActive(now),
+      remainingMinutes: quietMs === null ? null : Math.ceil(quietMs / MS_PER_MINUTE)
+    },
+    canPauseResume: io.platform.canPauseResume,
+    wiredKeys: listWiredKeys(),
+    webhookLog: readLogTail(join21(home, WEBHOOK_LOG)),
+    eventsLog: readLogTail(join21(home, EVENTS_LOG2))
+  };
+  io.out(formatStatus(model));
+  return EXIT_OK7;
+}
+
+// src/cli/quiet.ts
+import { mkdirSync as mkdirSync9, unlinkSync as unlinkSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname5 } from "path";
+var EXIT_OK8 = 0;
+var QUIET_INDEFINITE2 = "indefinite";
+var DURATION_RE = /^(\d+)([smh])$/;
+var UNIT_MS = { s: 1e3, m: 6e4, h: 36e5 };
+function parseDuration(spec) {
+  const match = DURATION_RE.exec(spec);
+  if (match === null) {
+    return null;
+  }
+  const amount = Number.parseInt(match[1] ?? "", 10);
+  const unit = UNIT_MS[match[2] ?? ""];
+  if (amount <= 0 || unit === void 0) {
+    return null;
+  }
+  return amount * unit;
+}
+function writeMarker(body) {
+  const path = quietUntilPath();
+  mkdirSync9(dirname5(path), { recursive: true });
+  writeFileSync9(path, body);
+}
+function clearMarker() {
+  try {
+    unlinkSync4(quietUntilPath());
+  } catch {
+  }
+}
+function runQuiet(args, now) {
+  const arg = args[0];
+  if (arg === "off") {
+    clearMarker();
+    process.stdout.write("turnbell: back on\n");
+    return EXIT_OK8;
+  }
+  if (arg === void 0) {
+    writeMarker(QUIET_INDEFINITE2);
+    process.stdout.write("turnbell: quiet until you run `turnbell quiet off`\n");
+    return EXIT_OK8;
+  }
+  const ms = parseDuration(arg);
+  if (ms === null) {
+    throw new Error(`could not understand '${arg}' \u2014 try e.g. 30m, 1h, or 90s`);
+  }
+  writeMarker(String(now.getTime() + ms));
+  process.stdout.write(`turnbell: quiet for ${arg}
+`);
+  return EXIT_OK8;
+}
+
+// src/platform/sequencer.ts
+import { join as join22 } from "path";
+import { fileURLToPath } from "url";
+var NODE_BIN = "node";
+var READING_PIDFILE_NAME2 = "reading.pid";
+var HELPER_PATH = fileURLToPath(
+  new URL("../scripts/helper/play-then-say.mjs", import.meta.url)
+);
+function speakSequenced(opts) {
+  const soundArgv = opts.sound === null ? null : opts.platform.soundArgv(opts.sound);
+  const voiceArgv = opts.platform.voiceArgv(opts.text, opts.voice, opts.rateWpm);
+  if (soundArgv === null && voiceArgv === null) {
+    return;
+  }
+  const pidPath = join22(turnbellHome(), READING_PIDFILE_NAME2);
+  const payload = JSON.stringify({ soundArgv, voiceArgv, pidPath });
+  spawnDetached([NODE_BIN, HELPER_PATH, payload]);
+}
+
+// src/index.ts
+var CLI_NAME = "turnbell";
+var EXIT_OK9 = 0;
+var EXIT_REQUIRED_FAIL = 1;
+var EXIT_ERROR = 1;
+var EXIT_USAGE2 = 2;
+var USAGE = "usage: turnbell <init|uninstall|emit|run|test|status|on|off|quiet|pause|resume|stop|mute|doctor> [options] (--version for version)";
+var MARK_OK = "\u2714";
+var MARK_MISSING = "\u2716";
+var VERSION = "1.0.0";
+function getVersionString() {
+  return `${CLI_NAME} ${VERSION}`;
+}
+function realSinks() {
+  let pendingWebhooks = Promise.resolve();
+  return {
+    platform: selectPlatform(),
+    speak: speakSequenced,
+    notify: (argv) => {
+      spawnDetached(argv);
+    },
+    webhooks: (ev, targets, allowHttp) => {
+      pendingWebhooks = fireWebhooks2(ev, targets, { allowHttp });
+    },
+    awaitWebhooks: () => pendingWebhooks
+  };
+}
+function realEmitDeps() {
+  return { readStdin, ...realSinks() };
+}
+function realSpawn(command, args, mode) {
+  const stdio = mode === "stream" ? ["inherit", "pipe", "inherit"] : "inherit";
+  return spawn2(command, args, { stdio });
+}
+function realDelay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms).unref();
+  });
+}
+function realWrapperDeps() {
+  return {
+    spawn: realSpawn,
+    out: (chunk) => {
+      process.stdout.write(chunk);
+    },
+    cwd: process.cwd(),
+    now: () => /* @__PURE__ */ new Date(),
+    delay: realDelay,
+    ...realSinks()
+  };
+}
+function realTestDeps() {
+  return {
+    cwd: process.cwd(),
+    out: (text2) => {
+      process.stdout.write(text2);
+    },
+    ...realSinks()
+  };
+}
+async function readStdin() {
+  const chunks = [];
+  let total = 0;
+  for await (const chunk of process.stdin) {
+    const buffer = chunk;
+    total += buffer.length;
+    if (total > MAX_STDIN_BYTES) {
+      break;
+    }
+    chunks.push(buffer);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function runEmitSafe(args) {
+  try {
+    return await runEmit(args, realEmitDeps());
+  } catch {
+    return EXIT_OK9;
+  }
+}
+function emitControl(message) {
+  process.stdout.write(`${message}
+`);
+  return EXIT_OK9;
+}
+async function runDoctor() {
+  const checks = await checkAll({
+    which: whichOnPath,
+    platform: selectPlatform(),
+    adapters
+  });
+  for (const check of checks) {
+    printCheck(check);
+  }
+  return allRequiredOk(checks) ? EXIT_OK9 : EXIT_REQUIRED_FAIL;
+}
+function printCheck(check) {
+  const mark = check.ok ? MARK_OK : MARK_MISSING;
+  process.stdout.write(`${mark} ${check.label} \u2014 ${check.detail}
+`);
+  if (!check.ok && check.fix !== null) {
+    process.stdout.write(`    fix: ${check.fix}
+`);
+  }
+}
+async function run(argv) {
+  const [command, ...rest] = argv;
+  switch (command) {
+    case "--version":
+    case "-v":
+      return emitControl(getVersionString());
+    case "init":
+      return runInitCli(rest, () => runTest([], realTestDeps(), /* @__PURE__ */ new Date()));
+    case "uninstall":
+      return runUninstallCli();
+    case "emit":
+      return runEmitSafe(rest);
+    case "run":
+      return runWrapper(rest, realWrapperDeps());
+    case "test":
+      return runTest(rest, realTestDeps(), /* @__PURE__ */ new Date());
+    case "status":
+      return runStatus({
+        cwd: process.cwd(),
+        platform: selectPlatform(),
+        out: (text2) => {
+          process.stdout.write(text2);
+        }
+      });
+    case "pause":
+      return emitControl(pauseReading());
+    case "resume":
+      return emitControl(resumeReading());
+    case "stop":
+      return emitControl(stopReading());
+    case "quiet":
+      return runQuiet(rest, /* @__PURE__ */ new Date());
+    case "on":
+      return setProjectState(true, process.cwd());
+    case "off":
+      return setProjectState(false, process.cwd());
+    case "unmute":
+      return setProjectState(true, process.cwd());
+    case "mute":
+      return runMute(rest, process.cwd());
+    case "doctor":
+      return runDoctor();
+    default:
+      process.stderr.write(`${USAGE}
+`);
+      return EXIT_USAGE2;
+  }
+}
+async function main(argv) {
+  try {
+    migrateLegacyHome();
+    return await run(argv);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${CLI_NAME}: ${message}
+`);
+    return EXIT_ERROR;
+  }
+}
+var LEGACY_BIN_NAME = "hollr";
+var RENAME_NOTICE = "hollr is now turnbell. This alias keeps existing hooks working; install the new package (npm i -g turnbell && npm rm -g hollr-cli) and re-run `turnbell init` to update your wiring.";
+function printRenameNoticeIfLegacyInvocation(argv, stderr) {
+  const entry = argv[1];
+  if (entry !== void 0 && basename4(entry) === LEGACY_BIN_NAME) {
+    stderr(`${RENAME_NOTICE}
+`);
+  }
+}
+function isEntryModule(entry, modulePath, resolve) {
+  if (entry === void 0) {
+    return false;
+  }
+  if (entry === modulePath) {
+    return true;
+  }
+  try {
+    return resolve(entry) === modulePath;
+  } catch {
+    return false;
+  }
+}
+function isExecutedDirectly() {
+  return isEntryModule(
+    process.argv[1],
+    fileURLToPath2(import.meta.url),
+    realpathSync
+  );
+}
+if (isExecutedDirectly()) {
+  printRenameNoticeIfLegacyInvocation(process.argv, (line) => {
+    process.stderr.write(line);
+  });
+  main(process.argv.slice(2)).then((code) => {
+    process.exit(code);
+  }).catch(() => {
+    process.exit(EXIT_ERROR);
+  });
+}
+export {
+  VERSION,
+  getVersionString,
+  isEntryModule,
+  main,
+  printRenameNoticeIfLegacyInvocation,
+  run
+};