agentwrangler 0.1.0

package/dist/daemon/static.js

@@ -0,0 +1,146 @@
+/**
+ * src/daemon/static.ts — hardened static file serving for the built SPA.
+ *
+ * Security properties:
+ *
+ * 1. safeResolve(root, input): the single choke-point for any request-derived
+ *    filesystem path. Defends against:
+ *    - Path traversal (../../, URL-encoded, double-encoded).
+ *    - Null-byte injection.
+ *    - Absolute paths (Unix / and Windows drive letters).
+ *    - UNC paths (\\server\share, //server/share).
+ *    - Symlinks that escape root (checked via realpathSync).
+ *    - Sibling-prefix attacks (<root>-evil/...) — blocked by the `root + sep`
+ *      prefix check after realpathSync.
+ *
+ * 2. sirv with dotfiles:false blocks .env and other dotfiles.
+ *
+ * 3. The static handler is only mounted when uiRoot exists; it is not exposed
+ *    unless the SPA has been built.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import sirv from "sirv";
+/**
+ * Resolve `input` (from a request URL segment) safely within `root`.
+ *
+ * Returns the absolute, real path if it is within `root`, or `null` if:
+ * - `input` contains a null byte.
+ * - `input` is or resolves to an absolute path.
+ * - `input` is a UNC path.
+ * - The real path after symlink resolution escapes `root`.
+ *
+ * The URL-decode loop handles single-, double-, and triple-encoded sequences.
+ */
+export function safeResolve(root, input) {
+    // 1. URL-decode loop until stable (handles %25-encoding, etc.).
+    let decoded = input;
+    for (let i = 0; i < 16; i++) {
+        let next;
+        try {
+            next = decodeURIComponent(decoded);
+        }
+        catch {
+            // Malformed percent-encoding — reject.
+            return null;
+        }
+        if (next === decoded)
+            break;
+        decoded = next;
+    }
+    // 2. Reject null bytes (bypass attempts via null-byte injection).
+    if (decoded.includes("\0"))
+        return null;
+    // 3. Reject UNC paths (\\server\share or //server/share).
+    if (decoded.startsWith("\\\\") || decoded.startsWith("//"))
+        return null;
+    // 4. Reject Windows drive letters (C:\, D:/, etc.).
+    if (/^[a-zA-Z]:/.test(decoded))
+        return null;
+    // 5. Reject absolute Unix paths.
+    if (path.isAbsolute(decoded))
+        return null;
+    // 6. Resolve relative to root.
+    const resolved = path.resolve(root, decoded);
+    // 7. RealpathSync: follow symlinks and get the canonical path.
+    //    For non-existent paths (ENOENT/ENOTDIR), no symlink can exist, so
+    //    the path.resolve result is already canonical — fall through with it.
+    //    This lets createStaticHandler pass unknown paths to sirv's single:true
+    //    SPA fallback (serving index.html) rather than returning a spurious 404.
+    let realResolved;
+    try {
+        realResolved = fs.realpathSync(resolved);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT" && code !== "ENOTDIR") {
+            // Inaccessible for reasons other than "doesn't exist" — reject.
+            return null;
+        }
+        // File does not exist; use the path.resolve result for the prefix check.
+        realResolved = resolved;
+    }
+    // 8. Get the canonical root path (once; callers may cache this).
+    let realRoot;
+    try {
+        realRoot = fs.realpathSync(root);
+    }
+    catch {
+        return null;
+    }
+    // 9. Guard: real path must be root itself or begin with root + separator.
+    //    The `+ sep` prevents sibling-prefix attacks: /var/www/app vs /var/www/app-evil.
+    if (realResolved !== realRoot && !realResolved.startsWith(realRoot + path.sep)) {
+        return null;
+    }
+    return realResolved;
+}
+/**
+ * Create a sirv-based static file handler for `uiRoot`.
+ *
+ * sirv is configured with:
+ *   - dotfiles: false — blocks .env and other hidden files.
+ *   - dev: false — production mode (ETags, caching headers).
+ *   - single: true — falls back to index.html for SPA client-side routing.
+ *
+ * The returned function is a Node HTTP middleware: (req, res, next) => void.
+ * Call `next()` when sirv cannot serve the path (404 fallback in http.ts).
+ */
+export function createStaticHandler(uiRoot) {
+    // Verify root exists before constructing the handler.
+    if (!fs.existsSync(uiRoot)) {
+        // Return a no-op that always calls next — UI not built yet.
+        return (_req, _res, next) => next();
+    }
+    const serve = sirv(uiRoot, {
+        dotfiles: false,
+        dev: false,
+        single: true, // SPA: fall back to index.html on 404.
+        etag: true,
+    });
+    return (req, res, next) => {
+        // Intercept the path for an extra safety check before handing off to sirv.
+        const rawPath = (req.url ?? "/").split("?")[0] ?? "/";
+        // Strip leading slash for safeResolve (it expects a relative input).
+        const relative = rawPath.startsWith("/") ? rawPath.slice(1) : rawPath;
+        if (relative.length > 0) {
+            // Block dotfiles explicitly (sirv's single: true would otherwise fall
+            // back to index.html instead of 404 for paths like /.env).
+            const segments = relative.split(/[/\\]/);
+            if (segments.some((seg) => seg.length > 0 && seg.startsWith("."))) {
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("404 Not Found");
+                return;
+            }
+            const safe = safeResolve(uiRoot, relative);
+            if (safe === null) {
+                // Traversal or other rejection — short-circuit with 404.
+                res.writeHead(404, { "Content-Type": "text/plain" });
+                res.end("404 Not Found");
+                return;
+            }
+        }
+        // Path is within root — hand off to sirv.
+        serve(req, res, next);
+    };
+}

package/dist/db/migrate.js

@@ -0,0 +1,72 @@
+/**
+ * src/db/migrate.ts — migration runner for AgentWrangler.
+ *
+ * Discovers SQL migration files in `src/db/migrations/` ordered by filename,
+ * records each applied migration in the `schema_migrations` table, and is
+ * idempotent: re-running applies nothing if all migrations are already recorded.
+ *
+ * Convention: migration filenames must be `NNN_<slug>.sql` (e.g. `001_observe.sql`).
+ * The version key stored is the bare filename without the `.sql` extension.
+ *
+ * Boot-strapping note: schema_migrations is created by 001_observe.sql itself.
+ * The runner checks sqlite_master directly to determine whether schema_migrations
+ * already exists, avoiding the circular dependency of creating it first.
+ *
+ * Each migration is applied in its own transaction. If a migration fails, the
+ * transaction rolls back and the error propagates — leaving the DB at the last
+ * successfully applied migration.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MIGRATIONS_DIR = path.join(__dirname, "migrations");
+/** Return true if the schema_migrations table exists in the DB. */
+function migrationsTableExists(db) {
+    const row = db
+        .prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='schema_migrations'")
+        .get();
+    return row !== undefined;
+}
+/** Return the set of already-applied migration versions. */
+function appliedVersions(db) {
+    const rows = db.prepare("SELECT version FROM schema_migrations").all();
+    return new Set(rows.map((r) => r.version));
+}
+/** Discover migration files, sorted lexicographically (ascending). */
+function discoverMigrations() {
+    const files = fs
+        .readdirSync(MIGRATIONS_DIR)
+        .filter((f) => f.endsWith(".sql"))
+        .sort();
+    return files.map((f) => ({
+        version: f.slice(0, -4), // strip .sql
+        filePath: path.join(MIGRATIONS_DIR, f),
+    }));
+}
+/**
+ * Run pending migrations against `db`, optionally stopping at `throughVersion`.
+ * Returns the list of newly-applied version strings (empty when already up-to-date).
+ *
+ * The first migration (001_observe.sql) is responsible for creating the
+ * schema_migrations table. Subsequent calls find the table already present.
+ */
+export function runMigrations(db, throughVersion) {
+    // Determine which migrations have already been applied (if the bookkeeping
+    // table exists) or treat the list as empty (first ever run).
+    const hasTable = migrationsTableExists(db);
+    const applied = hasTable ? appliedVersions(db) : new Set();
+    const pending = discoverMigrations().filter((m) => !applied.has(m.version) && (throughVersion === undefined || m.version <= throughVersion));
+    const applied_now = [];
+    for (const { version, filePath } of pending) {
+        const sql = fs.readFileSync(filePath, "utf-8");
+        // Run the migration SQL + record the version atomically.
+        db.transaction(() => {
+            db.exec(sql);
+            // schema_migrations must now exist (created by the SQL if it wasn't before).
+            db.prepare("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)").run(version, new Date().toISOString());
+        })();
+        applied_now.push(version);
+    }
+    return applied_now;
+}

package/dist/db/migrations/001_observe.sql

@@ -0,0 +1,196 @@
+-- AgentWrangler Data Model v2 DDL — verbatim from AgentWrangler_Data_Model_and_Metrics_v2.md §1
+-- metric_definition_version = 'observe-1'
+-- Applied by: src/db/migrate.ts
+
+CREATE TABLE workspaces (
+  workspace_id   TEXT PRIMARY KEY,
+  project_slug   TEXT NOT NULL UNIQUE,          -- ~/.claude/projects/<slug>
+  repo_path      TEXT,                          -- local checkout, if registered
+  repo_owner     TEXT, repo_name TEXT,          -- canonical GitHub identity
+  registered_at  TEXT NOT NULL
+);
+
+CREATE TABLE sessions (
+  session_id     TEXT PRIMARY KEY,              -- sessionId or filename stem
+  workspace_id   TEXT NOT NULL REFERENCES workspaces(workspace_id),
+  file_path      TEXT NOT NULL,
+  first_turn_at  TEXT, last_turn_at TEXT,
+  state          TEXT NOT NULL CHECK (state IN ('LIVE','RECONCILED')),
+  turn_count     INTEGER NOT NULL DEFAULT 0,
+  cost_equiv_u   INTEGER NOT NULL DEFAULT 0,    -- rollforward; reconciled at close
+  hygiene_flags  TEXT NOT NULL DEFAULT '[]'     -- JSON: LONG_FULL_CONTEXT, COMPACT_MID_TASK...
+);
+
+CREATE TABLE turns (                             -- one row per assistant message (deduped)
+  message_id     TEXT PRIMARY KEY,               -- message.id, fallback uuid
+  session_id     TEXT NOT NULL REFERENCES sessions(session_id),
+  workspace_id   TEXT NOT NULL,
+  ts             TEXT NOT NULL,
+  model          TEXT NOT NULL,                  -- '<synthetic>' rows excluded upstream
+  is_sidechain   INTEGER NOT NULL DEFAULT 0,     -- subagent marker
+  input_tokens   INTEGER NOT NULL DEFAULT 0,
+  output_tokens  INTEGER NOT NULL DEFAULT 0,
+  cache_read_tokens   INTEGER NOT NULL DEFAULT 0,
+  cache_write_5m      INTEGER NOT NULL DEFAULT 0,
+  cache_write_1h      INTEGER NOT NULL DEFAULT 0,
+  cache_write_other   INTEGER NOT NULL DEFAULT 0,
+  context_tokens AS (input_tokens + cache_read_tokens
+                     + cache_write_5m + cache_write_1h + cache_write_other) STORED,
+  tool_result_bytes   INTEGER,                   -- SUM over all tool_result blocks in the turn; size only, never content
+  pricing_snapshot_id TEXT REFERENCES pricing_snapshots(snapshot_id),
+  cost_equiv_u   INTEGER,                        -- NULL = unpriceable
+  cost_claim     TEXT NOT NULL DEFAULT 'LIST_EQUIV'
+                 CHECK (cost_claim IN ('LIST_EQUIV','LIST_EQUIV_STALE','BILLED')),
+  provisional    INTEGER NOT NULL DEFAULT 0,
+  effort         TEXT,                               -- extended thinking effort label; nullable, tolerated since 2026-08-14
+  parser_version TEXT NOT NULL
+);
+CREATE INDEX idx_turns_ws_ts ON turns(workspace_id, ts);
+CREATE INDEX idx_turns_session ON turns(session_id, ts);
+CREATE INDEX idx_turns_model ON turns(model, ts);
+
+CREATE TABLE tool_events (                       -- names/sizes/sequence only
+  event_id     TEXT PRIMARY KEY,
+  session_id   TEXT NOT NULL REFERENCES sessions(session_id),
+  ts           TEXT NOT NULL,
+  tool_name    TEXT NOT NULL,
+  input_bytes  INTEGER, result_bytes INTEGER,
+  input_hash   TEXT,                             -- for loop/near-duplicate detection
+  exit_class   TEXT,                             -- OK | ERROR | TEST_FAIL | ...
+  commit_sha   TEXT                              -- harvested when the event exposes one
+);
+CREATE INDEX idx_tool_session ON tool_events(session_id, ts);
+CREATE INDEX idx_tool_sha ON tool_events(commit_sha) WHERE commit_sha IS NOT NULL;
+
+CREATE TABLE pricing_snapshots (
+  snapshot_id TEXT PRIMARY KEY,
+  model_tier  TEXT NOT NULL,                     -- opus|sonnet|haiku|fable...
+  unit_prices_json TEXT NOT NULL,                -- [in, out, cacheRead, cw5m, cw1h] $/MTok
+  captured_at TEXT NOT NULL, stale_after TEXT NOT NULL
+);
+
+CREATE TABLE context_inventory (                  -- always-loaded attribution time series
+  probe_id     TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id),
+  probed_at    TEXT NOT NULL,
+  component    TEXT NOT NULL CHECK (component IN
+               ('CLAUDE_MD','RULES','MCP_SCHEMAS','SETTINGS_SYSTEM','MEMORY','OTHER')),
+  file_ref     TEXT NOT NULL,                    -- path, not content
+  file_hash    TEXT NOT NULL,
+  tokens       INTEGER NOT NULL,
+  attribution_version TEXT NOT NULL
+  -- NOTE (v1 qualification): system-prompt and MCP-schema tokens (~1-3% of context) are NOT
+  -- attributable from local files in v1; the attributed total may undercount (SG-S5-03 / FW-04).
+);
+
+CREATE TABLE work_items (                         -- PRs
+  work_item_id TEXT PRIMARY KEY,                  -- gh:<owner>/<repo>#<number>
+  workspace_id TEXT NOT NULL REFERENCES workspaces(workspace_id),
+  number       INTEGER NOT NULL,
+  state        TEXT NOT NULL,                     -- OPEN|MERGED|CLOSED
+  final_commit TEXT,
+  checks_conclusion TEXT,                         -- SUCCESS|FAILURE|PENDING|NONE
+  opened_at TEXT, merged_at TEXT, closed_at TEXT,
+  synced_at TEXT NOT NULL
+);
+
+CREATE TABLE session_work_links (
+  session_id   TEXT NOT NULL REFERENCES sessions(session_id),
+  work_item_id TEXT NOT NULL REFERENCES work_items(work_item_id),
+  confidence   REAL NOT NULL,                     -- SHA-overlap strength
+  method       TEXT NOT NULL,                     -- SHA_OVERLAP | BRANCH | MANUAL
+  PRIMARY KEY (session_id, work_item_id)
+);
+
+CREATE TABLE observed_outcomes (
+  work_item_id TEXT PRIMARY KEY REFERENCES work_items(work_item_id),
+  outcome      TEXT NOT NULL CHECK (outcome IN
+    ('OBSERVED_SUCCESS','OBSERVED_SUCCESS_WITH_DEFERRALS',
+     'OBSERVED_FAILURE','IN_PROGRESS')),
+  derived_at   TEXT NOT NULL,
+  methodology_version TEXT NOT NULL
+);
+
+CREATE TABLE review_findings (
+  finding_id   TEXT PRIMARY KEY,
+  work_item_id TEXT NOT NULL REFERENCES work_items(work_item_id),
+  source       TEXT NOT NULL CHECK (source IN
+    ('UNRESOLVED_THREAD','DEFERRAL_SECTION','DIFF_MARKER','LLM')),   -- LLM = P0.5 seam
+  severity     TEXT CHECK (severity IN ('HIGH','MEDIUM','LOW','UNKNOWN')),
+  status       TEXT NOT NULL CHECK (status IN ('ADDRESSED','DEFERRED','UNKNOWN')),
+  evidence_ref TEXT NOT NULL,                    -- thread id / body anchor / file:line
+  confidence   REAL,                             -- NULL for deterministic sources
+  human_state  TEXT CHECK (human_state IN ('CONFIRMED','REJECTED')),  -- LLM findings only
+  raised_at    TEXT NOT NULL,
+  cleared_at   TEXT,
+  cleared_by   TEXT,                             -- resolving commit SHA or work_item_id
+  extractor_version TEXT NOT NULL
+);
+CREATE INDEX idx_findings_open ON review_findings(status, cleared_at);
+
+CREATE TABLE recommendations (
+  rec_id        TEXT PRIMARY KEY,
+  provenance    TEXT NOT NULL CHECK (provenance IN ('RULE','CLAUDE_ANALYZED')),
+  detector_id   TEXT,                            -- RULE provenance
+  analysis_run_id TEXT REFERENCES analysis_runs(run_id),   -- CLAUDE provenance
+  category      TEXT NOT NULL,
+  scope_workspace_id TEXT,                       -- NULL = global
+  lever         TEXT NOT NULL,
+  modeled_savings_u_per_wk INTEGER,
+  modeled_formula_json TEXT NOT NULL,            -- inputs so the model is reproducible
+  evidence_json TEXT NOT NULL,                   -- citations: metric ids + values + row ids
+  target_metric TEXT NOT NULL,                   -- what effect measurement watches
+  state         TEXT NOT NULL CHECK (state IN
+    ('PROPOSED','ADOPTED','DISMISSED','MEASURING',
+     'MEASURED_EFFECTIVE','MEASURED_NO_EFFECT')),
+  created_at TEXT NOT NULL, adopted_at TEXT, dismissed_until TEXT
+);
+
+CREATE TABLE recommendation_effects (
+  rec_id       TEXT NOT NULL REFERENCES recommendations(rec_id),
+  measured_at  TEXT NOT NULL,                      -- adoption-cycle grain; composite PK with rec_id
+  before_from  TEXT NOT NULL, before_to TEXT NOT NULL,
+  after_from   TEXT NOT NULL, after_to  TEXT NOT NULL,
+  before_value REAL, after_value REAL,
+  before_n INTEGER, after_n INTEGER,
+  delta_pct    REAL,
+  verdict      TEXT CHECK (verdict IN ('EFFECTIVE','NO_EFFECT','INCONCLUSIVE')),
+  PRIMARY KEY (rec_id, measured_at)                -- composite: effects re-measurable across cycles
+);
+
+CREATE TABLE analysis_runs (                      -- Tier 2 provenance + metering
+  run_id        TEXT PRIMARY KEY,
+  scope         TEXT NOT NULL,                    -- GLOBAL | workspace_id | session_id
+  model         TEXT NOT NULL,
+  prompt_version TEXT NOT NULL,
+  evidence_pack_hash TEXT NOT NULL,
+  content_included INTEGER NOT NULL DEFAULT 0,    -- explicit opt-in only (SEC-104)
+  input_tokens INTEGER, output_tokens INTEGER,
+  cost_equiv_u INTEGER,
+  contract_valid INTEGER,                         -- schema + citation resolution result
+  ran_at TEXT NOT NULL
+);
+
+CREATE TABLE ingest_quarantine (
+  q_id TEXT PRIMARY KEY,
+  file_path TEXT NOT NULL, line_no INTEGER NOT NULL,
+  error_class TEXT NOT NULL, parser_version TEXT NOT NULL,
+  seen_at TEXT NOT NULL                          -- pointer only; no content (SEC-107)
+);
+
+CREATE TABLE ingest_offsets (
+  file_path TEXT PRIMARY KEY,
+  byte_offset INTEGER NOT NULL,
+  file_hash_head TEXT,                           -- rotation/truncation detection
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE schema_migrations (version TEXT PRIMARY KEY, applied_at TEXT NOT NULL);
+
+CREATE TABLE user_config (                        -- daemon-side persisted config + alert state
+  key        TEXT PRIMARY KEY,                   -- e.g. 'limit_tokens', 'last_warned_jd'
+  value      TEXT,                               -- stored as text; callers cast to required type
+  updated_at TEXT NOT NULL
+  -- Enables Burn-Forecast persistence (FW-06) and alerting detector D5 (FW-07).
+  -- Seed rows: ('limit_tokens', NULL, ...) and ('last_warned_jd', NULL, ...).
+);

package/dist/db/migrations/002_indexes.sql

@@ -0,0 +1,6 @@
+-- AgentWrangler migration 002 — additional indexes for high-frequency FK lookups.
+-- Applied by: src/db/migrate.ts
+
+CREATE INDEX IF NOT EXISTS idx_work_items_workspace ON work_items(workspace_id);
+CREATE INDEX IF NOT EXISTS idx_session_work_links_work_item ON session_work_links(work_item_id);
+CREATE INDEX IF NOT EXISTS idx_review_findings_work_item ON review_findings(work_item_id);

package/dist/db/migrations/003_context_inventory_history.sql

@@ -0,0 +1,20 @@
+-- AgentWrangler migration 003 — context_inventory_history for realized-savings measurement.
+-- Applied by: src/db/migrate.ts (auto-discovered by filename order)
+--
+-- Sibling to context_inventory: stores one row per distinct file_hash version, appended
+-- by the probe whenever file_hash changes from the last recorded value.  This gives a
+-- bounded change-log (one row per version, not one per probe) so byte-deltas are measurable.
+
+CREATE TABLE context_inventory_history (
+  id                  INTEGER PRIMARY KEY AUTOINCREMENT,
+  workspace_id        TEXT NOT NULL REFERENCES workspaces(workspace_id),
+  component           TEXT NOT NULL CHECK (component IN
+                      ('CLAUDE_MD','RULES','MCP_SCHEMAS','SETTINGS_SYSTEM','MEMORY','OTHER')),
+  file_ref            TEXT NOT NULL,
+  file_hash           TEXT NOT NULL,
+  tokens              INTEGER NOT NULL,
+  attribution_version TEXT NOT NULL,
+  observed_at         TEXT NOT NULL
+);
+CREATE INDEX idx_ctx_hist_workspace ON context_inventory_history(workspace_id, observed_at);
+CREATE INDEX idx_ctx_hist_file_ref  ON context_inventory_history(workspace_id, component, file_ref, observed_at);

package/dist/db/migrations/004_apply_jobs.sql

@@ -0,0 +1,17 @@
+CREATE TABLE apply_jobs (
+  job_id        TEXT PRIMARY KEY,
+  rec_id        TEXT NOT NULL REFERENCES recommendations(rec_id),
+  run_id        TEXT REFERENCES analysis_runs(run_id),
+  status        TEXT NOT NULL CHECK (status IN
+                ('PENDING','DRY_RUNNING','DRY_DONE','CONFIRMING','APPLIED','FAILED','ROLLED_BACK')),
+  file_ref      TEXT NOT NULL,
+  workspace_cwd TEXT NOT NULL,
+  diff_preview  TEXT,
+  diff_applied  TEXT,
+  backup_path   TEXT,
+  error_msg     TEXT,
+  created_at    TEXT NOT NULL,
+  updated_at    TEXT NOT NULL
+);
+
+CREATE INDEX idx_apply_jobs_rec ON apply_jobs(rec_id, created_at DESC);

package/dist/db/migrations/005_tool_event_metadata.sql

@@ -0,0 +1,17 @@
+-- D7 ingestion foundation: privacy-safe target identity and structural ordering.
+-- Raw tool input/output and raw tool file paths are intentionally excluded.
+
+CREATE TABLE tool_event_metadata (
+  event_id          TEXT PRIMARY KEY REFERENCES tool_events(event_id) ON DELETE CASCADE,
+  file_path_hash    TEXT,
+  owner_message_id  TEXT,
+  block_index       INTEGER NOT NULL,
+  is_test_command   INTEGER NOT NULL CHECK (is_test_command IN (0, 1))
+);
+
+CREATE INDEX idx_tool_meta_path_order
+  ON tool_event_metadata(file_path_hash, block_index)
+  WHERE file_path_hash IS NOT NULL;
+
+CREATE INDEX idx_tool_meta_owner_event
+  ON tool_event_metadata(owner_message_id, event_id);

package/dist/db/migrations/006_d7_query_indexes.sql

@@ -0,0 +1,9 @@
+-- Keep D7's trailing-window scans bounded by time as the corpus grows.
+-- This is separate from migration 005 because 005 may already have been
+-- applied by pre-commit smoke runs during D7 development.
+
+CREATE INDEX idx_tool_ts_session_event
+  ON tool_events(ts, session_id, event_id);
+
+CREATE INDEX idx_turns_ts_provisional_session
+  ON turns(ts, provisional, session_id);

package/dist/db/migrations/007_work_item_branch_keys.sql

@@ -0,0 +1,11 @@
+CREATE TABLE work_item_branch_keys (
+  work_item_id          TEXT PRIMARY KEY REFERENCES work_items(work_item_id) ON DELETE CASCADE,
+  head_ref_key          TEXT NOT NULL
+                        CHECK (length(head_ref_key) = 64
+                           AND head_ref_key NOT GLOB '*[^0-9a-f]*'),
+  normalization_version TEXT NOT NULL CHECK (normalization_version = 'branch-v1'),
+  synced_at             TEXT NOT NULL
+);
+
+CREATE INDEX idx_work_item_branch_key
+  ON work_item_branch_keys(head_ref_key, work_item_id);

package/dist/db/migrations/008_thinking_tokens.sql

@@ -0,0 +1 @@
+ALTER TABLE turns ADD COLUMN thinking_tokens INTEGER;

package/dist/db/migrations/009_user_turn_count.sql

@@ -0,0 +1 @@
+ALTER TABLE sessions ADD COLUMN user_turn_count INTEGER NOT NULL DEFAULT 0;

package/dist/db/migrations/010_workspace_cwd.sql

@@ -0,0 +1 @@
+ALTER TABLE workspaces ADD COLUMN discovered_cwd TEXT;

package/dist/db/migrations/011_reports.sql

@@ -0,0 +1 @@
+CREATE TABLE reports (report_id TEXT PRIMARY KEY, kind TEXT NOT NULL, period_start TEXT NOT NULL, period_end TEXT NOT NULL, generated_at TEXT NOT NULL, content_json TEXT NOT NULL, UNIQUE(kind, period_start));

package/dist/db/migrations/012_reconcile_indexes.sql

@@ -0,0 +1,2 @@
+CREATE INDEX IF NOT EXISTS idx_turns_session_ctx ON turns(session_id, context_tokens);
+CREATE INDEX IF NOT EXISTS idx_tool_session_name_hash ON tool_events(session_id, tool_name, input_hash);

package/dist/db/migrations/013_friction_fields.sql

@@ -0,0 +1,5 @@
+-- RV2a: L1 Friction substrate — per-session counters for friction signal ingestion.
+-- SEC-101: counts only; never message content.
+ALTER TABLE sessions ADD COLUMN compaction_count  INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE sessions ADD COLUMN api_error_count   INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE sessions ADD COLUMN interrupt_count   INTEGER NOT NULL DEFAULT 0;

package/dist/db/migrations/014_session_churn.sql

@@ -0,0 +1,11 @@
+CREATE TABLE session_churn (
+  session_id     TEXT PRIMARY KEY REFERENCES sessions(session_id),
+  status         TEXT NOT NULL,
+  window_days    INTEGER NOT NULL,
+  authored_lines INTEGER NOT NULL DEFAULT 0,
+  churned_lines  INTEGER NOT NULL DEFAULT 0,
+  churn_ratio    REAL,
+  commit_count   INTEGER NOT NULL DEFAULT 0,
+  commit_shas    TEXT NOT NULL DEFAULT '[]',
+  measured_at    TEXT NOT NULL
+);

package/dist/db/migrations/015_gap_aggregates.sql

@@ -0,0 +1,6 @@
+-- EF3: per-session inter-user-turn gap aggregates (SEC-101: durations in seconds only).
+-- Backfilled on next full re-scan (RV2a stance); historical rows keep defaults.
+ALTER TABLE sessions ADD COLUMN gap_median_s REAL;
+ALTER TABLE sessions ADD COLUMN gap_p90_s REAL;
+ALTER TABLE sessions ADD COLUMN long_gap_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE sessions ADD COLUMN gap_n INTEGER NOT NULL DEFAULT 0;

package/dist/db/open.js

@@ -0,0 +1,30 @@
+/**
+ * src/db/open.ts — open a better-sqlite3 database with required pragmas.
+ *
+ * Enforces:
+ *  - WAL journal mode (on-disk only; in-memory stays 'memory', which is expected).
+ *  - foreign_keys=ON (SEC constraint; enforced at every open).
+ *
+ * Never open :memory: in production paths — this module is for on-disk DBs.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import Database from "better-sqlite3";
+/**
+ * Open an on-disk SQLite database at `dbPath`, creating parent directories as needed.
+ * Applies WAL journal mode and foreign_keys=ON before returning.
+ */
+export function openDb(dbPath) {
+    const dir = path.dirname(dbPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const db = new Database(dbPath);
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("foreign_keys = ON");
+    const fk = db.pragma("foreign_keys")[0]?.foreign_keys;
+    if (fk !== 1) {
+        db.close();
+        throw new Error("FATAL: foreign_keys pragma failed to enable");
+    }
+    return db;
+}

package/dist/detector/benchmark-anchors.js

@@ -0,0 +1,36 @@
+/**
+ * src/detector/benchmark-anchors.ts — BM4 public benchmark anchor constants.
+ *
+ * Static, cited reference points sourced from public Anthropic data.
+ * These are display-only constants — NEVER a score input, NEVER stored.
+ *
+ * Re-verify when touched — $6→$13 is the precedent that these rot.
+ *
+ * SEC-101: only public aggregate/claim strings, no user data.
+ */
+/** $13/day average (enterprise API-billed). Supersedes the old $6/day figure. */
+export const DAILY_AVG_USD = {
+    daily_usd: 13,
+    label: "avg/day",
+    source_url: "https://code.claude.com/docs/en/costs",
+    fetched_date: "2026-09-02",
+};
+/** $30/day p90 (enterprise API-billed). */
+export const DAILY_P90_USD = {
+    daily_usd: 30,
+    label: "p90/day",
+    source_url: "https://code.claude.com/docs/en/costs",
+    fetched_date: "2026-09-02",
+};
+/** Rate-limit cap-impact claim from official Anthropic post. */
+export const CAP_IMPACT_CLAIM = {
+    claim: "<5% of subscribers",
+    source: "official Anthropic X post, 2025-07-28",
+};
+/**
+ * Mandatory caveat: anchor population is enterprise API-billed;
+ * our own figure is a LIST_EQUIV subscription estimate — a reference
+ * point, NOT like-for-like.
+ */
+export const ANCHOR_CAVEAT = "Benchmark figures are from enterprise API-billed users. " +
+    "Your figure is a subscription-plan estimate (LIST_EQUIV) — a reference point, not a like-for-like comparison.";