ccc-notifier 0.3.0 → 0.5.0

package/dist/chunk-5PH7PPD6.js

@@ -0,0 +1,1077 @@
+#!/usr/bin/env node
+
+// src/codex/subagent-store.ts
+import {
+  existsSync as existsSync2,
+  linkSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { createHash, createHmac, randomBytes, timingSafeEqual } from "crypto";
+import { basename, dirname, join as join2 } from "path";
+import { hostname } from "os";
+
+// src/store.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  appendFileSync,
+  renameSync,
+  rmSync,
+  statSync
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/types.ts
+var DEFAULT_CONFIG = {
+  notify: { os: true, slack: null },
+  minNotifyUSD: 0,
+  costLabel: "api_equivalent",
+  fx: { fallbackRate: 150, cacheHours: 12 },
+  includeDailyTotal: true,
+  monthlyBudgetUSD: 0,
+  dashboard: { autoRegenerate: true, autoReloadSec: 30, days: 30 }
+};
+
+// src/store.ts
+var ERROR_LOG_MAX_BYTES = 1024 * 1024;
+function dataHomePath() {
+  return process.env.CCCN_HOME || join(homedir(), ".ccc-notifier");
+}
+function configFilePath() {
+  return join(dataHomePath(), "config.json");
+}
+function paths() {
+  const home = dataHomePath();
+  const cacheDir = join(home, "cache");
+  mkdirSync(home, { recursive: true });
+  mkdirSync(cacheDir, { recursive: true });
+  return {
+    home,
+    configFile: configFilePath(),
+    historyFile: join(home, "history.jsonl"),
+    cursorsFile: join(home, "cursors.json"),
+    cacheDir,
+    errorLog: join(home, "error.log"),
+    lastNotifyFile: join(home, "last-notify.json"),
+    muteFile: join(home, "muted.json"),
+    recentDashboardFile: join(home, "report.html"),
+    fullDashboardFile: join(home, "report-all.html"),
+    dashboardFullStateFile: join(cacheDir, "dashboard-full-state.json"),
+    dataLockDir: join(cacheDir, "data.lock"),
+    dataReclaimDir: join(cacheDir, "data.lock.reclaim")
+  };
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function mergeConfig(partial) {
+  const result = structuredClone(DEFAULT_CONFIG);
+  if (!isPlainObject(partial)) return result;
+  if (isPlainObject(partial.notify)) {
+    if ("os" in partial.notify) {
+      result.notify.os = partial.notify.os;
+    }
+    if ("slack" in partial.notify) {
+      result.notify.slack = partial.notify.slack;
+    }
+  }
+  if ("minNotifyUSD" in partial) {
+    result.minNotifyUSD = partial.minNotifyUSD;
+  }
+  if ("costLabel" in partial) {
+    result.costLabel = partial.costLabel;
+  }
+  if (isPlainObject(partial.fx)) {
+    if ("fallbackRate" in partial.fx) {
+      result.fx.fallbackRate = partial.fx.fallbackRate;
+    }
+    if ("cacheHours" in partial.fx) {
+      result.fx.cacheHours = partial.fx.cacheHours;
+    }
+  }
+  if ("includeDailyTotal" in partial) {
+    result.includeDailyTotal = partial.includeDailyTotal;
+  }
+  if ("monthlyBudgetUSD" in partial) {
+    const b = partial.monthlyBudgetUSD;
+    if (typeof b === "number" && Number.isFinite(b) && b >= 0) {
+      result.monthlyBudgetUSD = b;
+    }
+  }
+  if (isPlainObject(partial.dashboard)) {
+    if ("autoRegenerate" in partial.dashboard) {
+      result.dashboard.autoRegenerate = partial.dashboard.autoRegenerate;
+    }
+    if ("autoReloadSec" in partial.dashboard) {
+      result.dashboard.autoReloadSec = partial.dashboard.autoReloadSec;
+    }
+    if ("days" in partial.dashboard) {
+      const days = partial.dashboard.days;
+      if (typeof days === "number" && Number.isFinite(days) && Number.isInteger(days) && days > 0) {
+        result.dashboard.days = days;
+      }
+    }
+  }
+  return result;
+}
+function readConfig() {
+  const p = paths();
+  if (!existsSync(p.configFile)) {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  let raw;
+  try {
+    raw = readFileSync(p.configFile, "utf8");
+  } catch (err) {
+    logError("readConfig", err);
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    logError("readConfig", err);
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  return mergeConfig(parsed);
+}
+function readMuteState() {
+  const p = paths();
+  if (!existsSync(p.muteFile)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(p.muteFile, "utf8"));
+    if (!isPlainObject(parsed) || !("until" in parsed)) return null;
+    const until = parsed.until;
+    if (until === null) return { until: null };
+    if (typeof until === "string" && !Number.isNaN(new Date(until).getTime())) {
+      return { until };
+    }
+    return null;
+  } catch (err) {
+    logError("readMuteState", err);
+    return null;
+  }
+}
+function isMuted(now = /* @__PURE__ */ new Date()) {
+  const state = readMuteState();
+  if (state === null) return false;
+  if (state.until === null) return true;
+  return new Date(state.until).getTime() > now.getTime();
+}
+function writeMuteState(state) {
+  writeFileSync(paths().muteFile, `${JSON.stringify(state)}
+`, "utf8");
+}
+function clearMuteState() {
+  rmSync(paths().muteFile, { force: true });
+}
+function loadCursor(transcriptPath) {
+  const p = paths();
+  if (!existsSync(p.cursorsFile)) return null;
+  let raw;
+  try {
+    raw = readFileSync(p.cursorsFile, "utf8");
+  } catch (err) {
+    logError("loadCursor", err);
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    logError("loadCursor", err);
+    return null;
+  }
+  if (!isPlainObject(parsed)) {
+    logError("loadCursor", new Error("cursors.json root is not an object"));
+    return null;
+  }
+  const cursor = parsed[transcriptPath];
+  return cursor ?? null;
+}
+function sanitizeCursor(raw) {
+  if (!isPlainObject(raw)) return null;
+  const { offset, lastUuid, lastTs, seenMessageKeys, codexTotals } = raw;
+  if (typeof offset !== "number" || !Number.isFinite(offset)) return null;
+  if (lastUuid !== null && typeof lastUuid !== "string") return null;
+  if (lastTs !== null && typeof lastTs !== "string") return null;
+  if (!Array.isArray(seenMessageKeys)) return null;
+  const keys = [];
+  for (const key of seenMessageKeys) {
+    if (typeof key !== "string") return null;
+    keys.push(key);
+  }
+  const cursor = { offset, lastUuid, lastTs, seenMessageKeys: keys };
+  if (isPlainObject(codexTotals)) {
+    const { input, cached, output } = codexTotals;
+    if (typeof input === "number" && Number.isFinite(input) && input >= 0 && typeof cached === "number" && Number.isFinite(cached) && cached >= 0 && typeof output === "number" && Number.isFinite(output) && output >= 0) {
+      cursor.codexTotals = { input, cached, output };
+    }
+  }
+  return cursor;
+}
+function saveCursor(transcriptPath, c) {
+  const p = paths();
+  let dict = {};
+  if (existsSync(p.cursorsFile)) {
+    try {
+      const raw = readFileSync(p.cursorsFile, "utf8");
+      const parsed = JSON.parse(raw);
+      if (isPlainObject(parsed)) {
+        dict = parsed;
+      }
+    } catch (err) {
+      logError("saveCursor", err);
+    }
+  }
+  dict[transcriptPath] = c;
+  const tmpFile = `${p.cursorsFile}.tmp`;
+  writeFileSync(tmpFile, JSON.stringify(dict), "utf8");
+  renameSync(tmpFile, p.cursorsFile);
+}
+function appendTurn(record) {
+  const p = paths();
+  const { subagentActivity: _runtimeActivity, ...persisted } = record;
+  appendFileSync(p.historyFile, JSON.stringify(persisted) + "\n", "utf8");
+}
+function readTurns(days) {
+  const p = paths();
+  if (!existsSync(p.historyFile)) return [];
+  let raw;
+  try {
+    raw = readFileSync(p.historyFile, "utf8");
+  } catch {
+    return [];
+  }
+  const cutoff = typeof days === "number" ? Date.now() - days * 864e5 : null;
+  const result = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let rec;
+    try {
+      rec = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (cutoff !== null) {
+      const ts = Date.parse(rec.ts);
+      if (!Number.isFinite(ts) || ts < cutoff) continue;
+    }
+    delete rec.subagentActivity;
+    result.push(rec);
+  }
+  const keyedRecords = result.filter(
+    (rec) => rec.source === "codex" && typeof rec.activityProjectionKey === "string" && /^[a-f0-9]{64}$/.test(rec.activityProjectionKey)
+  );
+  if (keyedRecords.length === 0) return result;
+  const byProjection = /* @__PURE__ */ new Map();
+  for (const state of readCodexSubagentActivity()) {
+    const states = byProjection.get(state.projectionKey) ?? [];
+    states.push(state);
+    byProjection.set(state.projectionKey, states);
+  }
+  for (const rec of keyedRecords) {
+    const activity = projectCodexSubagentActivity(byProjection.get(rec.activityProjectionKey) ?? []);
+    if (activity !== void 0) rec.subagentActivity = activity;
+  }
+  return result;
+}
+function todayTotalUSD() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = now.getMonth();
+  const d = now.getDate();
+  let total = 0;
+  for (const rec of readTurns()) {
+    const ts = new Date(rec.ts);
+    if (Number.isNaN(ts.getTime())) continue;
+    if (ts.getFullYear() === y && ts.getMonth() === m && ts.getDate() === d) {
+      total += rec.costUSD;
+    }
+  }
+  return total;
+}
+function currentMonthTotals() {
+  const now = /* @__PURE__ */ new Date();
+  const y = now.getFullYear();
+  const m = now.getMonth();
+  let usd = 0;
+  let jpy = 0;
+  let turns = 0;
+  for (const rec of readTurns()) {
+    const ts = new Date(rec.ts);
+    if (Number.isNaN(ts.getTime())) continue;
+    if (ts.getFullYear() === y && ts.getMonth() === m) {
+      const sa = rec.subagents?.costUSD ?? 0;
+      usd += rec.costUSD + sa;
+      jpy += rec.costJPY + sa * rec.fxRate;
+      turns += 1;
+    }
+  }
+  return { usd, jpy, turns };
+}
+function logError(context, err) {
+  try {
+    const p = paths();
+    const iso = (/* @__PURE__ */ new Date()).toISOString();
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    let entry = `[${iso}] [${context}] ${message}
+`;
+    if (stack) {
+      entry += `${stack}
+`;
+    }
+    try {
+      const stat = statSync(p.errorLog);
+      if (stat.size > ERROR_LOG_MAX_BYTES) {
+        renameSync(p.errorLog, `${p.errorLog}.old`);
+      }
+    } catch {
+    }
+    appendFileSync(p.errorLog, entry, "utf8");
+  } catch {
+  }
+}
+
+// src/codex/subagent-store.ts
+var KNOWN_AGENT_TYPES = /* @__PURE__ */ new Map([
+  ["default", "default"],
+  ["explorer", "explorer"],
+  ["worker", "worker"],
+  ["reviewer", "reviewer"],
+  ["researcher", "researcher"],
+  ["general", "general"]
+]);
+var UNKNOWN_AGENT_TYPE = "unknown";
+var MALFORMED_LOCK_GRACE_MS = 100;
+var CRASH_STAGING_GRACE_MS = 6e4;
+var KEY_CHECK_CONTEXT = "ccc-notifier:codex-subagent-key-check:v1";
+var SAFE_AGENT_TYPES = /* @__PURE__ */ new Set([...KNOWN_AGENT_TYPES.values(), UNKNOWN_AGENT_TYPE]);
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  const allowlist = new Set(allowed);
+  return Object.keys(value).every((key) => allowlist.has(key));
+}
+function activityPaths() {
+  const home = paths().home;
+  return {
+    ledger: join2(home, "codex-subagent-activity.json"),
+    salt: join2(home, "codex-subagent-key"),
+    lock: join2(home, "codex-subagent-activity.lock"),
+    keyLock: join2(home, "codex-subagent-key.lock"),
+    legacyBackup: join2(home, "codex-subagent-activity.v1.json")
+  };
+}
+function loadOrCreateSecret() {
+  const { salt: file, keyLock, ledger } = activityPaths();
+  const lock = acquireOwnedLock(keyLock, 2e3);
+  try {
+    cleanupStaleFileStaging(file, 16);
+    if (existsSync2(file)) {
+      const value2 = readFileSync2(file);
+      if (value2.length === 32) return value2;
+      if (existsSync2(ledger)) throw new Error("invalid activity key with existing ledger");
+    }
+    if (!existsSync2(file) && existsSync2(ledger)) {
+      throw new Error("missing activity key with existing ledger");
+    }
+    const value = randomBytes(32);
+    const staging = `${file}.${stagingHostTag()}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+    try {
+      writeFileSync2(staging, value, { mode: 384 });
+      renameSync2(staging, file);
+    } finally {
+      rmSync2(staging, { force: true });
+    }
+    return value;
+  } finally {
+    lock.release();
+  }
+}
+function keyedV2(secret, domain, ...values) {
+  const hmac = createHmac("sha256", secret);
+  hmac.update(`ccc-notifier:${domain}\0`);
+  for (const value of values) {
+    hmac.update(String(Buffer.byteLength(value)));
+    hmac.update(":");
+    hmac.update(value);
+    hmac.update("\0");
+  }
+  return hmac.digest("hex");
+}
+function computeKeyCheck(secret) {
+  return createHmac("sha256", secret).update(KEY_CHECK_CONTEXT).digest("hex");
+}
+function keyCheckMatches(secret, persisted) {
+  if (!/^[a-f0-9]{64}$/.test(persisted)) return false;
+  const actual = Buffer.from(computeKeyCheck(secret), "hex");
+  const expected = Buffer.from(persisted, "hex");
+  return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function normalizeAgentType(value) {
+  if (typeof value !== "string") return UNKNOWN_AGENT_TYPE;
+  const cleaned = value.replace(/[\u0000-\u001f\u007f-\u009f]/g, "").trim().slice(0, 64).toLowerCase();
+  return KNOWN_AGENT_TYPES.get(cleaned) ?? UNKNOWN_AGENT_TYPE;
+}
+function validateCodexSubagentPayload(payload, expectedKind) {
+  const raw = validateRawCodexSubagentPayload(payload, expectedKind);
+  if (raw === null) return null;
+  return deriveCodexSubagentEvent(loadVerifiedSecret(), raw);
+}
+function validateRawCodexSubagentPayload(payload, expectedKind) {
+  if (!isObject(payload)) return null;
+  const eventName = payload.hook_event_name;
+  const kind = eventName === "SubagentStart" ? "start" : eventName === "SubagentStop" ? "stop" : null;
+  if (kind === null || expectedKind !== void 0 && kind !== expectedKind) return null;
+  const { session_id: sessionId, turn_id: turnId, agent_id: agentId } = payload;
+  if (typeof sessionId !== "string" || sessionId.length === 0 || sessionId.length > 1024 || typeof turnId !== "string" || turnId.length === 0 || turnId.length > 1024 || typeof agentId !== "string" || agentId.length === 0 || agentId.length > 1024) return null;
+  return {
+    kind,
+    sessionId,
+    agentId,
+    agentTypeLabel: normalizeAgentType(payload.agent_type)
+  };
+}
+function deriveCodexSubagentEvent(secret, raw) {
+  return {
+    kind: raw.kind,
+    sessionKey: keyedV2(secret, "root-session-v2", raw.sessionId),
+    agentKey: keyedV2(secret, "agent-identity-v2", raw.sessionId, raw.agentId),
+    agentTypeLabel: raw.agentTypeLabel
+  };
+}
+function validateCodexRootPayload(payload, expectedEvent) {
+  if (!isObject(payload)) return null;
+  if (payload.hook_event_name !== expectedEvent) return null;
+  const { session_id: sessionId, turn_id: turnId } = payload;
+  if (typeof sessionId !== "string" || sessionId.length === 0 || sessionId.length > 1024 || typeof turnId !== "string" || turnId.length === 0 || turnId.length > 1024) return null;
+  return { sessionId, turnId };
+}
+function deriveCodexRootEvent(secret, raw) {
+  return {
+    sessionKey: keyedV2(secret, "root-session-v2", raw.sessionId),
+    rootKey: keyedV2(secret, "root-turn-v2", raw.sessionId, raw.turnId)
+  };
+}
+function isoMin(a, b) {
+  return a <= b ? a : b;
+}
+function isoMax(a, b) {
+  return a >= b ? a : b;
+}
+function reduceCodexSubagentActivity(previous, event, observedAt, projectionKey = previous?.projectionKey) {
+  if (projectionKey === void 0) throw new Error("missing root assignment");
+  const incomingLabel = event.agentTypeLabel;
+  const label = previous === void 0 ? incomingLabel : previous.agentTypeLabel === UNKNOWN_AGENT_TYPE ? incomingLabel : incomingLabel === UNKNOWN_AGENT_TYPE ? previous.agentTypeLabel : [previous.agentTypeLabel, incomingLabel].sort()[0];
+  return {
+    schemaVersion: 1,
+    projectionKey,
+    agentKey: event.agentKey,
+    agentTypeLabel: label,
+    startObserved: (previous?.startObserved ?? false) || event.kind === "start",
+    stopObserved: (previous?.stopObserved ?? false) || event.kind === "stop",
+    firstObservedAt: previous ? isoMin(previous.firstObservedAt, observedAt) : observedAt,
+    lastObservedAt: previous ? isoMax(previous.lastObservedAt, observedAt) : observedAt
+  };
+}
+function sleep(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function readLockOwner(lock) {
+  try {
+    const ownerPath = statSync2(lock).isDirectory() ? join2(lock, "owner.json") : lock;
+    const value = JSON.parse(readFileSync2(ownerPath, "utf8"));
+    if (!isObject(value) || typeof value.token !== "string" || !/^[a-f0-9]{32}$/.test(value.token) || typeof value.pid !== "number" || !Number.isSafeInteger(value.pid) || value.pid <= 0 || typeof value.hostname !== "string" || typeof value.createdAt !== "string" || !Number.isFinite(Date.parse(value.createdAt))) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function processLiveness(pid) {
+  try {
+    process.kill(pid, 0);
+    return "alive";
+  } catch (error) {
+    if (!isObject(error)) return "unknown";
+    if (error.code === "EPERM") return "alive";
+    if (error.code === "ESRCH") return "dead";
+    return "unknown";
+  }
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stagingHostTag() {
+  return createHash("sha256").update("ccc-notifier:staging-host:v1\0").update(hostname()).digest("hex").slice(0, 16);
+}
+function cleanupStaleFileStaging(file, randomHexLength) {
+  const parent = dirname(file);
+  const pattern = new RegExp(
+    `^${escapeRegExp(basename(file))}\\.([a-f0-9]{16})\\.(\\d+)\\.[a-f0-9]{${randomHexLength}}\\.tmp$`
+  );
+  const localHostTag = stagingHostTag();
+  let names;
+  try {
+    names = readdirSync(parent);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const match = pattern.exec(name);
+    if (match === null) continue;
+    if (match[1] !== localHostTag) continue;
+    const pid = Number(match[2]);
+    if (!Number.isSafeInteger(pid) || pid <= 0 || processLiveness(pid) !== "dead") continue;
+    const candidate = join2(parent, name);
+    try {
+      const stat = lstatSync(candidate);
+      if (!stat.isFile() || Date.now() - stat.mtimeMs < CRASH_STAGING_GRACE_MS) continue;
+      rmSync2(candidate);
+    } catch {
+    }
+  }
+}
+function releaseOwnedLock(lock, token) {
+  const owner = readLockOwner(lock);
+  if (owner?.token !== token) return;
+  const releasing = `${lock}.release-${token}`;
+  try {
+    renameSync2(lock, releasing);
+  } catch {
+    return;
+  }
+  const movedOwner = readLockOwner(releasing);
+  if (movedOwner?.token === token) rmSync2(releasing, { recursive: true, force: true });
+}
+function claimAndRemove(lock) {
+  const recovery = `${lock}.recovery-${randomBytes(8).toString("hex")}`;
+  try {
+    renameSync2(lock, recovery);
+  } catch {
+    return !existsSync2(lock);
+  }
+  rmSync2(recovery, { recursive: true, force: true });
+  return true;
+}
+function tryRecoverExistingLock(lock, malformedGraceMs) {
+  let stat;
+  try {
+    stat = statSync2(lock);
+  } catch (error) {
+    return isObject(error) && error.code === "ENOENT";
+  }
+  const owner = readLockOwner(lock);
+  if (owner !== null) {
+    if (owner.hostname !== hostname()) return false;
+    if (processLiveness(owner.pid) !== "dead") return false;
+    return claimAndRemove(lock);
+  }
+  if (!stat.isDirectory()) return false;
+  if (Date.now() - stat.mtimeMs < malformedGraceMs) return false;
+  const rechecked = readLockOwner(lock);
+  if (rechecked !== null) {
+    if (rechecked.hostname !== hostname() || processLiveness(rechecked.pid) !== "dead") return false;
+  }
+  return claimAndRemove(lock);
+}
+function publishOwnedLock(lock, owner) {
+  const staging = `${lock}.init-${owner.token}`;
+  const ownerTmp = join2(staging, "owner.json.tmp");
+  try {
+    mkdirSync2(staging);
+    writeFileSync2(ownerTmp, `${JSON.stringify(owner)}
+`, { encoding: "utf8", mode: 384 });
+    const ownerPath = join2(staging, "owner.json");
+    renameSync2(ownerTmp, ownerPath);
+    try {
+      linkSync(ownerPath, lock);
+      return true;
+    } catch (error) {
+      const errorCode = isObject(error) && typeof error.code === "string" ? error.code : null;
+      if (errorCode === "EEXIST" || existsSync2(lock)) return false;
+      const code = errorCode !== null && /^[A-Z0-9_]+$/.test(errorCode) ? ` (${errorCode})` : "";
+      throw new Error(`activity lock publication failed${code}`);
+    }
+  } finally {
+    rmSync2(staging, { recursive: true, force: true });
+  }
+}
+function cleanupStaleLockInitializations(lock) {
+  const parent = dirname(lock);
+  const pattern = new RegExp(`^${escapeRegExp(basename(lock))}\\.init-([a-f0-9]{32})$`);
+  let names;
+  try {
+    names = readdirSync(parent);
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const match = pattern.exec(name);
+    if (match === null) continue;
+    const candidate = join2(parent, name);
+    try {
+      const stat = lstatSync(candidate);
+      const ownerStat = lstatSync(join2(candidate, "owner.json"));
+      const owner = readLockOwner(candidate);
+      if (!stat.isDirectory() || Date.now() - stat.mtimeMs < CRASH_STAGING_GRACE_MS || !ownerStat.isFile() || Date.now() - ownerStat.mtimeMs < CRASH_STAGING_GRACE_MS || owner === null || owner.token !== match[1] || owner.hostname !== hostname() || Date.now() - Date.parse(owner.createdAt) < CRASH_STAGING_GRACE_MS || processLiveness(owner.pid) !== "dead") continue;
+      const recovery = `${candidate}.recovery-${randomBytes(8).toString("hex")}`;
+      try {
+        renameSync2(candidate, recovery);
+      } catch {
+        continue;
+      }
+      const movedOwner = readLockOwner(recovery);
+      const movedStat = lstatSync(recovery);
+      const movedOwnerStat = lstatSync(join2(recovery, "owner.json"));
+      if (movedStat.isDirectory() && Date.now() - movedStat.mtimeMs >= CRASH_STAGING_GRACE_MS && movedOwnerStat.isFile() && Date.now() - movedOwnerStat.mtimeMs >= CRASH_STAGING_GRACE_MS && movedOwner?.token === owner.token && movedOwner.hostname === owner.hostname && movedOwner.pid === owner.pid && Date.now() - Date.parse(movedOwner.createdAt) >= CRASH_STAGING_GRACE_MS && processLiveness(movedOwner.pid) === "dead") {
+        rmSync2(recovery, { recursive: true, force: true });
+      } else if (!existsSync2(candidate)) {
+        try {
+          renameSync2(recovery, candidate);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
+function acquireOwnedLock(lock, timeoutMs, malformedGraceMs = MALFORMED_LOCK_GRACE_MS) {
+  const deadline = Date.now() + timeoutMs;
+  const token = randomBytes(16).toString("hex");
+  for (; ; ) {
+    if (Date.now() >= deadline) throw new Error("activity lock timeout");
+    const owner = { token, pid: process.pid, hostname: hostname(), createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    if (publishOwnedLock(lock, owner)) {
+      cleanupStaleLockInitializations(lock);
+      return { token, release: () => releaseOwnedLock(lock, token) };
+    }
+    if (tryRecoverExistingLock(lock, malformedGraceMs)) continue;
+    if (Date.now() >= deadline) throw new Error("activity lock timeout");
+    sleep(10);
+  }
+}
+function acquireCodexActivityLock(timeoutMs = 2e3, options = {}) {
+  return acquireOwnedLock(activityPaths().lock, timeoutMs, options.staleMs ?? MALFORMED_LOCK_GRACE_MS);
+}
+function validState(value) {
+  return isObject(value) && hasOnlyKeys(value, [
+    "schemaVersion",
+    "projectionKey",
+    "agentKey",
+    "agentTypeLabel",
+    "startObserved",
+    "stopObserved",
+    "firstObservedAt",
+    "lastObservedAt"
+  ]) && value.schemaVersion === 1 && typeof value.projectionKey === "string" && /^[a-f0-9]{64}$/.test(value.projectionKey) && typeof value.agentKey === "string" && /^[a-f0-9]{64}$/.test(value.agentKey) && typeof value.agentTypeLabel === "string" && SAFE_AGENT_TYPES.has(value.agentTypeLabel) && typeof value.startObserved === "boolean" && typeof value.stopObserved === "boolean" && typeof value.firstObservedAt === "string" && Number.isFinite(Date.parse(value.firstObservedAt)) && typeof value.lastObservedAt === "string" && Number.isFinite(Date.parse(value.lastObservedAt)) && value.firstObservedAt <= value.lastObservedAt;
+}
+function isHexKey(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function validateV1(value) {
+  if (!isObject(value) || !hasOnlyKeys(value, ["schemaVersion", "keyCheck", "agents"]) || value.schemaVersion !== 1 || !isObject(value.agents)) {
+    throw new Error("invalid activity ledger");
+  }
+  if (value.keyCheck !== void 0 && !isHexKey(value.keyCheck)) {
+    throw new Error("invalid activity ledger keyCheck");
+  }
+  for (const [key, state] of Object.entries(value.agents)) {
+    if (!validState(state) || state.agentKey !== key) throw new Error("invalid activity ledger entry");
+  }
+  return value;
+}
+function validSessionState(value) {
+  return isObject(value) && hasOnlyKeys(value, ["activeRootKey", "latestRootKey"]) && (value.activeRootKey === null || isHexKey(value.activeRootKey)) && (value.latestRootKey === null || isHexKey(value.latestRootKey));
+}
+function validRootState(value) {
+  if (!isObject(value) || !hasOnlyKeys(value, [
+    "sessionKey",
+    "status",
+    "openedAt",
+    "openedSequence",
+    "closedAt",
+    "closedSequence",
+    "agents"
+  ]) || !isHexKey(value.sessionKey) || value.status !== "open" && value.status !== "closed" && value.status !== "abandoned" || typeof value.openedAt !== "string" || !Number.isFinite(Date.parse(value.openedAt)) || typeof value.openedSequence !== "number" || !Number.isSafeInteger(value.openedSequence) || value.openedSequence < 1 || !isObject(value.agents)) return false;
+  if (value.closedAt !== void 0 && (typeof value.closedAt !== "string" || !Number.isFinite(Date.parse(value.closedAt)))) return false;
+  if (value.closedSequence !== void 0 && (typeof value.closedSequence !== "number" || !Number.isSafeInteger(value.closedSequence) || value.closedSequence < 1)) return false;
+  if (value.status === "closed" && (value.closedAt === void 0 || value.closedSequence === void 0)) return false;
+  if (value.status !== "closed" && (value.closedAt !== void 0 || value.closedSequence !== void 0)) return false;
+  for (const [key, state] of Object.entries(value.agents)) {
+    if (!validState(state) || state.agentKey !== key) return false;
+  }
+  return true;
+}
+function validateV2(value) {
+  if (!isObject(value) || !hasOnlyKeys(value, [
+    "schemaVersion",
+    "keyCheck",
+    "sequence",
+    "sessions",
+    "roots",
+    "agentAssignments",
+    "conflictedAgents",
+    "legacyV1"
+  ]) || value.schemaVersion !== 2 || !isHexKey(value.keyCheck) || typeof value.sequence !== "number" || !Number.isSafeInteger(value.sequence) || value.sequence < 0 || !isObject(value.sessions) || !isObject(value.roots) || !isObject(value.agentAssignments) || !isObject(value.conflictedAgents)) throw new Error("invalid activity ledger v2");
+  for (const [key, session] of Object.entries(value.sessions)) {
+    if (!isHexKey(key) || !validSessionState(session)) throw new Error("invalid activity session");
+  }
+  for (const [key, root] of Object.entries(value.roots)) {
+    if (!isHexKey(key) || !validRootState(root)) throw new Error("invalid activity root");
+  }
+  for (const [agentKey, rootKey] of Object.entries(value.agentAssignments)) {
+    if (!isHexKey(agentKey) || !isHexKey(rootKey) || !(rootKey in value.roots)) {
+      throw new Error("invalid activity assignment");
+    }
+  }
+  for (const [agentKey, marker] of Object.entries(value.conflictedAgents)) {
+    if (!isHexKey(agentKey) || marker !== true) throw new Error("invalid activity conflict");
+  }
+  if (value.legacyV1 !== void 0) {
+    if (!isObject(value.legacyV1) || !hasOnlyKeys(value.legacyV1, ["agents"]) || !isObject(value.legacyV1.agents)) {
+      throw new Error("invalid legacy activity ledger");
+    }
+    for (const [key, state] of Object.entries(value.legacyV1.agents)) {
+      if (!validState(state) || state.agentKey !== key) throw new Error("invalid legacy activity entry");
+    }
+  }
+  const ledger = value;
+  for (const [agentKey, rootKey] of Object.entries(ledger.agentAssignments)) {
+    if (ledger.roots[rootKey]?.agents[agentKey] === void 0) {
+      throw new Error("invalid activity assignment state");
+    }
+  }
+  const openCount = /* @__PURE__ */ new Map();
+  const rootedAgents = /* @__PURE__ */ new Set();
+  for (const [rootKey, root] of Object.entries(ledger.roots)) {
+    if (ledger.sessions[root.sessionKey] === void 0) throw new Error("missing activity session");
+    if (root.status === "open") openCount.set(root.sessionKey, (openCount.get(root.sessionKey) ?? 0) + 1);
+    for (const [agentKey, state] of Object.entries(root.agents)) {
+      if (state.projectionKey !== rootKey) throw new Error("activity projection root mismatch");
+      if (rootedAgents.has(agentKey)) throw new Error("activity agent appears in multiple roots");
+      rootedAgents.add(agentKey);
+      if (ledger.agentAssignments[agentKey] !== rootKey) throw new Error("missing reverse activity assignment");
+    }
+  }
+  for (const [sessionKey, session] of Object.entries(ledger.sessions)) {
+    if ((openCount.get(sessionKey) ?? 0) > 1) throw new Error("ambiguous open root state");
+    if (session.activeRootKey !== null) {
+      const root = ledger.roots[session.activeRootKey];
+      if (root === void 0 || root.sessionKey !== sessionKey || root.status !== "open") {
+        throw new Error("invalid active root pointer");
+      }
+    }
+    if (session.latestRootKey !== null) {
+      const root = ledger.roots[session.latestRootKey];
+      if (root === void 0 || root.sessionKey !== sessionKey) throw new Error("invalid latest root pointer");
+    }
+  }
+  return ledger;
+}
+function atomicWriteLedger(ledger) {
+  const file = activityPaths().ledger;
+  const tmp = `${file}.${stagingHostTag()}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync2(tmp, `${JSON.stringify(ledger)}
+`, { encoding: "utf8", mode: 384 });
+    renameSync2(tmp, file);
+  } finally {
+    rmSync2(tmp, { force: true });
+  }
+}
+function emptyV2(secret) {
+  return {
+    schemaVersion: 2,
+    keyCheck: computeKeyCheck(secret),
+    sequence: 0,
+    sessions: {},
+    roots: {},
+    agentAssignments: {},
+    conflictedAgents: {}
+  };
+}
+function writeLegacyBackup(raw) {
+  const file = activityPaths().legacyBackup;
+  if (existsSync2(file)) {
+    if (readFileSync2(file, "utf8") !== raw) throw new Error("activity v1 backup mismatch");
+    return;
+  }
+  const tmp = `${file}.${stagingHostTag()}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync2(tmp, raw, { encoding: "utf8", mode: 384 });
+    renameSync2(tmp, file);
+  } finally {
+    rmSync2(tmp, { force: true });
+  }
+}
+function readLedgerForMutation(secret) {
+  const file = activityPaths().ledger;
+  if (!existsSync2(file)) return emptyV2(secret);
+  const raw = readFileSync2(file, "utf8");
+  const parsed = JSON.parse(raw);
+  if (isObject(parsed) && parsed.schemaVersion === 2) {
+    const ledger = validateV2(parsed);
+    if (!keyCheckMatches(secret, ledger.keyCheck)) {
+      throw new Error("activity key integrity mismatch; manual recovery required");
+    }
+    return ledger;
+  }
+  const legacy = validateV1(parsed);
+  if (legacy.keyCheck !== void 0 && !keyCheckMatches(secret, legacy.keyCheck)) {
+    throw new Error("activity key integrity mismatch; manual recovery required");
+  }
+  writeLegacyBackup(raw);
+  const migrated = emptyV2(secret);
+  migrated.legacyV1 = { agents: legacy.agents };
+  atomicWriteLedger(migrated);
+  return migrated;
+}
+function loadVerifiedSecret() {
+  const lock = acquireCodexActivityLock();
+  try {
+    cleanupStaleFileStaging(activityPaths().ledger, 12);
+    const secret = loadOrCreateSecret();
+    const ledger = readLedgerForMutation(secret);
+    if (!existsSync2(activityPaths().ledger)) atomicWriteLedger(ledger);
+    return secret;
+  } finally {
+    lock.release();
+  }
+}
+function recordCodexSubagentEventInLedger(ledger, event, observedAt) {
+  if (!Number.isFinite(Date.parse(observedAt))) throw new Error("invalid observation timestamp");
+  if (ledger.conflictedAgents[event.agentKey] === true) return null;
+  let rootKey = ledger.agentAssignments[event.agentKey];
+  const session = ledger.sessions[event.sessionKey];
+  const activeRootKey = session?.activeRootKey ?? null;
+  if (rootKey !== void 0) {
+    const assignedRoot = ledger.roots[rootKey];
+    if (assignedRoot === void 0 || assignedRoot.sessionKey !== event.sessionKey) {
+      throw new Error("invalid activity assignment integrity");
+    }
+    if (event.kind === "start" && activeRootKey !== null && activeRootKey !== rootKey) {
+      ledger.conflictedAgents[event.agentKey] = true;
+      atomicWriteLedger(ledger);
+      logError("codex-subagent:agent-conflict", new Error("agent identity conflict; event was not recorded"));
+      return null;
+    }
+  } else {
+    if (event.kind !== "start" || activeRootKey === null) return null;
+    const activeRoot = ledger.roots[activeRootKey];
+    if (activeRoot === void 0 || activeRoot.status !== "open" || activeRoot.sessionKey !== event.sessionKey) {
+      return null;
+    }
+    rootKey = activeRootKey;
+    ledger.agentAssignments[event.agentKey] = rootKey;
+  }
+  const root = ledger.roots[rootKey];
+  if (root === void 0) throw new Error("missing assigned activity root");
+  const prior = root.agents[event.agentKey];
+  const next = reduceCodexSubagentActivity(prior, event, observedAt, rootKey);
+  root.agents[event.agentKey] = next;
+  atomicWriteLedger(ledger);
+  return next;
+}
+function recordCodexSubagentEvent(event, options = {}) {
+  const lock = acquireCodexActivityLock(options.lockTimeoutMs ?? 2e3);
+  try {
+    cleanupStaleFileStaging(activityPaths().ledger, 12);
+    const secret = loadOrCreateSecret();
+    const ledger = readLedgerForMutation(secret);
+    const observedAt = options.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    return recordCodexSubagentEventInLedger(ledger, event, observedAt);
+  } finally {
+    lock.release();
+  }
+}
+function recordCodexSubagentPayload(payload, expectedKind, options = {}) {
+  const lock = acquireCodexActivityLock(options.lockTimeoutMs ?? 2e3);
+  try {
+    const raw = validateRawCodexSubagentPayload(payload, expectedKind);
+    if (raw === null) throw new Error("invalid hook payload");
+    cleanupStaleFileStaging(activityPaths().ledger, 12);
+    const secret = loadOrCreateSecret();
+    const ledger = readLedgerForMutation(secret);
+    const event = deriveCodexSubagentEvent(secret, raw);
+    return recordCodexSubagentEventInLedger(ledger, event, options.observedAt ?? (/* @__PURE__ */ new Date()).toISOString());
+  } finally {
+    lock.release();
+  }
+}
+function readCodexSubagentActivity(projectionKey) {
+  try {
+    const file = activityPaths().ledger;
+    if (!existsSync2(file)) return [];
+    const parsed = JSON.parse(readFileSync2(file, "utf8"));
+    let states;
+    if (isObject(parsed) && parsed.schemaVersion === 1) {
+      const ledger = validateV1(parsed);
+      if (ledger.keyCheck !== void 0) {
+        const secret = readFileSync2(activityPaths().salt);
+        if (secret.length !== 32 || !keyCheckMatches(secret, ledger.keyCheck)) {
+          throw new Error("activity key integrity mismatch; read was rejected");
+        }
+      }
+      states = Object.values(ledger.agents);
+    } else {
+      const ledger = validateV2(parsed);
+      const secret = readFileSync2(activityPaths().salt);
+      if (secret.length !== 32 || !keyCheckMatches(secret, ledger.keyCheck)) {
+        throw new Error("activity key integrity mismatch; read was rejected");
+      }
+      states = [
+        ...Object.values(ledger.roots).flatMap((root) => Object.values(root.agents)),
+        ...Object.values(ledger.legacyV1?.agents ?? {})
+      ];
+    }
+    return states.filter(
+      (state) => projectionKey === void 0 || state.projectionKey === projectionKey
+    );
+  } catch (error) {
+    logError("codex-subagent:read-ledger", error);
+    return [];
+  }
+}
+function nextSequence(ledger) {
+  if (ledger.sequence >= Number.MAX_SAFE_INTEGER) throw new Error("activity sequence exhausted");
+  ledger.sequence += 1;
+  return ledger.sequence;
+}
+function openCodexRootContext(payload, options = {}) {
+  const lock = acquireCodexActivityLock(options.lockTimeoutMs ?? 2e3);
+  try {
+    const raw = validateCodexRootPayload(payload, "UserPromptSubmit");
+    if (raw === null) return null;
+    const secret = loadOrCreateSecret();
+    const ledger = readLedgerForMutation(secret);
+    const event = deriveCodexRootEvent(secret, raw);
+    const observedAt = options.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (!Number.isFinite(Date.parse(observedAt))) throw new Error("invalid observation timestamp");
+    const existing = ledger.roots[event.rootKey];
+    if (existing !== void 0) {
+      return event.rootKey;
+    }
+    const session = ledger.sessions[event.sessionKey] ?? { activeRootKey: null, latestRootKey: null };
+    if (session.activeRootKey !== null) {
+      const previous = ledger.roots[session.activeRootKey];
+      if (previous === void 0 || previous.status !== "open") throw new Error("invalid active root state");
+      previous.status = "abandoned";
+    }
+    const sequence = nextSequence(ledger);
+    ledger.roots[event.rootKey] = {
+      sessionKey: event.sessionKey,
+      status: "open",
+      openedAt: observedAt,
+      openedSequence: sequence,
+      agents: {}
+    };
+    session.activeRootKey = event.rootKey;
+    session.latestRootKey = event.rootKey;
+    ledger.sessions[event.sessionKey] = session;
+    atomicWriteLedger(ledger);
+    return event.rootKey;
+  } finally {
+    lock.release();
+  }
+}
+function closeCodexRootContext(payload, options = {}) {
+  const lock = acquireCodexActivityLock(options.lockTimeoutMs ?? 2e3);
+  try {
+    const raw = validateCodexRootPayload(payload, "Stop");
+    if (raw === null) return null;
+    const secret = loadOrCreateSecret();
+    const ledger = readLedgerForMutation(secret);
+    const event = deriveCodexRootEvent(secret, raw);
+    const root = ledger.roots[event.rootKey];
+    if (root === void 0 || root.sessionKey !== event.sessionKey) return null;
+    if (root.status === "closed") return event.rootKey;
+    const observedAt = options.observedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    if (!Number.isFinite(Date.parse(observedAt))) throw new Error("invalid observation timestamp");
+    root.status = "closed";
+    root.closedAt = observedAt;
+    root.closedSequence = nextSequence(ledger);
+    const session = ledger.sessions[event.sessionKey];
+    if (session?.activeRootKey === event.rootKey) session.activeRootKey = null;
+    atomicWriteLedger(ledger);
+    return event.rootKey;
+  } finally {
+    lock.release();
+  }
+}
+function codexActivityProjectionKey(payload) {
+  return closeCodexRootContext(payload);
+}
+function projectCodexSubagentActivity(states) {
+  if (states.length === 0) return void 0;
+  return {
+    started: states.filter((state) => state.startObserved).length,
+    stopped: states.filter((state) => state.stopObserved).length,
+    agentTypes: [...new Set(states.map((state) => state.agentTypeLabel))].sort(),
+    usageStatus: "unavailable"
+  };
+}
+function handleCodexSubagentHook(rawText, kind) {
+  try {
+    const parsed = JSON.parse(rawText);
+    recordCodexSubagentPayload(parsed, kind);
+  } catch (error) {
+    const integrityFailure = error instanceof Error && (error.message.includes("activity key integrity mismatch") || error.message.includes("activity key with existing ledger") || error.message.includes("activity ledger keyCheck"));
+    logError(
+      "codex-subagent-hook",
+      new Error(integrityFailure ? "key integrity mismatch; manual recovery required; hook event was not recorded" : "hook event was not recorded")
+    );
+  }
+}
+function handleCodexUserPromptSubmitHook(rawText) {
+  try {
+    const parsed = JSON.parse(rawText);
+    if (openCodexRootContext(parsed) === null) throw new Error("invalid hook payload");
+  } catch {
+    logError("codex-root-hook", new Error("root context was not recorded"));
+  }
+}
+
+export {
+  normalizeAgentType,
+  validateCodexSubagentPayload,
+  reduceCodexSubagentActivity,
+  acquireCodexActivityLock,
+  recordCodexSubagentEvent,
+  recordCodexSubagentPayload,
+  readCodexSubagentActivity,
+  openCodexRootContext,
+  closeCodexRootContext,
+  codexActivityProjectionKey,
+  projectCodexSubagentActivity,
+  handleCodexSubagentHook,
+  handleCodexUserPromptSubmitHook,
+  configFilePath,
+  paths,
+  readConfig,
+  readMuteState,
+  isMuted,
+  writeMuteState,
+  clearMuteState,
+  loadCursor,
+  sanitizeCursor,
+  saveCursor,
+  appendTurn,
+  readTurns,
+  todayTotalUSD,
+  currentMonthTotals,
+  logError
+};