nilometer 0.0.0-stage → 0.2.0

package/core/pricing/prices.json

@@ -0,0 +1,348 @@
+{
+  "comment": "Anthropic API list prices, USD per million tokens. Every row was read from source_url on verified_on. effective_from 0000-01-01 means in effect since release as far as can be verified (D-020). A price change adds a row; never edit a past row. See the pricing-table skill.",
+  "rows": [
+    {
+      "model_id": "claude-fable-5-1",
+      "effective_from": "0000-01-01",
+      "input": 10,
+      "output": 50,
+      "cache_write_5m": 12.5,
+      "cache_write_1h": 20,
+      "cache_read": 0.25,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-fable-5",
+      "effective_from": "0000-01-01",
+      "input": 10,
+      "output": 50,
+      "cache_write_5m": 12.5,
+      "cache_write_1h": 20,
+      "cache_read": 1,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-mythos-5-1",
+      "effective_from": "0000-01-01",
+      "input": 10,
+      "output": 50,
+      "cache_write_5m": 12.5,
+      "cache_write_1h": 20,
+      "cache_read": 0.25,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-mythos-5",
+      "effective_from": "0000-01-01",
+      "input": 10,
+      "output": 50,
+      "cache_write_5m": 12.5,
+      "cache_write_1h": 20,
+      "cache_read": 1,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-5-5",
+      "effective_from": "0000-01-01",
+      "input": 4,
+      "output": 20,
+      "cache_write_5m": 5,
+      "cache_write_1h": 8,
+      "cache_read": 0.2,
+      "fast": {
+        "input": 8,
+        "output": 40,
+        "cache_write_5m": 10,
+        "cache_write_1h": 16,
+        "cache_read": 0.4
+      },
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-5",
+      "effective_from": "0000-01-01",
+      "input": 5,
+      "output": 25,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10,
+      "cache_read": 0.5,
+      "fast": {
+        "input": 10,
+        "output": 50,
+        "cache_write_5m": 12.5,
+        "cache_write_1h": 20,
+        "cache_read": 1
+      },
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-opus-4-8",
+      "effective_from": "0000-01-01",
+      "input": 5,
+      "output": 25,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10,
+      "cache_read": 0.5,
+      "fast": {
+        "input": 10,
+        "output": 50,
+        "cache_write_5m": 12.5,
+        "cache_write_1h": 20,
+        "cache_read": 1
+      },
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-opus-4-7",
+      "effective_from": "0000-01-01",
+      "input": 5,
+      "output": 25,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10,
+      "cache_read": 0.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-opus-4-6",
+      "effective_from": "0000-01-01",
+      "input": 5,
+      "output": 25,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10,
+      "cache_read": 0.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-opus-4-5",
+      "effective_from": "0000-01-01",
+      "input": 5,
+      "output": 25,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10,
+      "cache_read": 0.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-4-5-20251101",
+      "effective_from": "0000-01-01",
+      "input": 5,
+      "output": 25,
+      "cache_write_5m": 6.25,
+      "cache_write_1h": 10,
+      "cache_read": 0.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-4-1",
+      "effective_from": "0000-01-01",
+      "input": 15,
+      "output": 75,
+      "cache_write_5m": 18.75,
+      "cache_write_1h": 30,
+      "cache_read": 1.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-4-1-20250805",
+      "effective_from": "0000-01-01",
+      "input": 15,
+      "output": 75,
+      "cache_write_5m": 18.75,
+      "cache_write_1h": 30,
+      "cache_read": 1.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-4-0",
+      "effective_from": "0000-01-01",
+      "input": 15,
+      "output": 75,
+      "cache_write_5m": 18.75,
+      "cache_write_1h": 30,
+      "cache_read": 1.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-opus-4-20250514",
+      "effective_from": "0000-01-01",
+      "input": 15,
+      "output": 75,
+      "cache_write_5m": 18.75,
+      "cache_write_1h": 30,
+      "cache_read": 1.5,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-sonnet-5-5",
+      "effective_from": "0000-01-01",
+      "input": 2,
+      "output": 10,
+      "cache_write_5m": 2.5,
+      "cache_write_1h": 4,
+      "cache_read": 0.2,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-10-04"
+    },
+    {
+      "model_id": "claude-sonnet-5",
+      "effective_from": "0000-01-01",
+      "input": 2,
+      "output": 10,
+      "cache_write_5m": 2.5,
+      "cache_write_1h": 4,
+      "cache_read": 0.2,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-sonnet-4-6",
+      "effective_from": "0000-01-01",
+      "input": 3,
+      "output": 15,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6,
+      "cache_read": 0.3,
+      "fast": null,
+      "standard_rate_max_input_tokens": null,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-sonnet-4-5",
+      "effective_from": "0000-01-01",
+      "input": 3,
+      "output": 15,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6,
+      "cache_read": 0.3,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-sonnet-4-5-20250929",
+      "effective_from": "0000-01-01",
+      "input": 3,
+      "output": 15,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6,
+      "cache_read": 0.3,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-sonnet-4-0",
+      "effective_from": "0000-01-01",
+      "input": 3,
+      "output": 15,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6,
+      "cache_read": 0.3,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-sonnet-4-20250514",
+      "effective_from": "0000-01-01",
+      "input": 3,
+      "output": 15,
+      "cache_write_5m": 3.75,
+      "cache_write_1h": 6,
+      "cache_read": 0.3,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    },
+    {
+      "model_id": "claude-haiku-4-5-20251001",
+      "effective_from": "0000-01-01",
+      "input": 1,
+      "output": 5,
+      "cache_write_5m": 1.25,
+      "cache_write_1h": 2,
+      "cache_read": 0.1,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-haiku-4-5",
+      "effective_from": "0000-01-01",
+      "input": 1,
+      "output": 5,
+      "cache_write_5m": 1.25,
+      "cache_write_1h": 2,
+      "cache_read": 0.1,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-13"
+    },
+    {
+      "model_id": "claude-3-5-haiku-20241022",
+      "effective_from": "0000-01-01",
+      "input": 0.8,
+      "output": 4,
+      "cache_write_5m": 1,
+      "cache_write_1h": 1.6,
+      "cache_read": 0.08,
+      "fast": null,
+      "standard_rate_max_input_tokens": 200000,
+      "source_url": "https://platform.claude.com/docs/en/about-claude/pricing",
+      "verified_on": "2026-09-24"
+    }
+  ]
+}

package/core/schema/001_ingestion.sql

@@ -0,0 +1,57 @@
+-- 001_ingestion: raw storage for session logs and the status line spool.
+--
+-- Implements D-002 (store every raw line; everything else is derived and rebuildable) and D-003
+-- (incremental reading by byte offset of the last complete line). Rows in raw_lines are never
+-- updated or deleted: a log file rewritten by Claude Code keeps its earlier lines here, because
+-- those requests happened (fixtures/README.md, cumulative runs).
+--
+-- Column comments: "source:" names the log, payload, or filesystem value a column holds;
+-- "derived:" marks values computed by ingestion.
+
+CREATE TABLE ingest_runs (
+  id          INTEGER PRIMARY KEY, -- derived: run identity, increasing
+  started_at  TEXT NOT NULL,       -- derived: ISO-8601 UTC time the run began
+  finished_at TEXT,                -- derived: ISO-8601 UTC time the run ended; NULL while running or after a crash
+  mode        TEXT NOT NULL,       -- derived: 'incremental' reads from stored offsets; 'full' rereads every file
+  CHECK (mode IN ('incremental', 'full'))
+) STRICT;
+
+CREATE TABLE source_files (
+  id            INTEGER PRIMARY KEY, -- derived: file identity
+  kind          TEXT NOT NULL,       -- derived: 'log' for session JSONL, 'spool' for the status line spool
+  root          TEXT NOT NULL,       -- source: discovery root (a CLAUDE_CONFIG_DIR entry, ~/.claude, or the data dir)
+  relative_path TEXT NOT NULL,       -- source: path below the root, e.g. projects/<encoded>/<session>.jsonl
+  byte_offset   INTEGER NOT NULL,    -- derived: position just past the last complete line consumed (D-003)
+  size          INTEGER NOT NULL,    -- source: file size in bytes at the last read (stat)
+  inode         INTEGER,             -- source: inode at the last read (stat); NULL where the platform has none
+  first_run_id  INTEGER NOT NULL REFERENCES ingest_runs (id), -- derived: run that first saw the file
+  last_run_id   INTEGER NOT NULL REFERENCES ingest_runs (id), -- derived: run that last read the file
+  UNIQUE (root, relative_path),
+  CHECK (kind IN ('log', 'spool')),
+  CHECK (byte_offset >= 0 AND byte_offset <= size)
+) STRICT;
+
+CREATE TABLE raw_lines (
+  id             INTEGER PRIMARY KEY, -- derived: row identity; not an ordering (use file, first run, line)
+  source_file_id INTEGER NOT NULL REFERENCES source_files (id), -- derived: file the line came from
+  line_number    INTEGER NOT NULL,    -- source: 1-based line number where the line was first seen
+  byte_offset    INTEGER NOT NULL,    -- source: byte position of the line's first byte when first seen
+  content_hash   TEXT NOT NULL,       -- derived: SHA-256 of bytes, lowercase hex; with the file, the line's identity
+  bytes          BLOB NOT NULL,       -- source: the exact line bytes, without the terminating newline
+  first_run_id   INTEGER NOT NULL REFERENCES ingest_runs (id), -- derived: run that first stored the line
+  UNIQUE (source_file_id, content_hash),
+  CHECK (line_number >= 1),
+  CHECK (byte_offset >= 0),
+  CHECK (length(content_hash) = 64)
+) STRICT;
+
+-- The canonical order every derived list uses: file, then first run, then line.
+CREATE INDEX raw_lines_order ON raw_lines (source_file_id, first_run_id, line_number);
+
+CREATE TABLE ingest_report (
+  id             INTEGER PRIMARY KEY, -- derived: report row identity
+  run_id         INTEGER NOT NULL REFERENCES ingest_runs (id), -- derived: run that found the problem
+  source_file_id INTEGER REFERENCES source_files (id), -- derived: file involved; NULL for run-level problems
+  problem        TEXT NOT NULL,       -- derived: problem code, e.g. 'file_rewritten', 'file_unreadable'
+  detail         TEXT                 -- derived: human-readable detail; never a full log line
+) STRICT;

package/core/schema/002_line_count.sql

@@ -0,0 +1,7 @@
+-- 002_line_count: remember how many complete lines precede each file's stored byte offset.
+--
+-- Incremental reads start mid-file (D-003). Without this count, the first new line couldn't be
+-- given its true line number, and fixtures/README.md defines a line's number as where it was
+-- first seen. Reset to 0 together with byte_offset when a rewrite is detected.
+
+ALTER TABLE source_files ADD COLUMN line_count INTEGER NOT NULL DEFAULT 0 CHECK (line_count >= 0); -- derived: complete lines before byte_offset

package/core/schema/003_derived.sql

@@ -0,0 +1,70 @@
+-- 003_derived: tables derived from raw_lines by core/ingest/derive.ts.
+--
+-- Everything here is rebuildable (D-002): deleting these rows and deriving again from raw_lines
+-- must produce identical contents. derive_meta records the parser version that produced them, so
+-- a parser change triggers a rebuild instead of mixing old and new interpretations.
+--
+-- Classification and field rules: fixtures/README.md (D-001, D-004, D-007, D-019).
+-- The token tables are not STRICT on purpose: a JSON number that isn't an integer is stored as
+-- written rather than rejected, matching "a token value counts if it's a JSON number".
+
+CREATE TABLE derive_meta (
+  key   TEXT PRIMARY KEY, -- derived: setting name, e.g. 'parser_version'
+  value TEXT NOT NULL     -- derived: setting value
+) STRICT;
+
+CREATE TABLE parsed_lines (
+  raw_line_id   INTEGER PRIMARY KEY REFERENCES raw_lines (id), -- derived: the line these fields came from
+  class         TEXT NOT NULL,    -- derived: classification, first matching rule wins
+  session_id    TEXT,             -- source: sessionId ('<missing>' if absent or not a string); NULL when malformed
+  type          TEXT,             -- source: type ('<missing>' if absent or not a string); NULL when malformed
+  subtype       TEXT,             -- source: subtype when it's a string, else NULL
+  timestamp_raw TEXT,             -- source: timestamp as JSON text of its value; NULL when absent or malformed
+  timestamp_utc TEXT,             -- derived: timestamp normalized to UTC with milliseconds; NULL when it doesn't parse
+  cwd           TEXT,             -- source: cwd when it's a string, else NULL
+  git_branch    TEXT,             -- source: gitBranch when it's a string, else NULL
+  cc_version    TEXT,             -- source: version (Claude Code version) when it's a string, else NULL
+  is_sidechain  INTEGER NOT NULL, -- source: isSidechain === true (1) or anything else (0)
+  CHECK (class IN ('malformed', 'limit_hit', 'api_error', 'synthetic_other', 'request', 'retry_notice', 'ignored_type')),
+  CHECK (is_sidechain IN (0, 1))
+) STRICT;
+
+CREATE TABLE requests (
+  raw_line_id                INTEGER PRIMARY KEY REFERENCES raw_lines (id), -- derived: the request line
+  dedup_key                  TEXT,             -- derived: D-001 key; NULL when the line has neither ID (unkeyed)
+  message_id                 TEXT,             -- source: message.id when it's a string
+  request_id                 TEXT,             -- source: requestId when it's a string
+  model                      TEXT NOT NULL,    -- source: message.model ('<missing>' if absent or not a string)
+  input_tokens               NUMERIC NOT NULL, -- source: message.usage.input_tokens (0 when not a number)
+  output_tokens              NUMERIC NOT NULL, -- source: message.usage.output_tokens (0 when not a number)
+  cache_read_tokens          NUMERIC NOT NULL, -- source: message.usage.cache_read_input_tokens (0 when not a number)
+  cache_write_5m_tokens      NUMERIC,          -- source: message.usage.cache_creation.ephemeral_5m_input_tokens; NULL without the split object
+  cache_write_1h_tokens      NUMERIC,          -- source: message.usage.cache_creation.ephemeral_1h_input_tokens; NULL without the split object
+  cache_write_unsplit_tokens NUMERIC,          -- source: message.usage.cache_creation_input_tokens; only when the split object is absent
+  speed                      TEXT              -- source: message.usage.speed when it's a string
+);
+
+-- Requests grouped for dedup: each key's candidates are read together.
+CREATE INDEX requests_dedup_key ON requests (dedup_key);
+
+CREATE TABLE events (
+  raw_line_id               INTEGER PRIMARY KEY REFERENCES raw_lines (id), -- derived: the event line
+  class                     TEXT NOT NULL,    -- derived: 'limit_hit', 'api_error', 'synthetic_other', or 'retry_notice'
+  error                     TEXT,             -- source: error when it's a string
+  api_error_status          NUMERIC,          -- source: apiErrorStatus, or error.status for retry notices
+  window                    TEXT,             -- derived: 'five_hour' or 'seven_day' parsed from limit-hit text (D-004)
+  reset_text                TEXT,             -- derived: text after 'resets ' in limit-hit text (D-004)
+  unknown_error_key         TEXT,             -- derived: report label for an api_error's unrecognized or missing error
+  retry_rate_limits_present INTEGER NOT NULL, -- derived: 1 when a retry notice's error.rateLimits is present and not null (D-019)
+  CHECK (class IN ('limit_hit', 'api_error', 'synthetic_other', 'retry_notice'))
+);
+
+CREATE TABLE line_problems (
+  id          INTEGER PRIMARY KEY, -- derived: row identity
+  raw_line_id INTEGER NOT NULL REFERENCES raw_lines (id), -- derived: the line with the problem
+  problem     TEXT NOT NULL,       -- derived: 'missing_field', 'unparsed_timestamp', or 'non_message_iteration'
+  detail      TEXT,                -- derived: the field name, raw timestamp JSON, or iteration type
+  CHECK (problem IN ('missing_field', 'unparsed_timestamp', 'non_message_iteration'))
+) STRICT;
+
+CREATE INDEX line_problems_line ON line_problems (raw_line_id);

package/core/schema/004_requests_dedup.sql

@@ -0,0 +1,50 @@
+-- 004_requests_dedup: the deduplicated request set, as a view over derived rows (D-001).
+--
+-- One API response is written as several cumulative log lines. Each dedup key keeps one winner:
+-- largest output_tokens, then the non-sidechain copy, then the later line in (file, first run, line)
+-- order. Unkeyed requests (neither message.id nor requestId) pass through as themselves.
+-- Rows carry their source position so every number built on this view can be traced to a line.
+
+-- Observed: one row per distinct API response (winners) plus every unkeyed request line.
+CREATE VIEW requests_dedup AS
+WITH ranked AS (
+  SELECT
+    r.raw_line_id,
+    r.dedup_key,
+    r.message_id,
+    r.request_id,
+    r.model,
+    r.input_tokens,
+    r.output_tokens,
+    r.cache_read_tokens,
+    r.cache_write_5m_tokens,
+    r.cache_write_1h_tokens,
+    r.cache_write_unsplit_tokens,
+    r.speed,
+    p.session_id,
+    p.timestamp_raw,
+    p.timestamp_utc,
+    p.cwd,
+    p.is_sidechain,
+    f.root,
+    f.relative_path,
+    l.first_run_id,
+    l.line_number,
+    ROW_NUMBER() OVER (
+      PARTITION BY r.dedup_key
+      ORDER BY r.output_tokens DESC, p.is_sidechain ASC,
+               f.root DESC, f.relative_path DESC, l.first_run_id DESC, l.line_number DESC
+    ) AS candidate_rank
+  FROM requests r
+  JOIN parsed_lines p ON p.raw_line_id = r.raw_line_id
+  JOIN raw_lines l ON l.id = r.raw_line_id
+  JOIN source_files f ON f.id = l.source_file_id
+)
+SELECT
+  raw_line_id, dedup_key, message_id, request_id, model,
+  input_tokens, output_tokens, cache_read_tokens,
+  cache_write_5m_tokens, cache_write_1h_tokens, cache_write_unsplit_tokens, speed,
+  session_id, timestamp_raw, timestamp_utc, cwd, is_sidechain,
+  root, relative_path, first_run_id, line_number
+FROM ranked
+WHERE dedup_key IS NULL OR candidate_rank = 1;

package/core/schema/005_repositories.sql

@@ -0,0 +1,25 @@
+-- 005_repositories: which repository each working directory belongs to (D-010).
+--
+-- Filled by core/ingest/attribution.ts, once per distinct cwd, using git's common directory, so
+-- worktrees and subdirectories of one repository share a repo_root. Unlike the derived tables in
+-- 003, this depends on the filesystem at resolution time (a directory can disappear later), so it
+-- is a cache and is not part of the rebuild-identical set.
+
+CREATE TABLE repositories (
+  cwd         TEXT PRIMARY KEY, -- source: cwd from log lines
+  kind        TEXT NOT NULL,    -- derived: 'repo', 'not_git' (git found no repository), or 'missing' (path gone)
+  repo_root   TEXT,             -- derived: parent of git's common dir (the dir itself for bare repos); NULL unless kind = 'repo'
+  resolved_at TEXT NOT NULL,    -- derived: ISO-8601 UTC time of resolution
+  CHECK (kind IN ('repo', 'not_git', 'missing')),
+  CHECK ((kind = 'repo') = (repo_root IS NOT NULL))
+) STRICT;
+
+-- Observed: each request's repository, or its working directory when it has none.
+CREATE VIEW request_repositories AS
+SELECT
+  d.raw_line_id,
+  d.cwd,
+  COALESCE(r.kind, 'unresolved') AS repo_kind,
+  COALESCE(r.repo_root, d.cwd) AS repository
+FROM requests_dedup d
+LEFT JOIN repositories r ON r.cwd = d.cwd;

package/core/schema/006_status_readings.sql

@@ -0,0 +1,33 @@
+-- 006_status_readings: status line readings decoded from the hook's spool (D-008, D-009, D-018).
+--
+-- Spool lines are stored in raw_lines like log lines (source_files.kind = 'spool') and derived
+-- here instead of into parsed_lines. Values are stored as written and flagged, never clamped: an
+-- out-of-range percentage is evidence of a payload problem, not something to repair.
+-- Rebuildable from raw_lines, like the tables in 003.
+
+CREATE TABLE status_readings (
+  raw_line_id     INTEGER PRIMARY KEY REFERENCES raw_lines (id), -- derived: the spool line
+  status          TEXT NOT NULL,    -- derived: 'ok', 'malformed_line', 'malformed_payload_encoding', or 'malformed_payload'
+  captured_at_s   NUMERIC,          -- source: spool captured_at_s (epoch seconds, from the hook's clock)
+  hook_version    NUMERIC,          -- source: spool hook_version
+  session_id      TEXT,             -- source: payload session_id
+  transcript_path TEXT,             -- source: payload transcript_path; links the reading to its session log
+  model_id        TEXT,             -- source: payload model.id
+  cc_version      TEXT,             -- source: payload version (Claude Code version)
+  cost_total_usd  NUMERIC,          -- source: payload cost.total_cost_usd; a cross-check only, never a source (CLAUDE.md)
+  has_rate_limits INTEGER NOT NULL, -- derived: 1 when payload rate_limits is an object
+  CHECK (status IN ('ok', 'malformed_line', 'malformed_payload_encoding', 'malformed_payload')),
+  CHECK (has_rate_limits IN (0, 1))
+);
+
+CREATE TABLE rate_limit_windows (
+  raw_line_id     INTEGER NOT NULL REFERENCES status_readings (raw_line_id), -- derived: the reading
+  window          TEXT NOT NULL,    -- source: key under payload rate_limits, e.g. 'five_hour'
+  used_percentage NUMERIC,          -- source: rate_limits.<window>.used_percentage when it's a number
+  resets_at       NUMERIC,          -- source: rate_limits.<window>.resets_at when it's a number (epoch seconds)
+  validity        TEXT NOT NULL,    -- derived: 'valid' or the first problem found
+  PRIMARY KEY (raw_line_id, window),
+  CHECK (validity IN ('valid', 'invalid_percentage', 'invalid_epoch_in_percentage', 'invalid_resets_at', 'unknown_window'))
+);
+
+CREATE INDEX rate_limit_windows_window ON rate_limit_windows (window, validity);