sentinelayer-cli 0.8.0 → 0.8.2

package/src/commands/spec.js

@@ -13,6 +13,7 @@ import { loadConfig } from "../config/service.js";
 import { evaluateBudget } from "../cost/budget.js";
 import { appendCostEntry, summarizeCostHistory } from "../cost/history.js";
 import { estimateModelCost } from "../cost/tracker.js";
+import { estimateTokens } from "../cost/tokenizer.js";
 import { formatIngestResolutionNotice, resolveCodebaseIngest } from "../ingest/engine.js";
 import {
   buildLineDiff,
@@ -145,14 +146,6 @@ async function detectSessionActive(targetPath) {
   return false;
 }
 
-function estimateTokenCount(text) {
-  const normalized = String(text || "");
-  if (!normalized) {
-    return 0;
-  }
-  return Math.max(1, Math.ceil(normalized.length / 4));
-}
-
 function resolveConfiguredApiKey(provider, resolvedConfig = {}) {
   const normalizedProvider = String(provider || "").trim().toLowerCase();
   if (normalizedProvider === "openai") {
@@ -295,8 +288,8 @@ async function maybeEnhanceSpecWithAi({
   const normalizedText = String(result.text || "").trim();
   const enhancedMarkdown = normalizedText || baseSpecMarkdown;
 
-  const inputTokens = estimateTokenCount(prompt);
-  const outputTokens = estimateTokenCount(enhancedMarkdown);
+  const inputTokens = estimateTokens(prompt, { model: result.model });
+  const outputTokens = estimateTokens(enhancedMarkdown, { model: result.model });
   const modelCost = maybeEstimateModelCost({
     modelId: result.model,
     inputTokens,

package/src/coord/events-log.js

@@ -0,0 +1,141 @@
+// Append-only event log for the handshake primitive (#A9, spec §5.6).
+//
+// Every state transition — lock_granted, lock_denied, lock_renewed,
+// lock_preempted, lock_released, lock_expired, deadlock_broken, wait_recorded
+// — is written to .sentinel/events.jsonl. The log is the source of truth
+// for replay / audit; callers should never mutate it in place.
+//
+// We serialize writes with a directory-mkdir mutex so concurrent personas on
+// the same filesystem (workers + Omar Gate runner) don't interleave bytes.
+
+import fsp from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { setTimeout as sleep } from "node:timers/promises";
+
+import {
+  resolveEventsLockPath,
+  resolveEventsPath,
+  resolveSentinelDir,
+} from "./paths.js";
+
+const EVENTS_LOCK_TIMEOUT_MS = 5000;
+const EVENTS_LOCK_STALE_MS = 30_000;
+const EVENTS_LOCK_POLL_MS = 25;
+
+const KNOWN_EVENT_TYPES = new Set([
+  "lock_granted",
+  "lock_renewed",
+  "lock_denied",
+  "lock_preempted",
+  "lock_released",
+  "lock_expired",
+  "wait_recorded",
+  "wait_cleared",
+  "deadlock_broken",
+]);
+
+async function acquireEventsLock(
+  lockPath,
+  { timeoutMs = EVENTS_LOCK_TIMEOUT_MS, staleMs = EVENTS_LOCK_STALE_MS, pollMs = EVENTS_LOCK_POLL_MS } = {}
+) {
+  const start = Date.now();
+  while (true) {
+    try {
+      await fsp.mkdir(lockPath);
+      return;
+    } catch (err) {
+      const code = err && typeof err === "object" ? err.code : "";
+      if (code !== "EEXIST" && code !== "EPERM" && code !== "EACCES") {
+        throw err;
+      }
+      try {
+        const stat = await fsp.stat(lockPath);
+        const ageMs = Date.now() - Number(stat.mtimeMs || 0);
+        if (Number.isFinite(ageMs) && ageMs > staleMs) {
+          await fsp.rm(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        // Stat race — loop back.
+      }
+      if (Date.now() - start >= timeoutMs) {
+        throw new Error("Timed out waiting for .sentinel/events.jsonl lock.");
+      }
+      await sleep(pollMs);
+    }
+  }
+}
+
+async function releaseEventsLock(lockPath) {
+  await fsp.rm(lockPath, { recursive: true, force: true }).catch(() => {});
+}
+
+function stripUndefined(record) {
+  const out = {};
+  for (const [key, value] of Object.entries(record || {})) {
+    if (value !== undefined) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+export async function appendEvent(event, { targetPath = process.cwd() } = {}) {
+  const type = String(event?.type || "").trim();
+  if (!type) {
+    throw new Error("event.type is required.");
+  }
+  if (!KNOWN_EVENT_TYPES.has(type)) {
+    throw new Error(`Unknown handshake event type: ${type}`);
+  }
+
+  const sentinelDir = resolveSentinelDir({ targetPath });
+  await fsp.mkdir(sentinelDir, { recursive: true });
+
+  const record = stripUndefined({
+    schemaVersion: "1.0.0",
+    type,
+    ts: event.ts || new Date().toISOString(),
+    ...event,
+  });
+
+  const eventsPath = resolveEventsPath({ targetPath });
+  const lockPath = resolveEventsLockPath({ targetPath });
+
+  await acquireEventsLock(lockPath);
+  try {
+    await fsp.appendFile(eventsPath, `${JSON.stringify(record)}\n`, "utf-8");
+  } finally {
+    await releaseEventsLock(lockPath);
+  }
+  return record;
+}
+
+export async function readEvents({ targetPath = process.cwd() } = {}) {
+  const eventsPath = resolveEventsPath({ targetPath });
+  let raw;
+  try {
+    raw = await fsp.readFile(eventsPath, "utf-8");
+  } catch (err) {
+    if (err && typeof err === "object" && err.code === "ENOENT") {
+      return [];
+    }
+    throw err;
+  }
+  const events = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      events.push(JSON.parse(trimmed));
+    } catch {
+      // Corrupt row — skip rather than fail the caller.
+    }
+  }
+  return events;
+}
+
+export { KNOWN_EVENT_TYPES };