opencode-swarm 7.136.4 → 7.137.0

package/dist/cli/index-h5sbn1zr.js

@@ -0,0 +1,1670 @@
+// @bun
+import {
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
+
+// src/telemetry.ts
+import * as fs from "fs";
+import { createWriteStream } from "fs";
+import * as os from "os";
+import * as path from "path";
+
+// src/observability/catalog.ts
+var CATALOG_TEST_FILE = "tests/unit/observability/catalog-contract.test.ts";
+var ISSUE_SINK = 2047;
+var ISSUE_LIFECYCLE_RETENTION = 2045;
+var ISSUE_COST_RETENTION = 2043;
+var ISSUE_PLAN_EVIDENCE_RETENTION = 2036;
+var NO_WORKFLOW_IDS = Object.freeze([]);
+var NO_CONSUMERS = Object.freeze([]);
+var REQUIRE_SESSION = Object.freeze([
+  "hostSessionId"
+]);
+var REQUIRE_SESSION_AND_TASK = Object.freeze([
+  "hostSessionId",
+  "taskId"
+]);
+var REQUIRE_TASK = Object.freeze(["taskId"]);
+var FORBID_SESSION = Object.freeze([
+  "hostSessionId"
+]);
+var CONSUMER_COST_ACCOUNTING = Object.freeze([
+  "src/services/cost-accounting.ts:127"
+]);
+var CONSUMER_GATE_STATS = Object.freeze(["src/evaluation/gate-stats.ts:99"]);
+var CONSUMER_HEARTBEAT_LISTENER = Object.freeze(["src/telemetry.ts:153"]);
+function defineEntry(kind, input) {
+  const entry = {
+    kind,
+    category: input.category,
+    severity: input.severity,
+    privacyClass: input.privacyClass,
+    producer: input.producer,
+    consumers: input.consumers,
+    retentionOwnerIssue: input.retentionOwnerIssue,
+    requiredWorkflowIds: input.requiredWorkflowIds ?? NO_WORKFLOW_IDS,
+    forbiddenWorkflowIds: input.forbiddenWorkflowIds ?? NO_WORKFLOW_IDS,
+    requiresParent: input.requiresParent ?? false,
+    allowsLinks: input.allowsLinks ?? true,
+    otelMapping: input.otelMapping ?? "none",
+    docAnchor: `#${kind}`,
+    testFile: CATALOG_TEST_FILE
+  };
+  if (input.futureOwnerIssue !== undefined) {
+    return Object.freeze({
+      ...entry,
+      futureOwnerIssue: input.futureOwnerIssue
+    });
+  }
+  return Object.freeze(entry);
+}
+var CATALOG_SOURCE = [
+  [
+    "session_started",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:399",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      otelMapping: "openinference"
+    }
+  ],
+  [
+    "session_ended",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:403",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      otelMapping: "openinference"
+    }
+  ],
+  [
+    "agent_activated",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:407",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      otelMapping: "openinference"
+    }
+  ],
+  [
+    "task_state_changed",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:444",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION_AND_TASK,
+      otelMapping: "openinference"
+    }
+  ],
+  [
+    "phase_changed",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:492",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      otelMapping: "openinference"
+    }
+  ],
+  [
+    "heartbeat",
+    {
+      category: "lifecycle",
+      severity: "debug",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:642",
+      consumers: CONSUMER_HEARTBEAT_LISTENER,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      allowsLinks: false
+    }
+  ],
+  [
+    "turbo_mode_changed",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:650",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "environment_detected",
+    {
+      category: "lifecycle",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:675",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      allowsLinks: false
+    }
+  ],
+  [
+    "delegation_begin",
+    {
+      category: "delegation",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:411",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION_AND_TASK,
+      otelMapping: "genai"
+    }
+  ],
+  [
+    "delegation_end",
+    {
+      category: "delegation",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:421",
+      consumers: CONSUMER_COST_ACCOUNTING,
+      retentionOwnerIssue: ISSUE_COST_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION_AND_TASK,
+      otelMapping: "genai"
+    }
+  ],
+  [
+    "model_fallback",
+    {
+      category: "delegation",
+      severity: "notice",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:506",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION,
+      otelMapping: "genai"
+    }
+  ],
+  [
+    "gate_passed",
+    {
+      category: "gate",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:453",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION_AND_TASK
+    }
+  ],
+  [
+    "gate_failed",
+    {
+      category: "gate",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:470",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION_AND_TASK
+    }
+  ],
+  [
+    "gate_parse_error",
+    {
+      category: "gate",
+      severity: "warning",
+      privacyClass: "sensitive",
+      producer: "src/telemetry.ts:457",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_TASK,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "reviewer_gate_decision",
+    {
+      category: "gate",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:480",
+      consumers: CONSUMER_GATE_STATS,
+      retentionOwnerIssue: ISSUE_LIFECYCLE_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION_AND_TASK
+    }
+  ],
+  [
+    "budget_updated",
+    {
+      category: "cost",
+      severity: "info",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:496",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_COST_RETENTION,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "hard_limit_hit",
+    {
+      category: "guardrail",
+      severity: "error",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:521",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "revision_limit_hit",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:530",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "loop_detected",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "sensitive",
+      producer: "src/telemetry.ts:534",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "scope_violation",
+    {
+      category: "guardrail",
+      severity: "error",
+      privacyClass: "sensitive",
+      producer: "src/telemetry.ts:630",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "qa_skip_violation",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:638",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "auto_oversight_escalation",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:660",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "no_op_strong_warning",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:548",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "gate_denial_loop",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:569",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "execution_stall_warning",
+    {
+      category: "guardrail",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:583",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "execution_stall_denied",
+    {
+      category: "guardrail",
+      severity: "error",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:600",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "swarm_internals_read_denied",
+    {
+      category: "guardrail",
+      severity: "error",
+      privacyClass: "sensitive",
+      producer: "src/telemetry.ts:617",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "prm_hard_stop_delivered",
+    {
+      category: "prm",
+      severity: "error",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:752",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "prm_pattern_detected",
+    {
+      category: "prm",
+      severity: "notice",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:690",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "prm_course_correction_injected",
+    {
+      category: "prm",
+      severity: "notice",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:704",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "prm_escalation_triggered",
+    {
+      category: "prm",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:717",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "prm_hard_stop",
+    {
+      category: "prm",
+      severity: "critical",
+      privacyClass: "pseudonymous",
+      producer: "src/telemetry.ts:731",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: REQUIRE_SESSION
+    }
+  ],
+  [
+    "evidence_lock_acquired",
+    {
+      category: "evidence",
+      severity: "info",
+      privacyClass: "sensitive",
+      producer: "src/evidence/lock.ts:94",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
+      requiredWorkflowIds: REQUIRE_TASK,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "evidence_lock_contended",
+    {
+      category: "evidence",
+      severity: "notice",
+      privacyClass: "sensitive",
+      producer: "src/evidence/lock.ts:129",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
+      requiredWorkflowIds: REQUIRE_TASK,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "evidence_lock_stale_recovered",
+    {
+      category: "evidence",
+      severity: "notice",
+      privacyClass: "sensitive",
+      producer: "src/evidence/lock.ts:86",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
+      requiredWorkflowIds: REQUIRE_TASK,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "plan_ledger_cas_retry",
+    {
+      category: "plan",
+      severity: "notice",
+      privacyClass: "operational",
+      producer: "src/plan/manager.ts:329",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "plan_md_write_failed",
+    {
+      category: "plan",
+      severity: "warning",
+      privacyClass: "sensitive",
+      producer: "src/plan/manager.ts:1696",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "snapshot_failed",
+    {
+      category: "plan",
+      severity: "error",
+      privacyClass: "sensitive",
+      producer: "src/plan/ledger.ts:681",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
+      forbiddenWorkflowIds: FORBID_SESSION
+    }
+  ],
+  [
+    "agent_conflict_detected",
+    {
+      category: "conflict",
+      severity: "warning",
+      privacyClass: "pseudonymous",
+      producer: "src/hooks/conflict-resolution.ts:73",
+      consumers: NO_CONSUMERS,
+      futureOwnerIssue: ISSUE_SINK,
+      retentionOwnerIssue: ISSUE_SINK,
+      requiredWorkflowIds: Object.freeze([
+        "hostSessionId",
+        "phaseId"
+      ])
+    }
+  ]
+];
+var catalog = {};
+for (const [kind, input] of CATALOG_SOURCE) {
+  catalog[kind] = defineEntry(kind, input);
+}
+var EVENT_CATALOG = Object.freeze(catalog);
+var CATALOG_KINDS = Object.freeze(Object.keys(EVENT_CATALOG));
+function getCatalogEntry(kind) {
+  return Object.hasOwn(EVENT_CATALOG, kind) ? EVENT_CATALOG[kind] : undefined;
+}
+// src/observability/envelope.ts
+init_zod();
+var OBSERVABILITY_SCHEMA_VERSION = 1;
+var EventCategorySchema = exports_external.enum([
+  "lifecycle",
+  "delegation",
+  "gate",
+  "plan",
+  "evidence",
+  "guardrail",
+  "knowledge",
+  "cost",
+  "prm",
+  "conflict",
+  "unrecognized"
+]);
+var EventSeveritySchema = exports_external.enum([
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical"
+]);
+var PrivacyClassSchema = exports_external.enum([
+  "operational",
+  "pseudonymous",
+  "sensitive",
+  "content"
+]);
+var TimingConfidenceSchema = exports_external.enum([
+  "exact",
+  "writer-clock",
+  "inferred",
+  "unknown"
+]);
+var SpanLinkSchema = exports_external.object({
+  traceId: exports_external.string(),
+  spanId: exports_external.string(),
+  kind: exports_external.enum(["resume", "lane", "cross-process", "retry", "parent-batch"]),
+  note: exports_external.string().optional()
+});
+var TraceContextSchema = exports_external.object({
+  traceId: exports_external.string(),
+  spanId: exports_external.string(),
+  parentSpanId: exports_external.string().optional(),
+  links: exports_external.array(SpanLinkSchema)
+});
+var WorkflowIdsSchema = exports_external.object({
+  rootConversationId: exports_external.string().optional(),
+  hostSessionId: exports_external.string().optional(),
+  swarmSessionId: exports_external.string().optional(),
+  taskId: exports_external.string().optional(),
+  phaseId: exports_external.string().optional(),
+  laneId: exports_external.string().optional(),
+  batchId: exports_external.string().optional(),
+  resultId: exports_external.string().optional(),
+  councilRoundId: exports_external.string().optional(),
+  backgroundInvocationId: exports_external.string().optional(),
+  knowledgeTraceId: exports_external.string().optional(),
+  knowledgeEntryId: exports_external.string().optional(),
+  prRunId: exports_external.string().optional()
+});
+var LineageSchema = exports_external.object({
+  projectRef: exports_external.string().optional(),
+  cohortRef: exports_external.string().optional(),
+  worktreeRef: exports_external.string().optional()
+});
+var ProvenanceSchema = exports_external.object({
+  pluginVersion: exports_external.string().optional(),
+  opencodeVersion: exports_external.string().optional(),
+  runtime: exports_external.string().optional(),
+  runtimeVersion: exports_external.string().optional(),
+  os: exports_external.string().optional(),
+  arch: exports_external.string().optional(),
+  model: exports_external.string().optional(),
+  provider: exports_external.string().optional(),
+  gitSha: exports_external.string().optional(),
+  configHash: exports_external.string().optional()
+});
+var OutcomeSchema = exports_external.object({
+  status: exports_external.enum(["success", "failure", "partial", "unknown"]).optional(),
+  reason: exports_external.string().optional(),
+  errorName: exports_external.string().optional(),
+  errorMessage: exports_external.string().optional(),
+  retryIndex: exports_external.number().optional(),
+  durationMs: exports_external.number().optional()
+});
+var PolicySchema = exports_external.object({
+  sampled: exports_external.boolean(),
+  sampleRate: exports_external.number(),
+  dropReason: exports_external.string().optional(),
+  privacyClass: PrivacyClassSchema
+});
+var LegacyProjectionSchema = exports_external.object({
+  sourceStore: exports_external.string(),
+  sourceSchemaVersion: exports_external.number().nullable(),
+  timingConfidence: TimingConfidenceSchema,
+  unknown: exports_external.array(exports_external.string()),
+  extra: exports_external.record(exports_external.string(), exports_external.unknown()),
+  raw: exports_external.unknown()
+});
+var ObservabilityEventSchema = exports_external.object({
+  schemaVersion: exports_external.number(),
+  eventId: exports_external.string(),
+  kind: exports_external.string(),
+  category: EventCategorySchema,
+  severity: EventSeveritySchema,
+  occurredAt: exports_external.string(),
+  observedAt: exports_external.string(),
+  writerSequence: exports_external.number(),
+  trace: TraceContextSchema,
+  workflow: WorkflowIdsSchema,
+  lineage: LineageSchema,
+  provenance: ProvenanceSchema,
+  outcome: OutcomeSchema,
+  policy: PolicySchema,
+  legacy: LegacyProjectionSchema,
+  relationshipViolations: exports_external.array(exports_external.string())
+});
+// src/observability/ids.ts
+import { createHash, randomBytes, randomUUID } from "crypto";
+var TRACE_ID_BYTES = 16;
+var SPAN_ID_BYTES = 8;
+var TRACE_ID_HEX_LENGTH = TRACE_ID_BYTES * 2;
+var SPAN_ID_HEX_LENGTH = SPAN_ID_BYTES * 2;
+var ALL_ZERO_TRACE_ID = "0".repeat(TRACE_ID_HEX_LENGTH);
+var ALL_ZERO_SPAN_ID = "0".repeat(SPAN_ID_HEX_LENGTH);
+var SENTINEL_TRACE_ID = `${"0".repeat(TRACE_ID_HEX_LENGTH - 1)}1`;
+var SENTINEL_SPAN_ID = `${"0".repeat(SPAN_ID_HEX_LENGTH - 1)}1`;
+var MAX_REGENERATION_ATTEMPTS = 4;
+function newTraceId() {
+  for (let attempt = 0;attempt < MAX_REGENERATION_ATTEMPTS; attempt++) {
+    const hex = randomBytes(TRACE_ID_BYTES).toString("hex");
+    if (hex !== ALL_ZERO_TRACE_ID)
+      return hex;
+  }
+  return SENTINEL_TRACE_ID;
+}
+function newSpanId() {
+  for (let attempt = 0;attempt < MAX_REGENERATION_ATTEMPTS; attempt++) {
+    const hex = randomBytes(SPAN_ID_BYTES).toString("hex");
+    if (hex !== ALL_ZERO_SPAN_ID)
+      return hex;
+  }
+  return SENTINEL_SPAN_ID;
+}
+function newEventId() {
+  return randomUUID();
+}
+var POOL_DRAWS = 128;
+var POOL_BYTES = (TRACE_ID_BYTES + SPAN_ID_BYTES) * POOL_DRAWS;
+var _pool = Buffer.alloc(0);
+var _poolOffset = Number.POSITIVE_INFINITY;
+function takeIdBytes() {
+  const need = TRACE_ID_BYTES + SPAN_ID_BYTES;
+  if (_poolOffset + need > _pool.length) {
+    _pool = randomBytes(POOL_BYTES);
+    _poolOffset = 0;
+  }
+  const slice = _pool.subarray(_poolOffset, _poolOffset + need);
+  _poolOffset += need;
+  return slice;
+}
+function newTraceAndSpanId() {
+  const buffer = takeIdBytes();
+  const traceId = buffer.subarray(0, TRACE_ID_BYTES).toString("hex");
+  const spanId = buffer.subarray(TRACE_ID_BYTES).toString("hex");
+  if (traceId === ALL_ZERO_TRACE_ID || spanId === ALL_ZERO_SPAN_ID) {
+    return { traceId: newTraceId(), spanId: newSpanId() };
+  }
+  return { traceId, spanId };
+}
+// src/observability/legacy.ts
+var LEGACY_TELEMETRY_SOURCE_STORE = ".swarm/telemetry.jsonl";
+var NON_OBJECT_PAYLOAD_MARKER = "<non-object-payload>";
+var INTROSPECTION_FAILED_MARKER = "<payload-introspection-failed>";
+var LEGACY_ADAPTER_RULES = Object.freeze([
+  "Preserve unknown fields: an own key the contract does not recognize is kept under `extra` by reference and is never dropped.",
+  "Record the source store and its schema version: `sourceStore` names the file; `sourceSchemaVersion` is the version the store declares.",
+  "Preserve originally reported values: values are aliased, never coerced, normalized, rounded, or re-serialized.",
+  "Record timing confidence: a time read by the writer at record time is `writer-clock`, never `exact`.",
+  "Unknown is not zero: the adapter lists in `unknown` every catalogued key the PRODUCER left undefined, and never itself defaults one to 0, \"\", false, or null. The guarantee stops at the adapter boundary \u2014 a producer that pre-coerces its own defaults defeats it, because the adapter only ever sees the coerced value. The known instance is `delegation_end` (`src/telemetry.ts` `delegationEnd`, pre-existing): it coerces `?? 0` / `?? null` / `?? 'unavailable'` before emitting, so its cost fields can never appear in `unknown`; there, `cost_source: 'unavailable'` is how absence stays recoverable.",
+  "Missing lineage stays missing: an absent correlation ID stays `undefined` and is never synthesized to make a join succeed.",
+  "Never drop unrecognized fields: no allowlist filter is applied to the payload on the way through."
+]);
+var KNOWN_TELEMETRY_KEYS = Object.freeze({
+  session_started: Object.freeze(["sessionId", "agentName"]),
+  session_ended: Object.freeze(["sessionId", "reason"]),
+  agent_activated: Object.freeze(["sessionId", "agentName", "oldName"]),
+  delegation_begin: Object.freeze(["sessionId", "agentName", "taskId"]),
+  delegation_end: Object.freeze([
+    "sessionId",
+    "agentName",
+    "taskId",
+    "result",
+    "tokens_input",
+    "tokens_output",
+    "tokens_reasoning",
+    "tokens_cache",
+    "cost_usd",
+    "cost_source",
+    "model",
+    "gate",
+    "retry_index"
+  ]),
+  task_state_changed: Object.freeze([
+    "sessionId",
+    "taskId",
+    "newState",
+    "oldState"
+  ]),
+  gate_passed: Object.freeze(["sessionId", "gate", "taskId"]),
+  gate_parse_error: Object.freeze(["taskId", "errorName", "errorMessage"]),
+  gate_failed: Object.freeze(["sessionId", "gate", "taskId", "reason"]),
+  reviewer_gate_decision: Object.freeze([
+    "sessionId",
+    "gate",
+    "taskId",
+    "blocked",
+    "allowed",
+    "reasonCode",
+    "evidenceKind"
+  ]),
+  phase_changed: Object.freeze(["sessionId", "oldPhase", "newPhase"]),
+  budget_updated: Object.freeze(["sessionId", "budgetPct", "agentName"]),
+  model_fallback: Object.freeze([
+    "sessionId",
+    "agentName",
+    "fromModel",
+    "toModel",
+    "reason"
+  ]),
+  hard_limit_hit: Object.freeze([
+    "sessionId",
+    "agentName",
+    "limitType",
+    "value"
+  ]),
+  revision_limit_hit: Object.freeze(["sessionId", "agentName"]),
+  loop_detected: Object.freeze(["sessionId", "agentName", "loopType"]),
+  scope_violation: Object.freeze([
+    "sessionId",
+    "agentName",
+    "file",
+    "reason"
+  ]),
+  qa_skip_violation: Object.freeze(["sessionId", "agentName", "skipCount"]),
+  heartbeat: Object.freeze(["sessionId"]),
+  turbo_mode_changed: Object.freeze(["sessionId", "enabled", "agentName"]),
+  auto_oversight_escalation: Object.freeze([
+    "sessionId",
+    "reason",
+    "interactionCount",
+    "deadlockCount",
+    "phase"
+  ]),
+  environment_detected: Object.freeze([
+    "sessionId",
+    "hostOS",
+    "shellFamily",
+    "executionMode"
+  ]),
+  prm_pattern_detected: Object.freeze([
+    "sessionId",
+    "pattern",
+    "severity",
+    "category",
+    "stepRange"
+  ]),
+  prm_course_correction_injected: Object.freeze([
+    "sessionId",
+    "pattern",
+    "level"
+  ]),
+  prm_escalation_triggered: Object.freeze([
+    "sessionId",
+    "pattern",
+    "level",
+    "occurrenceCount"
+  ]),
+  prm_hard_stop: Object.freeze([
+    "sessionId",
+    "pattern",
+    "level",
+    "occurrenceCount"
+  ]),
+  no_op_strong_warning: Object.freeze([
+    "sessionId",
+    "agentName",
+    "count",
+    "threshold"
+  ]),
+  gate_denial_loop: Object.freeze(["sessionId", "tool", "code", "count"]),
+  execution_stall_warning: Object.freeze(["sessionId", "count", "threshold"]),
+  execution_stall_denied: Object.freeze([
+    "sessionId",
+    "tool",
+    "count",
+    "threshold"
+  ]),
+  swarm_internals_read_denied: Object.freeze(["sessionId", "tool", "target"]),
+  prm_hard_stop_delivered: Object.freeze([
+    "sessionId",
+    "pattern",
+    "level",
+    "occurrenceCount"
+  ]),
+  evidence_lock_acquired: Object.freeze([
+    "directory",
+    "evidencePath",
+    "agent",
+    "taskId",
+    "attempt"
+  ]),
+  evidence_lock_contended: Object.freeze([
+    "directory",
+    "evidencePath",
+    "agent",
+    "taskId",
+    "attempt"
+  ]),
+  evidence_lock_stale_recovered: Object.freeze([
+    "directory",
+    "evidencePath",
+    "agent",
+    "taskId",
+    "attempt"
+  ]),
+  plan_ledger_cas_retry: Object.freeze([
+    "attempt",
+    "expectedHashPrefix",
+    "delayMs"
+  ]),
+  plan_md_write_failed: Object.freeze(["directory", "error", "timestamp"]),
+  snapshot_failed: Object.freeze(["error", "retries", "source"]),
+  agent_conflict_detected: Object.freeze([
+    "type",
+    "timestamp",
+    "sessionId",
+    "phase",
+    "taskId",
+    "sourceAgent",
+    "targetAgent",
+    "conflictType",
+    "resolutionPath",
+    "summary"
+  ])
+});
+var EMPTY_EXTRA = Object.freeze({});
+var PROTO_KEY = "__proto__";
+function degradedProjection(marker, data) {
+  return {
+    sourceStore: LEGACY_TELEMETRY_SOURCE_STORE,
+    sourceSchemaVersion: null,
+    timingConfidence: "writer-clock",
+    unknown: [marker],
+    extra: EMPTY_EXTRA,
+    raw: data
+  };
+}
+var EMPTY_UNKNOWN = Object.freeze([]);
+var _knownKeySetCache = new WeakMap;
+function knownKeySetFor(knownKeys) {
+  const cached = _knownKeySetCache.get(knownKeys);
+  if (cached !== undefined)
+    return cached;
+  const built = new Set(knownKeys);
+  _knownKeySetCache.set(knownKeys, built);
+  return built;
+}
+function adaptLegacyTelemetryPayload(kind, data, knownKeys) {
+  if (data === null || typeof data !== "object") {
+    return degradedProjection(NON_OBJECT_PAYLOAD_MARKER, data);
+  }
+  try {
+    const record = data;
+    const known = knownKeySetFor(knownKeys);
+    const ownKeys = Object.keys(record);
+    let extra;
+    for (const key of ownKeys) {
+      if (known.has(key))
+        continue;
+      extra ??= {};
+      if (key === PROTO_KEY) {
+        Object.defineProperty(extra, key, {
+          value: record[key],
+          enumerable: true,
+          writable: true,
+          configurable: true
+        });
+        continue;
+      }
+      extra[key] = record[key];
+    }
+    let unknownFields;
+    for (const key of knownKeys) {
+      if (record[key] === undefined) {
+        unknownFields ??= [];
+        unknownFields.push(key);
+      }
+    }
+    return {
+      sourceStore: LEGACY_TELEMETRY_SOURCE_STORE,
+      sourceSchemaVersion: null,
+      timingConfidence: "writer-clock",
+      unknown: unknownFields ?? EMPTY_UNKNOWN,
+      extra: extra ?? EMPTY_EXTRA,
+      raw: data
+    };
+  } catch {
+    return degradedProjection(INTROSPECTION_FAILED_MARKER, data);
+  }
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function extractWorkflowIds(data) {
+  const ids = {};
+  try {
+    if (data === null || typeof data !== "object")
+      return ids;
+    const record = data;
+    const hostSessionId = nonEmptyString(record.sessionId);
+    if (hostSessionId !== undefined)
+      ids.hostSessionId = hostSessionId;
+    const taskId = nonEmptyString(record.taskId);
+    if (taskId !== undefined)
+      ids.taskId = taskId;
+    const laneId = nonEmptyString(record.laneId);
+    if (laneId !== undefined)
+      ids.laneId = laneId;
+    const batchId = nonEmptyString(record.batchId);
+    if (batchId !== undefined)
+      ids.batchId = batchId;
+    const phase = record.phase;
+    if (typeof phase === "number" && Number.isFinite(phase)) {
+      ids.phaseId = String(phase);
+    } else {
+      const phaseString = nonEmptyString(phase);
+      if (phaseString !== undefined)
+        ids.phaseId = phaseString;
+    }
+  } catch {}
+  return ids;
+}
+var RESULT_STATUS_MAP = Object.freeze({
+  success: "success",
+  succeeded: "success",
+  ok: "success",
+  pass: "success",
+  passed: "success",
+  complete: "success",
+  completed: "success",
+  failure: "failure",
+  failed: "failure",
+  fail: "failure",
+  error: "failure",
+  partial: "partial"
+});
+function extractOutcome(data) {
+  const outcome = {};
+  try {
+    if (data === null || typeof data !== "object")
+      return outcome;
+    const record = data;
+    const result = nonEmptyString(record.result);
+    if (result !== undefined) {
+      const normalized = result.toLowerCase();
+      outcome.status = Object.hasOwn(RESULT_STATUS_MAP, normalized) ? RESULT_STATUS_MAP[normalized] : "unknown";
+    }
+    const reason = nonEmptyString(record.reason);
+    if (reason !== undefined)
+      outcome.reason = reason;
+    const errorName = nonEmptyString(record.errorName);
+    if (errorName !== undefined)
+      outcome.errorName = errorName;
+    const errorMessage = nonEmptyString(record.errorMessage);
+    if (errorMessage !== undefined)
+      outcome.errorMessage = errorMessage;
+    const retryIndex = record.retry_index;
+    if (typeof retryIndex === "number" && Number.isFinite(retryIndex)) {
+      outcome.retryIndex = retryIndex;
+    }
+  } catch {}
+  return outcome;
+}
+// src/observability/relationships.ts
+var TRACE_ID_PATTERN = /^[0-9a-f]{32}$/;
+var SPAN_ID_PATTERN = /^[0-9a-f]{16}$/;
+var RELATIONSHIP_VIOLATION_CODES = Object.freeze({
+  unknownKind: "unknown_kind",
+  requiredWorkflowIdMissing: "required_workflow_id_missing",
+  forbiddenWorkflowIdPresent: "forbidden_workflow_id_present",
+  parentSpanNotAllowed: "parent_span_not_allowed",
+  parentSpanMissing: "parent_span_missing",
+  malformedParentSpanId: "malformed_parent_span_id",
+  linksNotAllowed: "links_not_allowed",
+  malformedLinkTraceId: "malformed_link_trace_id",
+  malformedLinkSpanId: "malformed_link_span_id",
+  validationFailed: "relationship_validation_failed"
+});
+function validateEventRelationships(event) {
+  const violations = [];
+  try {
+    const entry = getCatalogEntry(event.kind);
+    const links = Array.isArray(event.trace?.links) ? event.trace.links : [];
+    if (entry === undefined) {
+      violations.push(`${RELATIONSHIP_VIOLATION_CODES.unknownKind}:${event.kind}`);
+    } else {
+      const workflow = event.workflow ?? {};
+      for (const id of entry.requiredWorkflowIds) {
+        if (workflow[id] === undefined) {
+          violations.push(`${RELATIONSHIP_VIOLATION_CODES.requiredWorkflowIdMissing}:${id}`);
+        }
+      }
+      for (const id of entry.forbiddenWorkflowIds) {
+        if (workflow[id] !== undefined) {
+          violations.push(`${RELATIONSHIP_VIOLATION_CODES.forbiddenWorkflowIdPresent}:${id}`);
+        }
+      }
+      const parentSpanId = event.trace?.parentSpanId;
+      if (!entry.requiresParent && parentSpanId !== undefined) {
+        violations.push(RELATIONSHIP_VIOLATION_CODES.parentSpanNotAllowed);
+      }
+      if (entry.requiresParent && parentSpanId === undefined) {
+        violations.push(RELATIONSHIP_VIOLATION_CODES.parentSpanMissing);
+      }
+      if (parentSpanId !== undefined && !SPAN_ID_PATTERN.test(String(parentSpanId))) {
+        violations.push(RELATIONSHIP_VIOLATION_CODES.malformedParentSpanId);
+      }
+      if (!entry.allowsLinks && links.length > 0) {
+        violations.push(RELATIONSHIP_VIOLATION_CODES.linksNotAllowed);
+      }
+    }
+    for (let index = 0;index < links.length; index++) {
+      const link = links[index];
+      if (link === undefined || link === null)
+        continue;
+      if (!TRACE_ID_PATTERN.test(String(link.traceId))) {
+        violations.push(`${RELATIONSHIP_VIOLATION_CODES.malformedLinkTraceId}:${index}`);
+      }
+      if (!SPAN_ID_PATTERN.test(String(link.spanId))) {
+        violations.push(`${RELATIONSHIP_VIOLATION_CODES.malformedLinkSpanId}:${index}`);
+      }
+    }
+  } catch {
+    return {
+      ok: false,
+      violations: [RELATIONSHIP_VIOLATION_CODES.validationFailed]
+    };
+  }
+  return violations.length === 0 ? { ok: true } : { ok: false, violations };
+}
+
+// src/observability/sampling.ts
+var DEFAULT_SAMPLE_RATE = 1;
+var SAMPLE_SUFFIX_LENGTH = 8;
+var SAMPLE_DENOMINATOR = 4294967295;
+var SAMPLE_SUFFIX_PATTERN = /^[0-9a-f]{8}$/;
+function shouldSample(traceId, rate) {
+  if (typeof rate !== "number" || !Number.isFinite(rate))
+    return true;
+  if (rate >= 1)
+    return true;
+  if (rate <= 0)
+    return false;
+  if (typeof traceId !== "string" || traceId.length < SAMPLE_SUFFIX_LENGTH) {
+    return true;
+  }
+  const suffix = traceId.slice(-SAMPLE_SUFFIX_LENGTH).toLowerCase();
+  if (!SAMPLE_SUFFIX_PATTERN.test(suffix))
+    return true;
+  const value = Number.parseInt(suffix, 16);
+  if (!Number.isFinite(value))
+    return true;
+  return value / SAMPLE_DENOMINATOR < rate;
+}
+var METRIC_LABEL_ALLOWLIST = Object.freeze([
+  "kind",
+  "category",
+  "severity",
+  "outcome_status",
+  "cost_source",
+  "privacy_class",
+  "runtime",
+  "os",
+  "provider",
+  "sampled"
+]);
+var ALLOWED_LABELS = new Set(METRIC_LABEL_ALLOWLIST);
+var CARDINALITY_VIOLATION_CODES = Object.freeze({
+  notAllowlisted: "label_not_allowlisted",
+  highCardinalityShape: "high_cardinality_label_shape"
+});
+
+// src/observability/observe.ts
+var _provenance = Object.freeze({});
+var _lineage = Object.freeze({});
+var _writerSequence = 0;
+var _sampleRate = DEFAULT_SAMPLE_RATE;
+var EMPTY_KNOWN_KEYS = Object.freeze([]);
+var FALLBACK_EVENT_ID = "00000000-0000-4000-8000-000000000000";
+var FALLBACK_TRACE_ID = "00000000000000000000000000000001";
+var FALLBACK_SPAN_ID = "0000000000000001";
+var FALLBACK_TIMESTAMP = "1970-01-01T00:00:00.000Z";
+var OBSERVATION_BUILD_FAILED = "observation_build_failed";
+function nextWriterSequence() {
+  if (_writerSequence >= Number.MAX_SAFE_INTEGER)
+    _writerSequence = 0;
+  _writerSequence += 1;
+  return _writerSequence;
+}
+function safeNowIso() {
+  try {
+    return new Date().toISOString();
+  } catch {
+    return FALLBACK_TIMESTAMP;
+  }
+}
+function buildFallbackObservation(kind, data, writerSequence) {
+  const now = safeNowIso();
+  return {
+    schemaVersion: OBSERVABILITY_SCHEMA_VERSION,
+    eventId: FALLBACK_EVENT_ID,
+    kind,
+    category: "unrecognized",
+    severity: "error",
+    occurredAt: now,
+    observedAt: now,
+    writerSequence,
+    trace: { traceId: FALLBACK_TRACE_ID, spanId: FALLBACK_SPAN_ID, links: [] },
+    workflow: {},
+    lineage: {},
+    provenance: {},
+    outcome: {},
+    policy: {
+      sampled: shouldSample(FALLBACK_TRACE_ID, _sampleRate),
+      sampleRate: _sampleRate,
+      privacyClass: "operational"
+    },
+    legacy: {
+      sourceStore: LEGACY_TELEMETRY_SOURCE_STORE,
+      sourceSchemaVersion: null,
+      timingConfidence: "unknown",
+      unknown: [],
+      extra: {},
+      raw: data
+    },
+    relationshipViolations: [OBSERVATION_BUILD_FAILED]
+  };
+}
+function createObservation(kind, data) {
+  const writerSequence = nextWriterSequence();
+  try {
+    const entry = getCatalogEntry(kind);
+    const { traceId, spanId } = newTraceAndSpanId();
+    const observedAt = new Date().toISOString();
+    const knownKeys = Object.hasOwn(KNOWN_TELEMETRY_KEYS, kind) ? KNOWN_TELEMETRY_KEYS[kind] : EMPTY_KNOWN_KEYS;
+    const event = {
+      schemaVersion: OBSERVABILITY_SCHEMA_VERSION,
+      eventId: newEventId(),
+      kind,
+      category: entry?.category ?? "unrecognized",
+      severity: entry?.severity ?? "warning",
+      occurredAt: observedAt,
+      observedAt,
+      writerSequence,
+      trace: { traceId, spanId, links: [] },
+      workflow: extractWorkflowIds(data),
+      lineage: _lineage,
+      provenance: _provenance,
+      outcome: extractOutcome(data),
+      policy: {
+        sampled: shouldSample(traceId, _sampleRate),
+        sampleRate: _sampleRate,
+        privacyClass: entry?.privacyClass ?? "operational"
+      },
+      legacy: adaptLegacyTelemetryPayload(kind, data, knownKeys),
+      relationshipViolations: []
+    };
+    const validation = validateEventRelationships(event);
+    if (!validation.ok)
+      event.relationshipViolations = validation.violations;
+    return event;
+  } catch {
+    return buildFallbackObservation(kind, data, writerSequence);
+  }
+}
+function toLegacyTelemetryLine(event) {
+  return {
+    timestamp: event.observedAt,
+    event: event.kind,
+    ...event.legacy.raw
+  };
+}
+// src/observability/otel-mapping.ts
+var SWARM_EXTENSION_PREFIX = "swarm.";
+var OTEL_GENAI_ATTRIBUTES = Object.freeze({
+  kind: "gen_ai.operation.name",
+  "provenance.provider": "gen_ai.system",
+  "provenance.model": "gen_ai.request.model",
+  "legacy.raw.model": "gen_ai.response.model",
+  "legacy.raw.agentName": "gen_ai.agent.name",
+  "workflow.hostSessionId": "gen_ai.conversation.id",
+  "outcome.status": "gen_ai.response.finish_reasons",
+  "legacy.raw.tokens_input": "gen_ai.usage.input_tokens",
+  "legacy.raw.tokens_output": "gen_ai.usage.output_tokens",
+  "legacy.raw.tokens_cache": "gen_ai.usage.cache_read_input_tokens",
+  "legacy.raw.tokens_reasoning": `${SWARM_EXTENSION_PREFIX}gen_ai.usage.reasoning_tokens`,
+  "legacy.raw.cost_usd": `${SWARM_EXTENSION_PREFIX}gen_ai.usage.cost_usd`
+});
+var OPENINFERENCE_ATTRIBUTES = Object.freeze({
+  kind: "openinference.span.kind",
+  "provenance.model": "llm.model_name",
+  "provenance.provider": "llm.provider",
+  "legacy.raw.agentName": "agent.name",
+  "workflow.hostSessionId": "session.id",
+  "legacy.raw.tokens_input": "llm.token_count.prompt",
+  "legacy.raw.tokens_output": "llm.token_count.completion",
+  "legacy.raw.tokens_cache": "llm.token_count.prompt_details.cache_read",
+  "legacy.raw.tokens_reasoning": "llm.token_count.completion_details.reasoning",
+  "legacy.raw.cost_usd": `${SWARM_EXTENSION_PREFIX}llm.cost_usd`
+});
+var NO_ATTRIBUTES = Object.freeze({});
+// src/telemetry.ts
+var _writeStream = null;
+var _projectDirectory = null;
+var _listeners = [];
+var _disabled = false;
+var _heartbeatTrackingActive = false;
+var _heartbeatListener = null;
+var heartbeatTimestamps = new Map;
+function capHeartbeatMap() {
+  while (heartbeatTimestamps.size >= 500) {
+    const oldestKey = heartbeatTimestamps.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    heartbeatTimestamps.delete(oldestKey);
+  }
+}
+function startHeartbeatTracking() {
+  if (_heartbeatTrackingActive)
+    return;
+  _heartbeatTrackingActive = true;
+  const listener = (event, data) => {
+    if (event !== "heartbeat")
+      return;
+    const payload = data;
+    if (!payload?.sessionId)
+      return;
+    heartbeatTimestamps.set(payload.sessionId, Date.now());
+    capHeartbeatMap();
+  };
+  _heartbeatListener = listener;
+  addTelemetryListener(listener);
+}
+function getLastHeartbeat(sessionId) {
+  return heartbeatTimestamps.get(sessionId);
+}
+function stopHeartbeatTracking() {
+  _heartbeatTrackingActive = false;
+  if (_heartbeatListener !== null) {
+    const idx = _listeners.indexOf(_heartbeatListener);
+    if (idx >= 0)
+      _listeners.splice(idx, 1);
+    _heartbeatListener = null;
+  }
+}
+function resetHeartbeatTrackingForTesting() {
+  _heartbeatTrackingActive = false;
+  heartbeatTimestamps.clear();
+  if (_heartbeatListener !== null) {
+    const idx = _listeners.indexOf(_heartbeatListener);
+    if (idx >= 0)
+      _listeners.splice(idx, 1);
+    _heartbeatListener = null;
+  }
+}
+var _emitCount = 0;
+var ROTATION_CHECK_INTERVAL = 50;
+function resetTelemetryForTesting() {
+  _disabled = false;
+  _projectDirectory = null;
+  _listeners.length = 0;
+  _emitCount = 0;
+  resetHeartbeatTrackingForTesting();
+  if (_writeStream !== null) {
+    _writeStream.end();
+    _writeStream = null;
+  }
+}
+function initTelemetry(projectDirectory) {
+  if (_writeStream !== null || _disabled) {
+    return;
+  }
+  try {
+    _projectDirectory = projectDirectory;
+    const swarmDir = path.join(projectDirectory, ".swarm");
+    if (!fs.existsSync(swarmDir)) {
+      fs.mkdirSync(swarmDir, { recursive: true });
+    }
+    const telemetryPath = path.join(swarmDir, "telemetry.jsonl");
+    const stream = createWriteStream(telemetryPath, { flags: "a" });
+    stream.on("error", () => {
+      if (_writeStream === stream) {
+        _disabled = true;
+        _writeStream = null;
+      }
+    });
+    _writeStream = stream;
+  } catch {
+    _disabled = true;
+    _writeStream = null;
+  }
+}
+function emit(event, data) {
+  try {
+    if (_disabled || _writeStream === null) {
+      return;
+    }
+    const canonical = _internals.createObservation(event, data);
+    const line = JSON.stringify(_internals.toLegacyTelemetryLine(canonical)) + os.EOL;
+    const stream = _writeStream;
+    stream.write(line, (err) => {
+      if (err && _writeStream === stream) {
+        _disabled = true;
+        _writeStream = null;
+      }
+    });
+    for (const listener of _listeners) {
+      try {
+        listener(event, data);
+      } catch {}
+    }
+    _emitCount++;
+    if (_emitCount >= ROTATION_CHECK_INTERVAL) {
+      _emitCount = 0;
+      _internals.rotateTelemetryIfNeeded();
+    }
+  } catch {}
+}
+function addTelemetryListener(callback) {
+  _listeners.push(callback);
+}
+function rotateTelemetryIfNeeded(maxBytes = 10 * 1024 * 1024) {
+  try {
+    if (_projectDirectory === null) {
+      return;
+    }
+    const telemetryPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl");
+    if (!fs.existsSync(telemetryPath)) {
+      return;
+    }
+    const stats = fs.statSync(telemetryPath);
+    if (stats.size < maxBytes) {
+      return;
+    }
+    const rotatedPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl.1");
+    fs.renameSync(telemetryPath, rotatedPath);
+    if (_writeStream !== null) {
+      _writeStream.end();
+      const stream = createWriteStream(telemetryPath, { flags: "a" });
+      stream.on("error", () => {
+        if (_writeStream === stream) {
+          _disabled = true;
+          _writeStream = null;
+        }
+      });
+      _writeStream = stream;
+    }
+  } catch {}
+}
+var telemetry = {
+  sessionStarted(sessionId, agentName) {
+    _internals.emit("session_started", { sessionId, agentName });
+  },
+  sessionEnded(sessionId, reason) {
+    _internals.emit("session_ended", { sessionId, reason });
+  },
+  agentActivated(sessionId, agentName, oldName) {
+    _internals.emit("agent_activated", { sessionId, agentName, oldName });
+  },
+  delegationBegin(sessionId, agentName, taskId) {
+    _internals.emit("delegation_begin", { sessionId, agentName, taskId });
+  },
+  delegationEnd(sessionId, agentName, taskId, result, costFields) {
+    _internals.emit("delegation_end", {
+      sessionId,
+      agentName,
+      taskId,
+      result,
+      tokens_input: costFields?.tokens_input ?? 0,
+      tokens_output: costFields?.tokens_output ?? 0,
+      tokens_reasoning: costFields?.tokens_reasoning ?? 0,
+      tokens_cache: costFields?.tokens_cache ?? 0,
+      cost_usd: costFields?.cost_usd ?? null,
+      cost_source: costFields?.cost_source ?? "unavailable",
+      model: costFields?.model,
+      gate: costFields?.gate,
+      retry_index: costFields?.retry_index
+    });
+  },
+  taskStateChanged(sessionId, taskId, newState, oldState) {
+    _internals.emit("task_state_changed", {
+      sessionId,
+      taskId,
+      newState,
+      oldState
+    });
+  },
+  gatePassed(sessionId, gate, taskId) {
+    _internals.emit("gate_passed", { sessionId, gate, taskId });
+  },
+  gateParseError(taskId, error) {
+    _internals.emit("gate_parse_error", {
+      taskId,
+      errorName: error.name,
+      errorMessage: error.message.slice(0, 200)
+    });
+  },
+  gateFailed(sessionId, gate, taskId, reason) {
+    _internals.emit("gate_failed", { sessionId, gate, taskId, reason });
+  },
+  reviewerGateDecision(sessionId, taskId, blocked, reasonCode, evidenceKind) {
+    _internals.emit("reviewer_gate_decision", {
+      sessionId,
+      gate: "qa_gate",
+      taskId,
+      blocked,
+      allowed: !blocked,
+      reasonCode,
+      evidenceKind
+    });
+  },
+  phaseChanged(sessionId, oldPhase, newPhase) {
+    _internals.emit("phase_changed", { sessionId, oldPhase, newPhase });
+  },
+  budgetUpdated(sessionId, budgetPct, agentName) {
+    _internals.emit("budget_updated", { sessionId, budgetPct, agentName });
+  },
+  modelFallback(sessionId, agentName, fromModel, toModel, reason) {
+    _internals.emit("model_fallback", {
+      sessionId,
+      agentName,
+      fromModel,
+      toModel,
+      reason
+    });
+  },
+  hardLimitHit(sessionId, agentName, limitType, value) {
+    _internals.emit("hard_limit_hit", {
+      sessionId,
+      agentName,
+      limitType,
+      value
+    });
+  },
+  revisionLimitHit(sessionId, agentName) {
+    _internals.emit("revision_limit_hit", { sessionId, agentName });
+  },
+  loopDetected(sessionId, agentName, loopType) {
+    _internals.emit("loop_detected", { sessionId, agentName, loopType });
+  },
+  noOpStrongWarning(sessionId, agentName, count, threshold) {
+    _internals.emit("no_op_strong_warning", {
+      sessionId,
+      agentName,
+      count,
+      threshold
+    });
+  },
+  gateDenialLoop(sessionId, tool, code, count) {
+    _internals.emit("gate_denial_loop", { sessionId, tool, code, count });
+  },
+  executionStallWarning(sessionId, count, threshold) {
+    _internals.emit("execution_stall_warning", {
+      sessionId,
+      count,
+      threshold
+    });
+  },
+  executionStallDenied(sessionId, tool, count, threshold) {
+    _internals.emit("execution_stall_denied", {
+      sessionId,
+      tool,
+      count,
+      threshold
+    });
+  },
+  swarmInternalsReadDenied(sessionId, tool, target) {
+    _internals.emit("swarm_internals_read_denied", {
+      sessionId,
+      tool,
+      target
+    });
+  },
+  scopeViolation(sessionId, agentName, file, reason) {
+    _internals.emit("scope_violation", { sessionId, agentName, file, reason });
+  },
+  qaSkipViolation(sessionId, agentName, skipCount) {
+    _internals.emit("qa_skip_violation", { sessionId, agentName, skipCount });
+  },
+  heartbeat(sessionId) {
+    _internals.emit("heartbeat", { sessionId });
+  },
+  turboModeChanged(sessionId, enabled, agentName) {
+    _internals.emit("turbo_mode_changed", { sessionId, enabled, agentName });
+  },
+  autoOversightEscalation(sessionId, reason, interactionCount, deadlockCount, phase) {
+    _internals.emit("auto_oversight_escalation", {
+      sessionId,
+      reason,
+      interactionCount,
+      deadlockCount,
+      phase
+    });
+  },
+  environmentDetected(sessionId, hostOS, shellFamily, executionMode) {
+    _internals.emit("environment_detected", {
+      sessionId,
+      hostOS,
+      shellFamily,
+      executionMode
+    });
+  },
+  prmPatternDetected(sessionId, pattern, severity, category, stepRange) {
+    _internals.emit("prm_pattern_detected", {
+      sessionId,
+      pattern,
+      severity,
+      category,
+      stepRange
+    });
+  },
+  prmCourseCorrectionInjected(sessionId, pattern, level) {
+    _internals.emit("prm_course_correction_injected", {
+      sessionId,
+      pattern,
+      level
+    });
+  },
+  prmEscalationTriggered(sessionId, pattern, level, occurrenceCount) {
+    _internals.emit("prm_escalation_triggered", {
+      sessionId,
+      pattern,
+      level,
+      occurrenceCount
+    });
+  },
+  prmHardStop(sessionId, pattern, level, occurrenceCount) {
+    _internals.emit("prm_hard_stop", {
+      sessionId,
+      pattern,
+      level,
+      occurrenceCount
+    });
+  },
+  prmHardStopDelivered(sessionId, pattern, level, occurrenceCount) {
+    _internals.emit("prm_hard_stop_delivered", {
+      sessionId,
+      pattern,
+      level,
+      occurrenceCount
+    });
+  }
+};
+var _internals = {
+  telemetry,
+  emit,
+  rotateTelemetryIfNeeded,
+  heartbeatListenerCount: () => _heartbeatListener !== null ? 1 : 0,
+  createObservation,
+  toLegacyTelemetryLine
+};
+
+export { startHeartbeatTracking, getLastHeartbeat, stopHeartbeatTracking, resetHeartbeatTrackingForTesting, ROTATION_CHECK_INTERVAL, resetTelemetryForTesting, initTelemetry, emit, addTelemetryListener, rotateTelemetryIfNeeded, telemetry, _internals };