segreant 0.1.0 → 0.2.0

package/dist/config.js

@@ -37,6 +37,10 @@ function validNullableUsd(value) {
 export function validateBudgetConfig(value) {
     if (!isRecord(value))
         throw new ConfigValidationError('budget must be an object');
+    const allowed = ['dailyUsd', 'dailySoftUsd', 'sessionUsd', 'runawayWindowSec', 'runawayMaxUsd', 'capIncludesImported'];
+    if (Object.keys(value).some((key) => !allowed.includes(key))) {
+        throw new ConfigValidationError('budget contains an unknown field; check the configured cap names');
+    }
     for (const key of ['dailyUsd', 'dailySoftUsd', 'sessionUsd', 'runawayMaxUsd']) {
         if (!validNullableUsd(value[key])) {
             throw new ConfigValidationError(`budget.${key} must be null or a finite non-negative USD value`);
@@ -133,6 +137,10 @@ function exactUsdCap(value, label) {
 }
 const CAP_CACHE = new WeakMap();
 export function exactBudgetCaps(cfg) {
+    // A caller can supply or mutate the live proxy config without loadConfig.
+    // Validate before consulting the cache: a new unknown key must never reuse
+    // previously valid, unlimited caps.
+    validateBudgetConfig(cfg);
     const source = CAP_KEYS.map((key) => cfg[key]);
     const cached = CAP_CACHE.get(cfg);
     if (cached && cached.source.length === source.length
@@ -187,6 +195,32 @@ function validateFeatureOverrides(value) {
             throw new ConfigValidationError(`features.${key} must be boolean`);
     }
 }
+export const PLAN_SOURCES = ['claude-code', 'codex'];
+/** Plan prices are bounded and shaped exactly; anything else stops the load. */
+export function validatePlansConfig(value) {
+    if (!isRecord(value))
+        throw new ConfigValidationError('plans must be an object of tool -> { monthlyUsd, plan, setAt }');
+    for (const [source, price] of Object.entries(value)) {
+        if (!PLAN_SOURCES.includes(source)) {
+            throw new ConfigValidationError(`plans.${source}: unknown tool (expected one of ${PLAN_SOURCES.join(', ')})`);
+        }
+        if (!isRecord(price))
+            throw new ConfigValidationError(`plans.${source} must be an object`);
+        const usdValue = price.monthlyUsd;
+        if (typeof usdValue !== 'number' || !Number.isFinite(usdValue) || usdValue < 0 || usdValue > 100_000) {
+            throw new ConfigValidationError(`plans.${source}.monthlyUsd must be a number from 0 to 100000`);
+        }
+        if (price.plan !== null && (typeof price.plan !== 'string' || price.plan.length > 40)) {
+            throw new ConfigValidationError(`plans.${source}.plan must be null or a short name`);
+        }
+        if (typeof price.setAt !== 'string' || Number.isNaN(Date.parse(price.setAt))) {
+            throw new ConfigValidationError(`plans.${source}.setAt must be a date`);
+        }
+        const extra = Object.keys(price).filter((k) => !['monthlyUsd', 'plan', 'setAt'].includes(k));
+        if (extra.length > 0)
+            throw new ConfigValidationError(`plans.${source}: unexpected field ${extra[0]}`);
+    }
+}
 export const DEFAULT_CONFIG = {
     features: { ...FEATURE_DEFAULTS },
     port: 8090,
@@ -238,6 +272,7 @@ export const DEFAULT_CONFIG = {
         manifestUrl: null,
         maxAgeDays: 30,
         autoRefresh: false,
+        lookupUnknownModels: true,
     },
     perUser: {
         enabled: false,
@@ -252,6 +287,7 @@ export const DEFAULT_CONFIG = {
     retentionDays: 180,
     metadataOnly: false,
     proposalRetentionDays: 30,
+    plans: {},
 };
 /**
  * The environment overrides. `SEGREANT_*` is the only family the product reads.
@@ -306,6 +342,23 @@ export class DemoReadOnlyError extends Error {
 export function isDemo() {
     return envOverride('DEMO') === '1';
 }
+/**
+ * Raised when a command would write real usage into the sample store. In demo
+ * mode the open store is demo.db, so an import there would sit inside totals
+ * labelled as synthetic data while claiming to be isolated.
+ */
+export class DemoWriteBlockedError extends Error {
+    code = 'DEMO_WRITE_BLOCKED';
+    constructor(what) {
+        super(`Demo mode holds sample data only, so ${what} was not written. Run it without --demo to bring in your own usage; the sample data stays in demo.db.`);
+        this.name = 'DemoWriteBlockedError';
+    }
+}
+/** Fail closed before any import writes into a store that is demo data. */
+export function refuseDemoWrite(what) {
+    if (isDemo())
+        throw new DemoWriteBlockedError(what);
+}
 /** Remove the demo database (and its WAL/SHM sidecars) for a clean re-seed. */
 export function unlinkDemoDb() {
     for (const suffix of ['', '-wal', '-shm']) {
@@ -385,17 +438,21 @@ function sanitizePort(value, fallback) {
  * an array of exact rule shapes, and boolean enabled flags.
  */
 function sanitizeEgressConfig(value) {
-    if (!isRecord(value))
+    // Absent is the default; present but malformed fails closed.
+    if (value === undefined)
         return { mode: 'local_locked', rules: [] };
+    const invalid = { mode: 'invalid', rules: [] };
+    if (!isRecord(value))
+        return invalid;
     if (value.mode !== 'local_locked' && value.mode !== 'controlled_cloud') {
-        return { mode: 'local_locked', rules: [] };
+        return invalid;
     }
     const keys = Object.keys(value).sort();
     if (keys.length !== 2 || keys[0] !== 'mode' || keys[1] !== 'rules') {
-        return { mode: 'local_locked', rules: [] };
+        return invalid;
     }
     if (!Array.isArray(value.rules) || !value.rules.every((rule) => validateEgressRule(rule).length === 0)) {
-        return { mode: 'local_locked', rules: [] };
+        return invalid;
     }
     return {
         mode: value.mode,
@@ -411,13 +468,20 @@ export function loadConfig() {
     else {
         let raw;
         try {
-            raw = JSON.parse(readFileSync(path, 'utf8'));
+            // Windows PowerShell 5.1 writes UTF-8 with a byte-order mark
+            // (`Set-Content -Encoding utf8`). The mark is not content, so it is
+            // skipped rather than reported as a parse error.
+            const text = readFileSync(path, 'utf8');
+            raw = JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text);
         }
         catch (error) {
             throw new ConfigValidationError(`cannot parse ${path}; repair or restore ${path}.bak before starting Segreant (${error instanceof Error ? error.message : String(error)})`);
         }
         if (!isRecord(raw))
             throw new ConfigValidationError(`configuration root in ${path} must be an object`);
+        if (Object.keys(raw).some((key) => !Object.hasOwn(DEFAULT_CONFIG, key))) {
+            throw new ConfigValidationError('configuration contains an unknown field; check the configured section names');
+        }
         if (Object.hasOwn(raw, 'features'))
             validateFeatureOverrides(raw.features);
         cfg = deepMerge(DEFAULT_CONFIG, raw);
@@ -431,8 +495,12 @@ export function loadConfig() {
         port: sanitizePort(cfg.port, DEFAULT_CONFIG.port),
         dashboardPort: sanitizePort(cfg.dashboardPort, DEFAULT_CONFIG.dashboardPort),
     };
+    if (typeof cfg.pricing.lookupUnknownModels !== 'boolean') {
+        throw new ConfigValidationError('pricing.lookupUnknownModels must be true or false');
+    }
     validateBudgetConfig(cfg.budget);
     validateFeaturesConfig(cfg.features);
+    validatePlansConfig(cfg.plans);
     return isDemo() ? withDemoDefaults(cfg) : cfg;
 }
 function configLockOwner(path) {
@@ -513,6 +581,27 @@ function assertConfigMutationLock(lock) {
         throw new ConfigValidationError('config mutation lock ownership cannot be proven');
     }
 }
+/**
+ * `invalid` is how a malformed egress section loads; it is never written. A
+ * write that does not touch egress (a cap, a plan price) keeps the section
+ * exactly as it is on disk, so the user's rules survive to be repaired. Writing
+ * the marker replaced the section with `{"mode":"invalid","rules":[]}`, and the
+ * rules were gone once the next write rotated the backup (independent review,
+ * 2026-10-18). A write that repairs egress sets a real mode and is written as is.
+ */
+function withPersistedEgress(config, path) {
+    if (config.egress.mode !== 'invalid')
+        return config;
+    let onDisk;
+    try {
+        const text = readFileSync(path, 'utf8');
+        onDisk = JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text)['egress'];
+    }
+    catch (error) {
+        throw new ConfigValidationError(`the egress section of ${path} is malformed and could not be kept as it is; repair it before changing other settings (${error instanceof Error ? error.message : String(error)})`);
+    }
+    return { ...config, egress: onDisk };
+}
 function persistConfigUnlocked(config) {
     ensureHome();
     validateBudgetConfig(config.budget);
@@ -520,7 +609,7 @@ function persistConfigUnlocked(config) {
     const path = configPath();
     const tempPath = `${path}.tmp-${randomUUID()}`;
     const backupPath = `${path}.bak`;
-    const text = JSON.stringify(config, null, 2) + '\n';
+    const text = JSON.stringify(withPersistedEgress(config, path), null, 2) + '\n';
     let descriptor = null;
     try {
         // Preserve the previous known-good config before replacing it. The target

package/dist/connect/antigravity.js

@@ -0,0 +1,310 @@
+/**
+ * Native metering for Google Antigravity (the IDE agent and the `agy` CLI).
+ *
+ * Antigravity keeps one SQLite file per conversation under
+ * ~/.gemini/antigravity/conversations and ~/.gemini/antigravity-cli/conversations.
+ * Each model call is a row of `gen_metadata` holding a protobuf
+ * `CortexStepGeneratorMetadata`; its `chat_model` (field 1) carries the call's
+ * `ModelUsageStats` (field 4) and the model that answered (`response_model`,
+ * field 19). Field numbers follow the published Windsurf/Antigravity schema
+ * (`exa.cortex_pb` and `exa.codeium_common_pb`, as mirrored in open-source
+ * Antigravity tooling); nothing is guessed from values.
+ *
+ *   ModelUsageStats: 2 input_tokens · 3 output_tokens · 4 cache_write_tokens ·
+ *                    5 cache_read_tokens · 9 thinking_output_tokens
+ *
+ * The same usage is repeated in each step's metadata and in `retry_infos`; only
+ * the generator's own usage is counted, once. The call's time is its first
+ * step's `created_at`; the workspace folder comes from the trajectory metadata.
+ *
+ * Read-only: each database is opened read-only, so Antigravity keeps writing.
+ * Antigravity prices nothing locally, so every row is list cost from the rate
+ * card; a model the card does not carry (Gemini 3.x today) gets the labelled
+ * fallback estimate, never an invented price.
+ */
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DatabaseSync } from 'node:sqlite';
+import { computeCost } from '../cost/pricing.js';
+import { emptyImportSummary, recordInsert, createRepoResolver, noteRelabel, markImportTruncated, fileStampForImport, noteFileImported, noteFileUnchanged, truncationMark, } from './importShared.js';
+import { pbFields, pbMessage, pbString, pbTimestampMs, pbUint, pbUints } from './protobuf.js';
+import { RESOURCE_LIMITS } from '../util/resource-limits.js';
+/** ~/.gemini, where Antigravity keeps its data. null = not installed. */
+export function defaultAntigravityRoot() {
+    const root = join(homedir(), '.gemini');
+    return ['antigravity', 'antigravity-cli'].some((d) => existsSync(join(root, d, 'conversations'))) ? root : null;
+}
+function measureRead(profile, read) {
+    if (profile === undefined)
+        return read();
+    const start = performance.now();
+    try {
+        return read();
+    }
+    finally {
+        profile.readMs += performance.now() - start;
+    }
+}
+function providerFor(model) {
+    const m = model.toLowerCase();
+    if (m.startsWith('claude'))
+        return 'anthropic';
+    if (/^(gpt|o\d)/.test(m))
+        return 'openai';
+    return 'google';
+}
+function workspacePath(uri) {
+    if (uri === null || !uri.startsWith('file://'))
+        return null;
+    try {
+        return fileURLToPath(uri);
+    }
+    catch {
+        return null;
+    }
+}
+/** Every model call in one conversation database. Pure over the database's rows. */
+export function readAntigravityConversation(db, fallbackId, profile) {
+    const tableNames = new Set(measureRead(profile, () => db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all()).map((t) => t.name));
+    if (!tableNames.has('gen_metadata'))
+        return [];
+    let trajectoryId = fallbackId;
+    let cwd = null;
+    let startedMs = null;
+    if (tableNames.has('trajectory_metadata_blob')) {
+        const meta = measureRead(profile, () => db.prepare('SELECT data FROM trajectory_metadata_blob LIMIT 1').get());
+        if (meta?.data) {
+            const decodeStart = profile === undefined ? 0 : performance.now();
+            const f = pbFields(meta.data);
+            const workspace = pbMessage(f, 1);
+            cwd = workspace === null ? null : workspacePath(pbString(workspace, 1));
+            startedMs = pbTimestampMs(pbMessage(f, 2));
+            trajectoryId = pbString(f, 3) ?? trajectoryId;
+            if (profile !== undefined)
+                profile.decodeMs += performance.now() - decodeStart;
+        }
+    }
+    const stepTimes = new Map();
+    if (tableNames.has('steps')) {
+        const steps = measureRead(profile, () => db.prepare('SELECT idx, metadata FROM steps').all());
+        if (profile !== undefined)
+            profile.stepRows += steps.length;
+        const decodeStart = profile === undefined ? 0 : performance.now();
+        for (const s of steps) {
+            if (!s.metadata)
+                continue;
+            const t = pbTimestampMs(pbMessage(pbFields(s.metadata), 1));
+            if (t !== null)
+                stepTimes.set(s.idx, t);
+        }
+        if (profile !== undefined)
+            profile.decodeMs += performance.now() - decodeStart;
+    }
+    const calls = [];
+    const generators = measureRead(profile, () => db.prepare('SELECT idx, data FROM gen_metadata ORDER BY idx').all());
+    if (profile !== undefined)
+        profile.generatorRows += generators.length;
+    const decodeStart = profile === undefined ? 0 : performance.now();
+    for (const g of generators) {
+        if (!g.data)
+            continue;
+        const gen = pbFields(g.data);
+        const chat = pbMessage(gen, 1);
+        if (chat === null)
+            continue; // an injected response: no model call
+        const usage = pbMessage(chat, 4);
+        if (usage === null)
+            continue;
+        const inputTokens = pbUint(usage, 2);
+        const outputTokens = pbUint(usage, 3);
+        const cacheWriteTokens = pbUint(usage, 4);
+        const cacheReadTokens = pbUint(usage, 5);
+        if (inputTokens + outputTokens + cacheWriteTokens + cacheReadTokens === 0)
+            continue;
+        const model = pbString(chat, 19) || `antigravity-model-${pbUint(chat, 3)}`;
+        const firstStep = pbUints(gen, 2)[0];
+        const ts = (firstStep !== undefined ? stepTimes.get(firstStep) : undefined) ?? startedMs;
+        if (ts === null || ts === undefined)
+            continue;
+        calls.push({
+            requestId: `antigravity:${trajectoryId}:${g.idx}`,
+            sessionId: trajectoryId,
+            tsEpochMs: ts,
+            model,
+            provider: providerFor(model),
+            cwd,
+            inputTokens,
+            outputTokens,
+            cacheWriteTokens,
+            cacheReadTokens,
+            reasoningTokens: pbUint(usage, 9),
+        });
+    }
+    if (profile !== undefined) {
+        profile.decodeMs += performance.now() - decodeStart;
+        profile.decodedCalls += calls.length;
+    }
+    return calls;
+}
+function conversationFiles(root) {
+    const out = [];
+    for (const sub of ['antigravity', 'antigravity-cli']) {
+        const dir = join(root, sub, 'conversations');
+        let names = [];
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const n of names)
+            if (n.endsWith('.db'))
+                out.push(join(dir, n));
+    }
+    return out;
+}
+/** Imports in periodic commits rather than one commit per row (see Store.importBatch). */
+export async function importAntigravity(store, opts = {}) {
+    const batch = store.importBatch();
+    try {
+        return await importAntigravityRows(store, opts);
+    }
+    finally {
+        batch.end();
+    }
+}
+async function importAntigravityRows(store, opts) {
+    const started = performance.now();
+    const profile = opts.onProfile === undefined ? undefined : {
+        filesRead: 0, stepRows: 0, generatorRows: 0, decodedCalls: 0, eligibleCalls: 0,
+        insertedRows: 0, readMs: 0, decodeMs: 0, filterMs: 0,
+        attributionMs: 0, pricingMs: 0, persistMs: 0, totalMs: 0,
+    };
+    const root = opts.root ?? defaultAntigravityRoot();
+    const source = opts.source ?? 'antigravity';
+    const sinceMs = opts.sinceMs ?? 0;
+    if (root === null) {
+        const empty = emptyImportSummary(0);
+        if (profile !== undefined) {
+            profile.totalMs = performance.now() - started;
+            opts.onProfile?.(profile);
+        }
+        return empty;
+    }
+    const files = conversationFiles(root);
+    const summary = emptyImportSummary(files.length);
+    const resolveProject = createRepoResolver();
+    let rows = 0;
+    for (const file of files) {
+        // A live conversation writes to its WAL first; the main file's size and time
+        // do not move until a checkpoint, so such a file is always read again.
+        let walLive = false;
+        try {
+            walLive = statSync(`${file}-wal`).size > 0;
+        }
+        catch {
+            walLive = false;
+        }
+        const stamp = fileStampForImport(store, source, file, walLive ? { ...opts, rescan: true } : opts);
+        if (stamp === 'deferred') {
+            summary.filesDeferred = (summary.filesDeferred ?? 0) + 1;
+            continue;
+        }
+        if (stamp === 'unchanged') {
+            noteFileUnchanged(store, source, file, summary);
+            continue;
+        }
+        const truncationsBefore = truncationMark(summary);
+        let db;
+        try {
+            db = new DatabaseSync(file, { readOnly: true });
+        }
+        catch {
+            continue; // locked or not a database: skipped, never a crash
+        }
+        if (profile !== undefined)
+            profile.filesRead += 1;
+        let calls = [];
+        try {
+            calls = readAntigravityConversation(db, file.replace(/^.*[\\/]/, '').replace(/\.db$/, ''), profile);
+        }
+        catch {
+            calls = [];
+        }
+        finally {
+            db.close();
+        }
+        for (const c of calls) {
+            const filterStart = profile === undefined ? 0 : performance.now();
+            const tooOld = c.tsEpochMs < sinceMs;
+            if (profile !== undefined)
+                profile.filterMs += performance.now() - filterStart;
+            if (tooOld)
+                continue;
+            if (++rows > RESOURCE_LIMITS.importRows) {
+                markImportTruncated(summary, 'rows');
+                break;
+            }
+            if (profile !== undefined)
+                profile.eligibleCalls += 1;
+            const attributionStart = profile === undefined ? 0 : performance.now();
+            const attribution = await resolveProject(c.cwd, 'antigravity');
+            if (profile !== undefined)
+                profile.attributionMs += performance.now() - attributionStart;
+            noteRelabel(summary, attribution);
+            // The rate card's lookup follows the model across providers (rateFor), so a
+            // Gemini row finds the Google table through any named provider.
+            const pricingStart = profile === undefined ? 0 : performance.now();
+            const cost = computeCost(c.provider === 'anthropic' ? 'anthropic' : 'openai', c.model, {
+                inputTokens: c.inputTokens,
+                outputTokens: c.outputTokens,
+                cacheWriteTokens: c.cacheWriteTokens,
+                cacheReadTokens: c.cacheReadTokens,
+            });
+            if (profile !== undefined)
+                profile.pricingMs += performance.now() - pricingStart;
+            const row = {
+                requestId: c.requestId,
+                sessionId: c.sessionId,
+                tsEpochMs: c.tsEpochMs,
+                provider: c.provider,
+                model: c.model,
+                project: attribution.project,
+                attributionBasis: attribution.basis,
+                taskWeight: 1,
+                inputTokens: c.inputTokens,
+                outputTokens: c.outputTokens,
+                cacheWriteTokens: c.cacheWriteTokens,
+                cacheReadTokens: c.cacheReadTokens,
+                reasoningTokens: c.reasoningTokens,
+                costUsd: cost.costUsd,
+                economicAmount: cost.exact?.total,
+                estimated: cost.estimated,
+                pricing: cost.pricing,
+                streamed: true,
+                statusCode: 200,
+                durationMs: null,
+                user: null,
+                source,
+                cwd: c.cwd,
+            };
+            const persistStart = profile === undefined ? 0 : performance.now();
+            store.upsertSession(c.sessionId, attribution.project, source, c.tsEpochMs);
+            recordInsert(store, summary, row, cost.estimated);
+            if (profile !== undefined)
+                profile.persistMs += performance.now() - persistStart;
+        }
+        const cursorStart = profile === undefined ? 0 : performance.now();
+        noteFileImported(store, source, file, stamp, opts, truncationsBefore, summary);
+        if (profile !== undefined)
+            profile.persistMs += performance.now() - cursorStart;
+    }
+    if (profile !== undefined) {
+        profile.insertedRows = summary.inserted;
+        profile.totalMs = performance.now() - started;
+        opts.onProfile?.(profile);
+    }
+    return summary;
+}

package/dist/connect/claudeCode.js

@@ -24,10 +24,11 @@ import { createReadStream } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { computeCost } from '../cost/pricing.js';
+import { cacheWriteDuration, computeCost } from '../cost/pricing.js';
 import { projectKeyWithBasis } from '../value/characterization.js';
-import { emptyImportSummary, recordInsert, createRepoResolver, noteRelabel, boundedJsonlFiles, markImportTruncated, fileStampForImport, noteFileImported, noteFileUnchanged, truncationMark, } from './importShared.js';
+import { emptyImportSummary, recordInsert, createRepoResolver, noteRelabel, boundedJsonlFiles, markImportTruncated, fileStampForImport, noteFileImported, noteFileUnchanged, truncationMark, commitObservationsInLine, } from './importShared.js';
 import { RESOURCE_LIMITS } from '../util/resource-limits.js';
+import { claudeLimitEvent } from '../quota/limits.js';
 /** Default transcript root: ~/.claude/projects (override for tests / unusual installs). */
 export function defaultClaudeCodeRoot() {
     return join(homedir(), '.claude', 'projects');
@@ -73,7 +74,10 @@ export function parseTranscriptLine(line) {
         outputTokens: u.output_tokens ?? 0,
         cacheWriteTokens: cacheWrite,
         cacheReadTokens: u.cache_read_input_tokens ?? 0,
-        cacheWriteTtl: cacheWrite > 0 ? (ttl1h >= ttl5m ? '1h' : '5m') : undefined,
+        ...(cacheWrite > 0 ? (() => {
+            const d = cacheWriteDuration(ttl5m, ttl1h);
+            return { ...(d.ttl === undefined ? {} : { cacheWriteTtl: d.ttl }), cacheWriteTtlObserved: d.observed };
+        })() : {}),
     };
 }
 /**
@@ -106,6 +110,10 @@ async function importClaudeCodeRows(store, opts) {
     const resolveProject = createRepoResolver();
     for (const file of files) {
         const stamp = fileStampForImport(store, source, file, opts);
+        if (stamp === 'deferred') {
+            summary.filesDeferred = (summary.filesDeferred ?? 0) + 1;
+            continue;
+        }
         if (stamp === 'unchanged') {
             noteFileUnchanged(store, source, file, summary);
             continue;
@@ -115,6 +123,30 @@ async function importClaudeCodeRows(store, opts) {
         noteFileImported(store, source, file, stamp, opts, truncationsBefore, summary);
     }
     return summary;
+    // A tool result that shows git creating a commit names the session that made
+    // it. Each transcript line carries its own session id, time and directory.
+    function recordCommitsIn(line) {
+        const commits = commitObservationsInLine(line);
+        if (commits.length === 0)
+            return;
+        const sessionId = /"sessionId":"([^"]+)"/.exec(line)?.[1];
+        const ts = Date.parse(/"timestamp":"([^"]+)"/.exec(line)?.[1] ?? '');
+        if (!sessionId || !Number.isFinite(ts) || ts < sinceMs)
+            return;
+        let cwd = null;
+        const rawCwd = /"cwd":"((?:[^"\\]|\\.)*)"/.exec(line)?.[1];
+        if (rawCwd !== undefined) {
+            try {
+                cwd = JSON.parse(`"${rawCwd}"`);
+            }
+            catch {
+                cwd = null;
+            }
+        }
+        for (const c of commits) {
+            store.recordObservedCommit({ source, sessionId, shortSha: c.shortSha, branch: c.branch, subject: c.subject, tsEpochMs: ts, cwd });
+        }
+    }
     async function importTranscriptFile(file) {
         // One API request = many transcript lines; first wins. A copy in ANOTHER file
         // (a resumed session) goes to the store, which recognises the same charge as a
@@ -126,6 +158,13 @@ async function importClaudeCodeRows(store, opts) {
                 markImportTruncated(summary, 'lines');
                 continue;
             }
+            recordCommitsIn(line);
+            if (line.includes('"isApiErrorMessage":true')) {
+                const ts = Date.parse(/"timestamp":"([^"]+)"/.exec(line)?.[1] ?? '');
+                const limit = Number.isFinite(ts) && ts >= sinceMs ? claudeLimitEvent(line, ts) : null;
+                if (limit !== null)
+                    store.recordQuotaEvent(limit);
+            }
             const ev = parseTranscriptLine(line);
             if (!ev || ev.tsEpochMs < sinceMs)
                 continue;
@@ -158,6 +197,7 @@ async function importClaudeCodeRows(store, opts) {
                 outputTokens: ev.outputTokens,
                 cacheWriteTokens: ev.cacheWriteTokens,
                 cacheReadTokens: ev.cacheReadTokens,
+                ...(ev.cacheWriteTtl === undefined || !ev.cacheWriteTtlObserved ? {} : { cacheWriteTtl: ev.cacheWriteTtl }),
                 reasoningTokens: 0,
                 costUsd: cost.costUsd,
                 economicAmount: cost.exact?.total,

package/dist/connect/codex.js

@@ -25,8 +25,9 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { computeCost, unpricedPricingEvidence } from '../cost/pricing.js';
 import { projectKeyWithBasis } from '../value/characterization.js';
-import { emptyImportSummary, recordInsert, createRepoResolver, noteRelabel, boundedJsonlFiles, markImportTruncated, fileStampForImport, noteFileImported, noteFileUnchanged, truncationMark, } from './importShared.js';
+import { emptyImportSummary, recordInsert, createRepoResolver, noteRelabel, boundedJsonlFiles, markImportTruncated, fileStampForImport, noteFileImported, noteFileUnchanged, truncationMark, commitObservationsInLine, } from './importShared.js';
 import { RESOURCE_LIMITS } from '../util/resource-limits.js';
+import { codexRateLimitEvents } from '../quota/limits.js';
 /** Codex home: ~/.codex (override with CODEX_HOME). null = not installed. */
 export function defaultCodexRoot() {
     const home = process.env.CODEX_HOME ?? join(homedir(), '.codex');
@@ -94,6 +95,7 @@ export async function parseCodexRollout(file, options = {}) {
     let emittedRows = 0;
     const maxRows = options.maxRows ?? RESOURCE_LIMITS.importRows;
     const projFromCwd = (cwd) => projectKeyWithBasis(cwd, 'codex');
+    const lastMeter = new Map();
     for await (const line of rl) {
         if (Buffer.byteLength(line, 'utf8') > RESOURCE_LIMITS.transcriptLineBytes) {
             options.onTruncatedLine?.();
@@ -107,6 +109,17 @@ export async function parseCodexRollout(file, options = {}) {
             continue; // torn tail of a live session — next import gets it whole
         }
         const p = o.payload ?? {};
+        // A fork or subagent file opens with its parent's history replayed; its own
+        // turns begin after its first token count. Commits in the replay are the
+        // parent's, so they are not credited to this thread.
+        if (options.onCommit && o.type !== 'session_meta' && o.type !== 'turn_context' && !(forked && firstCount)) {
+            const thread = forkId ?? sessionId;
+            const ts = Date.parse(o.timestamp ?? '');
+            if (thread && Number.isFinite(ts)) {
+                for (const c of commitObservationsInLine(line))
+                    options.onCommit({ sessionId: thread, ...c, tsEpochMs: ts, cwd });
+            }
+        }
         if (o.type === 'session_meta') {
             // Only the first session_meta names this file's thread; later ones are
             // the parent's context replayed into a subagent or fork.
@@ -134,6 +147,18 @@ export async function parseCodexRollout(file, options = {}) {
             }
             continue;
         }
+        if (o.type === 'event_msg' && p.type === 'token_count' && options.onRateLimit && p.rate_limits !== undefined) {
+            const ts = Date.parse(o.timestamp ?? '');
+            if (Number.isFinite(ts)) {
+                for (const e of codexRateLimitEvents(p.rate_limits, ts)) {
+                    const key = JSON.stringify([e.usedPercent, e.resetsAtMs]);
+                    if (lastMeter.get(e.kind) === key)
+                        continue;
+                    lastMeter.set(e.kind, key);
+                    options.onRateLimit(e);
+                }
+            }
+        }
         if (o.type === 'event_msg' && p.type === 'token_count') {
             const info = p.info;
             const tot = totalsFrom(info?.total_token_usage);
@@ -220,6 +245,10 @@ async function importCodexRows(store, opts) {
     const resolveProject = createRepoResolver();
     for (const file of files) {
         const stamp = fileStampForImport(store, source, file, opts);
+        if (stamp === 'deferred') {
+            summary.filesDeferred = (summary.filesDeferred ?? 0) + 1;
+            continue;
+        }
         if (stamp === 'unchanged') {
             noteFileUnchanged(store, source, file, summary);
             continue;
@@ -229,6 +258,14 @@ async function importCodexRows(store, opts) {
             await parseCodexRollout(file, {
                 onTruncatedLine: () => markImportTruncated(summary, 'lines'),
                 onTruncatedRow: () => markImportTruncated(summary, 'rows'),
+                onCommit: (c) => {
+                    if (c.tsEpochMs >= sinceMs)
+                        store.recordObservedCommit({ source, ...c });
+                },
+                onRateLimit: (e) => {
+                    if (e.tsEpochMs >= sinceMs)
+                        store.recordQuotaEvent(e);
+                },
                 onRow: async (ev) => {
                     if (ev.tsEpochMs < sinceMs)
                         return;