@cohortapp/agent-sdk 2.17.0 → 2.18.4

package/lib/diagnostics/counters.test.mjs

@@ -1,206 +0,0 @@
-/**
- * lib/diagnostics/counters.test.mjs
- *
- * node:test coverage for the loud guard-fail-open counters:
- *  - bump increments the in-memory tally and persists a JSONL row
- *  - bump persists to the date-stamped path under the counters dir
- *  - snapshot sums today's rows per name from disk (cross-restart view)
- *  - snapshot is isolated to "today" by the injected clock
- *  - bump never throws on an un-serializable attr / bad name / failing append
- *  - snapshot never throws on a missing dir / corrupt line / unreadable file
- *  - concurrent-style appends (multiple rows) sum correctly
- *
- * Run: cd /Users/layla/maestro && node --test lib/diagnostics/counters.test.mjs
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readdirSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  bump,
-  snapshot,
-  memSnapshot,
-  resetMem,
-  listStreams,
-} from "./counters.mjs";
-
-function tmpDir() {
-  return mkdtempSync(join(tmpdir(), "maestro-counters-"));
-}
-
-/** Fixed clock at 2026-06-11T12:00:00Z. */
-const FIXED = Date.parse("2026-06-11T12:00:00.000Z");
-const fixedNow = () => FIXED;
-
-test("bump increments the in-memory tally and returns the new total", () => {
-  resetMem();
-  const captured = [];
-  const append = (p, row) => { captured.push({ p, row }); return true; };
-
-  const t1 = bump("rate_guard.persist_failed", { provider: "anthropic" }, { append, now: fixedNow });
-  const t2 = bump("rate_guard.persist_failed", { provider: "anthropic" }, { append, now: fixedNow });
-  assert.equal(t1, 1);
-  assert.equal(t2, 2);
-  assert.equal(memSnapshot()["rate_guard.persist_failed"], 2);
-  assert.equal(captured.length, 2);
-  assert.equal(captured[0].row.name, "rate_guard.persist_failed");
-  assert.equal(captured[0].row.by, 1);
-  assert.equal(captured[0].row.attrs.provider, "anthropic");
-  assert.equal(typeof captured[0].row.ts, "string");
-});
-
-test("bump honours an explicit increment amount", () => {
-  resetMem();
-  const append = () => true;
-  assert.equal(bump("budget.stale_ledger", {}, { append, by: 5, now: fixedNow }), 5);
-  assert.equal(bump("budget.stale_ledger", {}, { append, by: 3, now: fixedNow }), 8);
-});
-
-test("bump persists to a date-stamped path under the counters dir", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("g.fail", { reason: "x" }, { dir, now: fixedNow });
-    const files = readdirSync(dir);
-    assert.deepEqual(files, ["2026-06-11.jsonl"]);
-    const raw = readFileSync(join(dir, "2026-06-11.jsonl"), "utf-8").trim();
-    const row = JSON.parse(raw);
-    assert.equal(row.name, "g.fail");
-    assert.equal(row.by, 1);
-    assert.equal(row.attrs.reason, "x");
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("snapshot sums today's rows per name from disk", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("a", {}, { dir, now: fixedNow });
-    bump("a", {}, { dir, now: fixedNow });
-    bump("b", {}, { dir, now: fixedNow, by: 4 });
-    const snap = snapshot({ dir, now: fixedNow });
-    assert.equal(snap.a, 2);
-    assert.equal(snap.b, 4);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("snapshot is isolated to the clock's day", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    const day1 = () => Date.parse("2026-06-11T01:00:00.000Z");
-    const day2 = () => Date.parse("2026-06-12T01:00:00.000Z");
-    bump("x", {}, { dir, now: day1 });
-    bump("x", {}, { dir, now: day1 });
-    bump("x", {}, { dir, now: day2 });
-    // Two distinct day files exist.
-    assert.deepEqual(readdirSync(dir).sort(), ["2026-06-11.jsonl", "2026-06-12.jsonl"]);
-    // Each day's snapshot only sees its own rows.
-    assert.equal(snapshot({ dir, now: day1 }).x, 2);
-    assert.equal(snapshot({ dir, now: day2 }).x, 1);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("snapshot survives across a simulated restart (reads disk, not memory)", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("survives", {}, { dir, now: fixedNow });
-    bump("survives", {}, { dir, now: fixedNow });
-    // Simulate a process restart: the in-memory tally is gone, the disk isn't.
-    resetMem();
-    assert.deepEqual(memSnapshot(), {});
-    assert.equal(snapshot({ dir, now: fixedNow }).survives, 2);
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("bump never throws and still moves the in-memory tally when append fails", () => {
-  resetMem();
-  const failingAppend = () => { throw new Error("disk full"); };
-  // append throwing must NOT propagate; the in-memory tally must still advance.
-  const total = bump("resilient", {}, { append: failingAppend, now: fixedNow });
-  // append threw before returning, but the in-memory bump happened first.
-  assert.equal(total, 1);
-  assert.equal(memSnapshot().resilient, 1);
-});
-
-test("bump tolerates an un-serializable attr and a non-string name", () => {
-  resetMem();
-  const captured = [];
-  const append = (p, row) => { captured.push(row); return true; };
-  const circular = {};
-  circular.self = circular;
-  // A circular attrs object would break naive JSON.stringify; bump must not throw.
-  assert.doesNotThrow(() => bump("circ", circular, { append, now: fixedNow }));
-  // A non-string name folds to a stable string rather than dropping the row.
-  const total = bump(12345, {}, { append, now: fixedNow });
-  assert.equal(total, 1);
-  assert.equal(captured.at(-1).name, "12345");
-});
-
-test("an empty/whitespace name folds to 'unknown'", () => {
-  resetMem();
-  const captured = [];
-  const append = (p, row) => { captured.push(row); return true; };
-  bump("   ", {}, { append, now: fixedNow });
-  assert.equal(captured.at(-1).name, "unknown");
-});
-
-test("snapshot returns {} for a missing dir and never throws", () => {
-  resetMem();
-  const dir = join(tmpDir(), "does-not-exist");
-  assert.deepEqual(snapshot({ dir, now: fixedNow }), {});
-});
-
-test("snapshot skips corrupt lines but sums the valid ones", () => {
-  resetMem();
-  const good = JSON.stringify({ name: "ok", by: 2 });
-  const good2 = JSON.stringify({ name: "ok", by: 3 });
-  const raw = `${good}\nnot json at all\n${good2}\n{"name":123}\n`;
-  const read = () => raw;
-  const snap = snapshot({ now: fixedNow, read });
-  assert.equal(snap.ok, 5); // 2 + 3; the garbage line and the bad-name line skip
-});
-
-test("snapshot treats a row with a missing/NaN by as 1", () => {
-  resetMem();
-  const raw = `${JSON.stringify({ name: "n" })}\n${JSON.stringify({ name: "n", by: "x" })}\n`;
-  const snap = snapshot({ now: fixedNow, read: () => raw });
-  assert.equal(snap.n, 2); // both default to +1
-});
-
-test("snapshot returns {} when the reader throws (unreadable file)", () => {
-  resetMem();
-  const read = () => { throw new Error("EACCES"); };
-  assert.deepEqual(snapshot({ now: fixedNow, read }), {});
-});
-
-test("listStreams enumerates the date-stamped streams in order", () => {
-  resetMem();
-  const dir = tmpDir();
-  try {
-    bump("s", {}, { dir, now: () => Date.parse("2026-06-11T00:00:00Z") });
-    bump("s", {}, { dir, now: () => Date.parse("2026-06-09T00:00:00Z") });
-    const streams = listStreams({ dir });
-    assert.equal(streams.length, 2);
-    assert.ok(streams[0].endsWith("2026-06-09.jsonl"));
-    assert.ok(streams[1].endsWith("2026-06-11.jsonl"));
-  } finally {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test("listStreams returns [] for a missing dir", () => {
-  assert.deepEqual(listStreams({ dir: join(tmpdir(), "nope-counters-xyz") }), []);
-});

package/lib/diagnostics/events.test.mjs

@@ -1,290 +0,0 @@
-/**
- * events.test.mjs — node:test coverage for the diagnostic-event spine.
- *
- * Hermetic: each test writes into an isolated tmpdir and injects a fixed clock,
- * so date-stamped filenames and timestamps are deterministic. We assert the
- * on-disk JSONL is valid, carries trace_id, and that emitEvent NEVER throws —
- * including on an unwritable directory.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { promises as fsp } from "node:fs";
-import { readFileSync, existsSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import {
-  emitEvent,
-  isValidEventType,
-  EVENT_TYPES,
-} from "./events.mjs";
-import { mintTraceId, withTrace } from "./trace.mjs";
-
-async function makeDir() {
-  const path = join(
-    tmpdir(),
-    `events-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
-  );
-  await fsp.mkdir(path, { recursive: true });
-  return path;
-}
-async function rm(path) {
-  try { await fsp.rm(path, { recursive: true, force: true }); } catch { /* */ }
-}
-
-const FIXED_MS = Date.UTC(2026, 5, 11, 12, 30, 0); // 2026-06-11T12:30:00Z
-const fixedNow = () => FIXED_MS;
-
-function readRows(logDir) {
-  const file = join(logDir, "2026-06-11.jsonl");
-  const body = readFileSync(file, "utf-8");
-  return body
-    .trim()
-    .split("\n")
-    .filter(Boolean)
-    .map((l) => JSON.parse(l)); // throws if any line is not valid JSON
-}
-
-// ---------------------------------------------------------------------------
-// EVENT_TYPES contract
-// ---------------------------------------------------------------------------
-
-test("EVENT_TYPES is the closed 8-type set and is frozen", () => {
-  const values = Object.values(EVENT_TYPES).sort();
-  assert.deepEqual(values, [
-    "classified",
-    "dispatched",
-    "error",
-    "guard_fail",
-    "item_received",
-    "sent",
-    "session_closed",
-    "session_opened",
-  ]);
-  assert.ok(Object.isFrozen(EVENT_TYPES));
-});
-
-test("isValidEventType only accepts the contract types", () => {
-  assert.equal(isValidEventType("item_received"), true);
-  assert.equal(isValidEventType("sent"), true);
-  assert.equal(isValidEventType("nope"), false);
-  assert.equal(isValidEventType(""), false);
-  assert.equal(isValidEventType(null), false);
-  assert.equal(isValidEventType(42), false);
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — happy path writes valid JSONL with trace_id
-// ---------------------------------------------------------------------------
-
-test("emitEvent writes a valid JSONL row with the full contract shape", async () => {
-  const logDir = await makeDir();
-  try {
-    const traceId = mintTraceId();
-    const ok = emitEvent(
-      {
-        type: EVENT_TYPES.ITEM_RECEIVED,
-        trace_id: traceId,
-        span: "root",
-        attrs: { source: "slack", item_id: "C123.456" },
-      },
-      { now: fixedNow, logDir }
-    );
-    assert.equal(ok, true);
-
-    const rows = readRows(logDir);
-    assert.equal(rows.length, 1);
-    const row = rows[0];
-    assert.equal(row.type, "item_received");
-    assert.equal(row.trace_id, traceId);
-    assert.equal(row.span, "root");
-    assert.equal(row.ts, "2026-06-11T12:30:00.000Z");
-    assert.deepEqual(row.attrs, { source: "slack", item_id: "C123.456" });
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent appends successive rows to the same date stream", async () => {
-  const logDir = await makeDir();
-  try {
-    const t = mintTraceId();
-    emitEvent({ type: "item_received", trace_id: t }, { now: fixedNow, logDir });
-    emitEvent({ type: "classified", trace_id: t }, { now: fixedNow, logDir });
-    emitEvent({ type: "sent", trace_id: t }, { now: fixedNow, logDir });
-    const rows = readRows(logDir);
-    assert.equal(rows.length, 3);
-    assert.deepEqual(rows.map((r) => r.type), ["item_received", "classified", "sent"]);
-    // All correlate to one interaction.
-    assert.ok(rows.every((r) => r.trace_id === t));
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent names the file by UTC date of the event", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "sent" }, { now: fixedNow, logDir });
-    assert.ok(existsSync(join(logDir, "2026-06-11.jsonl")));
-  } finally {
-    await rm(logDir);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — ambient trace context fills trace_id/span
-// ---------------------------------------------------------------------------
-
-test("emitEvent inherits trace_id/span from the ambient withTrace context", async () => {
-  const logDir = await makeDir();
-  try {
-    const traceId = mintTraceId();
-    withTrace({ trace_id: traceId, span: "root.classify" }, () => {
-      emitEvent({ type: "classified", attrs: { category: "action_required" } }, {
-        now: fixedNow,
-        logDir,
-      });
-    });
-    const [row] = readRows(logDir);
-    assert.equal(row.trace_id, traceId);
-    assert.equal(row.span, "root.classify");
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent trace_id is null when no id supplied and no ambient context", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "error", attrs: { msg: "boom" } }, { now: fixedNow, logDir });
-    const [row] = readRows(logDir);
-    assert.equal(row.trace_id, null);
-    assert.equal(row.span, "root");
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("an explicit trace_id overrides the ambient context", async () => {
-  const logDir = await makeDir();
-  try {
-    const ambient = mintTraceId();
-    const explicit = mintTraceId();
-    withTrace(ambient, () => {
-      emitEvent({ type: "sent", trace_id: explicit }, { now: fixedNow, logDir });
-    });
-    const [row] = readRows(logDir);
-    assert.equal(row.trace_id, explicit);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — closed type set: unknown type is coerced to error
-// ---------------------------------------------------------------------------
-
-test("an unknown event type is coerced to error and preserves the original", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "totally_made_up", attrs: { a: 1 } }, { now: fixedNow, logDir });
-    const [row] = readRows(logDir);
-    assert.equal(row.type, "error");
-    assert.equal(row.attrs._invalid_type, "totally_made_up");
-    assert.equal(row.attrs.a, 1);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("a missing type is coerced to error with _invalid_type null", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ attrs: {} }, { now: fixedNow, logDir });
-    const [row] = readRows(logDir);
-    assert.equal(row.type, "error");
-    assert.equal(row.attrs._invalid_type, null);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-// ---------------------------------------------------------------------------
-// emitEvent — never throws; degrades to false
-// ---------------------------------------------------------------------------
-
-test("emitEvent never throws on a bad/unwritable dir (returns false)", async () => {
-  const logDir = await makeDir();
-  try {
-    // Make the diagnostics dir a FILE so mkdir/append fails.
-    const blocker = join(logDir, "blocked");
-    await fsp.writeFile(blocker, "x");
-    // Point logDir at a path under the file → cannot create a directory there.
-    const badDir = join(blocker, "diagnostics");
-    let ok;
-    assert.doesNotThrow(() => {
-      ok = emitEvent({ type: "sent", trace_id: "T" }, { now: fixedNow, logDir: badDir });
-    });
-    assert.equal(ok, false);
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent never throws on a null/garbage event argument", () => {
-  let ok;
-  assert.doesNotThrow(() => {
-    ok = emitEvent(null, { append: () => true });
-  });
-  assert.equal(ok, true); // coerced to {} → error row, write succeeds
-});
-
-test("emitEvent returns false when the injected appender fails", () => {
-  const ok = emitEvent(
-    { type: "sent", trace_id: "T" },
-    { append: () => false }
-  );
-  assert.equal(ok, false);
-});
-
-test("emitEvent never throws when the appender itself throws", () => {
-  let ok;
-  assert.doesNotThrow(() => {
-    ok = emitEvent({ type: "sent" }, {
-      append: () => { throw new Error("disk gone"); },
-    });
-  });
-  assert.equal(ok, false);
-});
-
-test("emitEvent tolerates non-object attrs by wrapping them", async () => {
-  const logDir = await makeDir();
-  try {
-    emitEvent({ type: "sent", trace_id: "T", attrs: "just a string" }, {
-      now: fixedNow,
-      logDir,
-    });
-    const [row] = readRows(logDir);
-    assert.deepEqual(row.attrs, { value: "just a string" });
-  } finally {
-    await rm(logDir);
-  }
-});
-
-test("emitEvent uses the injected appender with the date-stamped path", () => {
-  const calls = [];
-  const ok = emitEvent(
-    { type: "dispatched", trace_id: "T" },
-    {
-      now: fixedNow,
-      logDir: "/somewhere/logs/diagnostics",
-      append: (path, record) => { calls.push({ path, record }); return true; },
-    }
-  );
-  assert.equal(ok, true);
-  assert.equal(calls.length, 1);
-  assert.equal(calls[0].path, "/somewhere/logs/diagnostics/2026-06-11.jsonl");
-  assert.equal(calls[0].record.type, "dispatched");
-});

package/lib/diagnostics/otel.test.mjs

@@ -1,196 +0,0 @@
-/**
- * otel.test.mjs — node:test coverage for the Claude Code OTLP env builder.
- *
- * Pure-function tests: env and identity are passed in, never read from the real
- * process.env, so nothing leaks between cases. We assert the builder emits env
- * ONLY when enabled, stamps service.name + agent id, and never throws.
- */
-
-import { test } from "node:test";
-import assert from "node:assert/strict";
-
-import {
-  buildOtelEnv,
-  otelEnabled,
-  deriveAgentId,
-  buildResourceAttributes,
-} from "./otel.mjs";
-
-// ---------------------------------------------------------------------------
-// otelEnabled
-// ---------------------------------------------------------------------------
-
-test("otelEnabled is false by default (empty env, no config)", () => {
-  assert.equal(otelEnabled({ env: {}, config: {} }), false);
-});
-
-test("otelEnabled honours MAESTRO_OTEL truthy values", () => {
-  for (const v of ["1", "true", "yes", "on", "TRUE", "On"]) {
-    assert.equal(otelEnabled({ env: { MAESTRO_OTEL: v }, config: {} }), true, v);
-  }
-  for (const v of ["0", "false", "no", "off", "", "nope"]) {
-    assert.equal(otelEnabled({ env: { MAESTRO_OTEL: v }, config: {} }), false, v);
-  }
-});
-
-test("config.enabled boolean overrides the env flag", () => {
-  // config wins both ways
-  assert.equal(otelEnabled({ env: { MAESTRO_OTEL: "1" }, config: { enabled: false } }), false);
-  assert.equal(otelEnabled({ env: { MAESTRO_OTEL: "0" }, config: { enabled: true } }), true);
-});
-
-// ---------------------------------------------------------------------------
-// buildOtelEnv — disabled => empty
-// ---------------------------------------------------------------------------
-
-test("buildOtelEnv returns an empty map when disabled", () => {
-  assert.deepEqual(buildOtelEnv({ env: {}, config: {} }), {});
-  assert.deepEqual(
-    buildOtelEnv({ env: { MAESTRO_OTEL: "0" }, config: {}, identity: { repoSlug: "alex-ai" } }),
-    {}
-  );
-});
-
-test("the empty map is safe to spread (no telemetry keys leak)", () => {
-  const merged = { PATH: "/usr/bin", ...buildOtelEnv({ env: {}, config: {} }) };
-  assert.deepEqual(Object.keys(merged), ["PATH"]);
-});
-
-// ---------------------------------------------------------------------------
-// buildOtelEnv — enabled => full block with sane defaults
-// ---------------------------------------------------------------------------
-
-test("buildOtelEnv emits the enabling block when MAESTRO_OTEL=1", () => {
-  const env = buildOtelEnv({
-    env: { MAESTRO_OTEL: "1" },
-    config: {},
-    identity: { repoSlug: "alex-ai" },
-  });
-  assert.equal(env.CLAUDE_CODE_ENABLE_TELEMETRY, "1");
-  assert.equal(env.OTEL_METRICS_EXPORTER, "otlp");
-  assert.equal(env.OTEL_LOGS_EXPORTER, "otlp");
-  assert.equal(env.OTEL_TRACES_EXPORTER, "otlp");
-  assert.equal(env.OTEL_EXPORTER_OTLP_PROTOCOL, "http/protobuf");
-});
-
-test("buildOtelEnv stamps service.name and agent id into resource attributes", () => {
-  const env = buildOtelEnv({
-    config: { enabled: true },
-    identity: { repoSlug: "alex-ai", maestroVersion: "0.15.2" },
-  });
-  const attrs = env.OTEL_RESOURCE_ATTRIBUTES;
-  assert.ok(attrs.includes("service.name=maestro-agent"), attrs);
-  assert.ok(attrs.includes("service.version=0.15.2"), attrs);
-  assert.ok(attrs.includes("service.instance.id=alex-ai"), attrs);
-  assert.ok(attrs.includes("agent.id=alex-ai"), attrs);
-});
-
-test("buildOtelEnv lets serviceName be overridden", () => {
-  const env = buildOtelEnv({
-    config: { enabled: true },
-    identity: { repoSlug: "robin-ai" },
-    serviceName: "claude-code-robin",
-  });
-  assert.ok(env.OTEL_RESOURCE_ATTRIBUTES.includes("service.name=claude-code-robin"));
-});
-
-// ---------------------------------------------------------------------------
-// buildOtelEnv — optional knobs only when present
-// ---------------------------------------------------------------------------
-
-test("endpoint/headers/intervals are emitted only when configured", () => {
-  const bare = buildOtelEnv({ config: { enabled: true }, identity: { repoSlug: "a" } });
-  assert.ok(!("OTEL_EXPORTER_OTLP_ENDPOINT" in bare));
-  assert.ok(!("OTEL_EXPORTER_OTLP_HEADERS" in bare));
-  assert.ok(!("OTEL_METRIC_EXPORT_INTERVAL" in bare));
-  assert.ok(!("OTEL_LOGS_EXPORT_INTERVAL" in bare));
-
-  const full = buildOtelEnv({
-    config: {
-      enabled: true,
-      endpoint: "https://otel.fleet.internal:4318",
-      headers: "Authorization=Bearer xyz",
-      protocol: "grpc",
-      metricExportIntervalMs: 60000,
-      logsExportIntervalMs: 5000,
-    },
-    identity: { repoSlug: "a" },
-  });
-  assert.equal(full.OTEL_EXPORTER_OTLP_ENDPOINT, "https://otel.fleet.internal:4318");
-  assert.equal(full.OTEL_EXPORTER_OTLP_HEADERS, "Authorization=Bearer xyz");
-  assert.equal(full.OTEL_EXPORTER_OTLP_PROTOCOL, "grpc");
-  assert.equal(full.OTEL_METRIC_EXPORT_INTERVAL, "60000");
-  assert.equal(full.OTEL_LOGS_EXPORT_INTERVAL, "5000");
-});
-
-test("config takes precedence over env for exporter knobs", () => {
-  const env = buildOtelEnv({
-    env: { MAESTRO_OTEL: "1", OTEL_EXPORTER_OTLP_ENDPOINT: "http://env-endpoint:4318" },
-    config: { endpoint: "http://config-endpoint:4318" },
-    identity: { repoSlug: "a" },
-  });
-  assert.equal(env.OTEL_EXPORTER_OTLP_ENDPOINT, "http://config-endpoint:4318");
-});
-
-test("env supplies the endpoint when config omits it", () => {
-  const env = buildOtelEnv({
-    env: { MAESTRO_OTEL: "1", OTEL_EXPORTER_OTLP_ENDPOINT: "http://env-endpoint:4318" },
-    config: {},
-    identity: { repoSlug: "a" },
-  });
-  assert.equal(env.OTEL_EXPORTER_OTLP_ENDPOINT, "http://env-endpoint:4318");
-});
-
-test("extra resource attributes from config are appended", () => {
-  const env = buildOtelEnv({
-    config: { enabled: true, resourceAttributes: { "deployment.environment": "prod" } },
-    identity: { repoSlug: "a" },
-  });
-  assert.ok(env.OTEL_RESOURCE_ATTRIBUTES.includes("deployment.environment=prod"));
-});
-
-// ---------------------------------------------------------------------------
-// deriveAgentId
-// ---------------------------------------------------------------------------
-
-test("deriveAgentId prefers explicit id, then repoSlug, then name", () => {
-  assert.equal(deriveAgentId({ agentId: "spiffe-007", repoSlug: "x" }), "spiffe-007");
-  assert.equal(deriveAgentId({ repoSlug: "Alex-AI" }), "alex-ai");
-  assert.equal(deriveAgentId({ fullName: "Robin Quist" }), "robin-quist");
-  assert.equal(deriveAgentId({}), "");
-});
-
-test("deriveAgentId slugifies unsafe characters", () => {
-  assert.equal(deriveAgentId({ fullName: "Señor  Tester!" }), "se-or-tester");
-});
-
-// ---------------------------------------------------------------------------
-// buildResourceAttributes — formatting + sanitization
-// ---------------------------------------------------------------------------
-
-test("buildResourceAttributes skips empty values (no dangling k=)", () => {
-  const attrs = buildResourceAttributes({ serviceName: "svc", serviceVersion: "", agentId: "" });
-  assert.equal(attrs, "service.name=svc");
-});
-
-test("buildResourceAttributes sanitizes comma/equals inside a value", () => {
-  const attrs = buildResourceAttributes({
-    serviceName: "svc",
-    agentId: "a=b,c",
-  });
-  // a=b,c would corrupt the k=v,k=v list; commas/equals stripped to spaces.
-  assert.ok(!attrs.includes("a=b,c"));
-  assert.ok(attrs.includes("agent.id=a b c"));
-});
-
-// ---------------------------------------------------------------------------
-// never throws
-// ---------------------------------------------------------------------------
-
-test("buildOtelEnv never throws on garbage input", () => {
-  let out;
-  assert.doesNotThrow(() => {
-    out = buildOtelEnv({ env: null, config: null, identity: null });
-  });
-  assert.equal(typeof out, "object");
-});