@aaac/observability 0.1.14 → 0.1.15

package/dist/{chunk-J2F5GEMO.js → chunk-3DXZNA3E.js}

@@ -154,6 +154,112 @@ function extractString(attrs, key) {
   return typeof v === "string" && v.length > 0 ? v : void 0;
 }
 
+// src/normalize/vendor-otel-mapper.ts
+var VENDOR_OTEL_SOURCE = "claude-code-otel";
+var VENDOR_OTEL_DEDUP_PREFIX = "vendor-otel";
+function convertAnyValue(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value.stringValue === "string") return value.stringValue;
+  if (typeof value.boolValue === "boolean") return value.boolValue;
+  if (value.intValue !== void 0) {
+    const n = typeof value.intValue === "string" ? Number(value.intValue) : value.intValue;
+    return Number.isFinite(n) ? n : String(value.intValue);
+  }
+  if (typeof value.doubleValue === "number") return value.doubleValue;
+  if (value.arrayValue !== void 0) return JSON.stringify(value.arrayValue);
+  if (value.kvlistValue !== void 0) return JSON.stringify(value.kvlistValue);
+  return void 0;
+}
+function convertAttributes(attrs) {
+  const out = {};
+  if (!Array.isArray(attrs)) return out;
+  for (const kv of attrs) {
+    if (!kv || typeof kv.key !== "string" || kv.key.length === 0) continue;
+    const v = convertAnyValue(kv.value);
+    if (v !== void 0) out[kv.key] = v;
+  }
+  return out;
+}
+var SESSION_ID_KEYS = [
+  "session.id",
+  "session_id",
+  "agent.session_id",
+  "claude.session_id",
+  "conversation_id",
+  "conversation.id"
+];
+function firstString(attrs, keys2) {
+  for (const k of keys2) {
+    const v = attrs[k];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+function toBigIntNano(value) {
+  if (value === void 0) return void 0;
+  try {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? BigInt(Math.trunc(value)) : void 0;
+    }
+    const trimmed = value.trim();
+    if (trimmed === "" || !/^\d+$/.test(trimmed)) return void 0;
+    return BigInt(trimmed);
+  } catch {
+    return void 0;
+  }
+}
+function mapVendorOtelExport(doc, options = {}) {
+  const source = options.source ?? VENDOR_OTEL_SOURCE;
+  const events = [];
+  let skipped = 0;
+  const resourceSpans = doc?.resourceSpans;
+  if (!Array.isArray(resourceSpans)) return { events, skipped };
+  for (const rs of resourceSpans) {
+    const resourceAttrs = convertAttributes(rs?.resource?.attributes);
+    const projectId = firstString(resourceAttrs, ["project.id", "service.name", "service.namespace"]) ?? void 0;
+    for (const ss of rs?.scopeSpans ?? []) {
+      for (const span of ss?.spans ?? []) {
+        const traceId = typeof span?.traceId === "string" ? span.traceId : "";
+        const spanId = typeof span?.spanId === "string" ? span.spanId : "";
+        if (traceId === "" || spanId === "") {
+          skipped += 1;
+          continue;
+        }
+        const spanAttrs = convertAttributes(span.attributes);
+        const attributes = { ...resourceAttrs, ...spanAttrs };
+        const start = toBigIntNano(span.startTimeUnixNano);
+        const end = toBigIntNano(span.endTimeUnixNano);
+        if (start !== void 0 && end !== void 0 && end >= start) {
+          attributes["vendor.duration_ns"] = Number(end - start);
+        }
+        if (projectId !== void 0 && attributes["project.id"] === void 0) {
+          attributes["project.id"] = projectId;
+        }
+        const sessionId = firstString(attributes, SESSION_ID_KEYS);
+        if (sessionId !== void 0 && attributes["agent.session_id"] === void 0) {
+          attributes["agent.session_id"] = sessionId;
+        }
+        events.push({
+          id: generateId(),
+          timeUnixNano: start ?? 0n,
+          source,
+          eventType: typeof span.name === "string" && span.name.length > 0 ? span.name : "vendor.otel",
+          lifecycle: "instant",
+          traceId,
+          spanId,
+          ...typeof span.parentSpanId === "string" && span.parentSpanId.length > 0 ? { parentSpanId: span.parentSpanId } : {},
+          ...sessionId !== void 0 ? { sessionId } : {},
+          attributes,
+          links: [],
+          // Deterministic identity → idempotent re-ingestion (§9.2).
+          dedupKey: `${VENDOR_OTEL_DEDUP_PREFIX}:${traceId}:${spanId}`
+        });
+      }
+    }
+  }
+  return { events, skipped };
+}
+
 // src/correlate/cache-store.ts
 var MemoryCacheStore = class {
   map = /* @__PURE__ */ new Map();
@@ -588,6 +694,143 @@ function createPromotionRule() {
   };
 }
 
+// src/enrich/rules/worktree.ts
+var WORKTREE_WINDOW_MS = 60 * 60 * 1e3;
+function worktreeRepoKey(repoRoot) {
+  return `worktree:repo:${repoRoot}`;
+}
+function nanoToMs(timeUnixNano) {
+  return Number(timeUnixNano / 1000000n);
+}
+function parseCommittedFiles(raw) {
+  if (typeof raw !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return void 0;
+    return parsed.filter((x) => typeof x === "string");
+  } catch {
+    return void 0;
+  }
+}
+function createWorktreeRule(windowMs = WORKTREE_WINDOW_MS) {
+  return function worktreeRule(event, ctx) {
+    if (event.eventType === "promotion.worktree" && event.lifecycle === "instant") {
+      const repoRoot2 = event.attributes["repo.root"];
+      if (typeof repoRoot2 !== "string" || repoRoot2.length === 0) return;
+      const key = worktreeRepoKey(repoRoot2);
+      const ref = {
+        spanId: event.spanId,
+        traceId: event.traceId,
+        sessionId: event.sessionId,
+        timeMs: nanoToMs(event.timeUnixNano)
+      };
+      const existing = ctx.api.cacheGet(key);
+      if (!existing || ref.timeMs >= existing.timeMs) {
+        ctx.api.cacheSet(key, ref);
+        ctx.api.logDebug(
+          `R8: cached promotion.worktree span=${event.spanId} repo.root=${repoRoot2}`
+        );
+      }
+      return;
+    }
+    if (event.eventType !== "promotion.commit" || event.lifecycle !== "close") {
+      return;
+    }
+    const repoRoot = event.attributes["repo.root"];
+    if (typeof repoRoot !== "string" || repoRoot.length === 0) {
+      ctx.api.logDebug("R8: promotion.commit has no repo.root \u2014 skip");
+      return;
+    }
+    const wt = ctx.api.cacheGet(worktreeRepoKey(repoRoot));
+    if (!wt) {
+      ctx.api.logDebug(`R8: no cached worktree for repo.root=${repoRoot} \u2014 skip`);
+      return;
+    }
+    const commitMs = nanoToMs(event.timeUnixNano);
+    if (Math.abs(commitMs - wt.timeMs) > windowMs) {
+      ctx.api.logDebug(
+        `R8: worktree snapshot stale (\u0394=${Math.abs(commitMs - wt.timeMs)}ms) \u2014 skip`
+      );
+      return;
+    }
+    const alreadyLinked = event.links.some(
+      (l) => l.linkType === "materializes_as_commit" && l.targetSpanId === wt.spanId
+    );
+    if (alreadyLinked) return;
+    let confidence = "provisional";
+    const committedFiles = parseCommittedFiles(event.attributes["committed_files"]);
+    if (committedFiles && committedFiles.length > 0 && wt.sessionId) {
+      const committedSet = new Set(committedFiles);
+      const taskSpans = ctx.api.cacheGet(allTaskSpansKey(wt.sessionId)) ?? [];
+      const overlap = taskSpans.some((taskSpanId) => {
+        const files = ctx.api.cacheGet(taskFilesKey(wt.sessionId, taskSpanId)) ?? [];
+        return files.some((f) => committedSet.has(f));
+      });
+      if (overlap) confidence = "probable";
+    }
+    ctx.api.addLink({
+      linkType: "materializes_as_commit",
+      targetSpanId: wt.spanId,
+      targetTraceId: wt.traceId !== event.traceId ? wt.traceId : void 0,
+      attributes: { confidence }
+    });
+    ctx.api.logDebug(
+      `R8: linked promotion.commit \u2192 worktree=${wt.spanId} confidence=${confidence}`
+    );
+  };
+}
+
+// src/enrich/rules/issue-anchor.ts
+function issueIdCacheKey(sessionId) {
+  return `session:${sessionId}:issue_id`;
+}
+function issueTypeCacheKey(sessionId) {
+  return `session:${sessionId}:issue_type`;
+}
+function createIssueAnchorRule() {
+  return function issueAnchorRule(event, ctx) {
+    const sid = event.sessionId;
+    if (!sid) return;
+    const attrIssueId = event.attributes["issue.id"];
+    const attrIssueType = event.attributes["issue.type"];
+    if (attrIssueId !== void 0 && attrIssueId !== "") {
+      const cached = ctx.api.cacheGet(issueIdCacheKey(sid));
+      if (cached === void 0) {
+        ctx.api.cacheSet(issueIdCacheKey(sid), String(attrIssueId));
+        ctx.api.logDebug(
+          `R-ISSUE: cached issue.id=${attrIssueId} for session=${sid}`
+        );
+      }
+    }
+    if (attrIssueType !== void 0 && attrIssueType !== "") {
+      const cached = ctx.api.cacheGet(issueTypeCacheKey(sid));
+      if (cached === void 0) {
+        ctx.api.cacheSet(issueTypeCacheKey(sid), String(attrIssueType));
+        ctx.api.logDebug(
+          `R-ISSUE: cached issue.type=${attrIssueType} for session=${sid}`
+        );
+      }
+    }
+    if (attrIssueId === void 0 || attrIssueId === "") {
+      const cachedId = ctx.api.cacheGet(issueIdCacheKey(sid));
+      if (cachedId !== void 0) {
+        event.attributes["issue.id"] = cachedId;
+        ctx.api.logDebug(
+          `R-ISSUE: propagated issue.id=${cachedId} to span=${event.spanId}`
+        );
+      } else {
+        event.attributes["issue.id_missing"] = true;
+      }
+    }
+    if ((attrIssueType === void 0 || attrIssueType === "") && event.attributes["issue.type"] === void 0) {
+      const cachedType = ctx.api.cacheGet(issueTypeCacheKey(sid));
+      if (cachedType !== void 0) {
+        event.attributes["issue.type"] = cachedType;
+      }
+    }
+  };
+}
+
 // src/enrich/enricher.ts
 var Enricher = class {
   correlator;
@@ -649,17 +892,63 @@ var Enricher = class {
 };
 function createDefaultRules(artifactPatterns = []) {
   return [
+    createIssueAnchorRule(),
+    // R-ISSUE (#178 T-E1)
     createArtifactRule(artifactPatterns),
     // R7
     createProcessRule(),
     // R3/R4
     createCrossAxisRule(),
     // R5
-    createPromotionRule()
+    createPromotionRule(),
     // R1/R2
+    createWorktreeRule()
+    // R8 (#175)
   ];
 }
 
+// src/cli/worktree.ts
+import { execFileSync } from "child_process";
+function defaultGitRunner(args) {
+  try {
+    const out = execFileSync("git", args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+    return out;
+  } catch {
+    return void 0;
+  }
+}
+function captureWorktree(cwd, git = defaultGitRunner) {
+  const repoRootRaw = git(["-C", cwd, "rev-parse", "--show-toplevel"]);
+  const repoRoot = repoRootRaw?.trim();
+  if (!repoRoot) {
+    return void 0;
+  }
+  const shaRaw = git(["-C", cwd, "rev-parse", "HEAD"]);
+  const commitSha = shaRaw?.trim();
+  const statusRaw = git(["-C", cwd, "status", "--porcelain"]);
+  const dirty = typeof statusRaw === "string" ? statusRaw.trim().length > 0 : false;
+  const snapshot = { repoRoot, dirty };
+  if (commitSha && commitSha.length > 0) snapshot.commitSha = commitSha;
+  return snapshot;
+}
+function worktreeAttributes(snapshot, sessionId) {
+  const attributes = {
+    axis: "promotion",
+    dirty: snapshot.dirty
+  };
+  if (snapshot.commitSha) attributes["commit.sha"] = snapshot.commitSha;
+  if (snapshot.repoRoot) attributes["repo.root"] = snapshot.repoRoot;
+  if (sessionId) {
+    attributes["agent.session_id"] = sessionId;
+    attributes["session_id"] = sessionId;
+  }
+  return attributes;
+}
+
 // src/sink/sqlite-sink.ts
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync } from "fs";
@@ -686,7 +975,8 @@ CREATE TABLE IF NOT EXISTS canonical_events (
   run_id         TEXT,
   session_id     TEXT,
   task_id        TEXT,
-  attributes     TEXT    NOT NULL DEFAULT '{}'
+  attributes     TEXT    NOT NULL DEFAULT '{}',
+  dedup_key      TEXT
 );
 
 CREATE INDEX IF NOT EXISTS idx_ce_trace_id   ON canonical_events (trace_id);
@@ -752,6 +1042,24 @@ var SqliteSink = class {
     }
     configureSqliteDatabase(this.db);
     this.db.exec(SCHEMA);
+    this.migrateDedupKey();
+  }
+  /**
+   * Restart-safe migration for the dedup_key column + UNIQUE index (§9.2).
+   *
+   * `CREATE TABLE IF NOT EXISTS` is a no-op on databases created before dedup_key
+   * existed, so the column must be added in-place. PRAGMA table_info lets us detect
+   * its absence and ALTER it in (idempotent: skipped once present). The UNIQUE index
+   * is created only after the column is guaranteed to exist.
+   */
+  migrateDedupKey() {
+    const columns = this.db.prepare("PRAGMA table_info(canonical_events)").all();
+    if (!columns.some((c) => c.name === "dedup_key")) {
+      this.db.exec("ALTER TABLE canonical_events ADD COLUMN dedup_key TEXT");
+    }
+    this.db.exec(
+      "CREATE UNIQUE INDEX IF NOT EXISTS idx_ce_dedup_key ON canonical_events (dedup_key)"
+    );
   }
   // ── Public write API ───────────────────────────────────────────────────────
   /**
@@ -759,13 +1067,19 @@ var SqliteSink = class {
    *  1. Append to canonical_events (immutable)
    *  2. Upsert spans materialised view
    *  3. Insert canonical_links rows
+   *
+   * Returns `false` when the event carried a dedup_key that already exists (the
+   * INSERT was ignored and no span/link side effects were applied — making
+   * re-runs of a Canonical Projection batch fully idempotent), otherwise `true`.
    */
   write(event) {
-    this.insertCanonicalEvent(event);
+    const inserted = this.insertCanonicalEvent(event);
+    if (!inserted) return false;
     this.upsertSpan(event);
     if (event.links.length > 0) {
       this.insertLinks(event);
     }
+    return true;
   }
   /** Close the database connection. */
   close() {
@@ -779,14 +1093,23 @@ var SqliteSink = class {
     return this.db;
   }
   // ── Private helpers ────────────────────────────────────────────────────────
+  /**
+   * Append the immutable canonical_events row.
+   *
+   * Uses INSERT OR IGNORE so a dedup_key collision (UNIQUE idx_ce_dedup_key) is a
+   * silent no-op rather than an error — the basis of §9.2 idempotent re-ingestion.
+   * Returns true when a new row was written, false when ignored on conflict.
+   * Events without a dedup_key (NULL) are never ignored (multiple NULLs are
+   * distinct under SQLite's UNIQUE semantics).
+   */
   insertCanonicalEvent(event) {
     const stmt = this.db.prepare(`
-      INSERT INTO canonical_events
+      INSERT OR IGNORE INTO canonical_events
         (id, time_unix_nano, source, event_type, lifecycle,
-         trace_id, span_id, parent_span_id, run_id, session_id, task_id, attributes)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         trace_id, span_id, parent_span_id, run_id, session_id, task_id, attributes, dedup_key)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
-    stmt.run(
+    const result = stmt.run(
       event.id,
       event.timeUnixNano,
       event.source,
@@ -798,8 +1121,10 @@ var SqliteSink = class {
       event.runId ?? null,
       event.sessionId ?? null,
       event.taskId ?? null,
-      JSON.stringify(event.attributes)
+      JSON.stringify(event.attributes),
+      event.dedupKey ?? null
     );
+    return Number(result.changes) > 0;
   }
   upsertSpan(event) {
     switch (event.lifecycle) {
@@ -973,7 +1298,7 @@ var OtelEmitter = class {
       {
         kind: SpanKind.INTERNAL,
         startTime: startMs,
-        attributes: convertAttributes(mapped.attributes),
+        attributes: convertAttributes2(mapped.attributes),
         links: mapped.links.map((l) => ({
           context: {
             traceId: l.targetTraceId ?? mapped.traceId,
@@ -988,7 +1313,7 @@ var OtelEmitter = class {
     for (const ev of mapped.spanEvents) {
       otelSpan.addEvent(
         ev.name,
-        convertAttributes(ev.attributes),
+        convertAttributes2(ev.attributes),
         Number(ev.timeUnixNano / 1000000n)
       );
     }
@@ -1006,7 +1331,7 @@ var OtelEmitter = class {
     return trace.setSpanContext(ROOT_CONTEXT, spanContext);
   }
 };
-function convertAttributes(attrs) {
+function convertAttributes2(attrs) {
   return attrs;
 }
 
@@ -1238,8 +1563,9 @@ function parseEventRow(row) {
     sessionId: row.session_id ?? void 0,
     taskId: row.task_id ?? void 0,
     attributes: safeParseJson(row.attributes),
-    links: []
+    links: [],
     // links are stored in canonical_links, not inline on events
+    ...row.dedup_key ? { dedupKey: row.dedup_key } : {}
   };
 }
 function parseLinkRow(row) {
@@ -1598,6 +1924,658 @@ function emitPromotionPr(collector, options) {
   return spanId;
 }
 
+// src/promotion/github-recording.ts
+function parseIssueIdFromText(text) {
+  const hashMatch = text.match(/#(\d+)/);
+  if (hashMatch) {
+    return Number(hashMatch[1]);
+  }
+  const branchMatch = text.match(/issue-(\d+)/i);
+  if (branchMatch) {
+    return Number(branchMatch[1]);
+  }
+  return null;
+}
+function buildGithubPromotionAttributes(input) {
+  const issueId = input.commitMessage !== void 0 ? parseIssueIdFromText(input.commitMessage) : null;
+  const attrs = {
+    axis: "promotion",
+    "commit.sha": input.sha
+  };
+  if (issueId !== null) {
+    attrs["issue.id"] = issueId;
+  }
+  if (input.kind === "ci") {
+    attrs["ci.run_id"] = input.runId;
+    attrs["ci.verdict"] = input.verdict;
+    if (input.workflowName) {
+      attrs["ci.workflow"] = input.workflowName;
+    }
+    return attrs;
+  }
+  attrs["deploy.id"] = input.runId;
+  attrs["deploy.status"] = input.verdict;
+  attrs["deploy.target"] = input.deployTarget ?? "unknown";
+  return attrs;
+}
+function githubPromotionEventType(kind) {
+  return kind === "ci" ? "promotion.ci" : "promotion.deploy";
+}
+
+// src/analysis/outcome-chain.ts
+var OUTCOME_CHAIN_STAGES = [
+  "agent.session",
+  "process.task",
+  "process.edit",
+  "promotion.commit",
+  "promotion.ci",
+  "promotion.deploy"
+];
+function observationMatchesIssue(observation, issueId) {
+  const attrs = observation.attributes ?? {};
+  const attrIssue = attrs["issue.id"];
+  if (attrIssue !== void 0 && String(attrIssue) === issueId) {
+    return true;
+  }
+  const commitMessage = attrs["commit.message"];
+  if (typeof commitMessage === "string") {
+    const parsed = parseIssueIdFromText(commitMessage);
+    if (parsed !== null && String(parsed) === issueId) {
+      return true;
+    }
+  }
+  const prCommand = attrs["pr.command"];
+  if (typeof prCommand === "string" && prCommand.includes(`#${issueId}`)) {
+    return true;
+  }
+  return false;
+}
+function isProvisionalObservation(observation) {
+  const sessionId = observation.sessionId ?? observation.attributes?.["session_id"];
+  if (sessionId === "unknown" || sessionId === void 0 || sessionId === "") {
+    return true;
+  }
+  const confidence = observation.attributes?.["link.confidence"] ?? observation.attributes?.["confidence"];
+  return confidence === "provisional";
+}
+function collectObservations(adapter) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const event of adapter.queryEvents({})) {
+    latest.set(`${event.spanId}:${event.eventType}`, event);
+  }
+  for (const span of adapter.querySpans({})) {
+    latest.set(`${span.spanId}:${span.eventType}`, {
+      id: span.spanId,
+      timeUnixNano: span.startTime ?? 0n,
+      source: "spans",
+      eventType: span.eventType,
+      lifecycle: span.status === "closed" ? "close" : span.status === "open" ? "open" : "instant",
+      traceId: span.traceId ?? "",
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId ?? void 0,
+      sessionId: span.sessionId ?? void 0,
+      attributes: span.attributes,
+      links: []
+    });
+  }
+  return [...latest.values()];
+}
+function analyzeOutcomeChain(adapter, issueId) {
+  const normalizedIssueId = String(issueId);
+  const observations = collectObservations(adapter);
+  const issueObservations = observations.filter(
+    (obs) => observationMatchesIssue(obs, normalizedIssueId)
+  );
+  const stages = OUTCOME_CHAIN_STAGES.map((eventType) => {
+    const matched = issueObservations.filter((obs) => obs.eventType === eventType);
+    if (matched.length === 0) {
+      return { eventType, status: "missing", spanIds: [] };
+    }
+    const provisionalOnly = matched.every(isProvisionalObservation);
+    return {
+      eventType,
+      status: provisionalOnly ? "provisional" : "present",
+      spanIds: matched.map((obs) => obs.spanId)
+    };
+  });
+  const gaps = stages.filter((s) => s.status === "missing").map((s) => s.eventType);
+  const provisional = stages.filter((s) => s.status === "provisional").map((s) => s.eventType);
+  return {
+    issueId: normalizedIssueId,
+    stages,
+    complete: gaps.length === 0,
+    gaps,
+    provisional
+  };
+}
+
+// src/analysis/diagnostic-report.ts
+var STAGE_SET = new Set(OUTCOME_CHAIN_STAGES);
+function attrStr(attrs, key) {
+  const v = attrs[key];
+  return v === void 0 || v === null ? "" : String(v);
+}
+function attrNum(attrs, key) {
+  const v = attrs[key];
+  if (v === void 0 || v === null || v === "") return 0;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+function projectIdOf(span) {
+  const p = attrStr(span.attributes, "project.id");
+  if (p !== "") return p;
+  const s = attrStr(span.attributes, "service.name");
+  return s;
+}
+function issueIdOf(span) {
+  return attrStr(span.attributes, "issue.id");
+}
+function sessionIdOf(span) {
+  if (span.sessionId !== null && span.sessionId !== void 0 && span.sessionId !== "") {
+    return span.sessionId;
+  }
+  const a = attrStr(span.attributes, "agent.session_id") || attrStr(span.attributes, "session_id");
+  return a;
+}
+function round(value, decimals) {
+  if (!Number.isFinite(value)) return 0;
+  const f = 10 ** decimals;
+  return Math.round(value * f) / f;
+}
+function average(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((a, b) => a + b, 0) / values.length;
+}
+function inWindow(span, fromNano, toNano) {
+  if (fromNano === void 0 && toNano === void 0) return true;
+  const t = span.startTime;
+  if (t === null) return false;
+  if (fromNano !== void 0 && t < fromNano) return false;
+  if (toNano !== void 0 && t > toNano) return false;
+  return true;
+}
+function filterSpans(spans, opts) {
+  return spans.filter((s) => {
+    if (opts.projectId !== void 0 && projectIdOf(s) !== opts.projectId) {
+      return false;
+    }
+    return inWindow(s, opts.fromNano, opts.toNano);
+  });
+}
+function computeLayer1(spans) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const issueId = issueIdOf(s);
+    if (issueId === "") continue;
+    const key = `${issueId}\0${projectIdOf(s)}`;
+    (groups.get(key) ?? groups.set(key, []).get(key)).push(s);
+  }
+  const rows = [];
+  for (const group of groups.values()) {
+    const issueId = issueIdOf(group[0]);
+    const projectId = projectIdOf(group[0]);
+    const issueType = group.map((s) => attrStr(s.attributes, "issue.type")).find((t) => t !== "") ?? "";
+    const sessionIds = /* @__PURE__ */ new Set();
+    let editCount = 0;
+    let commitCount = 0;
+    let ciCount = 0;
+    let ciPassed = 0;
+    for (const s of group) {
+      if (s.eventType === "agent.session") {
+        const sid = sessionIdOf(s);
+        if (sid !== "") sessionIds.add(sid);
+      }
+      if (s.eventType === "process.edit") editCount += 1;
+      if (s.eventType === "promotion.commit") commitCount += 1;
+      if (s.eventType === "promotion.ci") {
+        ciCount += 1;
+        if (attrStr(s.attributes, "ci.verdict") === "passed") ciPassed += 1;
+      }
+    }
+    const sessionCount = sessionIds.size;
+    rows.push({
+      issueId,
+      issueType,
+      projectId,
+      sessionCount,
+      editCount,
+      commitCount,
+      ciCount,
+      ciPassed,
+      leverage: sessionCount > 0 ? round(editCount / sessionCount, 2) : 0
+    });
+  }
+  return rows.sort((a, b) => a.issueId.localeCompare(b.issueId));
+}
+function computeLayer2(spans) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const issueId = issueIdOf(s);
+    if (issueId === "") continue;
+    const key = `${issueId}\0${projectIdOf(s)}`;
+    (groups.get(key) ?? groups.set(key, []).get(key)).push(s);
+  }
+  const rows = [];
+  for (const group of groups.values()) {
+    const issueId = issueIdOf(group[0]);
+    const projectId = projectIdOf(group[0]);
+    const sessionIds = /* @__PURE__ */ new Set();
+    let commits = 0;
+    let ciPassed = 0;
+    let totalCostUsd = 0;
+    for (const s of group) {
+      if (s.eventType === "agent.session") {
+        const sid = sessionIdOf(s);
+        if (sid !== "") sessionIds.add(sid);
+        totalCostUsd += attrNum(s.attributes, "cost_usd");
+      }
+      if (s.eventType === "promotion.commit") commits += 1;
+      if (s.eventType === "promotion.ci" && attrStr(s.attributes, "ci.verdict") === "passed") {
+        ciPassed += 1;
+      }
+    }
+    const sessions = sessionIds.size;
+    rows.push({
+      issueId,
+      projectId,
+      sessions,
+      commits,
+      ciPassed,
+      totalCostUsd: round(totalCostUsd, 4),
+      commitRate: sessions > 0 ? round(commits / sessions, 4) : 0,
+      ciPassRate: commits > 0 ? round(ciPassed / commits, 4) : 0,
+      commitsPerDollar: totalCostUsd > 0 ? round(commits / totalCostUsd, 4) : 0
+    });
+  }
+  return rows.sort((a, b) => a.issueId.localeCompare(b.issueId));
+}
+function computeLayer3(spans) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const issueId = issueIdOf(s);
+    if (issueId === "") continue;
+    const key = `${issueId}\0${projectIdOf(s)}`;
+    (groups.get(key) ?? groups.set(key, []).get(key)).push(s);
+  }
+  const rows = [];
+  for (const group of groups.values()) {
+    const issueId = issueIdOf(group[0]);
+    const projectId = projectIdOf(group[0]);
+    const issueType = group.map((s) => attrStr(s.attributes, "issue.type")).find((t) => t !== "") ?? "";
+    const stages = /* @__PURE__ */ new Set();
+    let totalCostUsd = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    for (const s of group) {
+      if (STAGE_SET.has(s.eventType)) stages.add(s.eventType);
+      if (s.eventType === "agent.session") {
+        totalCostUsd += attrNum(s.attributes, "cost_usd");
+        totalInputTokens += attrNum(s.attributes, "gen_ai.usage.input_tokens");
+        totalOutputTokens += attrNum(s.attributes, "gen_ai.usage.output_tokens");
+      }
+    }
+    const stagesPresent = stages.size;
+    rows.push({
+      issueId,
+      issueType,
+      projectId,
+      stagesPresent,
+      stagesTotal: OUTCOME_CHAIN_STAGES.length,
+      chainCompleteness: round(stagesPresent / OUTCOME_CHAIN_STAGES.length, 4),
+      totalCostUsd: round(totalCostUsd, 4),
+      totalInputTokens,
+      totalOutputTokens
+    });
+  }
+  return rows.sort((a, b) => a.issueId.localeCompare(b.issueId));
+}
+function computeSessionLinkRate(spans) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    if (s.eventType !== "agent.session") continue;
+    const projectId = projectIdOf(s);
+    const acc = byProject.get(projectId) ?? { total: 0, linked: 0 };
+    acc.total += 1;
+    if (issueIdOf(s) !== "") acc.linked += 1;
+    byProject.set(projectId, acc);
+  }
+  return [...byProject.entries()].map(([projectId, { total, linked }]) => ({
+    projectId,
+    totalSessions: total,
+    linkedSessions: linked,
+    linkRate: total > 0 ? round(linked / total, 4) : 0
+  })).sort((a, b) => a.projectId.localeCompare(b.projectId));
+}
+function computeStageArrival(spans) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const issueId = issueIdOf(s);
+    if (issueId === "") continue;
+    const projectId = projectIdOf(s);
+    const acc = byProject.get(projectId) ?? { commit: /* @__PURE__ */ new Set(), ci: /* @__PURE__ */ new Set(), deploy: /* @__PURE__ */ new Set() };
+    if (s.eventType === "promotion.commit") acc.commit.add(issueId);
+    if (s.eventType === "promotion.ci") acc.ci.add(issueId);
+    if (s.eventType === "promotion.deploy") acc.deploy.add(issueId);
+    byProject.set(projectId, acc);
+  }
+  return [...byProject.entries()].map(([projectId, { commit, ci, deploy }]) => {
+    const issuesWithCommit = commit.size;
+    const issuesWithCi = ci.size;
+    const issuesWithDeploy = deploy.size;
+    return {
+      projectId,
+      issuesWithCommit,
+      issuesWithCi,
+      issuesWithDeploy,
+      ciArrivalRate: issuesWithCommit > 0 ? round(issuesWithCi / issuesWithCommit, 4) : 0,
+      deployArrivalRate: issuesWithCommit > 0 ? round(issuesWithDeploy / issuesWithCommit, 4) : 0
+    };
+  }).sort((a, b) => a.projectId.localeCompare(b.projectId));
+}
+function computeProvisional(spans) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    const projectId = projectIdOf(s);
+    const acc = byProject.get(projectId) ?? { total: 0, unknown: 0, provisional: 0 };
+    acc.total += 1;
+    const sid = sessionIdOf(s);
+    if (sid === "" || sid === "unknown") acc.unknown += 1;
+    const confidence = attrStr(s.attributes, "link.confidence") || attrStr(s.attributes, "confidence");
+    if (confidence === "provisional") acc.provisional += 1;
+    byProject.set(projectId, acc);
+  }
+  return [...byProject.entries()].map(([projectId, { total, unknown, provisional }]) => ({
+    projectId,
+    totalSpans: total,
+    unknownSessionSpans: unknown,
+    provisionalSpans: provisional,
+    unknownRatio: total > 0 ? round(unknown / total, 4) : 0,
+    provisionalRatio: total > 0 ? round(provisional / total, 4) : 0
+  })).sort((a, b) => a.projectId.localeCompare(b.projectId));
+}
+function tierOf(issuesTouched) {
+  if (issuesTouched >= 10) return "high";
+  if (issuesTouched >= 3) return "mid";
+  return "low";
+}
+function computeTierRatio(spans) {
+  const byPerson = /* @__PURE__ */ new Map();
+  for (const s of spans) {
+    if (s.eventType !== "promotion.commit") continue;
+    const email = attrStr(s.attributes, "git.user.email");
+    if (email === "") continue;
+    const projectId = projectIdOf(s);
+    const key = `${email}\0${projectId}`;
+    const acc = byPerson.get(key) ?? { projectId, commits: 0, issues: /* @__PURE__ */ new Set() };
+    acc.commits += 1;
+    const issueId = issueIdOf(s);
+    if (issueId !== "") acc.issues.add(issueId);
+    byPerson.set(key, acc);
+  }
+  const byTier = /* @__PURE__ */ new Map();
+  for (const { projectId, commits, issues } of byPerson.values()) {
+    const tier = tierOf(issues.size);
+    const key = `${projectId}\0${tier}`;
+    const acc = byTier.get(key) ?? { projectId, tier, personCount: 0, commits: 0, issues: 0 };
+    acc.personCount += 1;
+    acc.commits += commits;
+    acc.issues += issues.size;
+    byTier.set(key, acc);
+  }
+  const order = { high: 0, mid: 1, low: 2 };
+  return [...byTier.values()].map((t) => ({
+    projectId: t.projectId,
+    tier: t.tier,
+    personCount: t.personCount,
+    tierCommits: t.commits,
+    tierIssues: t.issues
+  })).sort(
+    (a, b) => a.projectId.localeCompare(b.projectId) || order[a.tier] - order[b.tier]
+  );
+}
+function summarize(layer1, layer2, layer3, sessionLinkRate, tierRatio) {
+  const totalSessions = sessionLinkRate.reduce((a, r) => a + r.totalSessions, 0);
+  const linkedSessions = sessionLinkRate.reduce((a, r) => a + r.linkedSessions, 0);
+  const tierCounts = { high: 0, mid: 0, low: 0 };
+  for (const t of tierRatio) tierCounts[t.tier] += t.personCount;
+  return {
+    issueCount: new Set(layer1.map((r) => r.issueId)).size,
+    sessionCount: totalSessions,
+    totalCostUsd: round(
+      layer2.reduce((a, r) => a + r.totalCostUsd, 0),
+      4
+    ),
+    avgLeverage: round(average(layer1.map((r) => r.leverage)), 4),
+    avgCommitRate: round(average(layer2.map((r) => r.commitRate)), 4),
+    avgCiPassRate: round(average(layer2.map((r) => r.ciPassRate)), 4),
+    avgChainCompleteness: round(average(layer3.map((r) => r.chainCompleteness)), 4),
+    sessionLinkRate: totalSessions > 0 ? round(linkedSessions / totalSessions, 4) : 0,
+    tierCounts
+  };
+}
+function computeMetrics(spans) {
+  const layer1 = computeLayer1(spans);
+  const layer2 = computeLayer2(spans);
+  const layer3 = computeLayer3(spans);
+  const sessionLinkRate = computeSessionLinkRate(spans);
+  const stageArrival = computeStageArrival(spans);
+  const provisional = computeProvisional(spans);
+  const tierRatio = computeTierRatio(spans);
+  return {
+    layer1,
+    layer2,
+    layer3,
+    linkCompletion: { sessionLinkRate, stageArrival, provisional },
+    tierRatio,
+    summary: summarize(layer1, layer2, layer3, sessionLinkRate, tierRatio)
+  };
+}
+function diffSummary(after, before) {
+  return {
+    issueCount: after.issueCount - before.issueCount,
+    sessionCount: after.sessionCount - before.sessionCount,
+    totalCostUsd: round(after.totalCostUsd - before.totalCostUsd, 4),
+    avgLeverage: round(after.avgLeverage - before.avgLeverage, 4),
+    avgCommitRate: round(after.avgCommitRate - before.avgCommitRate, 4),
+    avgCiPassRate: round(after.avgCiPassRate - before.avgCiPassRate, 4),
+    avgChainCompleteness: round(after.avgChainCompleteness - before.avgChainCompleteness, 4),
+    sessionLinkRate: round(after.sessionLinkRate - before.sessionLinkRate, 4)
+  };
+}
+function generateDiagnosticReport(adapter, options = {}) {
+  const allSpans = adapter.querySpans({});
+  const fromNano = options.from !== void 0 ? isoToUnixNano(options.from) : void 0;
+  const toNano = options.to !== void 0 ? isoToUnixNano(options.to) : void 0;
+  const currentSpans = filterSpans(allSpans, {
+    projectId: options.projectId,
+    fromNano,
+    toNano
+  });
+  const metrics = computeMetrics(currentSpans);
+  const report = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    projectId: options.projectId ?? null,
+    period: { from: options.from ?? null, to: options.to ?? null },
+    metrics
+  };
+  if (options.baselineFrom !== void 0 || options.baselineTo !== void 0) {
+    const bFromNano = options.baselineFrom !== void 0 ? isoToUnixNano(options.baselineFrom) : void 0;
+    const bToNano = options.baselineTo !== void 0 ? isoToUnixNano(options.baselineTo) : void 0;
+    const baselineSpans = filterSpans(allSpans, {
+      projectId: options.projectId,
+      fromNano: bFromNano,
+      toNano: bToNano
+    });
+    const baselineMetrics = computeMetrics(baselineSpans);
+    report.baseline = {
+      period: { from: options.baselineFrom ?? null, to: options.baselineTo ?? null },
+      metrics: baselineMetrics,
+      comparison: diffSummary(metrics.summary, baselineMetrics.summary)
+    };
+  }
+  return report;
+}
+function bigIntReplacer(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function renderReportJson(report) {
+  return JSON.stringify(report, bigIntReplacer, 2);
+}
+function fmtPeriod(p) {
+  if (p.from === null && p.to === null) return "all time";
+  return `${p.from ?? "-\u221E"} \u2026 ${p.to ?? "now"}`;
+}
+function summaryTable(summary) {
+  return [
+    "| Metric | Value |",
+    "|---|---|",
+    `| Issues | ${summary.issueCount} |`,
+    `| Sessions | ${summary.sessionCount} |`,
+    `| Total cost (USD) | ${summary.totalCostUsd} |`,
+    `| Avg leverage (edits/session) | ${summary.avgLeverage} |`,
+    `| Avg commit rate | ${summary.avgCommitRate} |`,
+    `| Avg CI pass rate | ${summary.avgCiPassRate} |`,
+    `| Avg chain completeness | ${summary.avgChainCompleteness} |`,
+    `| Session link rate | ${summary.sessionLinkRate} |`,
+    `| Person tier (high/mid/low) | ${summary.tierCounts.high} / ${summary.tierCounts.mid} / ${summary.tierCounts.low} |`
+  ];
+}
+function signed(n) {
+  return n > 0 ? `+${n}` : `${n}`;
+}
+function renderReportMarkdown(report) {
+  const lines = [];
+  lines.push("# AaaC Observability \u8A3A\u65AD\u30EC\u30DD\u30FC\u30C8");
+  lines.push("");
+  lines.push(`- Generated at: ${report.generatedAt}`);
+  lines.push(`- Project: ${report.projectId ?? "(all)"}`);
+  lines.push(`- Period: ${fmtPeriod(report.period)}`);
+  lines.push("");
+  lines.push("## Summary");
+  lines.push("");
+  lines.push(...summaryTable(report.metrics.summary));
+  lines.push("");
+  lines.push("## Layer 1 \u2014 Scope / Leverage");
+  lines.push("");
+  if (report.metrics.layer1.length === 0) {
+    lines.push("_No issue-linked activity in range._");
+  } else {
+    lines.push("| Issue | Type | Project | Sessions | Edits | Commits | CI | CI passed | Leverage |");
+    lines.push("|---|---|---|---|---|---|---|---|---|");
+    for (const r of report.metrics.layer1) {
+      lines.push(
+        `| ${r.issueId} | ${r.issueType} | ${r.projectId} | ${r.sessionCount} | ${r.editCount} | ${r.commitCount} | ${r.ciCount} | ${r.ciPassed} | ${r.leverage} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## Layer 2 \u2014 Outcome Efficiency");
+  lines.push("");
+  if (report.metrics.layer2.length === 0) {
+    lines.push("_No issue-linked activity in range._");
+  } else {
+    lines.push("| Issue | Project | Sessions | Commits | CI passed | Cost (USD) | Commit rate | CI pass rate | Commits/$ |");
+    lines.push("|---|---|---|---|---|---|---|---|---|");
+    for (const r of report.metrics.layer2) {
+      lines.push(
+        `| ${r.issueId} | ${r.projectId} | ${r.sessions} | ${r.commits} | ${r.ciPassed} | ${r.totalCostUsd} | ${r.commitRate} | ${r.ciPassRate} | ${r.commitsPerDollar} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## Layer 3 \u2014 Outcome Chain & Cost");
+  lines.push("");
+  if (report.metrics.layer3.length === 0) {
+    lines.push("_No issue-linked activity in range._");
+  } else {
+    lines.push("| Issue | Type | Project | Stages | Completeness | Cost (USD) | Input tokens | Output tokens |");
+    lines.push("|---|---|---|---|---|---|---|---|");
+    for (const r of report.metrics.layer3) {
+      lines.push(
+        `| ${r.issueId} | ${r.issueType} | ${r.projectId} | ${r.stagesPresent}/${r.stagesTotal} | ${r.chainCompleteness} | ${r.totalCostUsd} | ${r.totalInputTokens} | ${r.totalOutputTokens} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## Link Completion KPIs");
+  lines.push("");
+  lines.push("### Session link rate");
+  lines.push("");
+  if (report.metrics.linkCompletion.sessionLinkRate.length === 0) {
+    lines.push("_No sessions in range._");
+  } else {
+    lines.push("| Project | Total sessions | Linked | Link rate |");
+    lines.push("|---|---|---|---|");
+    for (const r of report.metrics.linkCompletion.sessionLinkRate) {
+      lines.push(`| ${r.projectId} | ${r.totalSessions} | ${r.linkedSessions} | ${r.linkRate} |`);
+    }
+  }
+  lines.push("");
+  lines.push("### Stage arrival rate (commit \u2192 CI \u2192 deploy)");
+  lines.push("");
+  if (report.metrics.linkCompletion.stageArrival.length === 0) {
+    lines.push("_No issue-linked commits in range._");
+  } else {
+    lines.push("| Project | Commit | CI | Deploy | CI arrival | Deploy arrival |");
+    lines.push("|---|---|---|---|---|---|");
+    for (const r of report.metrics.linkCompletion.stageArrival) {
+      lines.push(
+        `| ${r.projectId} | ${r.issuesWithCommit} | ${r.issuesWithCi} | ${r.issuesWithDeploy} | ${r.ciArrivalRate} | ${r.deployArrivalRate} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("### Provisional / unknown ratio");
+  lines.push("");
+  if (report.metrics.linkCompletion.provisional.length === 0) {
+    lines.push("_No spans in range._");
+  } else {
+    lines.push("| Project | Total spans | Unknown session | Provisional | Unknown ratio | Provisional ratio |");
+    lines.push("|---|---|---|---|---|---|");
+    for (const r of report.metrics.linkCompletion.provisional) {
+      lines.push(
+        `| ${r.projectId} | ${r.totalSpans} | ${r.unknownSessionSpans} | ${r.provisionalSpans} | ${r.unknownRatio} | ${r.provisionalRatio} |`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## Person Tier Ratio");
+  lines.push("");
+  if (report.metrics.tierRatio.length === 0) {
+    lines.push("_No committer activity in range._");
+  } else {
+    lines.push("| Project | Tier | People | Commits | Issues |");
+    lines.push("|---|---|---|---|---|");
+    for (const r of report.metrics.tierRatio) {
+      lines.push(`| ${r.projectId} | ${r.tier} | ${r.personCount} | ${r.tierCommits} | ${r.tierIssues} |`);
+    }
+  }
+  lines.push("");
+  if (report.baseline !== void 0) {
+    const b = report.baseline;
+    lines.push("## Before / After Comparison");
+    lines.push("");
+    lines.push(`- Baseline (before): ${fmtPeriod(b.period)}`);
+    lines.push(`- Current (after): ${fmtPeriod(report.period)}`);
+    lines.push("");
+    lines.push("| Metric | Before | After | \u0394 |");
+    lines.push("|---|---|---|---|");
+    const before = b.metrics.summary;
+    const after = report.metrics.summary;
+    const c = b.comparison;
+    lines.push(`| Issues | ${before.issueCount} | ${after.issueCount} | ${signed(c.issueCount)} |`);
+    lines.push(`| Sessions | ${before.sessionCount} | ${after.sessionCount} | ${signed(c.sessionCount)} |`);
+    lines.push(`| Total cost (USD) | ${before.totalCostUsd} | ${after.totalCostUsd} | ${signed(c.totalCostUsd)} |`);
+    lines.push(`| Avg leverage | ${before.avgLeverage} | ${after.avgLeverage} | ${signed(c.avgLeverage)} |`);
+    lines.push(`| Avg commit rate | ${before.avgCommitRate} | ${after.avgCommitRate} | ${signed(c.avgCommitRate)} |`);
+    lines.push(`| Avg CI pass rate | ${before.avgCiPassRate} | ${after.avgCiPassRate} | ${signed(c.avgCiPassRate)} |`);
+    lines.push(`| Avg chain completeness | ${before.avgChainCompleteness} | ${after.avgChainCompleteness} | ${signed(c.avgChainCompleteness)} |`);
+    lines.push(`| Session link rate | ${before.sessionLinkRate} | ${after.sessionLinkRate} | ${signed(c.sessionLinkRate)} |`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
 // src/index.ts
 function createPipeline(options = {}) {
   const {
@@ -1682,6 +2660,9 @@ export {
   NormalizationError,
   validateRawEvent,
   Normalizer,
+  VENDOR_OTEL_SOURCE,
+  VENDOR_OTEL_DEDUP_PREFIX,
+  mapVendorOtelExport,
   MemoryCacheStore,
   SqliteCacheStore,
   Correlator,
@@ -1696,8 +2677,17 @@ export {
   recordTaskArtifact,
   createCrossAxisRule,
   createPromotionRule,
+  WORKTREE_WINDOW_MS,
+  worktreeRepoKey,
+  createWorktreeRule,
+  issueIdCacheKey,
+  issueTypeCacheKey,
+  createIssueAnchorRule,
   Enricher,
   createDefaultRules,
+  defaultGitRunner,
+  captureWorktree,
+  worktreeAttributes,
   DEFAULT_DB_PATH,
   SqliteSink,
   OtelEmitter,
@@ -1716,6 +2706,14 @@ export {
   emitQualityGateResult,
   extractPrUrl,
   emitPromotionPr,
+  parseIssueIdFromText,
+  buildGithubPromotionAttributes,
+  githubPromotionEventType,
+  OUTCOME_CHAIN_STAGES,
+  analyzeOutcomeChain,
+  generateDiagnosticReport,
+  renderReportJson,
+  renderReportMarkdown,
   createPipeline
 };
-//# sourceMappingURL=chunk-J2F5GEMO.js.map
+//# sourceMappingURL=chunk-3DXZNA3E.js.map