@wrongstack/core 0.306.4 → 0.307.1

package/dist/chronicle/metrics-ingest.d.ts

@@ -0,0 +1,55 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type ChronicleMetricsRefreshResult } from './metrics-schema.js';
+export declare class ChronicleMetricsIngester {
+    private readonly db;
+    private readonly directory;
+    private readonly dbPath;
+    constructor(db: DatabaseSync, directory: string, dbPath: string);
+    refresh(): Promise<ChronicleMetricsRefreshResult>;
+    private loadOffsets;
+    /** True once the legacy JSONL journal was imported into the SQLite journal
+     *  (`importLegacyChronicleJournal` records the marker in `chronicle_meta`).
+     *  After that point the SQLite `events` table already holds every JSONL
+     *  event, so folding the leftover partition files again would double-count
+     *  every migrated event in the aggregates. `source` is the already-opened
+     *  read-only journal handle (null when no SQLite journal exists yet). */
+    private legacyJsonlConsumed;
+    /** Per-partition-file JSONL byte offsets recorded by
+     *  `importLegacyChronicleJournal` at import time (keyed by the same relative
+     *  path the fold uses). Files absent from the map were quarantined (or
+     *  created after the migration) — their events live only in JSONL. */
+    private loadJsonlBoundary;
+    /** Persist the rebuild sentinel idempotently. Its presence makes
+     *  `needsSqliteRebuild` return false, so post-migration jsonl-store offsets
+     *  are never mistaken for pre-migration progress. */
+    private ensureRebuildMarker;
+    /** Upgrade path: `metrics.db` already aggregated the legacy JSONL, then the
+     *  one-shot import copied those same events into the SQLite journal. There
+     *  is no `sqlite:` cursor yet, so a plain incremental fold would replay the
+     *  entire migrated history on top of the existing aggregates. The metrics
+     *  projection is disposable (fully derived from the journal), so rebuild it
+     *  from the SQLite source exactly once — the rebuild writes the cursors and
+     *  subsequent refreshes go back to incremental folding. */
+    private needsSqliteRebuild;
+    private rebuildFromSqliteJournal;
+    private pruneOffsets;
+    private ingestSqliteJournal;
+    private ingestFile;
+    /** Fold one event into the aggregates atomically. `ingestEvent` runs several
+     *  statements; when one throws mid-way (e.g. a malformed resource path), the
+     *  statements before it already mutated the aggregates. The savepoint rolls
+     *  those partial updates back: `ROLLBACK TO` rewinds, `RELEASE` (reached
+     *  before the re-throw) pops the savepoint so the next event in the batch
+     *  starts from a clean stack, and the batch commits only fully-succeeded
+     *  events. Dropping the `RELEASE` would leak the savepoint into the next
+     *  event's stack — the outer transaction ROLLBACK is never reached because
+     *  the per-event catch swallows the error and continues the batch. */
+    private ingestEventAtomically;
+    private ingestEvent;
+    private ingestDailyCounters;
+    private ingestProvider;
+    private ingestTokenCost;
+    private ingestTask;
+    private ingestFileEvent;
+}
+//# sourceMappingURL=metrics-ingest.d.ts.map

package/dist/chronicle/metrics-schema.d.ts

@@ -0,0 +1,86 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { ChronicleSignalFamily } from './query.js';
+import type { ChronicleEvent } from './types.js';
+export declare const SCHEMA_VERSION = 3;
+export declare const READ_CHUNK_BYTES: number;
+export declare const SQLITE_SOURCE_PREFIX = "sqlite:";
+export declare const SQLITE_INGEST_BATCH = 2000;
+export declare const EMPTY_FAMILIES: Record<ChronicleSignalFamily, number>;
+export interface ChronicleMetricsRefreshResult {
+    ingestedEvents: number;
+    ingestedBytes: number;
+    sourceFiles: number;
+    invalidLines: number;
+}
+export interface ChronicleProviderDailyRow {
+    day: string;
+    providerId: string;
+    modelId: string;
+    attempts: number;
+    completed: number;
+    failed: number;
+    retries: number;
+    fallbacks: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    avgDurationMs: number;
+    maxDurationMs: number;
+}
+export interface ChronicleTaskOutcomeRow {
+    taskId: string;
+    runId: string;
+    boardId: string;
+    sessionId: string;
+    agentId: string;
+    status: string;
+    startedAt: string | null;
+    endedAt: string | null;
+    durationMs: number | null;
+    retries: number;
+    verificationFailures: number;
+    filesTouched: number;
+}
+export interface ChronicleFileLineageRow {
+    path: string;
+    operation: string;
+    occurredAt: string;
+    sessionId: string;
+    agentId: string;
+    taskId: string;
+    boardId: string;
+    runId: string;
+    toolName: string;
+    providerId: string;
+    modelId: string;
+    source: string;
+}
+export interface ChronicleMetricsSummary {
+    providers: {
+        attempts: number;
+        completed: number;
+        failed: number;
+        successRate: number;
+    };
+    tasks: Record<string, number>;
+    files: {
+        mutations: number;
+        uniquePaths: number;
+    };
+    estimatedCostUsd: number;
+}
+export declare function loadDatabaseSync(): typeof DatabaseSync;
+export declare function isChronicleMetricsAvailable(): boolean;
+export declare function ensureMetricsSchema(db: DatabaseSync): void;
+export declare function eventDay(event: ChronicleEvent): string;
+export declare function durationMs(event: ChronicleEvent): number;
+export declare function numberOrDuration(event: ChronicleEvent, attributes: Record<string, unknown>): number;
+export declare function numberAt(event: ChronicleEvent, dotPath: string): number;
+export declare function readPath(value: Record<string, unknown>, key: string): unknown;
+export declare function stringAt(record: Record<string, unknown>, key: string): string | undefined;
+export declare function asString(value: unknown): string | undefined;
+export declare function clampLimit(limit: number | undefined, fallback: number): number;
+export declare function normalizeKey(value: string): string;
+export declare function normalizePathKey(value: string): string;
+//# sourceMappingURL=metrics-schema.d.ts.map

package/dist/chronicle/metrics-store.d.ts

@@ -6,98 +6,16 @@
  * projection kept in `<chronicleDir>/metrics.db` (node:sqlite, WAL). Each
  * `refresh()` incrementally consumes only the journal bytes appended since
  * the previous run (per-partition byte offsets in `ingest_state`), so the
- * raw JSONL partitions can be purged by retention without losing metrics:
- *
- * - `provider_daily`  — provider×model×day attempt/success/failure/retry/
- *                       fallback counts, token totals, duration stats.
- * - `task_outcomes`   — one row per task (kanban/SDD/subagent) with status,
- *                       timing, retry counts, and board/run/session lineage.
- * - `file_lineage`    — one row per observed file mutation with full
- *                       session/agent/task/board/tool/model attribution.
- * - `token_cost`      — latest cumulative token.accounted cost snapshot per
- *                       scope (same latest-wins semantics as the query
- *                       engine's summary).
- * - `daily_counters`, `family_daily`, `agent_daily`, `logical_request_daily`,
- *   `file_seen_daily` — per-day scalar counters and dedup sets backing
- *   `defaultSummary()`, a `ChronicleSummary` for the common unfiltered/
- *   time-bounded dashboard view. Any genuinely ad hoc filter (free text,
- *   path, session, provider, model) falls back to the raw-scan summary in
- *   query.ts — fixed-dimension aggregation fundamentally can't answer those.
- *
- * The schema is a cache: on version mismatch it is dropped and re-ingested
- * from whatever journal partitions still exist.
+ * raw JSONL partitions can be purged by retention without losing metrics.
  */
 import type { ChronicleSummary } from './query.js';
-export interface ChronicleMetricsRefreshResult {
-    ingestedEvents: number;
-    ingestedBytes: number;
-    sourceFiles: number;
-    invalidLines: number;
-}
-export interface ChronicleProviderDailyRow {
-    day: string;
-    providerId: string;
-    modelId: string;
-    attempts: number;
-    completed: number;
-    failed: number;
-    retries: number;
-    fallbacks: number;
-    inputTokens: number;
-    outputTokens: number;
-    cacheReadTokens: number;
-    cacheWriteTokens: number;
-    avgDurationMs: number;
-    maxDurationMs: number;
-}
-export interface ChronicleTaskOutcomeRow {
-    taskId: string;
-    runId: string;
-    boardId: string;
-    sessionId: string;
-    agentId: string;
-    status: string;
-    startedAt: string | null;
-    endedAt: string | null;
-    durationMs: number | null;
-    retries: number;
-    verificationFailures: number;
-    filesTouched: number;
-}
-export interface ChronicleFileLineageRow {
-    path: string;
-    operation: string;
-    occurredAt: string;
-    sessionId: string;
-    agentId: string;
-    taskId: string;
-    boardId: string;
-    runId: string;
-    toolName: string;
-    providerId: string;
-    modelId: string;
-    source: string;
-}
-export interface ChronicleMetricsSummary {
-    providers: {
-        attempts: number;
-        completed: number;
-        failed: number;
-        successRate: number;
-    };
-    tasks: Record<string, number>;
-    files: {
-        mutations: number;
-        uniquePaths: number;
-    };
-    estimatedCostUsd: number;
-}
-/** Non-throwing availability probe for callers that degrade gracefully. */
-export declare function isChronicleMetricsAvailable(): boolean;
+import { isChronicleMetricsAvailable, type ChronicleFileLineageRow, type ChronicleMetricsRefreshResult, type ChronicleMetricsSummary, type ChronicleProviderDailyRow, type ChronicleTaskOutcomeRow } from './metrics-schema.js';
+export { isChronicleMetricsAvailable, type ChronicleFileLineageRow, type ChronicleMetricsRefreshResult, type ChronicleMetricsSummary, type ChronicleProviderDailyRow, type ChronicleTaskOutcomeRow, };
 export declare class ChronicleMetricsStore {
     private readonly db;
     private readonly directory;
     private readonly dbPath;
+    private readonly ingester;
     private constructor();
     static open(chronicleDirectory: string): ChronicleMetricsStore;
     close(): void;
@@ -127,44 +45,11 @@ export declare class ChronicleMetricsStore {
     summary(): ChronicleMetricsSummary;
     /**
      * A `ChronicleSummary` for the default/unfiltered dashboard view — only
-     * `from`/`to` (day-precision) narrow it. Any other ad hoc filter (text,
-     * path, provider, model, session) can't be answered from these
-     * fixed-dimension aggregates; callers must fall back to query.ts's
-     * raw-scan summary for those.
+     * `from`/`to` (day-precision) narrow it.
      */
     defaultSummary(options?: {
         from?: string;
         to?: string;
     }): ChronicleSummary;
-    private ensureSchema;
-    private loadOffsets;
-    private pruneOffsets;
-    /**
-     * Fold everything the SQLite journal holds past this store's per-day cursor.
-     *
-     * Opened read-only on its own connection: the journal runs in WAL, so this
-     * never blocks the daemon writing to it, and metrics are best-effort — a
-     * journal that cannot be opened (mid-migration, absent, locked) leaves the
-     * cursors untouched and the next refresh retries.
-     *
-     * Rows the journal has already evicted are simply not seen. That is the
-     * intended split of responsibilities: the journal is a bounded ring, and this
-     * store is where an aggregate outlives the raw event it came from — which
-     * only holds if refresh runs more often than the ring turns over.
-     */
-    private ingestSqliteJournal;
-    /** Read complete lines appended after `consumed` bytes. The trailing
-     *  partial line of an actively-written partition is left for the next
-     *  refresh — `ingest_state.bytes` only ever advances past full lines. */
-    private ingestFile;
-    private ingestEvent;
-    /** Runs for every ingested event (not just the type-specific branches
-     *  below) — mirrors query.ts's updateSummary() closely enough that
-     *  defaultSummary() matches what a raw scan of the same window would say. */
-    private ingestDailyCounters;
-    private ingestProvider;
-    private ingestTokenCost;
-    private ingestTask;
-    private ingestFileEvent;
 }
 //# sourceMappingURL=metrics-store.d.ts.map