@aaac/observability 0.1.14 → 0.1.15

package/dist/index.d.ts

@@ -76,6 +76,16 @@ interface CanonicalEvent {
     attributes: Record<string, AttrValue>;
     /** Cross-axis links (first-class; maps to OTEL SpanLinks). */
     links: CanonicalLink[];
+    /**
+     * Optional deterministic idempotency key (observability-integration.md §9.2).
+     *
+     * When set, SqliteSink enforces UNIQUE(dedup_key) via INSERT OR IGNORE so that
+     * re-running a Canonical Projection batch (e.g. `aaac-observ ingest-vendor-otel`)
+     * never duplicates the same logical record. Left undefined for the primary
+     * hook/runtime write path, whose records are the canonical source (NULL keys do
+     * not participate in the UNIQUE constraint — SQLite allows multiple NULLs).
+     */
+    dedupKey?: string;
 }
 /**
  * Query return type — hides storage-backend differences (event-catalog.md §1.4).
@@ -251,6 +261,61 @@ declare class NormalizationError extends Error {
  */
 declare function validateRawEvent(event: RawEvent): void;
 
+/**
+ * vendor-otel-mapper — Canonical Projection of vendor OpenTelemetry exports.
+ *
+ * observability-integration.md §9.2 (T-D2): Claude Code (and other vendors) emit
+ * OTEL telemetry (token / cost / trace). This module projects a vendor OTLP **trace**
+ * export into CanonicalEvents so the data can be backfilled into the SQLite Ledger,
+ * which remains the canonical source of truth ("OTEL は補助証跡。正本は Canonical Event").
+ *
+ * ── Input format (assumption — see escalation note) ───────────────────────────
+ * The input is the standard OTLP/JSON `ExportTraceServiceRequest` shape, i.e. what
+ * an OTel Collector `file` exporter (or `OTEL_EXPORTER_OTLP_PROTOCOL=http/json`)
+ * produces:
+ *
+ *   { resourceSpans: [ { resource: { attributes: [...] },
+ *                        scopeSpans: [ { spans: [ { traceId, spanId, name,
+ *                                                   startTimeUnixNano, attributes }, ... ] } ] } ] }
+ *
+ * The exact attribute keys Claude Code uses for session id / cost are vendor-specific;
+ * we resolve a small candidate set and otherwise pass attributes through verbatim, so
+ * the projection degrades gracefully if the precise schema differs.
+ *
+ * ── Idempotency / dedup (§9.2) ────────────────────────────────────────────────
+ * Each projected event carries a deterministic `dedupKey` = `vendor-otel:{traceId}:{spanId}`.
+ * Combined with SqliteSink's UNIQUE(dedup_key) + INSERT OR IGNORE, re-running the
+ * ingest batch never duplicates rows. Hook/runtime records (dedup_key = NULL) remain
+ * the primary source and are never overwritten — vendor OTEL is auxiliary evidence.
+ */
+
+/** Default `source` tag applied to projected vendor events. */
+declare const VENDOR_OTEL_SOURCE = "claude-code-otel";
+/** Prefix for the deterministic dedup key namespace. */
+declare const VENDOR_OTEL_DEDUP_PREFIX = "vendor-otel";
+interface VendorOtelMapOptions {
+    /** `source` tag for projected events. Default: 'claude-code-otel'. */
+    source?: string;
+}
+interface VendorOtelMapResult {
+    /** Projected canonical events (ready for SqliteSink.write). */
+    events: CanonicalEvent[];
+    /** Number of input spans skipped because they lacked a usable identity. */
+    skipped: number;
+}
+/**
+ * Project a parsed vendor OTLP/JSON trace export into CanonicalEvents.
+ *
+ * Each vendor span becomes one `instant` CanonicalEvent (the Ledger records vendor
+ * telemetry as point-in-time evidence; original duration is preserved in the
+ * `vendor.duration_ns` attribute). Resource attributes (e.g. `service.name`) are
+ * merged into each span and surfaced as `project.id` for cross-project rollups.
+ *
+ * Spans without both a traceId and spanId are skipped (no stable dedup identity).
+ * Pure function — performs no IO; callers own reading/parsing and persistence.
+ */
+declare function mapVendorOtelExport(doc: unknown, options?: VendorOtelMapOptions): VendorOtelMapResult;
+
 /**
  * CacheStore — pluggable backend for the Correlator's short-term key-value cache.
  *
@@ -530,10 +595,15 @@ declare class Enricher {
  * Build the standard Phase 5 enrichment rule set.
  *
  * Rule ordering:
- *   1. R7 artifact.ts   — resolve edit.artifact_id first (R3 disambiguation depends on it)
- *   2. R3/R4 process.ts — maintain active-task stack; resolve process.edit/tool parent
- *   3. R5 cross-axis.ts — materializes_as_commit on promotion.commit close
- *   4. R1/R2 promotion.ts — cache changes; emit promotion.file on commit close
+ *   1. R-ISSUE issue-anchor.ts — cache/propagate issue.id early so downstream
+ *                                  rules see it (#178 T-E1). Runs first.
+ *   2. R7 artifact.ts   — resolve edit.artifact_id first (R3 disambiguation depends on it)
+ *   3. R3/R4 process.ts — maintain active-task stack; resolve process.edit/tool parent
+ *   4. R5 cross-axis.ts — materializes_as_commit on promotion.commit close
+ *   5. R1/R2 promotion.ts — cache changes; emit promotion.file on commit close
+ *   6. R8 worktree.ts   — provisional materializes_as_commit from the latest
+ *                          in-window same-repo worktree (out-of-band commits, #175).
+ *                          Runs last so it can observe R5's confirmed links.
  *
  * @param artifactPatterns  Passed to createArtifactRule for R7 lookupArtifact.
  */
@@ -657,6 +727,89 @@ declare function createCrossAxisRule(): EnrichRule;
  */
 declare function createPromotionRule(): EnrichRule;
 
+/** Default attribution window: 1 hour (ms). A snapshot older than this is stale. */
+declare const WORKTREE_WINDOW_MS: number;
+/** Cached latest worktree snapshot for a repo root. */
+interface WorktreeRef {
+    spanId: string;
+    traceId: string;
+    sessionId?: string;
+    /** Snapshot time in epoch milliseconds (derived from timeUnixNano). */
+    timeMs: number;
+}
+declare function worktreeRepoKey(repoRoot: string): string;
+/**
+ * Create the WS-B worktree-attribution enrichment rule.
+ *
+ * @param windowMs  Attribution window in ms (default {@link WORKTREE_WINDOW_MS}).
+ */
+declare function createWorktreeRule(windowMs?: number): EnrichRule;
+
+/**
+ * R-ISSUE — Issue anchor enrichment rule (#178 T-E1).
+ *
+ * observability-integration.md §8 (Economic Conversion Layer):
+ *   When a span carries `issue.id` (and optionally `issue.type`), cache the
+ *   values per session. Subsequent spans in the same session that lack
+ *   `issue.id` inherit the cached value (propagation within a session).
+ *
+ * When no `issue.id` is found on an event AND no cached value exists for
+ * that session, sets `issue.id_missing=true` so downstream monitoring can
+ * detect attribution gaps without guessing.
+ *
+ * Cache schema:
+ *   session:{sid}:issue_id   → string   (first issue.id seen in session)
+ *   session:{sid}:issue_type → string   (first issue.type seen in session)
+ */
+
+declare function issueIdCacheKey(sessionId: string): string;
+declare function issueTypeCacheKey(sessionId: string): string;
+/**
+ * Create the issue-anchor enrichment rule.
+ *
+ * Behaviour:
+ *   1. If event carries `issue.id` → cache per session (first-wins).
+ *   2. If event lacks `issue.id` but session has a cached value → propagate.
+ *   3. If event lacks `issue.id` AND no cached value → set `issue.id_missing=true`.
+ *   4. Same logic applies to `issue.type` (propagation only, no _missing flag).
+ *
+ * Only fires for events that have a sessionId (standalone CI events must
+ * carry issue.id themselves — this is already the case per the pipeline design).
+ */
+declare function createIssueAnchorRule(): EnrichRule;
+
+/** A best-effort snapshot of the working tree at a point in time. */
+interface WorktreeSnapshot {
+    /** Working-tree HEAD sha (full 40-char). Absent on an empty repo (no commits). */
+    commitSha?: string;
+    /** Absolute repository root (`git rev-parse --show-toplevel`). */
+    repoRoot?: string;
+    /** True when there are uncommitted changes (staged or unstaged / untracked). */
+    dirty: boolean;
+}
+/**
+ * Injectable git runner: receives the argv (after `git`) and returns trimmed
+ * stdout, or `undefined` on any error / non-zero exit. Defaults to a real,
+ * timeout-bounded `git` invocation.
+ */
+type GitRunner = (args: string[]) => string | undefined;
+/** Real git runner — bounded by a short timeout; swallows all errors. */
+declare function defaultGitRunner(args: string[]): string | undefined;
+/**
+ * Capture the working-tree snapshot for `cwd`.
+ *
+ * Returns `undefined` when `cwd` is not inside a git repository (no repo root),
+ * so callers can skip emission entirely. A repo with no commits yet still
+ * returns a snapshot (commitSha absent, dirty reflects the index/worktree).
+ */
+declare function captureWorktree(cwd: string, git?: GitRunner): WorktreeSnapshot | undefined;
+/**
+ * Build the `promotion.worktree` attribute map from a snapshot + session id.
+ * `agent.session_id` is the catalog attribute (event-catalog.md §2.4); `session_id`
+ * is also set so the Normalizer resolves a non-null cross-axis correlation key.
+ */
+declare function worktreeAttributes(snapshot: WorktreeSnapshot, sessionId: string | undefined): Record<string, AttrValue>;
+
 /**
  * SqliteSink — persists CanonicalEvents to a local SQLite database.
  *
@@ -676,13 +829,26 @@ declare const DEFAULT_DB_PATH = ".agent-logs/observability.db";
 declare class SqliteSink {
     private readonly db;
     constructor(dbPath?: string);
+    /**
+     * 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.
+     */
+    private migrateDedupKey;
     /**
      * Persist a single CanonicalEvent.
      *  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: CanonicalEvent): void;
+    write(event: CanonicalEvent): boolean;
     /** Close the database connection. */
     close(): void;
     /**
@@ -690,6 +856,15 @@ declare class SqliteSink {
      * Should not be used in production write paths.
      */
     getDb(): DatabaseSync;
+    /**
+     * 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).
+     */
     private insertCanonicalEvent;
     private upsertSpan;
     private insertLinks;
@@ -1094,6 +1269,210 @@ declare function emitPromotionPr(collector: EventCollector, options: {
     parentSpanId?: string;
 }): string | null;
 
+/** Parse GitHub Issue number from commit message, branch name, or PR title. */
+declare function parseIssueIdFromText(text: string): number | null;
+type GithubPromotionKind = "ci" | "deploy";
+interface GithubPromotionRecordInput {
+    kind: GithubPromotionKind;
+    runId: string;
+    sha: string;
+    verdict: string;
+    commitMessage?: string;
+    deployTarget?: string;
+    workflowName?: string;
+}
+/**
+ * Build attributes for promotion.ci / promotion.deploy external events.
+ * Required correlation fields per observability-integration.md §7.1.
+ */
+declare function buildGithubPromotionAttributes(input: GithubPromotionRecordInput): Record<string, AttrValue>;
+declare function githubPromotionEventType(kind: GithubPromotionKind): string;
+
+/** Target Outcome chain stages (#176 T-C3). */
+declare const OUTCOME_CHAIN_STAGES: readonly ["agent.session", "process.task", "process.edit", "promotion.commit", "promotion.ci", "promotion.deploy"];
+type OutcomeChainStageName = (typeof OUTCOME_CHAIN_STAGES)[number];
+type OutcomeChainStageStatus = "present" | "missing" | "provisional";
+interface OutcomeChainStageResult {
+    eventType: OutcomeChainStageName;
+    status: OutcomeChainStageStatus;
+    spanIds: string[];
+}
+interface OutcomeChainAnalysis {
+    issueId: string;
+    stages: OutcomeChainStageResult[];
+    /** True when every stage is present (provisional counts as present but flagged). */
+    complete: boolean;
+    /** Stages with no matching span. */
+    gaps: OutcomeChainStageName[];
+    /** Stages present only via provisional correlation. */
+    provisional: OutcomeChainStageName[];
+}
+/**
+ * Detect Outcome chain coverage for one Issue (#176 T-C3).
+ * Does not infer missing stages — gaps stay explicit.
+ */
+declare function analyzeOutcomeChain(adapter: SqliteQueryAdapter, issueId: string | number): OutcomeChainAnalysis;
+
+/**
+ * diagnostic-report — Observability 診断レポート生成 (#179 WS-F T-F1).
+ *
+ * Computes the Layer 1–3 / link-completion / Person-Tier metrics that the
+ * `aaac-diagnostic` Grafana dashboard renders from ClickHouse VIEWs, but over
+ * the local SQLite Ledger via SqliteQueryAdapter so the same diagnostic can be
+ * produced as a CLI report (Markdown / JSON) without a running stack.
+ *
+ * The formulas intentionally mirror docker/observability/analysis-views.sql so
+ * the CLI report and the Grafana dashboard agree:
+ *   - aaac_layer1_issue            → Layer1Row
+ *   - aaac_layer2_issue_efficiency → Layer2Row
+ *   - aaac_layer3_issue_outcome    → Layer3Row
+ *   - aaac_kpi_session_link_rate   → SessionLinkRateRow
+ *   - aaac_kpi_stage_arrival_rate  → StageArrivalRow
+ *   - aaac_kpi_provisional_ratio   → ProvisionalRow
+ *   - aaac_person_tier_ratio       → TierRatioRow
+ *
+ * Before/After comparison: when a baseline window is supplied the same metrics
+ * are computed over the baseline period and the summary deltas are reported.
+ */
+
+interface Layer1Row {
+    issueId: string;
+    issueType: string;
+    projectId: string;
+    sessionCount: number;
+    editCount: number;
+    commitCount: number;
+    ciCount: number;
+    ciPassed: number;
+    leverage: number;
+}
+interface Layer2Row {
+    issueId: string;
+    projectId: string;
+    sessions: number;
+    commits: number;
+    ciPassed: number;
+    totalCostUsd: number;
+    commitRate: number;
+    ciPassRate: number;
+    commitsPerDollar: number;
+}
+interface Layer3Row {
+    issueId: string;
+    issueType: string;
+    projectId: string;
+    stagesPresent: number;
+    stagesTotal: number;
+    chainCompleteness: number;
+    totalCostUsd: number;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+}
+interface SessionLinkRateRow {
+    projectId: string;
+    totalSessions: number;
+    linkedSessions: number;
+    linkRate: number;
+}
+interface StageArrivalRow {
+    projectId: string;
+    issuesWithCommit: number;
+    issuesWithCi: number;
+    issuesWithDeploy: number;
+    ciArrivalRate: number;
+    deployArrivalRate: number;
+}
+interface ProvisionalRow {
+    projectId: string;
+    totalSpans: number;
+    unknownSessionSpans: number;
+    provisionalSpans: number;
+    unknownRatio: number;
+    provisionalRatio: number;
+}
+type PersonTier = "high" | "mid" | "low";
+interface TierRatioRow {
+    projectId: string;
+    tier: PersonTier;
+    personCount: number;
+    tierCommits: number;
+    tierIssues: number;
+}
+interface MetricsSummary {
+    issueCount: number;
+    sessionCount: number;
+    totalCostUsd: number;
+    avgLeverage: number;
+    avgCommitRate: number;
+    avgCiPassRate: number;
+    avgChainCompleteness: number;
+    /** Overall linked / total sessions across all selected projects. */
+    sessionLinkRate: number;
+    tierCounts: Record<PersonTier, number>;
+}
+interface DiagnosticMetrics {
+    layer1: Layer1Row[];
+    layer2: Layer2Row[];
+    layer3: Layer3Row[];
+    linkCompletion: {
+        sessionLinkRate: SessionLinkRateRow[];
+        stageArrival: StageArrivalRow[];
+        provisional: ProvisionalRow[];
+    };
+    tierRatio: TierRatioRow[];
+    summary: MetricsSummary;
+}
+interface PeriodWindow {
+    from: string | null;
+    to: string | null;
+}
+interface ComparisonDelta {
+    issueCount: number;
+    sessionCount: number;
+    totalCostUsd: number;
+    avgLeverage: number;
+    avgCommitRate: number;
+    avgCiPassRate: number;
+    avgChainCompleteness: number;
+    sessionLinkRate: number;
+}
+interface DiagnosticReport {
+    generatedAt: string;
+    /** Project filter applied, or null when all projects are included. */
+    projectId: string | null;
+    period: PeriodWindow;
+    metrics: DiagnosticMetrics;
+    baseline?: {
+        period: PeriodWindow;
+        metrics: DiagnosticMetrics;
+        comparison: ComparisonDelta;
+    };
+}
+interface DiagnosticReportOptions {
+    /** Restrict to a single project_id (matches project.id attr / service.name). */
+    projectId?: string;
+    /** Inclusive lower bound (ISO 8601) for the current/after window. */
+    from?: string;
+    /** Inclusive upper bound (ISO 8601) for the current/after window. */
+    to?: string;
+    /** Inclusive lower bound (ISO 8601) for the baseline/before window. */
+    baselineFrom?: string;
+    /** Inclusive upper bound (ISO 8601) for the baseline/before window. */
+    baselineTo?: string;
+}
+/**
+ * Generate a diagnostic report from the SQLite Ledger.
+ *
+ * Reads all materialised spans once, then derives Layer 1–3 / link-completion /
+ * Tier metrics over the (optionally project- and time-filtered) span set. When
+ * a baseline window is supplied, the same metrics are computed over the baseline
+ * period and a summary-level Before/After comparison is attached.
+ */
+declare function generateDiagnosticReport(adapter: SqliteQueryAdapter, options?: DiagnosticReportOptions): DiagnosticReport;
+declare function renderReportJson(report: DiagnosticReport): string;
+/** Render the report as Markdown (customer-facing diagnostic). */
+declare function renderReportMarkdown(report: DiagnosticReport): string;
+
 /**
  * @aaac/observability — Phase 0–5 public API
  *
@@ -1166,4 +1545,4 @@ interface Pipeline {
  */
 declare function createPipeline(options?: PipelineOptions): Pipeline;
 
-export { type ActiveTask, type ArtifactPattern, type AttrValue, type CacheStore, type CanonicalEvent, type CanonicalLink, Correlator, DEFAULT_DB_PATH, DefaultExternalRegistrar, type EmitInput, type EnrichApi, type EnrichContext, type EnrichResult, type EnrichRule, Enricher, type EnricherOptions, EventCollector, type EventMappingConfig, type EventMappingResult, type EventMappingRule, type EventQueryFilter, type ExecutionEnvelope, type ExternalEventRegistrar, type Lifecycle, type LinkDirection, type LinkRecord, type LinkRule, type MappedSpan, type MappedSpanEvent, type MappedSpanLink, MemoryCacheStore, NormalizationError, Normalizer, OtelEmitter, type OtelEmitterOptions, type Pipeline, type PipelineOptions, QUALITY_GATE_PATTERNS, type QueryAdapter, type RawEvent, type RawEventHandler, type RawExternalEvent, type ResolvedLink, type ResolvedSpan, type SpanQueryFilter, type SpanRecord, type SpanRule, SqliteCacheStore, SqliteQueryAdapter, SqliteSink, type StoredEvent, activeTasksKey, allTaskSpansKey, keys as correlateKeys, createArtifactRule, createCrossAxisRule, createDefaultRules, createPipeline, createProcessRule, createPromotionRule, currentTimeUnixNano, emitHumanInstruction, emitPromotionPr, emitQualityGateResult, evaluateMapping, extractPrUrl, generateArtifactLookup, generateId, generateTaskPatterns, globToRegex, isoToUnixNano, loadEventMappingConfig, lookupArtifact, mapAllEventsToSpans, mapEventsToSpan, matchQualityGate, parseStructuredTags, recordTaskArtifact, resolveTemplate, taskFilesKey, validateRawEvent };
+export { type ActiveTask, type ArtifactPattern, type AttrValue, type CacheStore, type CanonicalEvent, type CanonicalLink, type ComparisonDelta, Correlator, DEFAULT_DB_PATH, DefaultExternalRegistrar, type DiagnosticMetrics, type DiagnosticReport, type DiagnosticReportOptions, type EmitInput, type EnrichApi, type EnrichContext, type EnrichResult, type EnrichRule, Enricher, type EnricherOptions, EventCollector, type EventMappingConfig, type EventMappingResult, type EventMappingRule, type EventQueryFilter, type ExecutionEnvelope, type ExternalEventRegistrar, type GitRunner, type GithubPromotionKind, type GithubPromotionRecordInput, type Layer1Row, type Layer2Row, type Layer3Row, type Lifecycle, type LinkDirection, type LinkRecord, type LinkRule, type MappedSpan, type MappedSpanEvent, type MappedSpanLink, MemoryCacheStore, type MetricsSummary, NormalizationError, Normalizer, OUTCOME_CHAIN_STAGES, OtelEmitter, type OtelEmitterOptions, type OutcomeChainAnalysis, type OutcomeChainStageName, type OutcomeChainStageResult, type OutcomeChainStageStatus, type PeriodWindow, type PersonTier, type Pipeline, type PipelineOptions, type ProvisionalRow, QUALITY_GATE_PATTERNS, type QueryAdapter, type RawEvent, type RawEventHandler, type RawExternalEvent, type ResolvedLink, type ResolvedSpan, type SessionLinkRateRow, type SpanQueryFilter, type SpanRecord, type SpanRule, SqliteCacheStore, SqliteQueryAdapter, SqliteSink, type StageArrivalRow, type StoredEvent, type TierRatioRow, VENDOR_OTEL_DEDUP_PREFIX, VENDOR_OTEL_SOURCE, type VendorOtelMapOptions, type VendorOtelMapResult, WORKTREE_WINDOW_MS, type WorktreeRef, type WorktreeSnapshot, activeTasksKey, allTaskSpansKey, analyzeOutcomeChain, buildGithubPromotionAttributes, captureWorktree, keys as correlateKeys, createArtifactRule, createCrossAxisRule, createDefaultRules, createIssueAnchorRule, createPipeline, createProcessRule, createPromotionRule, createWorktreeRule, currentTimeUnixNano, defaultGitRunner, emitHumanInstruction, emitPromotionPr, emitQualityGateResult, evaluateMapping, extractPrUrl, generateArtifactLookup, generateDiagnosticReport, generateId, generateTaskPatterns, githubPromotionEventType, globToRegex, isoToUnixNano, issueIdCacheKey, issueTypeCacheKey, loadEventMappingConfig, lookupArtifact, mapAllEventsToSpans, mapEventsToSpan, mapVendorOtelExport, matchQualityGate, parseIssueIdFromText, parseStructuredTags, recordTaskArtifact, renderReportJson, renderReportMarkdown, resolveTemplate, taskFilesKey, validateRawEvent, worktreeAttributes, worktreeRepoKey };

package/dist/index.js

@@ -7,42 +7,62 @@ import {
   MemoryCacheStore,
   NormalizationError,
   Normalizer,
+  OUTCOME_CHAIN_STAGES,
   OtelEmitter,
   QUALITY_GATE_PATTERNS,
   SqliteCacheStore,
   SqliteQueryAdapter,
   SqliteSink,
+  VENDOR_OTEL_DEDUP_PREFIX,
+  VENDOR_OTEL_SOURCE,
+  WORKTREE_WINDOW_MS,
   activeTasksKey,
   allTaskSpansKey,
+  analyzeOutcomeChain,
+  buildGithubPromotionAttributes,
+  captureWorktree,
   createArtifactRule,
   createCrossAxisRule,
   createDefaultRules,
+  createIssueAnchorRule,
   createPipeline,
   createProcessRule,
   createPromotionRule,
+  createWorktreeRule,
   currentTimeUnixNano,
+  defaultGitRunner,
   emitHumanInstruction,
   emitPromotionPr,
   emitQualityGateResult,
   evaluateMapping,
   extractPrUrl,
   generateArtifactLookup,
+  generateDiagnosticReport,
   generateId,
   generateTaskPatterns,
+  githubPromotionEventType,
   globToRegex,
   isoToUnixNano,
+  issueIdCacheKey,
+  issueTypeCacheKey,
   keys,
   loadEventMappingConfig,
   lookupArtifact,
   mapAllEventsToSpans,
   mapEventsToSpan,
+  mapVendorOtelExport,
   matchQualityGate,
+  parseIssueIdFromText,
   parseStructuredTags,
   recordTaskArtifact,
+  renderReportJson,
+  renderReportMarkdown,
   resolveTemplate,
   taskFilesKey,
-  validateRawEvent
-} from "./chunk-J2F5GEMO.js";
+  validateRawEvent,
+  worktreeAttributes,
+  worktreeRepoKey
+} from "./chunk-3DXZNA3E.js";
 export {
   Correlator,
   DEFAULT_DB_PATH,
@@ -52,40 +72,60 @@ export {
   MemoryCacheStore,
   NormalizationError,
   Normalizer,
+  OUTCOME_CHAIN_STAGES,
   OtelEmitter,
   QUALITY_GATE_PATTERNS,
   SqliteCacheStore,
   SqliteQueryAdapter,
   SqliteSink,
+  VENDOR_OTEL_DEDUP_PREFIX,
+  VENDOR_OTEL_SOURCE,
+  WORKTREE_WINDOW_MS,
   activeTasksKey,
   allTaskSpansKey,
+  analyzeOutcomeChain,
+  buildGithubPromotionAttributes,
+  captureWorktree,
   keys as correlateKeys,
   createArtifactRule,
   createCrossAxisRule,
   createDefaultRules,
+  createIssueAnchorRule,
   createPipeline,
   createProcessRule,
   createPromotionRule,
+  createWorktreeRule,
   currentTimeUnixNano,
+  defaultGitRunner,
   emitHumanInstruction,
   emitPromotionPr,
   emitQualityGateResult,
   evaluateMapping,
   extractPrUrl,
   generateArtifactLookup,
+  generateDiagnosticReport,
   generateId,
   generateTaskPatterns,
+  githubPromotionEventType,
   globToRegex,
   isoToUnixNano,
+  issueIdCacheKey,
+  issueTypeCacheKey,
   loadEventMappingConfig,
   lookupArtifact,
   mapAllEventsToSpans,
   mapEventsToSpan,
+  mapVendorOtelExport,
   matchQualityGate,
+  parseIssueIdFromText,
   parseStructuredTags,
   recordTaskArtifact,
+  renderReportJson,
+  renderReportMarkdown,
   resolveTemplate,
   taskFilesKey,
-  validateRawEvent
+  validateRawEvent,
+  worktreeAttributes,
+  worktreeRepoKey
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaac/observability",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "In-process observability for @aaac — EventCollector / Normalizer / Correlator / SqliteSink",
   "license": "MIT",
   "repository": {
@@ -14,7 +14,8 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
-    "aaac-observ": "./dist/cli/index.js"
+    "aaac-observ": "./dist/cli/index.js",
+    "aaac-observ-global-record": "./dist/cli/global-record.js"
   },
   "exports": {
     ".": {