@poetic-ai/poetic 1.42.0

package/dist/chunk-2BZ53J6J.js

@@ -0,0 +1,2344 @@
+import {
+  findLabRun,
+  findLatestLabRun
+} from "./chunk-ROMHOSMQ.js";
+import {
+  renderJsonError,
+  renderJsonResult
+} from "./chunk-Q3RO7N35.js";
+import {
+  UNIFIED_COST_METRIC_SOURCE_SAMPLES
+} from "./chunk-NJVD4PWE.js";
+import {
+  ensurePendingInvocationCostEnrichment,
+  formatCostProjectionNotice,
+  fromVisibilitySummary,
+  projectCostVisibility,
+  summarizeInvocationCostVisibility
+} from "./chunk-GKN3HMN4.js";
+import {
+  parseDuration
+} from "./chunk-TSXGRLPR.js";
+import {
+  ValidationError
+} from "./chunk-LUVKFFWR.js";
+import {
+  BooleanFlagSchema,
+  FilePathSchema,
+  ModelNameSchema,
+  PositiveIntegerSchema,
+  createSafeErrorMessage,
+  formatValidationErrors,
+  validateCommandOptions
+} from "./chunk-QOCOVLUH.js";
+import {
+  checkAndWarnLabContext
+} from "./chunk-7GDRQBQC.js";
+import {
+  emitWarning
+} from "./chunk-EJGCZGUF.js";
+
+// src/cli/commands/cost.ts
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { Command, InvalidArgumentError } from "commander";
+import { z } from "zod";
+
+// src/cost-tracking/pricing-verifier.ts
+function isExpectedFreeZeroCostModel(model) {
+  if (!model) return false;
+  return /:free(?:$|[:/])/i.test(model) || model.toLowerCase().endsWith(":free");
+}
+function isExpectedFreeZeroCostWarning(warning) {
+  if (warning.type !== "zero_cost") return false;
+  if (warning.details?.expectedFreeCatalog === true) return true;
+  return isExpectedFreeZeroCostModel(warning.model);
+}
+var PricingVerifier = class {
+  calculator;
+  logger;
+  config;
+  costHistory = /* @__PURE__ */ new Map();
+  constructor(calculator, logger, config) {
+    this.calculator = calculator;
+    this.logger = logger;
+    this.config = {
+      maxAgeDays: 30,
+      enableFreshnessChecks: true,
+      enableAnomalyDetection: true,
+      anomalyThresholdPercent: 50,
+      ...config
+    };
+  }
+  /**
+   * Verify pricing configuration for a specific provider
+   */
+  async verifyProvider(provider) {
+    const warnings = [];
+    const errors = [];
+    try {
+      this.calculator.ensurePricingLoadedSync();
+      const models = this.calculator.getAvailableModels(provider);
+      if (models.length === 0) {
+        const availability = this.getProviderPricingAvailability(provider);
+        if (isAdvisoryMissingPricing(availability)) {
+          warnings.push({
+            type: "pricing_unavailable",
+            severity: "medium",
+            message: `Provider "${provider}" has a model catalog but no per-token pricing because billing is ${availability.billingMode}`,
+            provider,
+            details: { availability }
+          });
+          return {
+            valid: true,
+            warnings,
+            errors,
+            metadata: {
+              version: "unknown",
+              providersChecked: [provider],
+              modelsChecked: 0
+            }
+          };
+        }
+        errors.push({
+          type: "missing_pricing",
+          message: `No models found for provider "${provider}"`,
+          provider
+        });
+        return {
+          valid: false,
+          warnings,
+          errors,
+          metadata: {
+            version: "unknown",
+            providersChecked: [provider],
+            modelsChecked: 0
+          }
+        };
+      }
+      for (const model of models) {
+        const modelWarnings = this.verifyModelPricing(provider, model);
+        warnings.push(...modelWarnings);
+      }
+      if (this.config.enableFreshnessChecks) {
+        const freshnessWarnings = this.checkPricingFreshness(provider);
+        warnings.push(...freshnessWarnings);
+      }
+      const freshness = resolveProviderFreshness(
+        this.calculator.getDynamicPricingManifest?.() ?? null,
+        provider
+      );
+      const ageDays = freshness.lastUpdated !== void 0 ? (Date.now() - new Date(freshness.lastUpdated).getTime()) / (1e3 * 60 * 60 * 24) : void 0;
+      const metadata = {
+        version: "unknown",
+        // TODO: Extract from calculator
+        providersChecked: [provider],
+        modelsChecked: models.length
+      };
+      if (freshness.lastUpdated !== void 0) {
+        metadata.lastUpdated = new Date(freshness.lastUpdated).toISOString();
+      }
+      if (ageDays !== void 0 && Number.isFinite(ageDays)) {
+        metadata.ageDays = Math.round(ageDays);
+      }
+      this.logger.logCostEvent("pricing_verification_complete", {
+        provider,
+        modelsChecked: models.length,
+        warningsCount: warnings.length,
+        errorsCount: errors.length
+      });
+      return {
+        valid: errors.length === 0,
+        warnings,
+        errors,
+        metadata
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push({
+        type: "invalid_pricing",
+        message: `Pricing verification failed: ${message}`,
+        provider
+      });
+      return {
+        valid: false,
+        warnings,
+        errors,
+        metadata: {
+          version: "unknown",
+          providersChecked: [provider],
+          modelsChecked: 0
+        }
+      };
+    }
+  }
+  /**
+   * Verify pricing for a specific model
+   */
+  verifyModelPricing(provider, model) {
+    const warnings = [];
+    try {
+      const pricing = this.getModelPricingSafe(provider, model);
+      if (!pricing) {
+        warnings.push({
+          type: "missing_model",
+          severity: "high",
+          message: `No pricing found for model "${model}"`,
+          provider,
+          model
+        });
+        return warnings;
+      }
+      if (pricing.inputTokens === 0 && pricing.outputTokens === 0 && pricing.billingMode === "metered" && !isIncludedPlanPricing(pricing)) {
+        const expectedFreeCatalog = isExpectedFreeZeroCostModel(model);
+        warnings.push({
+          type: "zero_cost",
+          severity: expectedFreeCatalog ? "low" : "high",
+          message: expectedFreeCatalog ? `Model "${model}" is a :free catalog entry with $0+$0 token prices` : `Model "${model}" has zero cost for input and output tokens`,
+          provider,
+          model,
+          details: { pricing, expectedFreeCatalog }
+        });
+      }
+      const typicalMaxInputCost = 100;
+      const typicalMaxOutputCost = 500;
+      if (pricing.inputTokens > typicalMaxInputCost || pricing.outputTokens > typicalMaxOutputCost) {
+        warnings.push({
+          type: "high_cost_variance",
+          severity: "medium",
+          message: `Model "${model}" has unusually high token costs`,
+          provider,
+          model,
+          details: {
+            inputTokens: pricing.inputTokens,
+            outputTokens: pricing.outputTokens,
+            thresholds: { typicalMaxInputCost, typicalMaxOutputCost }
+          }
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      warnings.push({
+        type: "missing_model",
+        severity: "high",
+        message: `Failed to verify pricing for "${model}": ${message}`,
+        provider,
+        model
+      });
+    }
+    return warnings;
+  }
+  /**
+   * Check if pricing data is fresh (not stale)
+   */
+  checkPricingFreshness(provider) {
+    const warnings = [];
+    const manifest = this.calculator.getDynamicPricingManifest?.();
+    if (!manifest) {
+      return warnings;
+    }
+    const providerFreshness = resolveProviderFreshness(manifest, provider);
+    const timestamp = providerFreshness.lastSuccessfulFetch ?? providerFreshness.lastUpdated;
+    if (!timestamp) {
+      return warnings;
+    }
+    const updatedDate = new Date(timestamp);
+    if (Number.isNaN(updatedDate.getTime())) {
+      return warnings;
+    }
+    const ageDays = (Date.now() - updatedDate.getTime()) / (1e3 * 60 * 60 * 24);
+    if (providerFreshness.stale || ageDays > this.config.maxAgeDays) {
+      warnings.push({
+        type: "stale_data",
+        severity: providerFreshness.stale ? "high" : "medium",
+        message: providerFreshness.stale ? `Pricing data for "${provider}" is using stale fallback data from ${Math.round(ageDays)} days ago` : `Pricing data for "${provider}" is ${Math.round(ageDays)} days old`,
+        provider,
+        details: {
+          ageDays: Math.round(ageDays),
+          maxAgeDays: this.config.maxAgeDays,
+          stale: providerFreshness.stale,
+          failureReason: providerFreshness.failureReason
+        }
+      });
+    }
+    return warnings;
+  }
+  /**
+   * Detect cost calculation anomalies
+   */
+  detectAnomaly(provider, model, actualCost) {
+    if (!this.config.enableAnomalyDetection) {
+      return null;
+    }
+    const historyKey = `${provider}:${model}`;
+    const history = this.costHistory.get(historyKey) || [];
+    if (history.length < 5) {
+      history.push(actualCost);
+      this.costHistory.set(historyKey, history);
+      return null;
+    }
+    const mean = history.reduce((sum, cost) => sum + cost, 0) / history.length;
+    if (mean === 0) {
+      history.push(actualCost);
+      this.costHistory.set(historyKey, history);
+      return null;
+    }
+    const threshold = mean * (this.config.anomalyThresholdPercent / 100);
+    const expectedRange = {
+      min: mean - threshold,
+      max: mean + threshold
+    };
+    if (actualCost < expectedRange.min || actualCost > expectedRange.max) {
+      const deviationPercent = Math.abs(actualCost - mean) / mean * 100;
+      const alert = {
+        provider,
+        model,
+        expectedCostRange: expectedRange,
+        actualCost,
+        deviationPercent,
+        severity: deviationPercent > this.config.anomalyThresholdPercent * 2 ? "critical" : "warning",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.logger.logCostEvent("cost_anomaly_detected", {
+        provider,
+        model,
+        actualCost,
+        expectedMin: expectedRange.min,
+        expectedMax: expectedRange.max,
+        deviationPercent,
+        severity: alert.severity
+      });
+      return alert;
+    }
+    history.push(actualCost);
+    if (history.length > 20) {
+      history.shift();
+    }
+    this.costHistory.set(historyKey, history);
+    return null;
+  }
+  /**
+   * Safe method to get model pricing without throwing
+   */
+  getModelPricingSafe(provider, model) {
+    try {
+      const calculator = this.calculator;
+      if (typeof calculator.getModelPricingWithFallback === "function") {
+        return calculator.getModelPricingWithFallback(provider, model);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  getProviderPricingAvailability(provider) {
+    const calculator = this.calculator;
+    if (typeof calculator.getProviderPricingAvailability !== "function") {
+      return null;
+    }
+    try {
+      return calculator.getProviderPricingAvailability(
+        provider
+      );
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Reset cost history (useful for testing or manual reset)
+   */
+  resetHistory() {
+    this.costHistory.clear();
+    this.logger.logCostEvent("pricing_verifier_history_reset", {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+function isIncludedPlanPricing(pricing) {
+  const explicitIncluded = pricing.billingSource === "included_plan" || pricing.pricingSource === "subscription_included";
+  if (explicitIncluded) {
+    return true;
+  }
+  const hasExplicitProvenance = pricing.billingSource !== void 0 || pricing.pricingSource !== void 0 && pricing.pricingSource !== "yaml" && pricing.pricingSource !== "dynamic";
+  if (hasExplicitProvenance) {
+    return false;
+  }
+  return hasIncludedPlanNote(pricing.pricingNotes);
+}
+function isAdvisoryMissingPricing(availability) {
+  if (!availability?.hasModelCatalog || availability.hasTokenPricing) {
+    return false;
+  }
+  return availability.billingMode === "flat_rate" || availability.billingMode === "non_metered";
+}
+function hasIncludedPlanNote(note) {
+  if (!note) {
+    return false;
+  }
+  const normalized = note.toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ").trim();
+  return /\bincluded\s+(with|in|under)\b.{0,80}\b(plan|subscription|license|seat)\b/.test(normalized) || /\bincluded\s+as\s+part\s+of\b.{0,80}\b(plan|subscription|license|seat)\b/.test(normalized) || /\b(plan|subscription)\s+included\b/.test(normalized);
+}
+function resolveProviderFreshness(manifest, provider) {
+  if (!manifest) {
+    return { stale: false };
+  }
+  const providerLower = provider.toLowerCase();
+  const providerEntry = manifest.providers.find(
+    (entry) => entry.providerId === provider || entry.providerId.toLowerCase() === providerLower
+  );
+  if (!providerEntry) {
+    return {
+      lastUpdated: manifest.generatedAt,
+      stale: false
+    };
+  }
+  return {
+    lastUpdated: providerEntry.lastUpdated,
+    lastSuccessfulFetch: providerEntry.lastSuccessfulFetch,
+    stale: providerEntry.stale,
+    failureReason: providerEntry.failureReason
+  };
+}
+
+// src/cli/formatters/currency.ts
+var formatterCache = /* @__PURE__ */ new Map();
+function getFormatter(currency) {
+  const normalized = currency.toUpperCase();
+  let formatter = formatterCache.get(normalized);
+  if (!formatter) {
+    try {
+      formatter = new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: normalized,
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+      });
+    } catch {
+      formatter = new Intl.NumberFormat("en-US", {
+        minimumFractionDigits: 2,
+        maximumFractionDigits: 2
+      });
+    }
+    formatterCache.set(normalized, formatter);
+  }
+  return formatter;
+}
+var subcentFormatterCache = /* @__PURE__ */ new Map();
+function getSubcentFormatter(currency) {
+  const normalized = currency.toUpperCase();
+  let formatter = subcentFormatterCache.get(normalized);
+  if (!formatter) {
+    try {
+      formatter = new Intl.NumberFormat("en-US", {
+        style: "currency",
+        currency: normalized,
+        minimumFractionDigits: 4,
+        maximumFractionDigits: 4
+      });
+    } catch {
+      formatter = new Intl.NumberFormat("en-US", {
+        minimumFractionDigits: 4,
+        maximumFractionDigits: 4
+      });
+    }
+    subcentFormatterCache.set(normalized, formatter);
+  }
+  return formatter;
+}
+function formatCurrency(amount, currency = "USD") {
+  const formatter = getFormatter(currency);
+  return formatter.format(amount);
+}
+function formatCostDisplay(amount, currency = "USD") {
+  if (amount !== 0 && Math.abs(amount) < 0.01) {
+    return getSubcentFormatter(currency).format(amount);
+  }
+  return getFormatter(currency).format(amount);
+}
+function formatCurrencyDelta(amount, currency = "USD") {
+  const formatted = formatCurrency(Math.abs(amount), currency);
+  if (amount > 0) {
+    return `+${formatted}`;
+  }
+  if (amount < 0) {
+    return `-${formatted}`;
+  }
+  return formatted;
+}
+
+// src/cli/formatters/tokens.ts
+var numberFormatter = new Intl.NumberFormat("en-US");
+function formatTokenCount(tokens) {
+  return `${numberFormatter.format(tokens)} tokens`;
+}
+
+// src/cli/commands/cost.ts
+function writeCostOutput(value) {
+  console.log(value);
+}
+function logCostEmptyStateHint(modelInvocationsDb, startTimestampMs, attempt) {
+  const projection = projectCostVisibility(modelInvocationsDb, startTimestampMs, attempt);
+  const notice = formatCostProjectionNotice(projection);
+  if (notice) {
+    writeCostOutput(chalk.gray(notice));
+  }
+}
+function formatDailyAggregationCost(value) {
+  return value === null ? "incomplete" : formatCostDisplay(value);
+}
+function sumCompleteDailyCosts(rows) {
+  let total = 0;
+  for (const row of rows) {
+    if (row.totalCost === null) {
+      return null;
+    }
+    total += row.totalCost;
+  }
+  return total;
+}
+var ToolUsageSchema = z.object({
+  name: z.string().min(1, "Tool name cannot be empty").max(100, "Tool name too long").regex(/^[a-zA-Z0-9._-]+$/, "Invalid tool name format"),
+  estimatedRequests: PositiveIntegerSchema
+});
+var StatusOptionsSchema = z.object({
+  json: BooleanFlagSchema.optional(),
+  swarm: BooleanFlagSchema.optional(),
+  days: z.string().regex(/^\d+$/, "Days must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  outputFile: FilePathSchema.optional(),
+  since: z.string().regex(/^\d+[mhdw]$/, "--since must match pattern like 7d or 24h").optional(),
+  lab: z.union([z.string(), z.boolean()]).optional(),
+  labId: z.string().optional(),
+  runId: z.string().optional(),
+  verbose: BooleanFlagSchema.optional()
+}).strict().superRefine((data, ctx) => {
+  if (data.lab && (data.labId || data.runId)) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "--lab cannot be combined with --lab-id/--run-id"
+    });
+  }
+  if (data.labId && !data.runId) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "--lab-id requires --run-id" });
+  }
+  if (data.runId && !data.labId) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, message: "--run-id requires --lab-id" });
+  }
+});
+var PredictOptionsSchema = z.object({
+  input: PositiveIntegerSchema,
+  output: PositiveIntegerSchema,
+  tool: z.array(ToolUsageSchema).optional(),
+  json: BooleanFlagSchema.optional()
+}).strict();
+var CompareOptionsSchema = z.object({
+  input: PositiveIntegerSchema,
+  output: PositiveIntegerSchema,
+  json: BooleanFlagSchema.optional()
+}).strict();
+var DailyOptionsSchema = z.object({
+  days: z.string().regex(/^\d+$/, "Days must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Start date must be in YYYY-MM-DD format").optional(),
+  end: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "End date must be in YYYY-MM-DD format").optional(),
+  group: z.enum(["date", "provider", "model"]).optional().default("date"),
+  json: BooleanFlagSchema.optional()
+}).strict().refine((data) => {
+  if (data.start && data.end) {
+    const start = new Date(data.start);
+    const end = new Date(data.end);
+    return start <= end;
+  }
+  return true;
+}, "Start date cannot be after end date");
+var ForecastOptionsSchema = z.object({
+  days: z.string().regex(/^\d+$/, "Days must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  horizon: z.string().regex(/^\d+$/, "Horizon must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  json: BooleanFlagSchema.optional()
+}).strict();
+var HistoryOptionsSchema = z.object({
+  task: z.string().min(1).max(100).optional(),
+  competition: z.string().min(1).max(100).optional(),
+  recalculate: z.union([
+    z.enum(["current", "snapshot"]),
+    z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in YYYY-MM-DD format")
+  ]).optional(),
+  days: z.string().regex(/^\d+$/, "Days must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  json: BooleanFlagSchema.optional()
+}).strict();
+var TasksOptionsSchema = z.object({
+  days: z.string().regex(/^\d+$/, "Days must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  top: z.string().regex(/^\d+$/, "Top must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(10),
+  json: BooleanFlagSchema.optional()
+}).strict();
+var TokensOptionsSchema = z.object({
+  days: z.string().regex(/^\d+$/, "Days must be a positive integer").transform(Number).pipe(PositiveIntegerSchema).optional().default(7),
+  provider: z.string().min(1).max(100).optional(),
+  model: ModelNameSchema.optional(),
+  json: BooleanFlagSchema.optional()
+}).strict();
+var ComparePricingOptionsSchema = z.object({
+  json: BooleanFlagSchema.optional()
+}).strict();
+function mergePersistedCostMetrics(metrics, recentExecutions, now = Date.now()) {
+  if (recentExecutions.length === 0) {
+    return metrics;
+  }
+  const sourceSamples = metrics[UNIFIED_COST_METRIC_SOURCE_SAMPLES] ?? [];
+  const remainingSourceSamples = sourceSamples.map((sample) => ({
+    ...sample,
+    // Use sub-cent precision (6 dp) to match the stored CostSnapshot.totalCostCents,
+    // which is REAL since i29 fix (12a0435bb). Whole-cent rounding here caused
+    // sub-cent invocations (< 0.5 cent) to produce totalCostCents=0 in the
+    // deduplication key, mismatching the persisted record and double-counting them.
+    totalCostCents: Math.round(sample.totalCost * 100 * 1e6) / 1e6
+  }));
+  const nonOverlappingExecutions = recentExecutions.filter((execution) => {
+    const executionCostCents = execution.costSnapshot.totalCostCents;
+    const exactExecutionIdIndex = remainingSourceSamples.findIndex(
+      (sample) => sample.executionId && sample.executionId === execution.executionId
+    );
+    if (exactExecutionIdIndex >= 0) {
+      remainingSourceSamples.splice(exactExecutionIdIndex, 1);
+      return false;
+    }
+    const matchingSampleIndex = remainingSourceSamples.findIndex(
+      (sample) => sample.provider === execution.provider && sample.model === execution.model && sample.totalCostCents === executionCostCents && Math.abs(sample.timestamp - execution.timestamp.getTime()) <= 2e3
+    );
+    if (matchingSampleIndex >= 0) {
+      remainingSourceSamples.splice(matchingSampleIndex, 1);
+      return false;
+    }
+    return true;
+  });
+  if (nonOverlappingExecutions.length === 0) {
+    return metrics;
+  }
+  const dayWindow = now - 24 * 60 * 60 * 1e3;
+  const monthWindow = now - 30 * 24 * 60 * 60 * 1e3;
+  const persistedDailyCost = nonOverlappingExecutions.filter((execution) => execution.timestamp.getTime() >= dayWindow).reduce((sum, execution) => sum + execution.costSnapshot.totalCostCents / 100, 0);
+  const persistedMonthlyCost = nonOverlappingExecutions.filter((execution) => execution.timestamp.getTime() >= monthWindow).reduce((sum, execution) => sum + execution.costSnapshot.totalCostCents / 100, 0);
+  const persistedWindowCost = nonOverlappingExecutions.reduce(
+    (sum, execution) => sum + execution.costSnapshot.totalCostCents / 100,
+    0
+  );
+  const byProviderModel = /* @__PURE__ */ new Map();
+  for (const execution of nonOverlappingExecutions) {
+    const key = `${execution.provider}::${execution.model}`;
+    const current = byProviderModel.get(key);
+    const cost = execution.costSnapshot.totalCostCents / 100;
+    if (current) {
+      current.cost += cost;
+    } else {
+      byProviderModel.set(key, {
+        provider: execution.provider,
+        model: execution.model,
+        cost
+      });
+    }
+  }
+  const top = [...byProviderModel.values()].sort((a, b) => b.cost - a.cost)[0];
+  const dailyCost = metrics.dailyCost + persistedDailyCost;
+  const monthlyCost = metrics.monthlyCost + persistedMonthlyCost;
+  const sessionCost = metrics.sessionCost + persistedWindowCost;
+  return {
+    ...metrics,
+    sessionCost,
+    dailyCost,
+    monthlyCost,
+    topCostProvider: top ? {
+      provider: top.provider,
+      model: top.model,
+      cost: top.cost,
+      percentage: sessionCost > 0 ? top.cost / sessionCost * 100 : 0
+    } : metrics.topCostProvider,
+    costTrend: metrics.costTrend.length > 0 ? metrics.costTrend : nonOverlappingExecutions.slice(-10).map((execution) => execution.costSnapshot.totalCostCents / 100)
+  };
+}
+async function verifyPricingForStatus(costCalculator, telemetry) {
+  const calculatorWithProviders = costCalculator;
+  if (typeof calculatorWithProviders.getAvailableProviders !== "function") {
+    return { valid: true, providersChecked: [], warnings: [], errors: [] };
+  }
+  try {
+    const providers = calculatorWithProviders.getAvailableProviders();
+    const verifier = new PricingVerifier(costCalculator, telemetry);
+    const results = await Promise.all(
+      providers.map((provider) => verifier.verifyProvider(provider))
+    );
+    return {
+      valid: results.every((result) => result.valid),
+      providersChecked: providers,
+      warnings: results.flatMap((result) => result.warnings),
+      errors: results.flatMap((result) => result.errors)
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      providersChecked: [],
+      warnings: [],
+      errors: [
+        {
+          type: "calculation_error",
+          message: error instanceof Error ? error.message : String(error),
+          provider: "all"
+        }
+      ]
+    };
+  }
+}
+function resolveCostLabRun(options) {
+  if (options.lab) {
+    const selector = typeof options.lab === "string" ? options.lab.trim().toLowerCase() : options.lab === true ? "latest" : null;
+    if (!selector || selector === "latest") {
+      const latest = findLatestLabRun();
+      if (!latest) {
+        throw new Error(
+          "No lab runs found. Start a lab run with `poetic compete --lab` before querying cost status."
+        );
+      }
+      return latest;
+    }
+    throw new Error("Unsupported --lab value. Supported value: latest.");
+  }
+  if (options.labId && options.runId) {
+    const run = findLabRun(options.labId, options.runId);
+    if (!run) {
+      throw new Error(`Lab run not found: ${options.labId}/${options.runId}`);
+    }
+    return run;
+  }
+  return null;
+}
+function listJsonlFiles(dir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const filePath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonlFiles(filePath));
+    } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+function readLabCostSummary(run, startTimeMs) {
+  const executions = [];
+  for (const filePath of listJsonlFiles(path.join(run.runPath, "logs"))) {
+    let contents;
+    try {
+      contents = fs.readFileSync(filePath, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of contents.split(/\n/)) {
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (record.event !== "model_invocation") continue;
+      const timestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : typeof record.timestamp === "number" ? record.timestamp : Number.NaN;
+      if (!Number.isFinite(timestamp) || timestamp < startTimeMs) continue;
+      const totalCost = typeof record.totalCost === "number" ? record.totalCost : 0;
+      if (!Number.isFinite(totalCost)) continue;
+      executions.push({
+        timestamp: new Date(timestamp),
+        provider: typeof record.provider === "string" ? record.provider : "unknown",
+        model: typeof record.model === "string" ? record.model : "unknown",
+        totalCost
+      });
+    }
+  }
+  return { run, executions };
+}
+function mergeLabCostMetrics(metrics, summary, now = Date.now()) {
+  const dayWindow = now - 24 * 60 * 60 * 1e3;
+  const monthWindow = now - 30 * 24 * 60 * 60 * 1e3;
+  const sessionCost = summary.executions.reduce((sum, execution) => sum + execution.totalCost, 0);
+  const dailyCost = summary.executions.filter((execution) => execution.timestamp.getTime() >= dayWindow).reduce((sum, execution) => sum + execution.totalCost, 0);
+  const monthlyCost = summary.executions.filter((execution) => execution.timestamp.getTime() >= monthWindow).reduce((sum, execution) => sum + execution.totalCost, 0);
+  const byProviderModel = /* @__PURE__ */ new Map();
+  for (const execution of summary.executions) {
+    const key = `${execution.provider}::${execution.model}`;
+    const current = byProviderModel.get(key);
+    if (current) {
+      current.cost += execution.totalCost;
+    } else {
+      byProviderModel.set(key, {
+        provider: execution.provider,
+        model: execution.model,
+        cost: execution.totalCost
+      });
+    }
+  }
+  const top = [...byProviderModel.values()].sort((a, b) => b.cost - a.cost)[0];
+  return {
+    ...metrics,
+    sessionCost,
+    dailyCost,
+    monthlyCost,
+    topCostProvider: top ? {
+      provider: top.provider,
+      model: top.model,
+      cost: top.cost,
+      percentage: sessionCost > 0 ? top.cost / sessionCost * 100 : 0
+    } : {
+      provider: "none",
+      model: "none",
+      cost: 0,
+      percentage: 0
+    },
+    costTrend: summary.executions.slice(-10).map((execution) => execution.totalCost)
+  };
+}
+function parseNonNegativeInteger(value) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new InvalidArgumentError("Value must be a non-negative integer");
+  }
+  return parsed;
+}
+function collectRawToolUsage(value, previous = []) {
+  return [...previous, value];
+}
+function parseWholeNonNegativeInteger(value, message) {
+  if (!/^\d+$/.test(value)) {
+    throw new InvalidArgumentError(message);
+  }
+  return Number(value);
+}
+function parsePredictTokenOption(value) {
+  return parseWholeNonNegativeInteger(value, "Value must be a non-negative integer");
+}
+function parsePredictToolUsageEntry(value) {
+  const [name, requests] = value.split(":");
+  if (!name || !requests) {
+    throw new InvalidArgumentError("Tool usage must be formatted as name:requests");
+  }
+  const parsed = parseWholeNonNegativeInteger(
+    requests,
+    "Tool requests must be a non-negative integer"
+  );
+  return { name, estimatedRequests: parsed };
+}
+function toPredictJsonError(error) {
+  if (error instanceof InvalidArgumentError) {
+    return new ValidationError(error.message);
+  }
+  if (error instanceof z.ZodError) {
+    return new ValidationError(formatValidationErrors(error));
+  }
+  if (error instanceof Error && error.message.startsWith("Invalid command options")) {
+    return new ValidationError(error.message);
+  }
+  return error;
+}
+function toToolUsage(estimates) {
+  return estimates.map((estimate) => ({
+    name: estimate.name,
+    requests: estimate.estimatedRequests
+  }));
+}
+function printCostBreakdown(label, breakdown) {
+  console.log(chalk.bold.cyan(`
+${label}
+`));
+  console.log(`${chalk.gray("Provider")}: ${breakdown.provider}`);
+  console.log(`${chalk.gray("Model")}: ${breakdown.model}`);
+  if (isPricingUnavailable(breakdown)) {
+    console.log(`${chalk.gray("Total Cost")}: unavailable`);
+    console.log(`${chalk.gray("Breakdown")}: unavailable`);
+  } else {
+    const total = breakdown.totalCostAmount.status === "available" ? breakdown.totalCostAmount.amount : breakdown.totalCost;
+    console.log(`${chalk.gray("Total Cost")}: ${formatCurrency(total, breakdown.currency)}`);
+    console.log(
+      `${chalk.gray("Breakdown")}: input ${formatCurrency(breakdown.inputCost, breakdown.currency)} | output ${formatCurrency(breakdown.outputCost, breakdown.currency)} | cache ${formatCurrency(breakdown.cacheCost, breakdown.currency)} | tools ${formatCurrency(breakdown.toolCosts, breakdown.currency)} | infra ${formatCurrency(breakdown.infrastructureCost, breakdown.currency)}`
+    );
+  }
+  console.log(`${chalk.gray("Pricing Version")}: ${breakdown.pricingVersion}`);
+  if (isPricingUnavailable(breakdown)) {
+    console.log(chalk.yellow(`${chalk.gray("Pricing Status")}: unavailable`));
+    if (breakdown.pricingError) {
+      console.log(chalk.yellow(`${chalk.gray("Pricing Error")}: ${breakdown.pricingError}`));
+    }
+    return;
+  }
+  if (breakdown.billingMode !== "metered") {
+    const modeDescription = breakdown.billingMode === "non_metered" ? "non-metered" : breakdown.billingMode.replace(/_/g, " ");
+    console.log(
+      chalk.yellow(
+        `Note: ${breakdown.provider}/${breakdown.model} is tracked as ${modeDescription}. Per-token cost fields are shown as $0 because billing is handled via seat or flat-rate licensing.`
+      )
+    );
+  }
+}
+function isPricingUnavailable(breakdown) {
+  return breakdown.pricingStatus === "unavailable" || breakdown.totalCostAmount.status !== "available";
+}
+function availableBreakdownUsd(breakdown) {
+  return breakdown.totalCostAmount.status === "available" ? breakdown.totalCostAmount.amount : null;
+}
+function createCostCommand(deps) {
+  const cost = new Command("cost");
+  cost.alias("$");
+  cost.description(
+    "Cost tracking, forecasting, and comparison utilities\n\nExamples:\n  poetic cost status\n  poetic cost predict cursor auto --input 1000 --output 500\n  poetic cost compare cursor:auto cursor:auto --input 1000 --output 500"
+  );
+  cost.command("status").description(
+    "Show current real-time cost tracking metrics\n\nExamples:\n  poetic cost status\n  poetic cost status --swarm --days 14"
+  ).option("--json", "(OPTIONAL) Output metrics as JSON").option("-v, --verbose", "(OPTIONAL) Include unused OpenRouter :free catalog $0+$0 warnings").option(
+    "--swarm",
+    "(OPTIONAL) Show cost breakdown by agent role (for swarm executions)\n    Example: --swarm"
+  ).option(
+    "--days <days>",
+    "(OPTIONAL) Number of days to look back for swarm costs (default: 7)\n    Example: --days 14",
+    "7"
+  ).option(
+    "--since <window>",
+    "(OPTIONAL) Filter cost data to a time window (e.g. 7d, 24h, 30m, 1w)\n    Example: --since 7d"
+  ).option(
+    "--output-file <path>",
+    "(OPTIONAL) Save the cost report as JSON to the specified file path\n    Example: --output-file cost-report.json"
+  ).option("--lab [selector]", "(OPTIONAL) Use lab cost data (value: latest)").option("--lab-id <labId>", "(OPTIONAL) Specify lab ID (requires --run-id)").option("--run-id <runId>", "(OPTIONAL) Specify run ID (requires --lab-id)").action(async (options) => {
+    const validatedOptions = validateCommandOptions(StatusOptionsSchema, options);
+    const costTracker = await deps.costTracker;
+    const telemetry = await deps.telemetry;
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const costCalculator = await deps.costCalculator;
+    if (telemetry.databaseModule && !validatedOptions.json) {
+      telemetry.databaseModule.printDbBanner();
+    }
+    if (!validatedOptions.json) {
+      checkAndWarnLabContext();
+    }
+    if (!costTracker) {
+      console.error(chalk.red("Cost tracker not available"));
+      process.exit(1);
+    }
+    let startTime;
+    let windowLabel;
+    if (validatedOptions.since) {
+      const parsedMs = parseDuration(validatedOptions.since);
+      startTime = Date.now() - (parsedMs ?? 7 * 24 * 60 * 60 * 1e3);
+      windowLabel = validatedOptions.since;
+    } else {
+      const daysBack = validatedOptions.days ?? 7;
+      startTime = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+      windowLabel = `${daysBack} days`;
+    }
+    const labRun = resolveCostLabRun({
+      lab: validatedOptions.lab,
+      labId: validatedOptions.labId,
+      runId: validatedOptions.runId
+    });
+    const enrichmentAttempt = await ensurePendingInvocationCostEnrichment(modelInvocationsDb);
+    const labCostSummary = labRun ? readLabCostSummary(labRun, startTime) : null;
+    const recentExecutions = labCostSummary ? [] : modelInvocationsDb.getExecutionCostsSince(startTime);
+    const metrics = labCostSummary ? mergeLabCostMetrics(costTracker.getCurrentMetrics(), labCostSummary) : mergePersistedCostMetrics(costTracker.getCurrentMetrics(), recentExecutions);
+    const pricingVerification = await verifyPricingForStatus(costCalculator, telemetry);
+    const invocationVisibility = labCostSummary ? {
+      rawInvocationCount: labCostSummary.executions.length,
+      enrichedInvocationCount: labCostSummary.executions.length,
+      pendingEnrichmentCount: 0,
+      visibility: labCostSummary.executions.length > 0 ? "enriched" : "no_invocations",
+      hint: labCostSummary.executions.length > 0 ? void 0 : "No lab model invocations recorded in this window."
+    } : summarizeInvocationCostVisibility(modelInvocationsDb, startTime);
+    const costProjection = fromVisibilitySummary(
+      invocationVisibility,
+      labCostSummary ? void 0 : enrichmentAttempt
+    );
+    const pricingWarningsForView = validatedOptions.verbose ? pricingVerification.warnings : pricingVerification.warnings.filter((warning) => !isExpectedFreeZeroCostWarning(warning));
+    const pricingVerificationForView = {
+      ...pricingVerification,
+      warnings: pricingWarningsForView
+    };
+    const statusPayload = {
+      ...metrics,
+      pricingVerification: pricingVerificationForView,
+      invocationVisibility,
+      costProjection,
+      labContext: labCostSummary ? {
+        labId: labCostSummary.run.labId,
+        runId: labCostSummary.run.runId,
+        source: "lab-jsonl"
+      } : null
+    };
+    telemetry.logCostEvent("cli_cost_status_viewed", {
+      sessionCost: metrics.sessionCost,
+      dailyCost: metrics.dailyCost,
+      monthlyCost: metrics.monthlyCost,
+      alertCount: metrics.activeAlerts.length,
+      optimizationCount: metrics.availableOptimizations.length,
+      pricingWarningCount: pricingVerification.warnings.length,
+      pricingErrorCount: pricingVerification.errors.length,
+      swarmView: validatedOptions.swarm ?? false,
+      rawInvocationCount: invocationVisibility.rawInvocationCount,
+      enrichedInvocationCount: invocationVisibility.enrichedInvocationCount,
+      pendingEnrichmentCount: invocationVisibility.pendingEnrichmentCount,
+      visibility: invocationVisibility.visibility,
+      labId: labCostSummary?.run.labId ?? null,
+      runId: labCostSummary?.run.runId ?? null
+    });
+    if (validatedOptions.outputFile) {
+      const { writeFile } = await import("fs/promises");
+      try {
+        await writeFile(
+          validatedOptions.outputFile,
+          JSON.stringify(statusPayload, null, 2),
+          "utf8"
+        );
+      } catch (err) {
+        console.error(
+          chalk.red(
+            `Failed to write output file: ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    if (validatedOptions.json) {
+      console.log(JSON.stringify(statusPayload, null, 2));
+      return;
+    }
+    console.log(chalk.bold.cyan("\nCost: Cost Tracking Status\n"));
+    if (labCostSummary) {
+      console.log(
+        `${chalk.gray("Lab Run")}: ${labCostSummary.run.labId}/${labCostSummary.run.runId}`
+      );
+    }
+    console.log(`${chalk.gray("Session Cost")}: ${formatCurrency(metrics.sessionCost)}`);
+    console.log(`${chalk.gray("Daily Cost")}: ${formatCurrency(metrics.dailyCost)}`);
+    console.log(`${chalk.gray("Monthly Cost")}: ${formatCurrency(metrics.monthlyCost)}`);
+    console.log(`${chalk.gray("Cost / Minute")}: ${formatCurrency(metrics.costPerMinute)}`);
+    const top = metrics.topCostProvider;
+    console.log(
+      `${chalk.gray("Top Contributor")}: ${top.provider}/${top.model} (${formatCurrency(top.cost)} | ${top.percentage.toFixed(1)}%)`
+    );
+    if (metrics.costTrend.length > 0) {
+      const trend = metrics.costTrend.map((value) => formatCurrency(value)).join(chalk.gray(" -> "));
+      console.log(`${chalk.gray("Recent Trend")}: ${trend}`);
+    } else {
+      console.log(`${chalk.gray("Recent Trend")}: ${chalk.gray("No executions recorded")}`);
+    }
+    if (metrics.sessionCost === 0 || costProjection.state !== "enriched") {
+      const projectionNotice = formatCostProjectionNotice(costProjection);
+      if (projectionNotice) {
+        console.log(chalk.gray(projectionNotice));
+      }
+    }
+    if (modelInvocationsDb.hasNonMeteredBilling()) {
+      console.log(
+        chalk.gray(
+          "Info: Seat-licensed providers (e.g., Copilot CLI) are tracked for usage but excluded from per-token totals."
+        )
+      );
+    }
+    if (recentExecutions.length > 0) {
+      const snapshotCost = recentExecutions.reduce(
+        (sum, exec) => sum + exec.costSnapshot.totalCostCents,
+        0
+      );
+      let recalculatedCost = 0;
+      for (const exec of recentExecutions) {
+        const newCost = modelInvocationsDb.recalculateCost(
+          exec.executionId,
+          (provider, model, usage) => {
+            try {
+              const breakdown = costCalculator.calculateCost(provider, model, {
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheReadTokens: usage.cacheReadTokens,
+                cacheWriteTokens: usage.cacheWriteTokens,
+                tools: usage.toolCalls?.map((t) => ({
+                  name: t.name,
+                  requests: t.requests
+                })) || [],
+                executionTimeMinutes: usage.executionTimeMs ? usage.executionTimeMs / 6e4 : void 0
+              });
+              const availableUsd = availableBreakdownUsd(breakdown);
+              if (availableUsd === null) {
+                return exec.costSnapshot.totalCostCents;
+              }
+              return availableUsd * 100;
+            } catch {
+              return exec.costSnapshot.totalCostCents;
+            }
+          }
+        );
+        recalculatedCost += newCost ?? exec.costSnapshot.totalCostCents;
+      }
+      console.log(chalk.bold.cyan("\nCost: Cost Basis Comparison\n"));
+      console.log(
+        `${chalk.gray("Historical (snapshot)")}: ${formatCurrency(snapshotCost / 100)}`
+      );
+      console.log(`${chalk.gray("Current pricing")}: ${formatCurrency(recalculatedCost / 100)}`);
+      if (Math.abs(recalculatedCost - snapshotCost) > 0.01) {
+        const delta = recalculatedCost - snapshotCost;
+        const pct = (delta / snapshotCost * 100).toFixed(1);
+        const direction = delta > 0 ? "up" : "down";
+        const color = delta > 0 ? chalk.red : chalk.green;
+        console.log(
+          `${chalk.gray("Price change")}: ${color(`${direction} ${formatCurrency(Math.abs(delta) / 100)} (${pct}%)`)}`
+        );
+      } else {
+        console.log(`${chalk.gray("Price change")}: ${chalk.gray("No change")}`);
+      }
+    }
+    if (validatedOptions.swarm) {
+      const roleBreakdown = modelInvocationsDb.getRoleCostBreakdown(startTime);
+      if (roleBreakdown.length > 0) {
+        console.log(chalk.bold.cyan(`
+Swarm Cost Breakdown (last ${windowLabel})
+`));
+        const totalCost = roleBreakdown.reduce((sum, role) => sum + role.avgCostCents, 0);
+        roleBreakdown.forEach((role) => {
+          const costDollars = role.avgCostCents / 100;
+          const percentage = totalCost > 0 ? role.avgCostCents / totalCost * 100 : 0;
+          console.log(
+            `${chalk.bold(role.agentRole.padEnd(15))} ${formatCurrency(costDollars)} (${percentage.toFixed(1)}%) [${role.totalInvocations} tasks]`
+          );
+          console.log(
+            `${chalk.gray("   tokens")}: ${formatTokenCount(role.totalTokensIn)} in, ${formatTokenCount(role.totalTokensOut)} out`
+          );
+        });
+        console.log(
+          chalk.gray("\nTip: Use role-specific providers to optimize costs per domain")
+        );
+      } else {
+        console.log(chalk.gray(`
+No swarm executions found in the last ${windowLabel}`));
+      }
+    }
+    if (metrics.activeAlerts.length > 0) {
+      console.log(chalk.bold.yellow("\nWarning: Internal Cost Heuristics"));
+      metrics.activeAlerts.forEach((alert) => {
+        console.log(
+          `${alert.severity.toUpperCase()} | ${alert.type} | ${alert.message} (${formatCurrency(alert.currentCost)} / ${formatCurrency(alert.threshold)})`
+        );
+      });
+    } else {
+      console.log(chalk.gray("\nNo internal cost heuristic alerts"));
+    }
+    if (pricingVerificationForView.warnings.length > 0 || pricingVerification.errors.length > 0) {
+      console.log(chalk.bold.yellow("\nWarning: Pricing Data"));
+      for (const warning of pricingVerificationForView.warnings) {
+        const provider = warning.provider ? `${warning.provider}: ` : "";
+        console.log(`${warning.severity.toUpperCase()} | ${provider}${warning.message}`);
+      }
+      for (const error of pricingVerification.errors) {
+        console.log(`ERROR | ${error.provider}: ${error.message}`);
+      }
+    }
+    if (metrics.availableOptimizations.length > 0) {
+      console.log(chalk.bold.green("\nTip: Optimization Suggestions"));
+      metrics.availableOptimizations.forEach((suggestion) => {
+        console.log(
+          `${suggestion.title} | saves ${formatCurrency(suggestion.estimatedSavings)} (${suggestion.estimatedSavingsPercent.toFixed(1)}%) | confidence ${(suggestion.confidence * 100).toFixed(0)}%`
+        );
+      });
+    }
+  });
+  cost.command("predict").description(
+    "Predict execution cost for a provider/model pair\n\nExamples:\n  poetic cost predict cursor auto --input 1000 --output 500\n  poetic cost predict claude sonnet --input 2000 --output 1000 --tool search:5"
+  ).argument("<provider>", "(REQUIRED) Provider identifier (e.g. anthropic)").argument("<model>", "(REQUIRED) Model name or alias (e.g. auto)").requiredOption(
+    "--input <tokens>",
+    "(REQUIRED) Estimated input tokens\n    Example: --input 1000"
+  ).requiredOption(
+    "--output <tokens>",
+    "(REQUIRED) Estimated output tokens\n    Example: --output 500"
+  ).option(
+    "--tool <usage>",
+    "(OPTIONAL) Tool usage in name:requests format (repeatable)\n    Example: --tool search:5",
+    collectRawToolUsage,
+    []
+  ).option("--json", "(OPTIONAL) Output breakdown as JSON").action(async (provider, model, options) => {
+    const jsonMode = Boolean(options.json);
+    try {
+      const parsedInput = parsePredictTokenOption(options.input);
+      const parsedOutput = parsePredictTokenOption(options.output);
+      const parsedTools = (options.tool ?? []).map(parsePredictToolUsageEntry);
+      const costCalculator = await deps.costCalculator;
+      const telemetry = await deps.telemetry;
+      const validatedProvider = z.string().min(1, "Provider cannot be empty").max(100, "Provider name too long").regex(/^[a-zA-Z0-9._-]+$/, "Invalid provider name format").parse(provider);
+      const validatedModel = ModelNameSchema.parse(model);
+      const validatedOptions = validateCommandOptions(PredictOptionsSchema, {
+        input: parsedInput,
+        output: parsedOutput,
+        tool: parsedTools.length > 0 ? parsedTools : void 0,
+        json: options.json
+      });
+      await deps.ensurePricingLoaded();
+      const tools = validatedOptions.tool ? toToolUsage(validatedOptions.tool) : [];
+      const breakdown = costCalculator.predictCost(validatedProvider, validatedModel, {
+        input: validatedOptions.input,
+        output: validatedOptions.output,
+        tools: tools.map((tool) => ({
+          name: tool.name,
+          estimatedRequests: tool.requests
+        }))
+      });
+      telemetry.logCostEvent("cli_cost_predict", {
+        provider: validatedProvider,
+        model: validatedModel,
+        inputTokens: validatedOptions.input,
+        outputTokens: validatedOptions.output,
+        tools: tools.length,
+        totalCost: availableBreakdownUsd(breakdown),
+        costStatus: breakdown.totalCostAmount.status,
+        currency: breakdown.currency,
+        pricingStatus: breakdown.pricingStatus
+      });
+      if (validatedOptions.json) {
+        renderJsonResult(breakdown);
+        return;
+      }
+      printCostBreakdown("Predictive: Cost Prediction", breakdown);
+      console.log(`${chalk.gray("Input Tokens")}: ${formatTokenCount(validatedOptions.input)}`);
+      console.log(`${chalk.gray("Output Tokens")}: ${formatTokenCount(validatedOptions.output)}`);
+      if (tools.length > 0) {
+        const toolSummary = tools.map((tool) => `${tool.name} \xD7 ${tool.requests}`).join(chalk.gray(", "));
+        console.log(`${chalk.gray("Tools")}: ${toolSummary}`);
+      }
+    } catch (error) {
+      if (jsonMode) {
+        renderJsonError(toPredictJsonError(error));
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+  });
+  cost.command("compare").description(
+    "Compare predicted costs across multiple provider/model pairs\n\nExamples:\n  poetic cost compare cursor:auto cursor:auto --input 1000 --output 500\n  poetic cost compare cursor:auto cursor:auto --input 2000 --output 1000 --json"
+  ).argument(
+    "[providerModels...]",
+    "(REQUIRED) Provider/model pairs (format provider:model, at least 2 required)"
+  ).requiredOption(
+    "--input <tokens>",
+    "(REQUIRED) Estimated input tokens\n    Example: --input 1000",
+    parseNonNegativeInteger
+  ).requiredOption(
+    "--output <tokens>",
+    "(REQUIRED) Estimated output tokens\n    Example: --output 500",
+    parseNonNegativeInteger
+  ).option("--json", "(OPTIONAL) Output comparison as JSON").action(async (providerModels, options) => {
+    try {
+      const costCalculator = await deps.costCalculator;
+      const telemetry = await deps.telemetry;
+      if (!Array.isArray(providerModels) || providerModels.length < 2) {
+        throw new InvalidArgumentError("Provide at least two provider:model pairs to compare");
+      }
+      const validatedOptions = validateCommandOptions(CompareOptionsSchema, options);
+      const ProviderModelPairSchema = z.string().regex(/^[a-zA-Z0-9._-]+:[a-zA-Z0-9._\-/]+$/, "Invalid provider:model format").refine((value) => {
+        const parts = value.split(":");
+        return parts.length === 2 && (parts[0]?.length ?? 0) > 0 && (parts[1]?.length ?? 0) > 0;
+      }, "Provider:model must have both provider and model specified");
+      const validatedPairs = providerModels.map((pair) => ProviderModelPairSchema.parse(pair));
+      await deps.ensurePricingLoaded();
+      const breakdowns = validatedPairs.map((entry) => {
+        const [provider, model] = entry.split(":");
+        if (!provider || !model) {
+          throw new InvalidArgumentError(
+            `Invalid provider:model pair '${entry}'. Expected format provider:model`
+          );
+        }
+        return costCalculator.predictCost(provider, model, {
+          input: validatedOptions.input,
+          output: validatedOptions.output
+        });
+      });
+      const pricedBreakdowns = breakdowns.filter((breakdown) => !isPricingUnavailable(breakdown));
+      const cheapestModel = pricedBreakdowns.reduce((min, current) => {
+        if (!min) return current;
+        const minUsd = availableBreakdownUsd(min) ?? Number.POSITIVE_INFINITY;
+        const currentUsd = availableBreakdownUsd(current) ?? Number.POSITIVE_INFINITY;
+        return currentUsd < minUsd ? current : min;
+      }, void 0);
+      telemetry.logCostEvent("cli_cost_compare", {
+        comparisons: validatedPairs.length,
+        inputTokens: validatedOptions.input,
+        outputTokens: validatedOptions.output,
+        cheapest: cheapestModel?.model ?? null,
+        unavailableComparisons: breakdowns.length - pricedBreakdowns.length
+      });
+      if (validatedOptions.json) {
+        console.log(JSON.stringify(breakdowns, null, 2));
+        return;
+      }
+      console.log(chalk.bold.cyan("\nCost Comparison\n"));
+      const unavailableBreakdowns = breakdowns.filter(isPricingUnavailable);
+      const sorted = [
+        ...pricedBreakdowns.sort((a, b) => {
+          const aUsd = availableBreakdownUsd(a) ?? Number.POSITIVE_INFINITY;
+          const bUsd = availableBreakdownUsd(b) ?? Number.POSITIVE_INFINITY;
+          return aUsd - bUsd;
+        }),
+        ...unavailableBreakdowns
+      ];
+      if (sorted.length === 0) {
+        console.log(chalk.red("No breakdowns available"));
+        return;
+      }
+      const cheapest = pricedBreakdowns[0];
+      const cheapestUsd = cheapest && cheapest.totalCostAmount.status === "available" ? cheapest.totalCostAmount.amount : null;
+      sorted.forEach((breakdown, index) => {
+        const totalAmount = breakdown.totalCostAmount;
+        const isUnavailable = breakdown.pricingStatus === "unavailable" || totalAmount.status !== "available";
+        const isCheapest = !isUnavailable && breakdown === cheapest;
+        const rankLabel = `${index + 1}. ${breakdown.provider}/${breakdown.model}`;
+        console.log(isCheapest ? chalk.green(rankLabel) : rankLabel);
+        if (breakdown.pricingStatus === "unavailable" || totalAmount.status !== "available") {
+          console.log("   total unavailable");
+          if (breakdown.pricingError) {
+            console.log(`   pricing unavailable: ${breakdown.pricingError}`);
+          }
+          return;
+        }
+        const totalUsd = totalAmount.amount;
+        if (cheapestUsd === null) {
+          console.log(`   total ${formatCurrency(totalUsd, breakdown.currency)}`);
+          return;
+        }
+        console.log(
+          `   total ${formatCurrency(totalUsd, breakdown.currency)} (${formatCurrencyDelta(totalUsd - cheapestUsd, breakdown.currency)})`
+        );
+        console.log(
+          `   input ${formatCurrency(breakdown.inputCost, breakdown.currency)} | output ${formatCurrency(breakdown.outputCost, breakdown.currency)}`
+        );
+        if (breakdown.toolCosts > 0 || breakdown.cacheCost > 0 || breakdown.infrastructureCost > 0) {
+          console.log(
+            `   cache ${formatCurrency(breakdown.cacheCost, breakdown.currency)} | tools ${formatCurrency(breakdown.toolCosts, breakdown.currency)} | infra ${formatCurrency(breakdown.infrastructureCost, breakdown.currency)}`
+          );
+        }
+      });
+    } catch (error) {
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              error: "cost_comparison_failed",
+              message: createSafeErrorMessage(error, "cost compare")
+            },
+            null,
+            2
+          )
+        );
+        process.exitCode = 1;
+        return;
+      }
+      throw error;
+    }
+  });
+  cost.command("daily").description(
+    "Generate and display daily cost reports\n\nExamples:\n  poetic cost daily\n  poetic cost daily --days 14 --group provider\n  poetic cost daily --start 2024-01-01 --end 2024-01-31"
+  ).option(
+    "--days <days>",
+    "(OPTIONAL) Number of recent days to include (default: 7)\n    Example: --days 14",
+    "7"
+  ).option(
+    "--start <date>",
+    "(OPTIONAL) Start date in YYYY-MM-DD format (overrides --days)\n    Example: --start 2024-01-01"
+  ).option(
+    "--end <date>",
+    "(OPTIONAL) End date in YYYY-MM-DD format (default: today)\n    Example: --end 2024-01-31"
+  ).option(
+    "--group <grouping>",
+    "(OPTIONAL) Group results by date, provider, or model (default: date)\n    Example: --group provider",
+    "date"
+  ).option("--json", "(OPTIONAL) Output report as JSON").action(async (options) => {
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const telemetry = await deps.telemetry;
+    if (!modelInvocationsDb) {
+      console.log(chalk.yellow("Daily cost reports require a telemetry database."));
+      console.log(chalk.gray("Ensure cost tracking is enabled and try again."));
+      return;
+    }
+    const validatedOptions = validateCommandOptions(DailyOptionsSchema, options);
+    const today = /* @__PURE__ */ new Date();
+    const endDate = validatedOptions.end ? new Date(validatedOptions.end) : today;
+    let startDate;
+    if (validatedOptions.start) {
+      startDate = new Date(validatedOptions.start);
+      if (Number.isNaN(startDate.getTime())) {
+        throw new InvalidArgumentError(
+          `Invalid --start date: ${validatedOptions.start}. Use YYYY-MM-DD format.`
+        );
+      }
+    } else {
+      const daysBack = validatedOptions.days ?? 7;
+      startDate = new Date(endDate);
+      startDate.setDate(startDate.getDate() - daysBack + 1);
+    }
+    if (Number.isNaN(endDate.getTime())) {
+      throw new InvalidArgumentError(
+        `Invalid --end date: ${validatedOptions.end}. Use YYYY-MM-DD format.`
+      );
+    }
+    if (startDate > endDate) {
+      throw new InvalidArgumentError(
+        "Invalid date range: --start date cannot be after --end date."
+      );
+    }
+    const startDateStr = startDate.toISOString().split("T")[0];
+    const endDateStr = endDate.toISOString().split("T")[0];
+    const dailyResult = modelInvocationsDb.getDailyCostAggregations(
+      startDateStr,
+      endDateStr,
+      validatedOptions.group
+    );
+    const dailyData = dailyResult.rows;
+    if (dailyResult.status === "error") {
+      if (validatedOptions.json) {
+        writeCostOutput(
+          JSON.stringify(
+            {
+              status: "error",
+              error: dailyResult.error ?? "daily cost aggregation failed",
+              detail: dailyResult.detail,
+              period: {
+                start: startDateStr,
+                end: endDateStr,
+                days: 0
+              },
+              grouping: validatedOptions.group,
+              data: []
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      writeCostOutput(
+        chalk.yellow(
+          `Error: Daily cost aggregation failed${dailyResult.error ? `: ${dailyResult.error}` : "."}`
+        )
+      );
+      return;
+    }
+    if (dailyData.length === 0) {
+      if (validatedOptions.json) {
+        console.log(
+          JSON.stringify(
+            {
+              status: "complete",
+              period: {
+                start: startDateStr,
+                end: endDateStr,
+                days: 0
+              },
+              summary: {
+                totalCost: 0,
+                totalExecutions: 0,
+                pricedExecutions: 0,
+                totalTokensIn: 0,
+                totalTokensOut: 0,
+                avgDailyCost: 0
+              },
+              grouping: validatedOptions.group,
+              data: []
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(chalk.yellow("No cost data found for the specified period."));
+      console.log(chalk.gray(`Query range: ${startDateStr} to ${endDateStr}`));
+      logCostEmptyStateHint(modelInvocationsDb, startDate.getTime());
+      return;
+    }
+    const totalExecutions = dailyResult.executionCount;
+    const pricedExecutions = dailyResult.pricedCount;
+    const totalTokensIn = dailyData.reduce((sum, day) => sum + day.totalTokensIn, 0);
+    const totalTokensOut = dailyData.reduce((sum, day) => sum + day.totalTokensOut, 0);
+    const totalCost = dailyResult.status === "complete" ? sumCompleteDailyCosts(dailyData) : null;
+    const avgDailyCost = totalCost !== null && dailyData.length > 0 ? totalCost / dailyData.length : null;
+    telemetry.logCostEvent("cli_cost_daily_viewed", {
+      startDate: startDateStr ?? null,
+      endDate: endDateStr ?? null,
+      grouping: validatedOptions.group,
+      recordCount: dailyData.length,
+      status: dailyResult.status,
+      totalCost,
+      totalExecutions,
+      pricedExecutions
+    });
+    if (validatedOptions.json) {
+      const summary = dailyResult.status === "complete" && totalCost !== null && avgDailyCost !== null ? {
+        totalCost,
+        totalExecutions,
+        pricedExecutions,
+        totalTokensIn,
+        totalTokensOut,
+        avgDailyCost
+      } : {
+        totalExecutions,
+        pricedExecutions,
+        totalTokensIn,
+        totalTokensOut
+      };
+      console.log(
+        JSON.stringify(
+          {
+            status: dailyResult.status,
+            ...dailyResult.detail ? { detail: dailyResult.detail } : {},
+            period: {
+              start: startDateStr,
+              end: endDateStr,
+              days: dailyData.length
+            },
+            summary,
+            grouping: validatedOptions.group,
+            data: dailyData
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold.cyan("\nDaily Cost Report\n"));
+    console.log(
+      `${chalk.gray("Period")}: ${startDateStr} to ${endDateStr} (${dailyData.length} days)`
+    );
+    console.log(`${chalk.gray("Grouping")}: ${validatedOptions.group}`);
+    if (dailyResult.status === "incomplete") {
+      writeCostOutput(
+        chalk.yellow(
+          `Evidence: incomplete (${pricedExecutions} of ${totalExecutions} invocations priced)`
+        )
+      );
+      writeCostOutput(
+        chalk.gray("Totals and averages omitted until all invocations are priced.")
+      );
+    }
+    console.log(chalk.bold("\nSummary"));
+    if (totalCost !== null && avgDailyCost !== null) {
+      console.log(`${chalk.gray("Total Cost")}: ${formatCostDisplay(totalCost)}`);
+      console.log(`${chalk.gray("Avg Daily Cost")}: ${formatCostDisplay(avgDailyCost)}`);
+    } else {
+      writeCostOutput(`${chalk.gray("Total Cost")}: incomplete`);
+      writeCostOutput(`${chalk.gray("Avg Daily Cost")}: incomplete`);
+    }
+    console.log(`${chalk.gray("Total Executions")}: ${totalExecutions.toLocaleString()}`);
+    if (dailyResult.status === "incomplete") {
+      writeCostOutput(`${chalk.gray("Priced Executions")}: ${pricedExecutions.toLocaleString()}`);
+    }
+    console.log(
+      `${chalk.gray("Total Tokens")}: ${formatTokenCount(totalTokensIn + totalTokensOut)}`
+    );
+    if (dailyResult.status === "complete" && dailyData.length > 1) {
+      const sortedByCost = [...dailyData].sort((a, b) => (b.totalCost ?? 0) - (a.totalCost ?? 0));
+      const mostExpensive = sortedByCost[0];
+      const leastExpensive = sortedByCost[sortedByCost.length - 1];
+      if (mostExpensive && leastExpensive && mostExpensive.totalCost !== null && leastExpensive.totalCost !== null && mostExpensive.totalCost > leastExpensive.totalCost) {
+        console.log(
+          `${chalk.gray("Highest Cost Day")}: ${mostExpensive.date} (${formatCostDisplay(mostExpensive.totalCost)})`
+        );
+        console.log(
+          `${chalk.gray("Lowest Cost Day")}: ${leastExpensive.date} (${formatCostDisplay(leastExpensive.totalCost)})`
+        );
+      }
+    }
+    console.log(chalk.bold("\nDetailed Breakdown\n"));
+    if (validatedOptions.group === "date") {
+      console.log(
+        `${chalk.bold("Date".padEnd(12))} ${chalk.bold("Cost".padEnd(12))} ${chalk.bold("Executions".padEnd(12))} ${chalk.bold("Tokens".padEnd(12))} ${chalk.bold("Avg Cost")}`
+      );
+      console.log(chalk.gray("-".repeat(60)));
+      dailyData.forEach((day) => {
+        const totalTokens = day.totalTokensIn + day.totalTokensOut;
+        console.log(
+          `${day.date.padEnd(12)} ${formatDailyAggregationCost(day.totalCost).padEnd(12)} ${day.executionCount.toLocaleString().padEnd(12)} ${formatTokenCount(totalTokens).padEnd(12)} ${formatDailyAggregationCost(day.avgCostPerExecution)}`
+        );
+      });
+    } else if (validatedOptions.group === "provider") {
+      const providerGroups = /* @__PURE__ */ new Map();
+      dailyData.forEach((item) => {
+        if (!item.provider) return;
+        if (!providerGroups.has(item.provider)) {
+          providerGroups.set(item.provider, []);
+        }
+        providerGroups.get(item.provider)?.push(item);
+      });
+      console.log(
+        `${chalk.bold("Provider".padEnd(20))} ${chalk.bold("Total Cost".padEnd(12))} ${chalk.bold("Executions".padEnd(12))} ${chalk.bold("Tokens".padEnd(12))} ${chalk.bold("Avg Cost")}`
+      );
+      console.log(chalk.gray("-".repeat(70)));
+      providerGroups.forEach((items, provider) => {
+        const providerCost = sumCompleteDailyCosts(items);
+        const providerExecutions = items.reduce((sum, item) => sum + item.executionCount, 0);
+        const providerTokens = items.reduce(
+          (sum, item) => sum + item.totalTokensIn + item.totalTokensOut,
+          0
+        );
+        const avgCost = providerCost !== null && providerExecutions > 0 ? providerCost / providerExecutions : null;
+        console.log(
+          `${provider.padEnd(20)} ${formatDailyAggregationCost(providerCost).padEnd(12)} ${providerExecutions.toLocaleString().padEnd(12)} ${formatTokenCount(providerTokens).padEnd(12)} ${formatDailyAggregationCost(avgCost)}`
+        );
+      });
+    } else if (validatedOptions.group === "model") {
+      const modelGroups = /* @__PURE__ */ new Map();
+      dailyData.forEach((item) => {
+        if (!item.model) return;
+        if (!modelGroups.has(item.model)) {
+          modelGroups.set(item.model, []);
+        }
+        modelGroups.get(item.model)?.push(item);
+      });
+      console.log(
+        `${chalk.bold("Model".padEnd(25))} ${chalk.bold("Total Cost".padEnd(12))} ${chalk.bold("Executions".padEnd(12))} ${chalk.bold("Tokens".padEnd(12))} ${chalk.bold("Avg Cost")}`
+      );
+      console.log(chalk.gray("-".repeat(75)));
+      modelGroups.forEach((items, model) => {
+        const modelCost = sumCompleteDailyCosts(items);
+        const modelExecutions = items.reduce((sum, item) => sum + item.executionCount, 0);
+        const modelTokens = items.reduce(
+          (sum, item) => sum + item.totalTokensIn + item.totalTokensOut,
+          0
+        );
+        const avgCost = modelCost !== null && modelExecutions > 0 ? modelCost / modelExecutions : null;
+        console.log(
+          `${model.padEnd(25)} ${formatDailyAggregationCost(modelCost).padEnd(12)} ${modelExecutions.toLocaleString().padEnd(12)} ${formatTokenCount(modelTokens).padEnd(12)} ${formatDailyAggregationCost(avgCost)}`
+        );
+      });
+    }
+    console.log(
+      chalk.gray("\nTip: Use --group provider or --group model to see different breakdowns")
+    );
+  });
+  cost.command("history").description(
+    "Show cost history with optional recalculation\n\nExamples:\n  poetic cost history --task task-123\n  poetic cost history --competition comp-456 --recalculate current\n  poetic cost history --days 30 --recalculate 2024-01-01"
+  ).option("--task <taskId>", "(OPTIONAL) Show costs for specific task").option("--competition <competitionId>", "(OPTIONAL) Show costs for specific competition").option(
+    "--recalculate <mode>",
+    "(OPTIONAL) Recalculation mode: current | snapshot | YYYY-MM-DD\n    Example: --recalculate current"
+  ).option(
+    "--days <days>",
+    "(OPTIONAL) Number of recent days (default: 7)\n    Example: --days 14",
+    "7"
+  ).option("--json", "(OPTIONAL) Output as JSON").action(async (options) => {
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const costCalculator = await deps.costCalculator;
+    const telemetry = await deps.telemetry;
+    const validatedOptions = validateCommandOptions(HistoryOptionsSchema, options);
+    let executions = [];
+    if (validatedOptions.task) {
+      const taskExecutions = modelInvocationsDb.getTaskExecutionCosts(validatedOptions.task);
+      executions = taskExecutions.map((exec) => ({
+        executionId: exec.executionId,
+        provider: exec.provider,
+        model: exec.model,
+        snapshotCost: exec.costSnapshot.totalCostCents,
+        currentCost: exec.costSnapshot.totalCostCents,
+        timestamp: exec.timestamp
+      }));
+    } else if (validatedOptions.competition) {
+      const competitionExecutions = modelInvocationsDb.getCompetitionExecutionCosts(
+        validatedOptions.competition
+      );
+      executions = competitionExecutions.map((exec) => ({
+        executionId: exec.executionId,
+        provider: exec.provider,
+        model: exec.model,
+        snapshotCost: exec.costSnapshot.totalCostCents,
+        currentCost: exec.costSnapshot.totalCostCents,
+        timestamp: exec.timestamp
+      }));
+    } else {
+      const daysBack = validatedOptions.days ?? 7;
+      const startTime = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+      const allExecutions = modelInvocationsDb.getExecutionCostsSince(startTime);
+      executions = allExecutions.map((exec) => ({
+        executionId: exec.executionId,
+        provider: exec.provider,
+        model: exec.model,
+        snapshotCost: exec.costSnapshot.totalCostCents,
+        currentCost: exec.costSnapshot.totalCostCents,
+        timestamp: exec.timestamp
+      }));
+    }
+    if (validatedOptions.recalculate === "current") {
+      for (const exec of executions) {
+        const newCost = modelInvocationsDb.recalculateCost(
+          exec.executionId,
+          (provider, model, usage) => {
+            try {
+              const breakdown = costCalculator.calculateCost(provider, model, {
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheReadTokens: usage.cacheReadTokens,
+                cacheWriteTokens: usage.cacheWriteTokens,
+                tools: usage.toolCalls?.map((t) => ({
+                  name: t.name,
+                  requests: t.requests
+                })) || [],
+                executionTimeMinutes: usage.executionTimeMs ? usage.executionTimeMs / 6e4 : void 0
+              });
+              const availableUsd = availableBreakdownUsd(breakdown);
+              if (availableUsd === null) {
+                return exec.snapshotCost;
+              }
+              return availableUsd * 100;
+            } catch (error) {
+              emitWarning(
+                "PR-003",
+                {
+                  taskId: validatedOptions.task || "cost-history",
+                  subsystem: "cost-tracking",
+                  executionPhase: "execution"
+                },
+                {
+                  severity: "WARN" /* WARN */,
+                  metadata: {
+                    executionId: exec.executionId,
+                    error: error instanceof Error ? error.message : String(error),
+                    operation: "recalculateCost"
+                  }
+                }
+              );
+              return exec.snapshotCost;
+            }
+          }
+        );
+        exec.currentCost = newCost ?? exec.snapshotCost;
+      }
+    }
+    telemetry.logCostEvent("cli_cost_history_viewed", {
+      taskId: validatedOptions.task ?? null,
+      competitionId: validatedOptions.competition ?? null,
+      recalculateMode: validatedOptions.recalculate ?? "snapshot",
+      executionCount: executions.length
+    });
+    if (validatedOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            executions: executions.map((e) => ({
+              executionId: e.executionId,
+              provider: e.provider,
+              model: e.model,
+              snapshotCost: e.snapshotCost / 100,
+              currentCost: e.currentCost / 100,
+              delta: (e.currentCost - e.snapshotCost) / 100,
+              deltaPercent: e.snapshotCost > 0 ? (e.currentCost - e.snapshotCost) / e.snapshotCost * 100 : 0,
+              timestamp: e.timestamp.toISOString()
+            })),
+            summary: {
+              totalSnapshot: executions.reduce((sum, e) => sum + e.snapshotCost, 0) / 100,
+              totalCurrent: executions.reduce((sum, e) => sum + e.currentCost, 0) / 100
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold.cyan("\nCost History\n"));
+    if (executions.length === 0) {
+      console.log(chalk.yellow("No execution history found."));
+      if (!validatedOptions.task && !validatedOptions.competition) {
+        const daysBack = validatedOptions.days ?? 7;
+        const startTime = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+        logCostEmptyStateHint(modelInvocationsDb, startTime);
+      }
+      return;
+    }
+    console.log(
+      `${chalk.bold("Execution".padEnd(30))} ${chalk.bold("Snapshot".padEnd(12))} ${chalk.bold("Current".padEnd(12))} ${chalk.bold("Delta")}`
+    );
+    console.log(chalk.gray("-".repeat(70)));
+    executions.forEach((exec) => {
+      const delta = exec.currentCost - exec.snapshotCost;
+      const deltaPercent = exec.snapshotCost > 0 ? (delta / exec.snapshotCost * 100).toFixed(1) : "0.0";
+      const direction = delta > 0 ? "up" : delta < 0 ? "down" : "flat";
+      const color = delta > 0 ? chalk.red : delta < 0 ? chalk.green : chalk.gray;
+      const label = `${exec.executionId.substring(0, 8)}... (${exec.provider}/${exec.model})`;
+      console.log(
+        `${label.padEnd(30)} ${formatCurrency(exec.snapshotCost / 100).padEnd(12)} ${formatCurrency(exec.currentCost / 100).padEnd(12)} ` + color(`${direction} ${deltaPercent}%`)
+      );
+    });
+    const totalSnapshot = executions.reduce((sum, e) => sum + e.snapshotCost, 0);
+    const totalCurrent = executions.reduce((sum, e) => sum + e.currentCost, 0);
+    const totalDelta = totalCurrent - totalSnapshot;
+    console.log(chalk.gray("-".repeat(70)));
+    console.log(`${chalk.bold("Total (Snapshot)")}: ${formatCurrency(totalSnapshot / 100)}`);
+    console.log(`${chalk.bold("Total (Current)")}: ${formatCurrency(totalCurrent / 100)}`);
+    if (Math.abs(totalDelta) > 0.01) {
+      const color = totalDelta > 0 ? chalk.red : chalk.green;
+      console.log(
+        `${chalk.bold("Savings/Cost")}: ${color(formatCurrency(Math.abs(totalDelta) / 100))}`
+      );
+    }
+    console.log(
+      chalk.gray(
+        "\nTip: Token usage unchanged - cost difference due to pricing updates or recalculation mode"
+      )
+    );
+  });
+  cost.command("tasks").description(
+    "Show cost breakdown by task\n\nExamples:\n  poetic cost tasks\n  poetic cost tasks --days 30 --top 20\n  poetic cost tasks --json"
+  ).option(
+    "--days <days>",
+    "(OPTIONAL) Number of recent days (default: 7)\n    Example: --days 30",
+    "7"
+  ).option(
+    "--top <n>",
+    "(OPTIONAL) Show top N most expensive tasks (default: 10)\n    Example: --top 20",
+    "10"
+  ).option("--json", "(OPTIONAL) Output as JSON").action(async (options) => {
+    const telemetry = await deps.telemetry;
+    const validatedOptions = validateCommandOptions(TasksOptionsSchema, options);
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const startTime = Date.now() - (validatedOptions.days ?? 7) * 24 * 60 * 60 * 1e3;
+    const executions = modelInvocationsDb.getExecutionCostsSince(startTime);
+    const taskSummaries = /* @__PURE__ */ new Map();
+    for (const execution of executions) {
+      const taskId = execution.taskId ?? execution.competitionId ?? "unattributed";
+      const existing = taskSummaries.get(taskId);
+      if (existing) {
+        existing.executionCount += 1;
+        existing.totalCostCents += execution.costSnapshot.totalCostCents;
+        existing.providers.add(execution.provider);
+        if (execution.timestamp > existing.lastExecutionAt) {
+          existing.lastExecutionAt = execution.timestamp;
+        }
+        continue;
+      }
+      taskSummaries.set(taskId, {
+        taskId,
+        executionCount: 1,
+        totalCostCents: execution.costSnapshot.totalCostCents,
+        providers: /* @__PURE__ */ new Set([execution.provider]),
+        lastExecutionAt: execution.timestamp
+      });
+    }
+    const rows = [...taskSummaries.values()].sort((a, b) => b.totalCostCents - a.totalCostCents).slice(0, validatedOptions.top ?? 10);
+    if (validatedOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            tasks: rows.map((row) => ({
+              taskId: row.taskId,
+              executionCount: row.executionCount,
+              totalCost: row.totalCostCents / 100,
+              providers: [...row.providers].sort(),
+              lastExecutionAt: row.lastExecutionAt.toISOString()
+            })),
+            summary: {
+              windowDays: validatedOptions.days ?? 7,
+              totalTasks: taskSummaries.size,
+              totalExecutions: executions.length
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold.cyan("\nTask Cost Breakdown\n"));
+    if (rows.length === 0) {
+      console.log(chalk.yellow("No task cost data found for the requested window."));
+      logCostEmptyStateHint(modelInvocationsDb, startTime);
+      return;
+    }
+    console.log(
+      `${chalk.bold("Task".padEnd(34))} ${chalk.bold("Cost".padEnd(12))} ${chalk.bold("Execs".padEnd(7))} ${chalk.bold("Providers")}`
+    );
+    console.log(chalk.gray("-".repeat(74)));
+    for (const row of rows) {
+      const label = row.taskId.length > 32 ? `${row.taskId.slice(0, 29)}...` : row.taskId.padEnd(32);
+      console.log(
+        `${label.padEnd(34)} ${formatCurrency(row.totalCostCents / 100).padEnd(12)} ${String(row.executionCount).padEnd(7)} ${[...row.providers].sort().join(", ")}`
+      );
+    }
+    telemetry.logCostEvent("cli_cost_tasks_viewed", {
+      days: validatedOptions.days ?? 7,
+      top: validatedOptions.top ?? 10,
+      taskCount: taskSummaries.size,
+      executionCount: executions.length
+    });
+  });
+  cost.command("tokens").description(
+    "Show token usage trends over time\n\nExamples:\n  poetic cost tokens\n  poetic cost tokens --days 30 --provider anthropic\n  poetic cost tokens --provider cursor --model auto"
+  ).option(
+    "--days <days>",
+    "(OPTIONAL) Number of recent days (default: 7)\n    Example: --days 30",
+    "7"
+  ).option(
+    "--provider <provider>",
+    "(OPTIONAL) Filter by provider\n    Example: --provider anthropic"
+  ).option("--model <model>", "(OPTIONAL) Filter by model\n    Example: --model auto").option("--json", "(OPTIONAL) Output as JSON").action(async (options) => {
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const telemetry = await deps.telemetry;
+    const validatedOptions = validateCommandOptions(TokensOptionsSchema, options);
+    const daysBack = validatedOptions.days ?? 7;
+    const endDate = /* @__PURE__ */ new Date();
+    const startDate = new Date(endDate);
+    startDate.setDate(startDate.getDate() - daysBack + 1);
+    const startDateStr = startDate.toISOString().split("T")[0];
+    const endDateStr = endDate.toISOString().split("T")[0];
+    const dailyResult = modelInvocationsDb.getDailyCostAggregations(
+      startDateStr,
+      endDateStr,
+      "date"
+    );
+    if (dailyResult.status === "error") {
+      if (validatedOptions.json) {
+        writeCostOutput(
+          JSON.stringify(
+            {
+              status: "error",
+              error: dailyResult.error ?? "daily cost aggregation failed",
+              detail: dailyResult.detail,
+              period: {
+                start: startDateStr,
+                end: endDateStr,
+                days: daysBack
+              },
+              data: []
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      writeCostOutput(
+        chalk.yellow(
+          `Error: Token trends unavailable${dailyResult.error ? `: ${dailyResult.error}` : "."}`
+        )
+      );
+      return;
+    }
+    const filteredData = dailyResult.rows.filter((day) => {
+      if (validatedOptions.provider && day.provider !== validatedOptions.provider) {
+        return false;
+      }
+      if (validatedOptions.model && day.model !== validatedOptions.model) {
+        return false;
+      }
+      return true;
+    });
+    telemetry.logCostEvent("cli_cost_tokens_viewed", {
+      days: daysBack,
+      provider: validatedOptions.provider ?? null,
+      model: validatedOptions.model ?? null,
+      recordCount: filteredData.length,
+      status: dailyResult.status
+    });
+    if (validatedOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: dailyResult.status,
+            period: {
+              start: startDateStr,
+              end: endDateStr,
+              days: daysBack
+            },
+            filters: {
+              provider: validatedOptions.provider ?? null,
+              model: validatedOptions.model ?? null
+            },
+            data: filteredData.map((day) => ({
+              date: day.date,
+              totalTokensIn: day.totalTokensIn,
+              totalTokensOut: day.totalTokensOut,
+              totalTokens: day.totalTokensIn + day.totalTokensOut,
+              executionCount: day.executionCount,
+              avgTokensPerExecution: day.executionCount > 0 ? (day.totalTokensIn + day.totalTokensOut) / day.executionCount : 0
+            }))
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold.cyan("\nToken Usage Trends\n"));
+    if (filteredData.length === 0) {
+      console.log(chalk.yellow("No token usage data found for the specified period."));
+      const startTimeMs = Date.now() - daysBack * 24 * 60 * 60 * 1e3;
+      logCostEmptyStateHint(modelInvocationsDb, startTimeMs);
+      return;
+    }
+    console.log(`${chalk.gray("Period")}: ${startDateStr} to ${endDateStr} (${daysBack} days)`);
+    if (validatedOptions.provider) {
+      console.log(`${chalk.gray("Provider")}: ${validatedOptions.provider}`);
+    }
+    if (validatedOptions.model) {
+      console.log(`${chalk.gray("Model")}: ${validatedOptions.model}`);
+    }
+    console.log(
+      `
+${chalk.bold("Date".padEnd(12))} ${chalk.bold("Input".padEnd(12))} ${chalk.bold("Output".padEnd(12))} ${chalk.bold("Total".padEnd(12))} ${chalk.bold("Execs")}`
+    );
+    console.log(chalk.gray("-".repeat(65)));
+    filteredData.forEach((day) => {
+      const totalTokens = day.totalTokensIn + day.totalTokensOut;
+      console.log(
+        `${day.date.padEnd(12)} ${formatTokenCount(day.totalTokensIn).padEnd(12)} ${formatTokenCount(day.totalTokensOut).padEnd(12)} ${formatTokenCount(totalTokens).padEnd(12)} ${day.executionCount.toLocaleString()}`
+      );
+    });
+    const totalIn = filteredData.reduce((sum, day) => sum + day.totalTokensIn, 0);
+    const totalOut = filteredData.reduce((sum, day) => sum + day.totalTokensOut, 0);
+    const totalExecs = filteredData.reduce((sum, day) => sum + day.executionCount, 0);
+    console.log(chalk.gray("-".repeat(65)));
+    console.log(`${chalk.bold("Total Input")}: ${formatTokenCount(totalIn)}`);
+    console.log(`${chalk.bold("Total Output")}: ${formatTokenCount(totalOut)}`);
+    console.log(`${chalk.bold("Total Tokens")}: ${formatTokenCount(totalIn + totalOut)}`);
+    console.log(`${chalk.bold("Total Executions")}: ${totalExecs.toLocaleString()}`);
+    console.log(
+      chalk.gray(
+        "\nTip: Token usage is independent of cost - use `poetic cost daily` for cost analysis"
+      )
+    );
+  });
+  cost.command("compare-pricing").description(
+    "Compare recorded snapshot cost against current pricing\n\nExamples:\n  poetic cost compare-pricing inv_123456\n  poetic cost compare-pricing inv_123456 --json"
+  ).argument("<executionId>", "(REQUIRED) Execution ID to analyze").option("--json", "(OPTIONAL) Output as JSON").action(async (executionId, options) => {
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const costCalculator = await deps.costCalculator;
+    const telemetry = await deps.telemetry;
+    const validatedOptions = validateCommandOptions(ComparePricingOptionsSchema, options);
+    const execution = modelInvocationsDb.getExecutionCost(executionId);
+    if (!execution) {
+      if (validatedOptions.json) {
+        console.log(
+          JSON.stringify(
+            {
+              error: "execution_not_found",
+              message: `Execution not found: ${executionId}`,
+              executionId
+            },
+            null,
+            2
+          )
+        );
+        process.exitCode = 1;
+        return;
+      }
+      console.error(chalk.red(`Execution not found: ${executionId}`));
+      process.exitCode = 1;
+      return;
+    }
+    const currentCost = modelInvocationsDb.recalculateCost(
+      executionId,
+      (provider, model, usage) => {
+        try {
+          const breakdown = costCalculator.calculateCost(provider, model, {
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            cacheWriteTokens: usage.cacheWriteTokens,
+            tools: usage.toolCalls?.map((t) => ({
+              name: t.name,
+              requests: t.requests
+            })) || [],
+            executionTimeMinutes: usage.executionTimeMs ? usage.executionTimeMs / 6e4 : void 0
+          });
+          const availableUsd = availableBreakdownUsd(breakdown);
+          if (availableUsd === null) {
+            return execution.costSnapshot.totalCostCents;
+          }
+          return availableUsd * 100;
+        } catch (error) {
+          emitWarning(
+            "PR-003",
+            {
+              taskId: executionId,
+              subsystem: "cost-tracking",
+              executionPhase: "execution"
+            },
+            {
+              severity: "WARN" /* WARN */,
+              metadata: {
+                executionId,
+                error: error instanceof Error ? error.message : String(error),
+                operation: "recalculateCostComparePricing"
+              }
+            }
+          );
+          return execution.costSnapshot.totalCostCents;
+        }
+      }
+    );
+    telemetry.logCostEvent("cli_cost_compare_pricing_viewed", {
+      executionId,
+      snapshotCost: execution.costSnapshot.totalCostCents,
+      currentCost: currentCost ?? execution.costSnapshot.totalCostCents
+    });
+    if (validatedOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            executionId,
+            provider: execution.provider,
+            model: execution.model,
+            usage: execution.usage,
+            comparisons: {
+              snapshot: {
+                version: execution.pricingVersion,
+                costCents: execution.costSnapshot.totalCostCents
+              },
+              current: {
+                version: "current",
+                costCents: currentCost ?? execution.costSnapshot.totalCostCents
+              }
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    console.log(chalk.bold.cyan("\nPricing Comparison\n"));
+    console.log(`${chalk.gray("Execution ID")}: ${executionId}`);
+    console.log(`${chalk.gray("Provider/Model")}: ${execution.provider}/${execution.model}`);
+    console.log(
+      `${chalk.gray("Tokens")}: ${formatTokenCount(execution.usage.inputTokens)} in, ${formatTokenCount(execution.usage.outputTokens)} out`
+    );
+    console.log(chalk.bold("\nCost Comparison\n"));
+    console.log(
+      `${chalk.bold("Version".padEnd(20))} ${chalk.bold("Cost".padEnd(12))} ${chalk.bold("\u0394 from snapshot")}`
+    );
+    console.log(chalk.gray("-".repeat(50)));
+    const snapshotCost = execution.costSnapshot.totalCostCents;
+    console.log(
+      `${"Snapshot".padEnd(20)} ${formatCurrency(snapshotCost / 100).padEnd(12)} ${chalk.gray("(baseline)")}`
+    );
+    if (currentCost !== null) {
+      const delta = currentCost - snapshotCost;
+      const deltaPercent = snapshotCost > 0 ? (delta / snapshotCost * 100).toFixed(1) : "0.0";
+      const direction = delta > 0 ? "up" : delta < 0 ? "down" : "flat";
+      const color = delta > 0 ? chalk.red : delta < 0 ? chalk.green : chalk.gray;
+      console.log(
+        `${"Current".padEnd(20)} ${formatCurrency(currentCost / 100).padEnd(12)} ` + color(`${direction} ${deltaPercent}%`)
+      );
+    }
+    console.log(
+      chalk.gray(
+        "\nTip: Pricing versions reflect changes in provider pricing over time. Snapshot cost preserves historical accuracy."
+      )
+    );
+  });
+  cost.command("forecast").description(
+    "Project future costs based on historical burn rate\n\nExamples:\n  poetic cost forecast\n  poetic cost forecast --days 14 --horizon 14\n  poetic cost forecast --json"
+  ).option(
+    "--days <days>",
+    "(OPTIONAL) Historical lookback window in days (default: 7)\n    Example: --days 14",
+    "7"
+  ).option(
+    "--horizon <days>",
+    "(OPTIONAL) Number of future days to project (default: 7)\n    Example: --horizon 14",
+    "7"
+  ).option("--json", "(OPTIONAL) Output forecast as JSON").action(async (options) => {
+    const modelInvocationsDb = await deps.modelInvocationsDb;
+    const telemetry = await deps.telemetry;
+    if (!modelInvocationsDb) {
+      console.log(chalk.yellow("Cost forecasting requires a telemetry database."));
+      console.log(chalk.gray("Ensure cost tracking is enabled and try again."));
+      return;
+    }
+    const validatedOptions = validateCommandOptions(ForecastOptionsSchema, options);
+    const today = /* @__PURE__ */ new Date();
+    const endDate = today;
+    const daysBack = validatedOptions.days ?? 7;
+    const startDate = new Date(endDate);
+    startDate.setDate(startDate.getDate() - daysBack + 1);
+    const startDateStr = startDate.toISOString().split("T")[0];
+    const endDateStr = endDate.toISOString().split("T")[0];
+    const dailyResult = modelInvocationsDb.getDailyCostAggregations(
+      startDateStr,
+      endDateStr,
+      "date"
+    );
+    const dailyData = dailyResult.rows;
+    const horizonDays = validatedOptions.horizon ?? 7;
+    if (dailyResult.status === "error" || dailyResult.status === "incomplete") {
+      const reason = dailyResult.status === "error" ? dailyResult.error ?? "daily cost aggregation failed" : dailyResult.detail ?? `incomplete cost evidence (${dailyResult.pricedCount}/${dailyResult.executionCount} priced)`;
+      if (validatedOptions.json) {
+        writeCostOutput(
+          JSON.stringify(
+            {
+              status: dailyResult.status,
+              period: {
+                start: startDateStr,
+                end: endDateStr,
+                days: dailyData.length
+              },
+              evidence: {
+                executionCount: dailyResult.executionCount,
+                pricedCount: dailyResult.pricedCount
+              },
+              message: dailyResult.status === "error" ? `Cost forecast unavailable: ${reason}` : `Cost forecast requires complete daily cost evidence. ${reason}`,
+              ...dailyResult.status === "error" ? { error: reason } : { detail: reason }
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      writeCostOutput(
+        chalk.yellow(
+          dailyResult.status === "error" ? `Error: Cost forecast unavailable: ${reason}` : `Cost forecast unavailable: incomplete cost evidence (${dailyResult.pricedCount} of ${dailyResult.executionCount} priced).`
+        )
+      );
+      writeCostOutput(
+        chalk.gray("Burn rate and projections are omitted until evidence is complete.")
+      );
+      return;
+    }
+    if (dailyData.length === 0) {
+      if (validatedOptions.json) {
+        console.log(
+          JSON.stringify(
+            {
+              status: "complete",
+              period: {
+                start: startDateStr,
+                end: endDateStr,
+                days: 0
+              },
+              burnRate: {
+                avgDailyCost: 0,
+                trendSlope: 0
+              },
+              forecast: {
+                horizonDays,
+                dailyProjections: [],
+                totalProjectedCost: 0
+              }
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      console.log(chalk.yellow("No historical cost data found for the specified period."));
+      return;
+    }
+    const totalCostSum = sumCompleteDailyCosts(dailyData);
+    if (totalCostSum === null) {
+      if (validatedOptions.json) {
+        writeCostOutput(
+          JSON.stringify(
+            {
+              status: "incomplete",
+              period: {
+                start: startDateStr,
+                end: endDateStr,
+                days: dailyData.length
+              },
+              message: "Cost forecast requires complete daily cost evidence."
+            },
+            null,
+            2
+          )
+        );
+        return;
+      }
+      writeCostOutput(chalk.yellow("Cost forecast unavailable: incomplete cost evidence."));
+      return;
+    }
+    const avgDailyCost = totalCostSum / Math.max(dailyData.length, 1);
+    const n = dailyData.length;
+    let sumI = 0;
+    let sumCost = 0;
+    let sumICost = 0;
+    let sumI2 = 0;
+    for (let i = 0; i < n; i++) {
+      const cost2 = dailyData[i]?.totalCost ?? 0;
+      sumI += i;
+      sumCost += cost2;
+      sumICost += i * cost2;
+      sumI2 += i * i;
+    }
+    const slopeDenominator = n * sumI2 - sumI * sumI;
+    const slope = slopeDenominator !== 0 ? (n * sumICost - sumI * sumCost) / slopeDenominator : 0;
+    const dailyProjections = [];
+    for (let d = 0; d < horizonDays; d++) {
+      const projDate = new Date(today);
+      projDate.setDate(projDate.getDate() + d + 1);
+      const projDateStr = projDate.toISOString().split("T")[0] ?? "";
+      dailyProjections.push({
+        date: projDateStr,
+        projectedCost: Math.max(0, avgDailyCost)
+      });
+    }
+    const totalProjectedCost = dailyProjections.reduce((sum, p) => sum + p.projectedCost, 0);
+    telemetry.logCostEvent("cli_cost_forecast_viewed", {
+      days: validatedOptions.days,
+      horizon: validatedOptions.horizon,
+      status: "complete",
+      avgDailyCost,
+      totalProjectedCost,
+      trendSlope: slope
+    });
+    if (validatedOptions.json) {
+      console.log(
+        JSON.stringify(
+          {
+            status: "complete",
+            period: {
+              start: startDateStr,
+              end: endDateStr,
+              days: dailyData.length
+            },
+            burnRate: {
+              avgDailyCost,
+              trendSlope: slope
+            },
+            forecast: {
+              horizonDays,
+              dailyProjections,
+              totalProjectedCost
+            }
+          },
+          null,
+          2
+        )
+      );
+      return;
+    }
+    const trendDirection = Math.abs(slope) < 1e-3 ? "stable" : slope > 0 ? "increasing" : "decreasing";
+    console.log(chalk.bold.cyan(`
+Cost Forecast (next ${horizonDays} days)
+`));
+    console.log(
+      `${chalk.gray("Period analyzed")}: ${startDateStr} to ${endDateStr} (${dailyData.length} days)`
+    );
+    console.log(`${chalk.gray("Avg daily burn rate")}: ${formatCurrency(avgDailyCost)}`);
+    console.log(`${chalk.gray("Trend")}: ${trendDirection}`);
+    console.log(`
+${chalk.bold("Date".padEnd(12))} ${chalk.bold("Projected Cost")}`);
+    console.log(chalk.gray("-".repeat(30)));
+    dailyProjections.forEach((proj) => {
+      console.log(`${proj.date.padEnd(12)} ${formatCurrency(proj.projectedCost)}`);
+    });
+    console.log(chalk.gray("-".repeat(30)));
+    console.log(`${chalk.bold("Total projected")}: ${formatCurrency(totalProjectedCost)}`);
+  });
+  return cost;
+}
+
+export {
+  createCostCommand
+};
+//# sourceMappingURL=chunk-2BZ53J6J.js.map