nilometer 0.0.0-stage → 0.1.0

package/core/schema/020_limit_quota_fields.sql

@@ -0,0 +1,131 @@
+-- 020_limit_quota_fields: a limit hit's window and reset come from quotaLimits when Claude Code writes it (D-067).
+--
+-- D-004 read the window and reset only from the message text, because that was the only place
+-- they existed (Claude Code 2.1.214). By 2.1.281 every limit-hit line also carries a structured
+-- quotaLimits object with rateLimitType and resetsAt (observed 2026-09-24; they agreed with the
+-- text on every hit examined). The text parse stays for older lines, and events.window,
+-- events.reset_text, and events.reset_at_utc keep meaning "from the text". The structured values
+-- get their own columns, the views prefer them, and each logged hit says which source its window
+-- and reset came from. Where the two disagree, ingestion records a line problem (report, don't
+-- fix): 'quota_window_disagrees' and 'quota_reset_disagrees'; a member present but unusable is
+-- 'unusable_quota_field'. line_problems is rebuilt to admit those codes, because SQLite can't
+-- change a CHECK constraint in place; it's derived data, and the parser version bump that ships
+-- with this migration re-derives it anyway.
+
+ALTER TABLE events ADD COLUMN quota_window TEXT CHECK (quota_window IN ('five_hour', 'seven_day')); -- source: quotaLimits.rateLimitType when it's 'five_hour' or 'seven_day' (limit hits only, D-067)
+ALTER TABLE events ADD COLUMN quota_resets_at_utc TEXT; -- source: quotaLimits.resetsAt (Unix seconds, whole, 1..253402300799) as ISO-8601 UTC (limit hits only, D-067)
+
+CREATE TABLE line_problems_020 (
+  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', 'non_message_iteration', 'unusable_quota_field', 'quota_window_disagrees', or 'quota_reset_disagrees'
+  detail      TEXT,                -- derived: the field name, raw timestamp JSON, iteration type, quotaLimits member, or both disagreeing values
+  CHECK (problem IN ('missing_field', 'unparsed_timestamp', 'non_message_iteration', 'unusable_quota_field', 'quota_window_disagrees', 'quota_reset_disagrees'))
+) STRICT;
+INSERT INTO line_problems_020 (id, raw_line_id, problem, detail)
+  SELECT id, raw_line_id, problem, detail FROM line_problems;
+DROP TABLE line_problems;
+ALTER TABLE line_problems_020 RENAME TO line_problems;
+CREATE INDEX line_problems_line ON line_problems (raw_line_id);
+
+DROP VIEW logged_limit_hits;
+
+-- Observed: logged limit hits, one per distinct line (copies of a uuid in one session count once), with the D-021 position.
+-- Window and reset prefer quotaLimits over the message text (D-067), and say which one they came from.
+CREATE VIEW logged_limit_hits AS
+WITH copies AS (
+  SELECT
+    p.raw_line_id, p.session_id, p.uuid, p.parent_uuid, p.timestamp_utc, p.is_sidechain,
+    e.window AS text_window, e.quota_window, e.reset_text,
+    e.reset_at_utc AS text_reset_at_utc, e.quota_resets_at_utc,
+    ROW_NUMBER() OVER (
+      -- A line without a uuid is its own group: NULL uuids must not merge with each other.
+      PARTITION BY p.session_id, p.uuid, CASE WHEN p.uuid IS NULL THEN p.raw_line_id END
+      ORDER BY f.root, f.relative_path, l.first_run_id, l.line_number
+    ) AS copy_rank
+  FROM events e
+  JOIN parsed_lines p ON p.raw_line_id = e.raw_line_id
+  JOIN raw_lines l ON l.id = e.raw_line_id
+  JOIN source_files f ON f.id = l.source_file_id
+  WHERE e.class = 'limit_hit'
+)
+SELECT
+  c.raw_line_id, c.session_id, c.uuid, c.parent_uuid, c.timestamp_utc, c.is_sidechain,
+  -- The structured field is exact and doesn't depend on wording; the text is the fallback for
+  -- lines written before Claude Code added quotaLimits.
+  COALESCE(c.quota_window, c.text_window) AS window,
+  c.reset_text,
+  COALESCE(c.quota_resets_at_utc, c.text_reset_at_utc) AS reset_at_utc,
+  COALESCE((
+    SELECT CASE
+      WHEN par.user_content = 'tool_result' THEN 'mid_task'
+      WHEN par.user_content = 'prompt' AND par.is_meta = 0 THEN 'turn_start'
+      ELSE 'unknown'
+    END
+    FROM parsed_lines par
+    JOIN raw_lines pl ON pl.id = par.raw_line_id
+    JOIN source_files pf ON pf.id = pl.source_file_id
+    WHERE par.session_id = c.session_id AND par.uuid = c.parent_uuid
+    ORDER BY pf.root, pf.relative_path, pl.first_run_id, pl.line_number
+    LIMIT 1
+  ), 'unknown') AS position,
+  CASE WHEN c.quota_window IS NOT NULL THEN 'log_field'
+       WHEN c.text_window IS NOT NULL THEN 'log_text' END AS window_source,
+  CASE WHEN c.quota_resets_at_utc IS NOT NULL THEN 'log_field'
+       WHEN c.text_reset_at_utc IS NOT NULL THEN 'log_text' END AS reset_source
+FROM copies c
+WHERE c.copy_rank = 1;
+
+DROP VIEW obs_limit_hits_events;
+
+-- Observed: every rate-limit interruption, logged hits merged with status line groups without double-counting (D-004, D-023).
+CREATE VIEW obs_limit_hits_events AS
+WITH logged AS (
+  SELECT
+    h.*,
+    (SELECT g.raw_line_id FROM status_limit_groups g
+       WHERE (h.window IS NULL OR h.window = g.window)
+         AND unixepoch(h.timestamp_utc, 'subsec') > g.resets_at - g.window_seconds
+         AND unixepoch(h.timestamp_utc, 'subsec') <= g.resets_at
+       ORDER BY g.resets_at, g.window
+       LIMIT 1) AS status_raw_line_id
+  FROM logged_limit_hits h
+),
+merged AS (
+  SELECT
+    'session_log' AS source,
+    l.raw_line_id,
+    l.status_raw_line_id,
+    l.session_id,
+    l.timestamp_utc AS hit_at_utc,
+    COALESCE(l.window, g.window) AS window,
+    -- The payload's resets_at is exact; so is quotaLimits.resetsAt, and reset text has minute precision.
+    COALESCE(g.reset_at_utc, l.reset_at_utc) AS reset_at_utc,
+    CASE WHEN g.raw_line_id IS NOT NULL THEN 'status_line' ELSE l.reset_source END AS reset_source,
+    l.reset_text,
+    l.position,
+    l.is_sidechain
+  FROM logged l
+  LEFT JOIN status_limit_groups g ON g.raw_line_id = l.status_raw_line_id
+  UNION ALL
+  SELECT 'status_line', g.raw_line_id, g.raw_line_id, g.session_id, g.first_at_utc, g.window,
+         g.reset_at_utc, 'status_line', NULL, 'unknown', 0
+  FROM status_limit_groups g
+  WHERE NOT EXISTS (SELECT 1 FROM logged l WHERE l.status_raw_line_id = g.raw_line_id)
+)
+SELECT
+  m.*,
+  (round(unixepoch(m.reset_at_utc, 'subsec') * 1000) - round(unixepoch(m.hit_at_utc, 'subsec') * 1000)) / 1000.0 AS hit_to_reset_seconds,
+  (SELECT MIN(d.timestamp_utc) FROM requests_dedup d
+     WHERE d.session_id = m.session_id AND d.timestamp_utc > m.hit_at_utc) AS next_session_request_at_utc,
+  (SELECT p.timestamp_utc FROM parsed_lines p
+     WHERE p.session_id = m.session_id AND p.user_content = 'prompt' AND p.is_meta = 0
+       AND p.timestamp_utc > m.hit_at_utc
+     ORDER BY p.timestamp_utc, p.raw_line_id LIMIT 1) AS next_session_prompt_at_utc,
+  -- origin.kind as written (D-022): never relabeled as automatic or manual.
+  (SELECT p.origin_kind FROM parsed_lines p
+     WHERE p.session_id = m.session_id AND p.user_content = 'prompt' AND p.is_meta = 0
+       AND p.timestamp_utc > m.hit_at_utc
+     ORDER BY p.timestamp_utc, p.raw_line_id LIMIT 1) AS next_session_prompt_origin_kind,
+  m.reset_at_utc > (SELECT covers_to FROM source_coverage WHERE source = 'session_logs') AS reset_after_coverage
+FROM merged m;

package/core/schema/021_plan_periods.sql

@@ -0,0 +1,121 @@
+-- 021_plan_periods: limit hits, lockouts, and elapsed lockout time per plan period (D-075, step G2.2).
+--
+-- The interruption counts span the whole log history (D-004), so after a plan change one count
+-- mixed two plans: a hit on the plan before an upgrade counted beside hits on the plan after it.
+-- The plan in effect comes from what the user entered with plan-price set (D-027): a plan applies
+-- from the first day of its entered month, in the process's local zone, until the next entry's.
+--
+-- Observed views may not read plan_prices, which holds prices (structure.test.ts). plan_periods
+-- reads only its names and months, and the structure test lets an observed view reach plan_prices
+-- through plan_periods alone, and fails if plan_periods ever reads a price. The counts stay
+-- observations: each hit and lockout is an event, and the plan is a label the user supplied.
+
+-- Helper: each entered plan's months, from its effective month until the next entry's (D-027, D-075).
+CREATE VIEW plan_periods AS
+SELECT
+  effective_month AS from_month, -- source: plan_prices.effective_month, the first local month the plan applies
+  -- derived: the next entry's month, where this plan stops applying (exclusive); NULL while it applies.
+  LEAD(effective_month) OVER (ORDER BY effective_month) AS until_month,
+  plan_name -- source: plan_prices.plan_name, as the user wrote it
+FROM plan_prices;
+
+-- Observed: each limit hit, with the plan period its local month falls in (D-075).
+CREATE VIEW obs_limit_hits_by_plan_events AS
+SELECT
+  e.raw_line_id,
+  e.session_id,
+  e.hit_at_utc,
+  e.window,
+  e.source,
+  -- 'plan' inside an entered plan's months, 'none' before the first entry (or with none at all),
+  -- and 'unknown' for a hit with no time, which no month can place.
+  CASE
+    WHEN e.hit_at_utc IS NULL THEN 'unknown'
+    WHEN p.from_month IS NULL THEN 'none'
+    ELSE 'plan'
+  END AS period_kind,
+  p.from_month,
+  p.until_month,
+  p.plan_name
+FROM obs_limit_hits_events e
+-- Periods never overlap, so a hit matches at most one; months compare as YYYY-MM text.
+LEFT JOIN plan_periods p
+  ON e.hit_at_utc IS NOT NULL
+ AND strftime('%Y-%m', e.hit_at_utc, 'localtime') >= p.from_month
+ AND (p.until_month IS NULL OR strftime('%Y-%m', e.hit_at_utc, 'localtime') < p.until_month);
+
+-- Observed: each lockout interval, with the plan period its first hit falls in (D-075).
+-- An interval crossing a period boundary belongs to the period where it began, so it is never
+-- split or counted twice.
+CREATE VIEW obs_lockout_by_plan_events AS
+SELECT
+  i.*,
+  CASE WHEN p.from_month IS NULL THEN 'none' ELSE 'plan' END AS period_kind,
+  p.from_month,
+  p.until_month,
+  p.plan_name
+FROM obs_lockout_intervals i
+LEFT JOIN plan_periods p
+  ON strftime('%Y-%m', i.locked_from_utc, 'localtime') >= p.from_month
+ AND (p.until_month IS NULL OR strftime('%Y-%m', i.locked_from_utc, 'localtime') < p.until_month);
+
+-- Observed: limit hits, lockouts, and elapsed lockout time per plan period, each with its own span (D-075).
+CREATE VIEW obs_interruptions_by_plan AS
+WITH periods AS (
+  SELECT 'plan' AS period_kind, from_month, until_month, plan_name FROM plan_periods
+  UNION ALL
+  -- Before the first entered plan; with no plan entered, the whole history.
+  SELECT 'none', NULL, (SELECT MIN(from_month) FROM plan_periods), NULL
+  UNION ALL
+  -- Hits with no time: counted, so the rows add up to obs_limit_hits, but in no period.
+  SELECT 'unknown', NULL, NULL, NULL
+),
+-- Materialized: the hit and lockout views are among the costliest on real data (D-059), and every
+-- period reads them.
+hits AS MATERIALIZED (
+  SELECT period_kind, from_month, window, hit_at_utc FROM obs_limit_hits_by_plan_events
+),
+locks AS MATERIALIZED (
+  SELECT period_kind, from_month, lockout_seconds FROM obs_lockout_by_plan_events
+),
+-- What a period's span is drawn from: request times and hit times, each with its local month.
+dated AS MATERIALIZED (
+  SELECT timestamp_utc AS at_utc, strftime('%Y-%m', timestamp_utc, 'localtime') AS month
+  FROM requests_dedup WHERE timestamp_utc IS NOT NULL
+  UNION ALL
+  SELECT hit_at_utc, strftime('%Y-%m', hit_at_utc, 'localtime') FROM hits WHERE hit_at_utc IS NOT NULL
+),
+counted AS (
+  SELECT
+    p.period_kind,
+    p.from_month,
+    -- The last month the plan applies, for display: the month before until_month.
+    CASE WHEN p.until_month IS NOT NULL
+      THEN strftime('%Y-%m', p.until_month || '-01', '-1 month') END AS to_month,
+    p.until_month,
+    p.plan_name,
+    (SELECT COUNT(*) FROM hits h WHERE h.period_kind = p.period_kind AND h.from_month IS p.from_month) AS hits,
+    (SELECT COUNT(*) FROM hits h WHERE h.period_kind = p.period_kind AND h.from_month IS p.from_month
+       AND h.window = 'five_hour') AS five_hour_hits,
+    (SELECT COUNT(*) FROM hits h WHERE h.period_kind = p.period_kind AND h.from_month IS p.from_month
+       AND h.window = 'seven_day') AS seven_day_hits,
+    (SELECT COUNT(*) FROM hits h WHERE h.period_kind = p.period_kind AND h.from_month IS p.from_month
+       AND h.window IS NULL) AS unknown_window_hits,
+    (SELECT COUNT(*) FROM locks l WHERE l.period_kind = p.period_kind AND l.from_month IS p.from_month) AS lockouts,
+    -- TOTAL, as obs_lockout_time totals intervals: 0 over none.
+    (SELECT TOTAL(l.lockout_seconds) FROM locks l
+       WHERE l.period_kind = p.period_kind AND l.from_month IS p.from_month) AS lockout_seconds,
+    -- The span the period's data covers, from what is in it (principle 5); none for 'unknown'.
+    (SELECT MIN(d.at_utc) FROM dated d WHERE p.period_kind <> 'unknown'
+       AND (p.from_month IS NULL OR d.month >= p.from_month)
+       AND (p.until_month IS NULL OR d.month < p.until_month)) AS covers_from,
+    (SELECT MAX(d.at_utc) FROM dated d WHERE p.period_kind <> 'unknown'
+       AND (p.from_month IS NULL OR d.month >= p.from_month)
+       AND (p.until_month IS NULL OR d.month < p.until_month)) AS covers_to
+  FROM periods p
+)
+SELECT *
+FROM counted
+-- A period appears when it holds a hit or any dated data; an entry for a month with no data, or
+-- a plan entered for the future, has nothing to report.
+WHERE hits > 0 OR covers_from IS NOT NULL;

package/core/schema/022_attachment_walk.sql

@@ -0,0 +1,223 @@
+-- 022_attachment_walk: a limit hit's position looks past attachment lines of known metadata types (D-076, step G2.3).
+--
+-- D-021 decides a hit's position by its direct parent: a tool result means the model was inside
+-- its own loop (mid-task), a non-meta prompt means a turn had just started, anything else is
+-- unknown. Newer Claude Code versions write attachment lines between a request and what it
+-- answered: token reminders, environment and memory context, hook output, and the like. By the
+-- end of Phase 8 the direct parent of 24 of 31 hits was such a line, so "unknown" held most hits.
+--
+-- The walk follows a hit's parent chain past attachment lines whose type is classified as
+-- metadata Claude Code adds by itself, and decides the position by D-021's rule at the first line
+-- that isn't one. attachment_walk lists every type seen in real logs on 2026-10-13, classified by
+-- its keys only (no values). A type not listed stops the walk, so a type a future Claude Code
+-- adds can only leave a hit unknown; it can never move one to mid-task.
+
+-- Reference: which attachment types the position walk passes (D-076). Seeded here, not derived.
+CREATE TABLE attachment_walk (
+  attachment_type TEXT PRIMARY KEY, -- source: attachment.type, as written in session logs (classified by structure, D-076)
+  rule            TEXT NOT NULL,    -- source: D-076: 'pass' walks past it; 'by_fields' passes it only when its own fields say it's automatic
+  CHECK (rule IN ('pass', 'by_fields'))
+) STRICT;
+
+INSERT INTO attachment_walk (attachment_type, rule) VALUES
+  -- Reminders Claude Code adds.
+  ('total_tokens_reminder', 'pass'),
+  ('batching_reminder_sent', 'pass'),
+  ('silent_turn_reminder', 'pass'),
+  ('todo_reminder', 'pass'),
+  ('task_reminder', 'pass'),
+  ('plan_mode', 'pass'),
+  -- Session context.
+  ('environment', 'pass'),
+  ('date', 'pass'),
+  ('date_change', 'pass'),
+  ('model', 'pass'),
+  ('session_context', 'pass'),
+  ('instructions', 'pass'),
+  ('nested_memory', 'pass'),
+  ('credential_org', 'pass'),
+  ('auto_mode', 'pass'),
+  ('command_permissions', 'pass'),
+  ('remote_session_change', 'pass'),
+  ('prompt_snapshot', 'pass'),
+  -- Tool and skill listings.
+  ('deferred_tools_record', 'pass'),
+  ('deferred_tools_delta', 'pass'),
+  ('mcp_instructions_delta', 'pass'),
+  ('skill_listing', 'pass'),
+  ('agent_listing_delta', 'pass'),
+  ('invoked_skills', 'pass'),
+  -- Notes on a tool call; the walk continues to the tool result they annotate.
+  ('hook_success', 'pass'),
+  ('hook_system_message', 'pass'),
+  ('hook_additional_context', 'pass'),
+  ('bash_output_audience_note', 'pass'),
+  ('read_truncation_notice', 'pass'),
+  ('structured_output', 'pass'),
+  -- Notes on files and thinking.
+  ('edited_text_file', 'pass'),
+  ('compact_file_reference', 'pass'),
+  ('thinking_drop', 'pass'),
+  ('thinking_stripped', 'pass'),
+  -- Carried with a prompt or a tool result; the walk continues to the line they belong to.
+  ('file', 'pass'),
+  ('plan_mode_exit', 'pass'),
+  -- A message delivered into a running loop: automatic when it's a task notification (247 of 271
+  -- on real data); a human or peer message is input, so it stops the walk.
+  ('queued_command', 'by_fields');
+
+DROP VIEW logged_limit_hits;
+
+-- Observed: logged limit hits, one per distinct line (copies of a uuid in one session count once), with the
+-- D-021 position decided past metadata attachment lines (D-076). Window and reset prefer quotaLimits (D-067).
+CREATE VIEW logged_limit_hits AS
+WITH RECURSIVE copies AS (
+  SELECT
+    p.raw_line_id, p.session_id, p.uuid, p.parent_uuid, p.timestamp_utc, p.is_sidechain,
+    e.window AS text_window, e.quota_window, e.reset_text,
+    e.reset_at_utc AS text_reset_at_utc, e.quota_resets_at_utc,
+    ROW_NUMBER() OVER (
+      -- A line without a uuid is its own group: NULL uuids must not merge with each other.
+      PARTITION BY p.session_id, p.uuid, CASE WHEN p.uuid IS NULL THEN p.raw_line_id END
+      ORDER BY f.root, f.relative_path, l.first_run_id, l.line_number
+    ) AS copy_rank
+  FROM events e
+  JOIN parsed_lines p ON p.raw_line_id = e.raw_line_id
+  JOIN raw_lines l ON l.id = e.raw_line_id
+  JOIN source_files f ON f.id = l.source_file_id
+  WHERE e.class = 'limit_hit'
+),
+firsts AS (
+  SELECT * FROM copies WHERE copy_rank = 1
+),
+-- Each hit's parent chain. A step finds its line as D-021 did: the first copy, in canonical
+-- order, of the parent uuid in the hit's session. The walk takes another step only past an
+-- attachment that attachment_walk passes; 50 steps is far past any chain seen (8), and stops a
+-- loop of uuids, which nothing guarantees can't occur.
+walk (raw_line_id, session_id, line_id, passed) AS (
+  SELECT
+    h.raw_line_id,
+    h.session_id,
+    (SELECT par.raw_line_id FROM parsed_lines par
+       JOIN raw_lines pl ON pl.id = par.raw_line_id
+       JOIN source_files pf ON pf.id = pl.source_file_id
+       WHERE par.session_id = h.session_id AND par.uuid = h.parent_uuid
+       ORDER BY pf.root, pf.relative_path, pl.first_run_id, pl.line_number
+       LIMIT 1),
+    0
+  FROM firsts h
+  UNION ALL
+  SELECT
+    w.raw_line_id,
+    w.session_id,
+    (SELECT par.raw_line_id FROM parsed_lines par
+       JOIN raw_lines pl ON pl.id = par.raw_line_id
+       JOIN source_files pf ON pf.id = pl.source_file_id
+       WHERE par.session_id = w.session_id AND par.uuid = cur.parent_uuid
+       ORDER BY pf.root, pf.relative_path, pl.first_run_id, pl.line_number
+       LIMIT 1),
+    w.passed + 1
+  FROM walk w
+  JOIN parsed_lines cur ON cur.raw_line_id = w.line_id
+  JOIN raw_lines cb ON cb.id = cur.raw_line_id
+  -- The attachment's type is read from its raw bytes: parsed_lines doesn't keep it, and only the
+  -- few lines on a hit's chain are read this way.
+  JOIN attachment_walk aw
+    ON aw.attachment_type = json_extract(CAST(cb.bytes AS TEXT), '$.attachment.type')
+  WHERE cur.type = 'attachment'
+    AND (aw.rule = 'pass'
+         OR json_extract(CAST(cb.bytes AS TEXT), '$.attachment.commandMode') = 'task-notification')
+    AND w.passed < 50
+),
+-- Where each walk stopped: its last step.
+ends AS (
+  SELECT raw_line_id, line_id, passed
+  FROM (
+    SELECT w.*, ROW_NUMBER() OVER (PARTITION BY w.raw_line_id ORDER BY w.passed DESC) AS step_rank
+    FROM walk w
+  )
+  WHERE step_rank = 1
+)
+SELECT
+  c.raw_line_id, c.session_id, c.uuid, c.parent_uuid, c.timestamp_utc, c.is_sidechain,
+  -- The structured field is exact and doesn't depend on wording; the text is the fallback for
+  -- lines written before Claude Code added quotaLimits.
+  COALESCE(c.quota_window, c.text_window) AS window,
+  c.reset_text,
+  COALESCE(c.quota_resets_at_utc, c.text_reset_at_utc) AS reset_at_utc,
+  -- D-021's rule, at the line the walk stopped on. A missing parent, a meta line, another type, or
+  -- an attachment the walk doesn't pass all leave the position unknown.
+  COALESCE((
+    SELECT CASE
+      WHEN par.user_content = 'tool_result' THEN 'mid_task'
+      WHEN par.user_content = 'prompt' AND par.is_meta = 0 THEN 'turn_start'
+      ELSE 'unknown'
+    END
+    FROM parsed_lines par
+    WHERE par.raw_line_id = e.line_id
+  ), 'unknown') AS position,
+  -- How many attachment lines the walk passed to decide it (D-076): 0 is D-021's direct parent.
+  e.passed AS attachments_passed,
+  CASE WHEN c.quota_window IS NOT NULL THEN 'log_field'
+       WHEN c.text_window IS NOT NULL THEN 'log_text' END AS window_source,
+  CASE WHEN c.quota_resets_at_utc IS NOT NULL THEN 'log_field'
+       WHEN c.text_reset_at_utc IS NOT NULL THEN 'log_text' END AS reset_source
+FROM firsts c
+JOIN ends e ON e.raw_line_id = c.raw_line_id;
+
+DROP VIEW obs_limit_hits_events;
+
+-- Observed: every rate-limit interruption, logged hits merged with status line groups without double-counting
+-- (D-004, D-023), each with the attachment lines its position looked past (D-076).
+CREATE VIEW obs_limit_hits_events AS
+WITH logged AS (
+  SELECT
+    h.*,
+    (SELECT g.raw_line_id FROM status_limit_groups g
+       WHERE (h.window IS NULL OR h.window = g.window)
+         AND unixepoch(h.timestamp_utc, 'subsec') > g.resets_at - g.window_seconds
+         AND unixepoch(h.timestamp_utc, 'subsec') <= g.resets_at
+       ORDER BY g.resets_at, g.window
+       LIMIT 1) AS status_raw_line_id
+  FROM logged_limit_hits h
+),
+merged AS (
+  SELECT
+    'session_log' AS source,
+    l.raw_line_id,
+    l.status_raw_line_id,
+    l.session_id,
+    l.timestamp_utc AS hit_at_utc,
+    COALESCE(l.window, g.window) AS window,
+    -- The payload's resets_at is exact; so is quotaLimits.resetsAt, and reset text has minute precision.
+    COALESCE(g.reset_at_utc, l.reset_at_utc) AS reset_at_utc,
+    CASE WHEN g.raw_line_id IS NOT NULL THEN 'status_line' ELSE l.reset_source END AS reset_source,
+    l.reset_text,
+    l.position,
+    l.is_sidechain,
+    l.attachments_passed
+  FROM logged l
+  LEFT JOIN status_limit_groups g ON g.raw_line_id = l.status_raw_line_id
+  UNION ALL
+  -- A hit seen only in the status line has no parent to walk: unknown, past nothing.
+  SELECT 'status_line', g.raw_line_id, g.raw_line_id, g.session_id, g.first_at_utc, g.window,
+         g.reset_at_utc, 'status_line', NULL, 'unknown', 0, 0
+  FROM status_limit_groups g
+  WHERE NOT EXISTS (SELECT 1 FROM logged l WHERE l.status_raw_line_id = g.raw_line_id)
+)
+SELECT
+  m.*,
+  (round(unixepoch(m.reset_at_utc, 'subsec') * 1000) - round(unixepoch(m.hit_at_utc, 'subsec') * 1000)) / 1000.0 AS hit_to_reset_seconds,
+  (SELECT MIN(d.timestamp_utc) FROM requests_dedup d
+     WHERE d.session_id = m.session_id AND d.timestamp_utc > m.hit_at_utc) AS next_session_request_at_utc,
+  (SELECT p.timestamp_utc FROM parsed_lines p
+     WHERE p.session_id = m.session_id AND p.user_content = 'prompt' AND p.is_meta = 0
+       AND p.timestamp_utc > m.hit_at_utc
+     ORDER BY p.timestamp_utc, p.raw_line_id LIMIT 1) AS next_session_prompt_at_utc,
+  -- origin.kind as written (D-022): never relabeled as automatic or manual.
+  (SELECT p.origin_kind FROM parsed_lines p
+     WHERE p.session_id = m.session_id AND p.user_content = 'prompt' AND p.is_meta = 0
+       AND p.timestamp_utc > m.hit_at_utc
+     ORDER BY p.timestamp_utc, p.raw_line_id LIMIT 1) AS next_session_prompt_origin_kind,
+  m.reset_at_utc > (SELECT covers_to FROM source_coverage WHERE source = 'session_logs') AS reset_after_coverage
+FROM merged m;

package/core/schema/023_auto_continuations.sql

@@ -0,0 +1,129 @@
+-- 023_auto_continuations: Claude Code's own resumption after a lockout is shown where it was logged (D-077, step G2.4).
+--
+-- After a limit's window resets, Claude Code continues a stopped session by itself and marks it:
+-- a user line with isMeta true and origin.kind "auto-continuation" (D-022, observed from 2.1.281).
+-- The report said only "reset to next Claude Code request", which doesn't say who continued.
+-- Only the logged marker earns the label; nothing is inferred from timing (D-022), so a workflow
+-- restarting its subagents, which writes no marker, stays unlabeled.
+--
+-- A marker belongs to the latest logged limit hit before it in its own session, and through that
+-- hit to the hit's lockout interval (D-023). A marker with no earlier hit in its session, or whose
+-- hit has no known reset and so no interval, follows no lockout and isn't counted.
+--
+-- Cost: the lockout views are read by several metrics, and the merged hit views behind them are
+-- the costliest on real data (D-059). So the markers and their hits are found from the raw lines
+-- (auto_continuation_marks), and each view computes interval membership once.
+
+-- Helper: each logged auto-continuation, once per line, with the latest logged limit hit before it in its session (D-077).
+CREATE VIEW auto_continuation_marks AS
+WITH marks AS (
+  SELECT
+    p.raw_line_id, p.session_id, p.timestamp_utc,
+    -- Copies of one line (a uuid written twice in a session) count once, as limit hits do.
+    ROW_NUMBER() OVER (
+      PARTITION BY p.session_id, p.uuid, CASE WHEN p.uuid IS NULL THEN p.raw_line_id END
+      ORDER BY f.root, f.relative_path, l.first_run_id, l.line_number
+    ) AS copy_rank
+  FROM parsed_lines p
+  JOIN raw_lines l ON l.id = p.raw_line_id
+  JOIN source_files f ON f.id = l.source_file_id
+  WHERE p.origin_kind = 'auto-continuation' AND p.is_meta = 1 AND p.timestamp_utc IS NOT NULL
+),
+-- The logged limit-hit lines, one per distinct line, chosen as logged_limit_hits chooses them.
+hit_lines AS MATERIALIZED (
+  SELECT raw_line_id, session_id, timestamp_utc
+  FROM (
+    SELECT
+      p.raw_line_id, p.session_id, p.timestamp_utc,
+      ROW_NUMBER() OVER (
+        PARTITION BY p.session_id, p.uuid, CASE WHEN p.uuid IS NULL THEN p.raw_line_id END
+        ORDER BY f.root, f.relative_path, l.first_run_id, l.line_number
+      ) AS copy_rank
+    FROM events e
+    JOIN parsed_lines p ON p.raw_line_id = e.raw_line_id
+    JOIN raw_lines l ON l.id = e.raw_line_id
+    JOIN source_files f ON f.id = l.source_file_id
+    WHERE e.class = 'limit_hit'
+  )
+  WHERE copy_rank = 1
+)
+SELECT
+  m.raw_line_id,                       -- source: the marker line
+  m.session_id,                        -- source: its sessionId
+  m.timestamp_utc AS continued_at_utc, -- source: its timestamp
+  (SELECT h.raw_line_id FROM hit_lines h
+     WHERE h.session_id = m.session_id AND h.timestamp_utc < m.timestamp_utc
+     ORDER BY h.timestamp_utc DESC, h.raw_line_id DESC
+     LIMIT 1) AS hit_raw_line_id       -- derived: the latest logged hit before it in the session
+FROM marks m
+WHERE m.copy_rank = 1;
+
+DROP VIEW obs_lockout_intervals;
+
+-- Observed: merged lockout intervals, hit → reset, with the first Claude Code request at or after each reset (D-023),
+-- and the sessions Claude Code itself resumed after it, as logged (D-077).
+CREATE VIEW obs_lockout_intervals AS
+WITH interval_hits AS MATERIALIZED (
+  -- Computed once for everything below: interval membership is the costly part.
+  SELECT raw_line_id, start_utc, end_utc, interval_number FROM obs_lockout_interval_hits
+),
+grouped AS (
+  SELECT
+    interval_number,
+    MIN(start_utc) AS locked_from_utc,
+    MAX(end_utc) AS locked_until_utc,
+    COUNT(*) AS hits
+  FROM interval_hits
+  GROUP BY interval_number
+),
+with_next AS (
+  SELECT
+    g.*,
+    (SELECT MIN(d.timestamp_utc) FROM requests_dedup d WHERE d.timestamp_utc >= g.locked_until_utc) AS next_request_at_utc
+  FROM grouped g
+),
+resumed AS (
+  SELECT
+    h.interval_number,
+    COUNT(*) AS auto_continuations,
+    MIN((round(unixepoch(m.continued_at_utc, 'subsec') * 1000) - round(unixepoch(g.locked_until_utc, 'subsec') * 1000)) / 1000.0)
+      AS first_seconds
+  FROM auto_continuation_marks m
+  JOIN interval_hits h ON h.raw_line_id = m.hit_raw_line_id
+  JOIN grouped g ON g.interval_number = h.interval_number
+  GROUP BY h.interval_number
+)
+SELECT
+  w.*,
+  (round(unixepoch(w.locked_until_utc, 'subsec') * 1000) - round(unixepoch(w.locked_from_utc, 'subsec') * 1000)) / 1000.0 AS lockout_seconds,
+  (round(unixepoch(w.next_request_at_utc, 'subsec') * 1000) - round(unixepoch(w.locked_until_utc, 'subsec') * 1000)) / 1000.0 AS reset_to_next_request_seconds,
+  w.locked_until_utc > (SELECT covers_to FROM source_coverage WHERE source = 'session_logs') AS reset_after_coverage,
+  -- How many sessions Claude Code resumed by itself after this reset, as logged; 0 when none.
+  COALESCE(r.auto_continuations, 0) AS auto_continuations,
+  -- The earliest of those, seconds after the reset; NULL when none.
+  r.first_seconds AS first_auto_continuation_seconds
+FROM with_next w
+LEFT JOIN resumed r ON r.interval_number = w.interval_number;
+
+-- Observed: each logged auto-continuation that followed a lockout, with its interval and how long after the reset (D-077).
+CREATE VIEW obs_auto_continuation_events AS
+WITH interval_hits AS MATERIALIZED (
+  SELECT raw_line_id, end_utc, interval_number FROM obs_lockout_interval_hits
+),
+resets AS (
+  -- Each interval's reset as obs_lockout_intervals takes it: the latest end of its hits' spans.
+  SELECT interval_number, MAX(end_utc) AS locked_until_utc FROM interval_hits GROUP BY interval_number
+)
+SELECT
+  m.raw_line_id,
+  m.session_id,
+  m.continued_at_utc,
+  m.hit_raw_line_id,
+  h.interval_number,
+  r.locked_until_utc,
+  -- As written: a marker logged before the reset would show a negative time (none observed).
+  (round(unixepoch(m.continued_at_utc, 'subsec') * 1000) - round(unixepoch(r.locked_until_utc, 'subsec') * 1000)) / 1000.0
+    AS seconds_after_reset
+FROM auto_continuation_marks m
+JOIN interval_hits h ON h.raw_line_id = m.hit_raw_line_id
+JOIN resets r ON r.interval_number = h.interval_number;

package/core/schema/024_counted_limit_groups.sql

@@ -0,0 +1,29 @@
+-- 024_counted_limit_groups: a status-line-only limit hit starts from a counted reading (D-078, step G2.6).
+--
+-- status_limit_groups took every reading at or over 100%, including readings observed after their
+-- own window's reset (the payload lag D-024 describes: a session's reading repeats its last
+-- response until it makes another request). A group whose first at-limit reading came after the
+-- reset drew a lockout of 0 s, from a hit to a reset it had already passed. Every other window
+-- metric counts only readings before the reset (after_reset = 0); this view now does too.
+
+DROP VIEW status_limit_groups;
+
+-- Observed: status line windows observed at 100%, one row per (window, resets_at), from init onward, counting only
+-- readings before the window's reset (D-023, D-044, D-078).
+CREATE VIEW status_limit_groups AS
+WITH at_limit AS (
+  SELECT
+    r.raw_line_id, r.window, r.resets_at, r.session_id, r.observed_at_utc,
+    ROW_NUMBER() OVER (PARTITION BY r.window, r.resets_at ORDER BY r.observed_at_s, r.raw_line_id) AS reading_rank,
+    COUNT(*) OVER (PARTITION BY r.window, r.resets_at) AS readings_at_limit
+  FROM window_readings r
+  -- A reading after its reset belongs to no window (D-024), so it can't show that window at its limit.
+  WHERE r.used_percentage >= 100 AND r.after_reset = 0
+)
+SELECT
+  raw_line_id, window, resets_at, session_id, readings_at_limit,
+  observed_at_utc AS first_at_utc,
+  strftime('%Y-%m-%dT%H:%M:%fZ', resets_at, 'unixepoch') AS reset_at_utc,
+  CASE window WHEN 'five_hour' THEN 5 * 3600 ELSE 7 * 86400 END AS window_seconds
+FROM at_limit
+WHERE reading_rank = 1;