@poetic-ai/poetic 1.42.1-bootstrap.0

package/dist/chunk-RGROYC2G.js

@@ -0,0 +1,638 @@
+import {
+  isTelemetryPersistenceEnabled
+} from "./chunk-H6G7QRMQ.js";
+import {
+  TelemetryPathResolver
+} from "./chunk-ZDTGECTN.js";
+import {
+  redactPersistedTelemetryValue
+} from "./chunk-6Y5U7UFY.js";
+import {
+  getRuntimeEnv
+} from "./chunk-ENRGKNR5.js";
+import {
+  ProviderRegistry
+} from "./chunk-AT4TNPWW.js";
+import {
+  resolvePoeticRoot
+} from "./chunk-LEIIWPWQ.js";
+import {
+  POETIC_ROUTING_HISTORY_DB,
+  POETIC_TELEMETRY_DIR,
+  readEnv
+} from "./chunk-5DLKYTQX.js";
+
+// src/telemetry/routing-history-store.ts
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import Database from "better-sqlite3";
+var SAFE_SQL_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+var SAFE_COLUMN_DEFINITION = /^(TEXT|INTEGER|REAL|BLOB|NUMERIC)$/iu;
+function validateSqlIdentifier(value, label) {
+  if (!SAFE_SQL_IDENTIFIER.test(value)) {
+    throw new Error(`Invalid SQL ${label}: ${value}`);
+  }
+  return value;
+}
+function validateColumnDefinition(value) {
+  if (!SAFE_COLUMN_DEFINITION.test(value)) {
+    throw new Error(`Invalid SQL column definition: ${value}`);
+  }
+  return value;
+}
+function resolveOutcomeQuality(qualityScore, qualityProvenance) {
+  if (qualityProvenance === "absent") {
+    return { qualityScore: void 0, qualityProvenance: "absent" };
+  }
+  if (qualityProvenance === "unknown") {
+    return typeof qualityScore === "number" && Number.isFinite(qualityScore) ? { qualityScore, qualityProvenance: "unknown" } : { qualityScore: void 0, qualityProvenance: "absent" };
+  }
+  if (typeof qualityScore === "number" && Number.isFinite(qualityScore)) {
+    return { qualityScore, qualityProvenance: "judged" };
+  }
+  return { qualityScore: void 0, qualityProvenance: "absent" };
+}
+var RoutingHistoryStore = class {
+  db = null;
+  dbPath;
+  isMemory;
+  constructor(dbPath = ":memory:") {
+    this.dbPath = dbPath;
+    this.isMemory = dbPath === ":memory:";
+    this.initialize();
+  }
+  /**
+   * Initialize database and schema
+   */
+  initialize() {
+    if (!isTelemetryPersistenceEnabled()) {
+      this.db = null;
+      return;
+    }
+    try {
+      if (!this.isMemory) {
+        const dir = dirname(this.dbPath);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+      }
+      this.db = new Database(this.dbPath);
+      if (this.db) {
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+      }
+      this.createSchema();
+    } catch (error) {
+      console.warn(
+        "[RoutingHistoryStore] Failed to initialize SQLite, falling back to no-op mode:",
+        error
+      );
+      this.db = null;
+    }
+  }
+  /**
+   * Create database schema
+   */
+  createSchema() {
+    if (!this.db) return;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS routing_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        type TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        provider TEXT,
+        model TEXT,
+        domain TEXT,
+        payload TEXT NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS routing_outcomes (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        routing_id TEXT NOT NULL,
+        provider TEXT NOT NULL,
+        model TEXT,
+        domain TEXT,
+        success INTEGER NOT NULL,
+        quality_score REAL,
+        quality_provenance TEXT,
+        quality_source TEXT,
+        duration_ms REAL,
+        token_cost REAL,
+        timestamp INTEGER NOT NULL,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+    `);
+    this.ensureColumnExists("routing_events", "model", "TEXT");
+    this.ensureColumnExists("routing_outcomes", "model", "TEXT");
+    this.ensureColumnExists("routing_outcomes", "quality_provenance", "TEXT");
+    this.ensureColumnExists("routing_outcomes", "quality_source", "TEXT");
+    this.db.exec(`
+      UPDATE routing_outcomes
+      SET quality_provenance = CASE
+        WHEN quality_score IS NULL THEN 'absent'
+        ELSE 'unknown'
+      END
+      WHERE quality_provenance IS NULL;
+    `);
+    this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_outcomes_routing_id ON routing_outcomes(routing_id);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_provider_model ON routing_outcomes(provider, model);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_provider ON routing_outcomes(provider);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_domain ON routing_outcomes(domain);
+      CREATE INDEX IF NOT EXISTS idx_outcomes_timestamp ON routing_outcomes(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_events_provider_model ON routing_events(provider, model);
+      CREATE INDEX IF NOT EXISTS idx_events_type ON routing_events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON routing_events(timestamp);
+    `);
+  }
+  ensureColumnExists(tableName, columnName, columnDef) {
+    if (!this.db) return;
+    const safeTableName = validateSqlIdentifier(tableName, "table name");
+    const safeColumnName = validateSqlIdentifier(columnName, "column name");
+    const safeColumnDef = validateColumnDefinition(columnDef);
+    try {
+      const rows = this.db.prepare(`PRAGMA table_info(${safeTableName})`).all();
+      const hasColumn = rows.some((row) => row.name === safeColumnName);
+      if (!hasColumn) {
+        this.db.exec(`ALTER TABLE ${safeTableName} ADD COLUMN ${safeColumnName} ${safeColumnDef}`);
+      }
+    } catch (error) {
+      console.warn(
+        `[RoutingHistoryStore] Failed to ensure column ${tableName}.${columnName}:`,
+        error
+      );
+    }
+  }
+  /**
+   * Persist a routing telemetry event
+   */
+  persistEvent(event) {
+    if (!this.db) return;
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO routing_events (type, timestamp, provider, model, domain, payload)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      const timestamp = new Date(event.timestamp).getTime();
+      const provider = "provider" in event ? event.provider : null;
+      const model = "model" in event && typeof event.model === "string" ? event.model : null;
+      const domain = "domain" in event ? event.domain : null;
+      const payload = JSON.stringify(redactPersistedTelemetryValue(event));
+      stmt.run(event.type, timestamp, provider, model, domain, payload);
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to persist event:", error);
+    }
+  }
+  /**
+   * Record a routing outcome (success/failure with quality score).
+   * Quality is normalized via resolveOutcomeQuality so non-finite values and
+   * explicit `qualityProvenance: 'absent'` never become judged quality samples;
+   * operational success is independent.
+   */
+  recordOutcome(outcome) {
+    if (!this.db) return;
+    try {
+      const { qualityScore, qualityProvenance } = resolveOutcomeQuality(
+        outcome.qualityScore,
+        outcome.qualityProvenance
+      );
+      const existing = this.db.prepare("SELECT id FROM routing_outcomes WHERE routing_id = ? ORDER BY id DESC LIMIT 1").get(outcome.routingId);
+      const values = [
+        outcome.provider,
+        outcome.model ?? null,
+        outcome.domain,
+        outcome.success ? 1 : 0,
+        qualityScore ?? null,
+        qualityProvenance,
+        outcome.qualitySource ?? null,
+        outcome.duration ?? null,
+        outcome.tokenCost ?? null,
+        outcome.timestamp
+      ];
+      if (existing) {
+        this.db.prepare(`
+            UPDATE routing_outcomes
+            SET provider = ?, model = ?, domain = ?, success = ?, quality_score = ?,
+                quality_provenance = ?, quality_source = ?, duration_ms = ?, token_cost = ?,
+                timestamp = ?
+            WHERE id = ?
+          `).run(...values, existing.id);
+      } else {
+        this.db.prepare(`
+            INSERT INTO routing_outcomes (
+              routing_id, provider, model, domain, success, quality_score,
+              quality_provenance, quality_source, duration_ms, token_cost, timestamp
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `).run(outcome.routingId, ...values);
+      }
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to record outcome:", error);
+    }
+  }
+  /**
+   * Get provider success rate (0-1) for a domain within a time window
+   */
+  getProviderSuccessRate(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return 0.5;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT AVG(success) as success_rate
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      return result?.success_rate ?? 0.5;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get success rate:", error);
+      return 0.5;
+    }
+  }
+  /**
+   * Get provider average quality score (0-100) for a domain within a time window.
+   * Returns null when no judged quality samples exist — never a synthetic default
+   * (e.g. 50) that would pretend quality was observed.
+   */
+  getProviderAverageScore(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return null;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT AVG(quality_score) as avg_score
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND quality_provenance = 'judged' AND quality_score IS NOT NULL
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      const avg = result?.avg_score;
+      return typeof avg === "number" && Number.isFinite(avg) ? avg : null;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get average score:", error);
+      return null;
+    }
+  }
+  /**
+   * Get operational sample size for a provider/domain combination
+   * (all outcomes, with or without judged quality).
+   */
+  getSampleSize(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return 0;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT COUNT(*) as count
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      return result?.count ?? 0;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get sample size:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get quality-sample size: only outcomes with a real judged quality_score.
+   * Missing quality must not inflate quality confidence, averages, or rankings.
+   */
+  getQualitySampleSize(providerId, domain, windowDays = 30, model) {
+    if (!this.db) return 0;
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      let query = `
+        SELECT COUNT(*) as count
+        FROM routing_outcomes
+        WHERE provider = ? AND timestamp >= ?
+          AND quality_provenance = 'judged' AND quality_score IS NOT NULL
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+      `;
+      const params = [providerId, cutoffTime];
+      if (model) {
+        query += " AND model = ?";
+        params.push(model);
+      }
+      if (domain) {
+        query += " AND domain = ?";
+        params.push(domain);
+      }
+      const result = this.db.prepare(query).get(...params);
+      return result?.count ?? 0;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get quality sample size:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get domain provider rankings sorted by performance
+   */
+  getDomainProviderRankings(domain, windowDays = 30) {
+    if (!this.db) return [];
+    try {
+      const cutoffTime = Date.now() - windowDays * 24 * 60 * 60 * 1e3;
+      const query = `
+        SELECT
+          provider,
+          AVG(quality_score) as score,
+          COUNT(*) as count
+        FROM routing_outcomes
+        WHERE domain = ? AND timestamp >= ?
+          AND quality_provenance = 'judged' AND quality_score IS NOT NULL
+          AND id = (SELECT MAX(latest.id) FROM routing_outcomes latest WHERE latest.routing_id = routing_outcomes.routing_id)
+        GROUP BY provider
+        ORDER BY score DESC
+      `;
+      const results = this.db.prepare(query).all(domain, cutoffTime);
+      return results;
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get provider rankings:", error);
+      return [];
+    }
+  }
+  /**
+   * Prune old records (older than N days)
+   * Returns number of records deleted
+   */
+  pruneOlderThan(days) {
+    if (!this.db) return 0;
+    try {
+      const cutoffTime = Date.now() - days * 24 * 60 * 60 * 1e3;
+      const eventsDeleted = this.db.prepare("DELETE FROM routing_events WHERE timestamp < ?").run(cutoffTime);
+      const outcomesDeleted = this.db.prepare("DELETE FROM routing_outcomes WHERE timestamp < ?").run(cutoffTime);
+      return (eventsDeleted.changes ?? 0) + (outcomesDeleted.changes ?? 0);
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to prune old records:", error);
+      return 0;
+    }
+  }
+  /**
+   * Get store statistics
+   */
+  getStats() {
+    if (!this.db) {
+      return {
+        totalEvents: 0,
+        oldestEvent: null,
+        providers: []
+      };
+    }
+    try {
+      const totalEvents = this.db.prepare("SELECT COUNT(*) as count FROM routing_events").get().count;
+      const oldestEventResult = this.db.prepare("SELECT MIN(timestamp) as oldest FROM routing_events").get();
+      const oldestEvent = oldestEventResult.oldest ? new Date(oldestEventResult.oldest) : null;
+      const providerResults = this.db.prepare(`
+          SELECT DISTINCT provider
+          FROM routing_outcomes
+          WHERE id = (
+            SELECT MAX(latest.id)
+            FROM routing_outcomes latest
+            WHERE latest.routing_id = routing_outcomes.routing_id
+          )
+        `).all();
+      const providers = providerResults.map((r) => r.provider);
+      return {
+        totalEvents,
+        oldestEvent,
+        providers
+      };
+    } catch (error) {
+      console.warn("[RoutingHistoryStore] Failed to get stats:", error);
+      return {
+        totalEvents: 0,
+        oldestEvent: null,
+        providers: []
+      };
+    }
+  }
+  /**
+   * Close database connection
+   */
+  close() {
+    if (this.db) {
+      try {
+        this.db.close();
+      } catch (error) {
+        console.warn("[RoutingHistoryStore] Failed to close database:", error);
+      }
+      this.db = null;
+    }
+  }
+};
+var SqliteRoutingTelemetryCollector = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async emitEvent(event) {
+    this.store.persistEvent(event);
+  }
+  /**
+   * @internal Not yet implemented. Returns zeroed defaults rather than querying
+   * the SQLite store; no public CLI surface should present its result as real
+   * routing statistics.
+   */
+  async getRoutingStats(_startTime, _endTime) {
+    return {
+      totalRoutings: 0,
+      averageAnalysisTime: 0,
+      averageRoutingTime: 0,
+      providerUsageCounts: buildZeroedProviderMap(),
+      successRate: null,
+      cacheHitRate: null
+    };
+  }
+  /**
+   * @internal Not yet implemented. Returns zeroed per-provider defaults rather
+   * than querying the SQLite store; no public CLI surface should present its
+   * result as real provider-performance analytics.
+   */
+  async getProviderPerformance(_startTime, _endTime) {
+    const emptyMetrics = {
+      assignments: 0,
+      averageConfidence: 0,
+      successRate: null,
+      averageRoutingTime: 0,
+      domainDistribution: {}
+    };
+    const result = {};
+    for (const providerId of resolveRegistryProviderIds()) {
+      result[providerId] = { ...emptyMetrics };
+    }
+    return result;
+  }
+};
+function resolveRegistryProviderIds() {
+  try {
+    return ProviderRegistry.getAllProviderIds();
+  } catch {
+    return [];
+  }
+}
+function buildZeroedProviderMap() {
+  const map = {};
+  for (const providerId of resolveRegistryProviderIds()) {
+    map[providerId] = 0;
+  }
+  return map;
+}
+var globalRoutingHistoryStores = /* @__PURE__ */ new Map();
+function getGlobalRoutingHistoryStore() {
+  const configuredPath = readEnv(POETIC_ROUTING_HISTORY_DB).value;
+  const dbPath = configuredPath ? configuredPath : (() => {
+    const poeticDir = getRuntimeEnv(POETIC_TELEMETRY_DIR.name) ?? join(resolvePoeticRoot(process.cwd()), ".poetic");
+    const resolver = TelemetryPathResolver.getInstance();
+    return join(resolver.resolveDbDir(poeticDir), "routing-history.db");
+  })();
+  const existing = globalRoutingHistoryStores.get(dbPath);
+  if (existing) {
+    return existing;
+  }
+  const store = new RoutingHistoryStore(dbPath);
+  globalRoutingHistoryStores.set(dbPath, store);
+  return store;
+}
+var ROUTING_SAMPLE_FLOOR = 2;
+var ROUTING_FULL_CONFIDENCE_SAMPLES = 20;
+function computeHistoricalAdjustment(providerId, domain, store, windowDays = 30, model) {
+  if (model) {
+    return computeHistoricalAdjustmentWithModelFallback(
+      providerId,
+      domain,
+      store,
+      windowDays,
+      model
+    );
+  }
+  return computeAdjustmentFromSamples(providerId, domain, store, windowDays, void 0);
+}
+function computeAdjustmentFromSamples(providerId, domain, store, windowDays, model) {
+  const sampleSize = store.getSampleSize(providerId, domain, windowDays, model);
+  const qualitySampleSize = store.getQualitySampleSize(providerId, domain, windowDays, model);
+  if (sampleSize < ROUTING_SAMPLE_FLOOR) {
+    return {
+      adjustment: 0,
+      confidence: 0,
+      sampleSize,
+      reason: "insufficient data"
+    };
+  }
+  const successRate = store.getProviderSuccessRate(providerId, domain, windowDays, model);
+  const qualityScore = store.getProviderAverageScore(providerId, domain, windowDays, model);
+  const hasQualitySamples = qualityScore != null && qualitySampleSize > 0;
+  const successConfidence = Math.min(1, sampleSize / ROUTING_FULL_CONFIDENCE_SAMPLES);
+  const qualityConfidence = hasQualitySamples ? Math.min(1, qualitySampleSize / ROUTING_FULL_CONFIDENCE_SAMPLES) : 0;
+  const confidence = hasQualitySamples ? successConfidence * 0.7 + qualityConfidence * 0.3 : successConfidence;
+  const successAdjustment = (successRate - 0.5) * 30;
+  const qualityAdjustment = hasQualitySamples ? (qualityScore - 50) / 50 * 15 : 0;
+  const scaledAdjustment = hasQualitySamples ? successAdjustment * 0.7 * successConfidence + qualityAdjustment * 0.3 * qualityConfidence : successAdjustment * successConfidence;
+  const adjustment = Math.max(-15, Math.min(15, scaledAdjustment));
+  const reasons = [];
+  if (successRate < 0.4) {
+    reasons.push("low success rate");
+  } else if (successRate > 0.6) {
+    reasons.push("high success rate");
+  }
+  if (hasQualitySamples) {
+    if (qualityScore < 40) {
+      reasons.push("low quality");
+    } else if (qualityScore > 60) {
+      reasons.push("high quality");
+    }
+  }
+  if (sampleSize < ROUTING_FULL_CONFIDENCE_SAMPLES) {
+    reasons.push("limited samples");
+  }
+  const reason = reasons.length > 0 ? reasons.join(", ") : hasQualitySamples ? `success=${(successRate * 100).toFixed(0)}%, quality=${qualityScore.toFixed(0)}` : `success=${(successRate * 100).toFixed(0)}% (no quality samples)`;
+  return { adjustment, confidence, sampleSize, reason };
+}
+function computeHistoricalAdjustmentWithModelFallback(providerId, domain, store, windowDays, model) {
+  const modelCount = store.getSampleSize(providerId, domain, windowDays, model);
+  const providerCount = store.getSampleSize(providerId, domain, windowDays, void 0);
+  const modelAboveFloor = modelCount >= ROUTING_SAMPLE_FLOOR;
+  const providerAboveFloor = providerCount >= ROUTING_SAMPLE_FLOOR;
+  if (!modelAboveFloor && !providerAboveFloor) {
+    return {
+      adjustment: 0,
+      confidence: 0,
+      sampleSize: modelCount,
+      reason: "insufficient data"
+    };
+  }
+  if (modelAboveFloor && !providerAboveFloor) {
+    return computeAdjustmentFromSamples(providerId, domain, store, windowDays, model);
+  }
+  if (!modelAboveFloor && providerAboveFloor) {
+    const base = computeAdjustmentFromSamples(providerId, domain, store, windowDays, void 0);
+    return {
+      ...base,
+      sampleSize: modelCount,
+      reason: `${base.reason} (provider fallback, n=${providerCount})`
+    };
+  }
+  const modelResult = computeAdjustmentFromSamples(providerId, domain, store, windowDays, model);
+  const providerResult = computeAdjustmentFromSamples(
+    providerId,
+    domain,
+    store,
+    windowDays,
+    void 0
+  );
+  const modelWeight = Math.min(0.8, modelCount / providerCount);
+  const providerWeight = 1 - modelWeight;
+  const blendedAdjustment = Math.max(
+    -15,
+    Math.min(15, modelResult.adjustment * modelWeight + providerResult.adjustment * providerWeight)
+  );
+  const blendedConfidence = Math.min(
+    1,
+    modelResult.confidence * modelWeight + providerResult.confidence * providerWeight
+  );
+  return {
+    adjustment: blendedAdjustment,
+    confidence: blendedConfidence,
+    sampleSize: modelCount,
+    reason: `${modelResult.reason} (model+provider blend, mw=${modelWeight.toFixed(2)})`
+  };
+}
+
+export {
+  resolveOutcomeQuality,
+  RoutingHistoryStore,
+  SqliteRoutingTelemetryCollector,
+  getGlobalRoutingHistoryStore,
+  ROUTING_SAMPLE_FLOOR,
+  ROUTING_FULL_CONFIDENCE_SAMPLES,
+  computeHistoricalAdjustment
+};
+//# sourceMappingURL=chunk-RGROYC2G.js.map

package/dist/chunk-RGWHUI5E.js

@@ -0,0 +1,68 @@
+import {
+  getProjectDataDir,
+  getStableRepoIdentity
+} from "./chunk-UUH2RVKS.js";
+
+// src/core/config/project-runtime-paths.ts
+import fs from "fs";
+import path from "path";
+function repoRootFromPoeticDir(poeticDir) {
+  const resolved = path.resolve(poeticDir);
+  return path.basename(resolved) === ".poetic" ? path.dirname(resolved) : resolved;
+}
+function getRepoDataMigrationMarkerPath(poeticDir) {
+  return path.join(repoRootFromPoeticDir(poeticDir), ".poetic", "state", "data-migration.json");
+}
+function getSharedDataMigrationMarkerPath(poeticDir) {
+  const repoRoot = repoRootFromPoeticDir(poeticDir);
+  return path.join(getProjectDataDir(repoRoot), "state", "data-migration.json");
+}
+function readMarker(markerPath) {
+  try {
+    const parsed = JSON.parse(
+      fs.readFileSync(markerPath, "utf8")
+    );
+    if (parsed.version === 1 && typeof parsed.migratedAt === "string" && typeof parsed.repoRoot === "string" && typeof parsed.projectId === "string" && typeof parsed.globalTelemetryDir === "string" && typeof parsed.projectDataDir === "string") {
+      return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+function isSameDirectory(left, right) {
+  const resolvedLeft = path.resolve(left);
+  const resolvedRight = path.resolve(right);
+  if (resolvedLeft === resolvedRight) return true;
+  try {
+    return fs.realpathSync(resolvedLeft) === fs.realpathSync(resolvedRight);
+  } catch {
+    return false;
+  }
+}
+function readProjectDataMigrationMarker(poeticDir) {
+  const repoRoot = repoRootFromPoeticDir(poeticDir);
+  const expectedProjectId = getStableRepoIdentity(repoRoot);
+  const expectedProjectDataDir = path.resolve(getProjectDataDir(repoRoot));
+  const shared = readMarker(getSharedDataMigrationMarkerPath(poeticDir));
+  if (shared?.projectId === expectedProjectId && isSameDirectory(shared.projectDataDir, expectedProjectDataDir)) {
+    return shared;
+  }
+  const local = readMarker(getRepoDataMigrationMarkerPath(poeticDir));
+  if (local?.projectId === expectedProjectId && isSameDirectory(local.projectDataDir, expectedProjectDataDir)) {
+    return local;
+  }
+  return null;
+}
+function resolveProjectRuntimeDir(poeticDir, category) {
+  const marker = readProjectDataMigrationMarker(poeticDir);
+  if (marker) return path.join(marker.projectDataDir, category);
+  return path.join(repoRootFromPoeticDir(poeticDir), ".poetic", category);
+}
+
+export {
+  getRepoDataMigrationMarkerPath,
+  getSharedDataMigrationMarkerPath,
+  readProjectDataMigrationMarker,
+  resolveProjectRuntimeDir
+};
+//# sourceMappingURL=chunk-RGWHUI5E.js.map