@cookielab.io/oopst 0.6.2 → 0.6.3

package/dist/index.js

@@ -7,7 +7,7 @@ import { realpathSync } from "fs";
 import process4 from "process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { NodeRuntime, NodeServices as NodeServices2 } from "@effect/platform-node";
-import { Effect as Effect26, Layer as Layer12, Option as Option4, Runtime } from "effect";
+import { Effect as Effect27, Layer as Layer12, Option as Option4, Runtime } from "effect";
 import { CliOutput, Command, Flag } from "effect/unstable/cli";
 
 // src/config.ts
@@ -524,220 +524,74 @@ var ParserSourcesLive = Layer2.effect(
 import { Context as Context6, Effect as Effect10, Layer as Layer5 } from "effect";
 
 // src/sync/run.ts
-import { Effect as Effect9, Stream as Stream4 } from "effect";
-
-// src/sync/aggregate.ts
-import { createHmac } from "crypto";
-import { Effect as Effect4, Schema as Schema3, Stream as Stream2 } from "effect";
-var UsageAggregationErrorFields = {
-  message: Schema3.String,
-  cause: Schema3.optionalKey(Schema3.Defect())
-};
-var UsageAggregationError = class extends Schema3.TaggedErrorClass()(
-  "UsageAggregationError",
-  UsageAggregationErrorFields
-) {
-};
-function toIso(hourUtc) {
-  return hourUtc instanceof Date ? hourUtc.toISOString() : hourUtc;
-}
-function key(b) {
-  return `${b.harness} ${b.model} ${toIso(b.hourUtc)}`;
-}
-function finalize(acc) {
-  return {
-    harness: acc.harness,
-    model: acc.model,
-    hourUtc: acc.hourUtc,
-    inputTokens: acc.inputTokens,
-    outputTokens: acc.outputTokens,
-    cacheReadTokens: acc.cacheReadTokens,
-    cacheCreateTokens: acc.cacheCreateTokens,
-    sessionCount: acc.sessionIds.size
-  };
-}
-var SESSION_KEY_SALT_PATTERN = /^[a-f0-9]{64}$/u;
-function createSessionKey(harness, localSessionId, sessionKeySalt) {
-  if (!SESSION_KEY_SALT_PATTERN.test(sessionKeySalt)) {
-    throw new Error("invalid session key salt");
-  }
-  return createHmac("sha256", Buffer.from(sessionKeySalt, "hex")).update("oopst/session-key/v1").update("\0").update(harness).update("\0").update(localSessionId).digest("hex");
-}
-function sessionMapKey(harness, sessionKey) {
-  return `${harness} ${sessionKey}`;
-}
-function finalizeSession(acc) {
-  return {
-    harness: acc.harness,
-    sessionKey: acc.sessionKey,
-    startedAt: acc.startedAt.toISOString(),
-    lastSeenAt: acc.lastSeenAt.toISOString()
-  };
-}
-function addSessionAccumulator(sessionAccumulators, bucket, localSessionId, sessionKeySalt) {
-  const sessionKey = createSessionKey(bucket.harness, localSessionId, sessionKeySalt);
-  const sessionAccumulatorKey = sessionMapKey(bucket.harness, sessionKey);
-  const existingSession = sessionAccumulators.get(sessionAccumulatorKey);
-  if (existingSession) {
-    if (bucket.sessionStartedAt.getTime() < existingSession.startedAt.getTime()) {
-      existingSession.startedAt = bucket.sessionStartedAt;
-    }
-    if (bucket.sessionLastSeenAt.getTime() > existingSession.lastSeenAt.getTime()) {
-      existingSession.lastSeenAt = bucket.sessionLastSeenAt;
-    }
-    return;
-  }
-  sessionAccumulators.set(sessionAccumulatorKey, {
-    harness: bucket.harness,
-    sessionKey,
-    startedAt: bucket.sessionStartedAt,
-    lastSeenAt: bucket.sessionLastSeenAt
-  });
-}
-function createUsageAggregationState() {
-  return {
-    accumulators: /* @__PURE__ */ new Map(),
-    sessionAccumulators: /* @__PURE__ */ new Map()
-  };
-}
-function addBucketToAggregationState(state, bucket, sessionKeySalt) {
-  const k = key(bucket);
-  let acc = state.accumulators.get(k);
-  if (!acc) {
-    acc = {
-      harness: bucket.harness,
-      model: bucket.model,
-      hourUtc: toIso(bucket.hourUtc),
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheReadTokens: 0,
-      cacheCreateTokens: 0,
-      sessionIds: /* @__PURE__ */ new Set()
-    };
-    state.accumulators.set(k, acc);
-  }
-  acc.inputTokens += bucket.inputTokens;
-  acc.outputTokens += bucket.outputTokens;
-  acc.cacheReadTokens += bucket.cacheReadTokens;
-  acc.cacheCreateTokens += bucket.cacheCreateTokens;
-  for (const id of bucket.sessionIds) {
-    acc.sessionIds.add(id);
-    addSessionAccumulator(state.sessionAccumulators, bucket, id, sessionKeySalt);
-  }
-  return state;
-}
-function addBucketToAggregationStateEffect(state, bucket, sessionKeySalt) {
-  return Effect4.try({
-    try: () => addBucketToAggregationState(state, bucket, sessionKeySalt),
-    catch: toUsageAggregationError
-  });
-}
-function finalizeUsageBatches(state, batchSize) {
-  const finalized = [];
-  for (const acc of state.accumulators.values()) {
-    finalized.push(finalize(acc));
-  }
-  const finalizedSessions = [];
-  for (const acc of state.sessionAccumulators.values()) {
-    finalizedSessions.push(finalizeSession(acc));
-  }
-  const batches = [];
-  const maxLength = Math.max(finalized.length, finalizedSessions.length);
-  for (let i = 0; i < maxLength; i += batchSize) {
-    batches.push({
-      buckets: finalized.slice(i, i + batchSize),
-      sessions: finalizedSessions.slice(i, i + batchSize)
-    });
-  }
-  return batches;
-}
-function toUsageAggregationError(cause) {
-  return new UsageAggregationError({
-    message: `usage aggregation failed: ${errorMessage(cause)}`,
-    cause
-  });
-}
-function errorMessage(cause) {
-  return cause instanceof Error ? cause.message : "unknown aggregation error";
-}
-function aggregateUsageStream(source, options) {
-  return Stream2.fromIterableEffect(
-    source.pipe(
-      Stream2.runFoldEffect(
-        () => createUsageAggregationState(),
-        (state, bucket) => addBucketToAggregationStateEffect(state, bucket, options.sessionKeySalt)
-      ),
-      Effect4.map((state) => finalizeUsageBatches(state, options.batchSize))
-    )
-  );
-}
+import { createHash } from "crypto";
 
 // ../../packages/api/src/errors.ts
-import { Schema as Schema4 } from "effect";
+import { Schema as Schema3 } from "effect";
 var ErrorFields = {
-  message: Schema4.String
+  message: Schema3.String
 };
 var InfrastructureErrorFields = {
   ...ErrorFields,
-  cause: Schema4.optionalKey(Schema4.Defect())
+  cause: Schema3.optionalKey(Schema3.Defect())
 };
-var UnauthorizedError = class extends Schema4.TaggedErrorClass()("UnauthorizedError", ErrorFields) {
+var UnauthorizedError = class extends Schema3.TaggedErrorClass()("UnauthorizedError", ErrorFields) {
 };
-var ForbiddenError = class extends Schema4.TaggedErrorClass()("ForbiddenError", ErrorFields) {
+var ForbiddenError = class extends Schema3.TaggedErrorClass()("ForbiddenError", ErrorFields) {
 };
-var NotFoundError = class extends Schema4.TaggedErrorClass()("NotFoundError", ErrorFields) {
+var NotFoundError = class extends Schema3.TaggedErrorClass()("NotFoundError", ErrorFields) {
 };
-var ConflictError = class extends Schema4.TaggedErrorClass()("ConflictError", ErrorFields) {
+var ConflictError = class extends Schema3.TaggedErrorClass()("ConflictError", ErrorFields) {
 };
-var ValidationError = class extends Schema4.TaggedErrorClass()("ValidationError", ErrorFields) {
+var ValidationError = class extends Schema3.TaggedErrorClass()("ValidationError", ErrorFields) {
 };
-var RateLimitedError = class extends Schema4.TaggedErrorClass()("RateLimitedError", ErrorFields) {
+var RateLimitedError = class extends Schema3.TaggedErrorClass()("RateLimitedError", ErrorFields) {
 };
-var ExternalHttpError = class extends Schema4.TaggedErrorClass()(
+var ExternalHttpError = class extends Schema3.TaggedErrorClass()(
   "ExternalHttpError",
   InfrastructureErrorFields
 ) {
 };
-var DatabaseError = class extends Schema4.TaggedErrorClass()(
+var DatabaseError = class extends Schema3.TaggedErrorClass()(
   "DatabaseError",
   InfrastructureErrorFields
 ) {
 };
-var AppConfigError = class extends Schema4.TaggedErrorClass()(
+var AppConfigError = class extends Schema3.TaggedErrorClass()(
   "AppConfigError",
   InfrastructureErrorFields
 ) {
 };
-var PricingRefreshError = class extends Schema4.TaggedErrorClass()(
+var PricingRefreshError = class extends Schema3.TaggedErrorClass()(
   "PricingRefreshError",
   InfrastructureErrorFields
 ) {
 };
-var ParserSourceError2 = class extends Schema4.TaggedErrorClass()(
+var ParserSourceError2 = class extends Schema3.TaggedErrorClass()(
   "ParserSourceError",
   InfrastructureErrorFields
 ) {
 };
-var SyncQuotaExceededError = class extends Schema4.TaggedErrorClass()(
+var SyncQuotaExceededError = class extends Schema3.TaggedErrorClass()(
   "SyncQuotaExceededError",
   ErrorFields
 ) {
 };
-var SyncTimestampRejectedError = class extends Schema4.TaggedErrorClass()(
+var SyncTimestampRejectedError = class extends Schema3.TaggedErrorClass()(
   "SyncTimestampRejectedError",
   ErrorFields
 ) {
 };
 
 // ../../packages/api/src/rpc/auth.ts
-import { Context as Context3, Schema as Schema7 } from "effect";
+import { Context as Context3, Schema as Schema6 } from "effect";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/auth.ts
-import { Schema as Schema5, SchemaGetter } from "effect";
+import { Schema as Schema4, SchemaGetter } from "effect";
 var MAX_DISPLAY_NAME_LENGTH = 80;
-var displayNameInput = Schema5.String.check(Schema5.isMaxLength(MAX_DISPLAY_NAME_LENGTH)).pipe(
-  Schema5.decodeTo(Schema5.NullOr(Schema5.String), {
+var displayNameInput = Schema4.String.check(Schema4.isMaxLength(MAX_DISPLAY_NAME_LENGTH)).pipe(
+  Schema4.decodeTo(Schema4.NullOr(Schema4.String), {
     decode: SchemaGetter.transform((value) => {
       const trimmed = value.trim();
       return trimmed.length === 0 ? null : trimmed;
@@ -745,12 +599,12 @@ var displayNameInput = Schema5.String.check(Schema5.isMaxLength(MAX_DISPLAY_NAME
     encode: SchemaGetter.transform((value) => value ?? "")
   })
 );
-var updateProfileInput = Schema5.Struct({
+var updateProfileInput = Schema4.Struct({
   displayName: displayNameInput
 });
 
 // ../../packages/api/src/schemas/common.ts
-import { Schema as Schema6 } from "effect";
+import { Schema as Schema5 } from "effect";
 var ISO_UTC_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
 var CIVIL_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/u;
 var HEX64_PATTERN = /^[0-9a-f]{64}$/u;
@@ -795,49 +649,49 @@ var isApiUrl = (value) => {
     return false;
   }
 };
-var nonEmptyTrimmedString = Schema6.String.check(
-  Schema6.isTrimmed(),
-  Schema6.isNonEmpty({ message: "Expected a non-empty string" })
+var nonEmptyTrimmedString = Schema5.String.check(
+  Schema5.isTrimmed(),
+  Schema5.isNonEmpty({ message: "Expected a non-empty string" })
 );
-var safeInteger = Schema6.Number.check(
-  Schema6.isInt(),
-  Schema6.isBetween({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER })
+var safeInteger = Schema5.Number.check(
+  Schema5.isInt(),
+  Schema5.isBetween({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER })
 );
-var nonNegativeSafeInteger = safeInteger.check(Schema6.isGreaterThanOrEqualTo(0));
-var isoUtcString = Schema6.String.check(
-  Schema6.makeFilter(isExactUtcInstant, { expected: "an ISO-8601 UTC timestamp with millisecond precision" })
+var nonNegativeSafeInteger = safeInteger.check(Schema5.isGreaterThanOrEqualTo(0));
+var isoUtcString = Schema5.String.check(
+  Schema5.makeFilter(isExactUtcInstant, { expected: "an ISO-8601 UTC timestamp with millisecond precision" })
 );
-var civilDate = Schema6.String.check(
-  Schema6.makeFilter(isCivilDate, { expected: "a valid calendar date formatted as YYYY-MM-DD" })
+var civilDate = Schema5.String.check(
+  Schema5.makeFilter(isCivilDate, { expected: "a valid calendar date formatted as YYYY-MM-DD" })
 );
-var ianaTimezone = Schema6.String.check(
-  Schema6.makeFilter(isIanaTimezone, { expected: "an IANA timezone identifier" })
+var ianaTimezone = Schema5.String.check(
+  Schema5.makeFilter(isIanaTimezone, { expected: "an IANA timezone identifier" })
 );
-var uuidV7 = Schema6.String.check(Schema6.isUUID(UUID_V7_VERSION)).pipe(Schema6.brand("UuidV7"));
-var generalUuid = Schema6.String.check(Schema6.isUUID()).pipe(Schema6.brand("GeneralUuid"));
-var hex64 = Schema6.String.check(
-  Schema6.isPattern(HEX64_PATTERN, { expected: "a 64-character lowercase hex string" })
+var uuidV7 = Schema5.String.check(Schema5.isUUID(UUID_V7_VERSION)).pipe(Schema5.brand("UuidV7"));
+var generalUuid = Schema5.String.check(Schema5.isUUID()).pipe(Schema5.brand("GeneralUuid"));
+var hex64 = Schema5.String.check(
+  Schema5.isPattern(HEX64_PATTERN, { expected: "a 64-character lowercase hex string" })
 );
-var apiUrl = Schema6.String.check(Schema6.makeFilter(isApiUrl, { expected: "an HTTP(S) URL" }));
+var apiUrl = Schema5.String.check(Schema5.makeFilter(isApiUrl, { expected: "an HTTP(S) URL" }));
 
 // ../../packages/api/src/rpc/auth.ts
-var AuthUserResponse = Schema7.Struct({
-  user: Schema7.Struct({
-    id: Schema7.String,
-    email: Schema7.String,
-    displayName: Schema7.NullOr(Schema7.String),
+var AuthUserResponse = Schema6.Struct({
+  user: Schema6.Struct({
+    id: Schema6.String,
+    email: Schema6.String,
+    displayName: Schema6.NullOr(Schema6.String),
     createdAt: isoUtcString
   })
 });
-var LogoutResponse = Schema7.Struct({
-  ok: Schema7.Boolean
+var LogoutResponse = Schema6.Struct({
+  ok: Schema6.Boolean
 });
 var WebRpcContext = class extends Context3.Service()("@oopst/api/WebRpcContext") {
 };
 var AuthRpcs = RpcGroup.make(
   Rpc.make("auth.logout", {
     success: LogoutResponse,
-    error: Schema7.Union([DatabaseError, UnauthorizedError])
+    error: Schema6.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc.make("auth.me", {
     success: AuthUserResponse,
@@ -846,42 +700,42 @@ var AuthRpcs = RpcGroup.make(
   Rpc.make("auth.updateProfile", {
     payload: updateProfileInput,
     success: AuthUserResponse,
-    error: Schema7.Union([DatabaseError, UnauthorizedError])
+    error: Schema6.Union([DatabaseError, UnauthorizedError])
   })
 );
 
 // ../../packages/api/src/rpc/devices.ts
-import { Schema as Schema9 } from "effect";
+import { Schema as Schema8 } from "effect";
 import { Rpc as Rpc2, RpcGroup as RpcGroup2 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/devices.ts
-import { Schema as Schema8 } from "effect";
+import { Schema as Schema7 } from "effect";
 var MIN_DEVICE_NAME_LENGTH = 1;
 var MAX_DEVICE_NAME_LENGTH = 80;
 var UUID_V7_VERSION2 = 7;
-var deviceNameSchema = Schema8.String.check(
-  Schema8.isMinLength(MIN_DEVICE_NAME_LENGTH),
-  Schema8.isMaxLength(MAX_DEVICE_NAME_LENGTH)
+var deviceNameSchema = Schema7.String.check(
+  Schema7.isMinLength(MIN_DEVICE_NAME_LENGTH),
+  Schema7.isMaxLength(MAX_DEVICE_NAME_LENGTH)
 );
-var editableDeviceNameSchema = Schema8.Trim.check(
-  Schema8.isMinLength(MIN_DEVICE_NAME_LENGTH),
-  Schema8.isMaxLength(MAX_DEVICE_NAME_LENGTH)
+var editableDeviceNameSchema = Schema7.Trim.check(
+  Schema7.isMinLength(MIN_DEVICE_NAME_LENGTH),
+  Schema7.isMaxLength(MAX_DEVICE_NAME_LENGTH)
 );
-var deviceIdSchema = Schema8.String.check(Schema8.isUUID(UUID_V7_VERSION2));
-var renameDeviceInput = Schema8.Struct({
+var deviceIdSchema = Schema7.String.check(Schema7.isUUID(UUID_V7_VERSION2));
+var renameDeviceInput = Schema7.Struct({
   id: deviceIdSchema,
   name: editableDeviceNameSchema
 });
-var deleteDeviceInput = Schema8.Struct({
+var deleteDeviceInput = Schema7.Struct({
   id: deviceIdSchema
 });
-var renameDeviceOutput = Schema8.Struct({
+var renameDeviceOutput = Schema7.Struct({
   id: deviceIdSchema,
-  name: Schema8.String,
+  name: Schema7.String,
   lastSeen: isoUtcString
 });
-var deleteDeviceOutput = Schema8.Struct({
-  ok: Schema8.Boolean
+var deleteDeviceOutput = Schema7.Struct({
+  ok: Schema7.Boolean
 });
 
 // ../../packages/api/src/rpc/devices.ts
@@ -889,27 +743,27 @@ var DevicesRpcs = RpcGroup2.make(
   Rpc2.make("devices.rename", {
     payload: renameDeviceInput,
     success: renameDeviceOutput,
-    error: Schema9.Union([ConflictError, DatabaseError, NotFoundError, UnauthorizedError])
+    error: Schema8.Union([ConflictError, DatabaseError, NotFoundError, UnauthorizedError])
   }),
   Rpc2.make("devices.delete", {
     payload: deleteDeviceInput,
     success: deleteDeviceOutput,
-    error: Schema9.Union([DatabaseError, NotFoundError, UnauthorizedError])
+    error: Schema8.Union([DatabaseError, NotFoundError, UnauthorizedError])
   })
 );
 
 // ../../packages/api/src/rpc/stats.ts
-import { Schema as Schema11 } from "effect";
+import { Schema as Schema10 } from "effect";
 import { Rpc as Rpc3, RpcGroup as RpcGroup3 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/stats.ts
-import { Effect as Effect5, Schema as Schema10 } from "effect";
-var scopeEnum = Schema10.Literals(["all", "me"]);
-var costStackByValueEnum = Schema10.Literals(["device", "harness", "model"]);
-var costStackByEnum = Schema10.optional(costStackByValueEnum);
-var usageDetailStackByEnum = Schema10.Literals(["device", "harness", "model"]);
-var stackByValueEnum = Schema10.Literals(["device", "harness"]);
-var stackByEnum = Schema10.optional(stackByValueEnum);
+import { Effect as Effect4, Schema as Schema9 } from "effect";
+var scopeEnum = Schema9.Literals(["all", "me"]);
+var costStackByValueEnum = Schema9.Literals(["device", "harness", "model"]);
+var costStackByEnum = Schema9.optional(costStackByValueEnum);
+var usageDetailStackByEnum = Schema9.Literals(["device", "harness", "model"]);
+var stackByValueEnum = Schema9.Literals(["device", "harness"]);
+var stackByEnum = Schema9.optional(stackByValueEnum);
 var MAX_TIME_ZONE_LENGTH = 64;
 var DEFAULT_DAYS = 90;
 var MAX_DAYS = 365;
@@ -927,16 +781,16 @@ var MAX_LEADERBOARD_LIMIT = 50;
 var DEFAULT_LEADERBOARD_LIMIT = 10;
 var UUID_V7_VERSION3 = 7;
 var CIVIL_DATE_PATTERN2 = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})$/u;
-var timeZoneSchema = ianaTimezone.check(Schema10.isMaxLength(MAX_TIME_ZONE_LENGTH));
+var timeZoneSchema = ianaTimezone.check(Schema9.isMaxLength(MAX_TIME_ZONE_LENGTH));
 var civilDateSchema = civilDate;
-var daysSchema = safeInteger.check(Schema10.isBetween({ minimum: MIN_LEADERBOARD_LIMIT, maximum: MAX_DAYS })).pipe(Schema10.withDecodingDefaultTypeKey(Effect5.succeed(DEFAULT_DAYS)));
-var leaderboardLimitSchema = safeInteger.check(Schema10.isBetween({ minimum: MIN_LEADERBOARD_LIMIT, maximum: MAX_LEADERBOARD_LIMIT })).pipe(Schema10.withDecodingDefaultTypeKey(Effect5.succeed(DEFAULT_LEADERBOARD_LIMIT)));
-var defaultTimeZoneSchema = timeZoneSchema.pipe(Schema10.withDecodingDefaultTypeKey(Effect5.succeed("UTC")));
-var uuidSchema = Schema10.String.check(Schema10.isUUID(UUID_V7_VERSION3));
+var daysSchema = safeInteger.check(Schema9.isBetween({ minimum: MIN_LEADERBOARD_LIMIT, maximum: MAX_DAYS })).pipe(Schema9.withDecodingDefaultTypeKey(Effect4.succeed(DEFAULT_DAYS)));
+var leaderboardLimitSchema = safeInteger.check(Schema9.isBetween({ minimum: MIN_LEADERBOARD_LIMIT, maximum: MAX_LEADERBOARD_LIMIT })).pipe(Schema9.withDecodingDefaultTypeKey(Effect4.succeed(DEFAULT_LEADERBOARD_LIMIT)));
+var defaultTimeZoneSchema = timeZoneSchema.pipe(Schema9.withDecodingDefaultTypeKey(Effect4.succeed("UTC")));
+var uuidSchema = Schema9.String.check(Schema9.isUUID(UUID_V7_VERSION3));
 var rangeFields = {
   days: daysSchema,
-  endDate: Schema10.optional(civilDateSchema),
-  startDate: Schema10.optional(civilDateSchema)
+  endDate: Schema9.optional(civilDateSchema),
+  startDate: Schema9.optional(civilDateSchema)
 };
 function validateDateRange(input) {
   if (!(input.startDate || input.endDate)) {
@@ -976,216 +830,216 @@ function parseCivilDateUtcMs(date) {
   }
   return parsed.getTime();
 }
-var dailyCostInput = Schema10.Struct({
+var dailyCostInput = Schema9.Struct({
   scope: scopeEnum,
   stackBy: costStackByEnum,
   ...rangeFields,
   timeZone: defaultTimeZoneSchema
-}).check(Schema10.makeFilter(validateDateRange));
-var dailyPointSchema = Schema10.Struct({
+}).check(Schema9.makeFilter(validateDateRange));
+var dailyPointSchema = Schema9.Struct({
   /** Local civil date in YYYY-MM-DD for the requested stats timezone. */
   date: civilDateSchema,
   /** null when stackBy is undefined. */
-  seriesName: Schema10.NullOr(Schema10.String),
+  seriesName: Schema9.NullOr(Schema9.String),
   /** USD; 0 or positive. */
-  usd: Schema10.Number
+  usd: Schema9.Number
 });
-var dailyCostOutput = Schema10.Array(dailyPointSchema);
-var dailySessionsInput = Schema10.Struct({
+var dailyCostOutput = Schema9.Array(dailyPointSchema);
+var dailySessionsInput = Schema9.Struct({
   scope: scopeEnum,
   stackBy: stackByEnum,
   ...rangeFields,
   timeZone: defaultTimeZoneSchema
-}).check(Schema10.makeFilter(validateDateRange));
-var dailySessionsPointSchema = Schema10.Struct({
+}).check(Schema9.makeFilter(validateDateRange));
+var dailySessionsPointSchema = Schema9.Struct({
   date: civilDateSchema,
-  seriesName: Schema10.NullOr(Schema10.String),
+  seriesName: Schema9.NullOr(Schema9.String),
   sessions: nonNegativeSafeInteger
 });
-var dailySessionsOutput = Schema10.Array(dailySessionsPointSchema);
+var dailySessionsOutput = Schema9.Array(dailySessionsPointSchema);
 var weekdaySessionsInput = dailySessionsInput;
-var weekdaySessionsPointSchema = Schema10.Struct({
+var weekdaySessionsPointSchema = Schema9.Struct({
   /** Local ISO weekday for the requested stats timezone: 1=Monday, 7=Sunday. */
-  weekday: safeInteger.check(Schema10.isBetween({ minimum: MIN_ISO_WEEKDAY, maximum: MAX_ISO_WEEKDAY })),
-  seriesName: Schema10.NullOr(Schema10.String),
+  weekday: safeInteger.check(Schema9.isBetween({ minimum: MIN_ISO_WEEKDAY, maximum: MAX_ISO_WEEKDAY })),
+  seriesName: Schema9.NullOr(Schema9.String),
   sessions: nonNegativeSafeInteger
 });
-var weekdaySessionsOutput = Schema10.Array(weekdaySessionsPointSchema);
+var weekdaySessionsOutput = Schema9.Array(weekdaySessionsPointSchema);
 var hourlySessionsInput = dailySessionsInput;
-var hourlySessionsPointSchema = Schema10.Struct({
+var hourlySessionsPointSchema = Schema9.Struct({
   /** Local hour of day for the requested stats timezone: 0-23. */
-  hour: safeInteger.check(Schema10.isBetween({ minimum: MIN_HOUR_OF_DAY, maximum: MAX_HOUR_OF_DAY })),
-  seriesName: Schema10.NullOr(Schema10.String),
+  hour: safeInteger.check(Schema9.isBetween({ minimum: MIN_HOUR_OF_DAY, maximum: MAX_HOUR_OF_DAY })),
+  seriesName: Schema9.NullOr(Schema9.String),
   sessions: nonNegativeSafeInteger
 });
-var hourlySessionsOutput = Schema10.Array(hourlySessionsPointSchema);
-var summaryInput = Schema10.Struct({
+var hourlySessionsOutput = Schema9.Array(hourlySessionsPointSchema);
+var summaryInput = Schema9.Struct({
   ...rangeFields,
   scope: scopeEnum,
   timeZone: defaultTimeZoneSchema
-}).check(Schema10.makeFilter(validateDateRange));
-var summaryOutput = Schema10.Struct({
-  rangeUsd: Schema10.Number.check(Schema10.isGreaterThanOrEqualTo(0)),
+}).check(Schema9.makeFilter(validateDateRange));
+var summaryOutput = Schema9.Struct({
+  rangeUsd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
   rangeSessions: nonNegativeSafeInteger,
   rangeSubjectCount: nonNegativeSafeInteger,
-  totalUsd: Schema10.Number.check(Schema10.isGreaterThanOrEqualTo(0)),
+  totalUsd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
   totalSessions: nonNegativeSafeInteger
 });
-var deviceSummarySchema = Schema10.Struct({
+var deviceSummarySchema = Schema9.Struct({
   id: uuidSchema,
-  name: Schema10.String,
+  name: Schema9.String,
   /** ISO-8601 UTC. */
   lastSeen: isoUtcString
 });
-var devicesOutput = Schema10.Array(deviceSummarySchema);
-var participantSyncSchema = Schema10.Struct({
+var devicesOutput = Schema9.Array(deviceSummarySchema);
+var participantSyncSchema = Schema9.Struct({
   userId: uuidSchema,
-  userLabel: Schema10.String,
+  userLabel: Schema9.String,
   /** ISO-8601 UTC, null when the participant has no synced devices yet. */
-  latestSyncAt: Schema10.NullOr(isoUtcString)
+  latestSyncAt: Schema9.NullOr(isoUtcString)
 });
-var participantsOutput = Schema10.Array(participantSyncSchema);
-var leaderboardInput = Schema10.Struct({
+var participantsOutput = Schema9.Array(participantSyncSchema);
+var leaderboardInput = Schema9.Struct({
   ...rangeFields,
   limit: leaderboardLimitSchema,
   timeZone: defaultTimeZoneSchema
-}).check(Schema10.makeFilter(validateDateRange));
-var leaderboardRowSchema = Schema10.Struct({
-  rank: safeInteger.check(Schema10.isGreaterThanOrEqualTo(1)),
+}).check(Schema9.makeFilter(validateDateRange));
+var leaderboardRowSchema = Schema9.Struct({
+  rank: safeInteger.check(Schema9.isGreaterThanOrEqualTo(1)),
   userId: uuidSchema,
-  userLabel: Schema10.String,
-  usd: Schema10.Number.check(Schema10.isGreaterThanOrEqualTo(0)),
+  userLabel: Schema9.String,
+  usd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
   tokens: nonNegativeSafeInteger,
   sessions: nonNegativeSafeInteger
 });
-var leaderboardOutput = Schema10.Array(leaderboardRowSchema);
+var leaderboardOutput = Schema9.Array(leaderboardRowSchema);
 var topDimensionsInput = leaderboardInput;
-var topDimensionRowSchema = Schema10.Struct({
-  rank: safeInteger.check(Schema10.isGreaterThanOrEqualTo(1)),
-  name: Schema10.String,
-  usd: Schema10.Number.check(Schema10.isGreaterThanOrEqualTo(0)),
+var topDimensionRowSchema = Schema9.Struct({
+  rank: safeInteger.check(Schema9.isGreaterThanOrEqualTo(1)),
+  name: Schema9.String,
+  usd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
   tokens: nonNegativeSafeInteger,
-  sessions: Schema10.NullOr(nonNegativeSafeInteger)
+  sessions: Schema9.NullOr(nonNegativeSafeInteger)
 });
-var topDimensionsOutput = Schema10.Struct({
-  harnesses: Schema10.Array(topDimensionRowSchema),
-  models: Schema10.Array(topDimensionRowSchema)
+var topDimensionsOutput = Schema9.Struct({
+  harnesses: Schema9.Array(topDimensionRowSchema),
+  models: Schema9.Array(topDimensionRowSchema)
 });
-var usageDetailsInput = Schema10.Struct({
+var usageDetailsInput = Schema9.Struct({
   ...rangeFields,
   stackBy: usageDetailStackByEnum,
   timeZone: defaultTimeZoneSchema
-}).check(Schema10.makeFilter(validateDateRange));
-var usageDetailsRowSchema = Schema10.Struct({
-  id: Schema10.String,
-  name: Schema10.String,
+}).check(Schema9.makeFilter(validateDateRange));
+var usageDetailsRowSchema = Schema9.Struct({
+  id: Schema9.String,
+  name: Schema9.String,
   tokens: nonNegativeSafeInteger,
-  sessions: Schema10.NullOr(nonNegativeSafeInteger),
-  usd: Schema10.Number.check(Schema10.isGreaterThanOrEqualTo(0)),
-  totalUsd: Schema10.Number.check(Schema10.isGreaterThanOrEqualTo(0))
+  sessions: Schema9.NullOr(nonNegativeSafeInteger),
+  usd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
+  totalUsd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0))
 });
-var usageDetailsOutput = Schema10.Array(usageDetailsRowSchema);
+var usageDetailsOutput = Schema9.Array(usageDetailsRowSchema);
 
 // ../../packages/api/src/rpc/stats.ts
 var StatsRpcs = RpcGroup3.make(
   Rpc3.make("stats.devices", {
     success: devicesOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.participants", {
     success: participantsOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.leaderboard", {
     payload: leaderboardInput,
     success: leaderboardOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.topDimensions", {
     payload: topDimensionsInput,
     success: topDimensionsOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.summary", {
     payload: summaryInput,
     success: summaryOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.dailyCost", {
     payload: dailyCostInput,
     success: dailyCostOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.dailySessions", {
     payload: dailySessionsInput,
     success: dailySessionsOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.weekdaySessions", {
     payload: weekdaySessionsInput,
     success: weekdaySessionsOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.hourlySessions", {
     payload: hourlySessionsInput,
     success: hourlySessionsOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.usageDetails", {
     payload: usageDetailsInput,
     success: usageDetailsOutput,
-    error: Schema11.Union([DatabaseError, UnauthorizedError])
+    error: Schema10.Union([DatabaseError, UnauthorizedError])
   })
 );
 
 // ../../packages/api/src/rpc/tokens.ts
-import { Schema as Schema13 } from "effect";
+import { Schema as Schema12 } from "effect";
 import { Rpc as Rpc4, RpcGroup as RpcGroup4 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/tokens.ts
-import { Schema as Schema12 } from "effect";
+import { Schema as Schema11 } from "effect";
 var MIN_TOKEN_NAME_LENGTH = 1;
 var MAX_TOKEN_NAME_LENGTH = 80;
-var createTokenInput = Schema12.Struct({
-  name: Schema12.String.check(Schema12.isMinLength(MIN_TOKEN_NAME_LENGTH), Schema12.isMaxLength(MAX_TOKEN_NAME_LENGTH))
+var createTokenInput = Schema11.Struct({
+  name: Schema11.String.check(Schema11.isMinLength(MIN_TOKEN_NAME_LENGTH), Schema11.isMaxLength(MAX_TOKEN_NAME_LENGTH))
 });
-var revokeTokenInput = Schema12.Struct({
+var revokeTokenInput = Schema11.Struct({
   id: uuidV7
 });
-var tokenMetadata = Schema12.Struct({
+var tokenMetadata = Schema11.Struct({
   id: uuidV7,
-  name: Schema12.String,
-  prefix: Schema12.String,
+  name: Schema11.String,
+  prefix: Schema11.String,
   createdAt: isoUtcString,
-  lastUsedAt: Schema12.NullOr(isoUtcString),
-  revokedAt: Schema12.NullOr(isoUtcString)
+  lastUsedAt: Schema11.NullOr(isoUtcString),
+  revokedAt: Schema11.NullOr(isoUtcString)
 });
-var listTokensOutput = Schema12.Struct({
-  tokens: Schema12.Array(tokenMetadata)
+var listTokensOutput = Schema11.Struct({
+  tokens: Schema11.Array(tokenMetadata)
 });
-var createTokenOutput = Schema12.Struct({
-  token: Schema12.String,
+var createTokenOutput = Schema11.Struct({
+  token: Schema11.String,
   metadata: tokenMetadata
 });
-var revokeTokenOutput = Schema12.Struct({
-  ok: Schema12.Boolean
+var revokeTokenOutput = Schema11.Struct({
+  ok: Schema11.Boolean
 });
 
 // ../../packages/api/src/rpc/tokens.ts
 var TokensRpcs = RpcGroup4.make(
   Rpc4.make("tokens.list", {
     success: listTokensOutput,
-    error: Schema13.Union([DatabaseError, UnauthorizedError])
+    error: Schema12.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc4.make("tokens.create", {
     payload: createTokenInput,
     success: createTokenOutput,
-    error: Schema13.Union([DatabaseError, UnauthorizedError])
+    error: Schema12.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc4.make("tokens.revoke", {
     payload: revokeTokenInput,
     success: revokeTokenOutput,
-    error: Schema13.Union([DatabaseError, NotFoundError, UnauthorizedError])
+    error: Schema12.Union([DatabaseError, NotFoundError, UnauthorizedError])
   })
 );
 
@@ -1193,11 +1047,11 @@ var TokensRpcs = RpcGroup4.make(
 var WebRpcs = AuthRpcs.merge(StatsRpcs).merge(TokensRpcs).merge(DevicesRpcs);
 
 // ../../packages/api/src/rpc/sync.ts
-import { Schema as Schema15 } from "effect";
+import { Schema as Schema14 } from "effect";
 import { Rpc as Rpc5, RpcGroup as RpcGroup5 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/sync.ts
-import { Effect as Effect6, Schema as Schema14 } from "effect";
+import { Effect as Effect5, Schema as Schema13 } from "effect";
 var MIN_DEVICE_NAME_LENGTH2 = 1;
 var MAX_DEVICE_NAME_LENGTH2 = 80;
 var MIN_MODEL_LENGTH = 1;
@@ -1208,28 +1062,31 @@ var MAX_BUCKETS_PER_SYNC = 5e3;
 var MAX_SESSIONS_PER_SYNC = 5e3;
 var MAX_BUCKET_SESSION_COUNT = 1e3;
 var MAX_BUCKET_TOKEN_COUNT = null;
+var MAX_REPLACEMENT_BATCHES = 1e4;
+var MAX_REPLACEMENT_FACTS = 1e5;
 var HARNESSES = ["codex", "claude_code", "pi", "hermes", "opencode"];
-var harnessEnum = Schema14.Literals(HARNESSES);
-var deviceNameSchema2 = Schema14.String.check(
-  Schema14.isMinLength(MIN_DEVICE_NAME_LENGTH2),
-  Schema14.isMaxLength(MAX_DEVICE_NAME_LENGTH2)
+var MAX_REPLACEMENT_HARNESSES = HARNESSES.length;
+var harnessEnum = Schema13.Literals(HARNESSES);
+var deviceNameSchema2 = Schema13.String.check(
+  Schema13.isMinLength(MIN_DEVICE_NAME_LENGTH2),
+  Schema13.isMaxLength(MAX_DEVICE_NAME_LENGTH2)
 );
-var getWatermarkInput = Schema14.Struct({
+var getWatermarkInput = Schema13.Struct({
   device: deviceNameSchema2
 });
-var getWatermarkOutput = Schema14.Struct({
-  watermarkHourUtc: Schema14.NullOr(isoUtcString),
-  sessionKeySalt: hex64.check(Schema14.isLengthBetween(SESSION_KEY_SALT_LENGTH, SESSION_KEY_SALT_LENGTH))
+var getWatermarkOutput = Schema13.Struct({
+  watermarkHourUtc: Schema13.NullOr(isoUtcString),
+  sessionKeySalt: hex64.check(Schema13.isLengthBetween(SESSION_KEY_SALT_LENGTH, SESSION_KEY_SALT_LENGTH))
 });
 function boundedInteger(max) {
   if (max === null) {
     return nonNegativeSafeInteger;
   }
-  return nonNegativeSafeInteger.check(Schema14.isLessThanOrEqualTo(max));
+  return nonNegativeSafeInteger.check(Schema13.isLessThanOrEqualTo(max));
 }
-var bucketInput = Schema14.Struct({
+var bucketInput = Schema13.Struct({
   harness: harnessEnum,
-  model: Schema14.String.check(Schema14.isMinLength(MIN_MODEL_LENGTH), Schema14.isMaxLength(MAX_MODEL_LENGTH)),
+  model: Schema13.String.check(Schema13.isMinLength(MIN_MODEL_LENGTH), Schema13.isMaxLength(MAX_MODEL_LENGTH)),
   hourUtc: isoUtcString,
   inputTokens: boundedInteger(MAX_BUCKET_TOKEN_COUNT),
   outputTokens: boundedInteger(MAX_BUCKET_TOKEN_COUNT),
@@ -1237,149 +1094,458 @@ var bucketInput = Schema14.Struct({
   cacheCreateTokens: boundedInteger(MAX_BUCKET_TOKEN_COUNT),
   sessionCount: boundedInteger(MAX_BUCKET_SESSION_COUNT)
 });
-var sessionInput = Schema14.Struct({
+var sessionInput = Schema13.Struct({
   harness: harnessEnum,
-  sessionKey: hex64.check(Schema14.isLengthBetween(SESSION_KEY_LENGTH, SESSION_KEY_LENGTH)),
+  sessionKey: hex64.check(Schema13.isLengthBetween(SESSION_KEY_LENGTH, SESSION_KEY_LENGTH)),
   startedAt: isoUtcString,
   lastSeenAt: isoUtcString
 });
-var upsertBucketsInput = Schema14.Struct({
+var upsertBucketsInput = Schema13.Struct({
   device: deviceNameSchema2,
-  buckets: Schema14.Array(bucketInput).check(Schema14.isMaxLength(MAX_BUCKETS_PER_SYNC)),
-  sessions: Schema14.Array(sessionInput).check(Schema14.isMaxLength(MAX_SESSIONS_PER_SYNC)).pipe(Schema14.withDecodingDefaultTypeKey(Effect6.succeed([])))
+  buckets: Schema13.Array(bucketInput).check(Schema13.isMaxLength(MAX_BUCKETS_PER_SYNC)),
+  sessions: Schema13.Array(sessionInput).check(Schema13.isMaxLength(MAX_SESSIONS_PER_SYNC)).pipe(Schema13.withDecodingDefaultTypeKey(Effect5.succeed([])))
 });
-var upsertBucketsOutput = Schema14.Struct({
+var upsertBucketsOutput = Schema13.Struct({
   upserted: boundedInteger(null),
   upsertedSessions: boundedInteger(null)
 });
+var replacementId = uuidV7;
+var createUsageReplacementInput = Schema13.Struct({
+  device: deviceNameSchema2,
+  startHourUtc: isoUtcString,
+  endHourUtc: isoUtcString,
+  harnesses: Schema13.Array(harnessEnum).check(Schema13.isMinLength(1), Schema13.isMaxLength(MAX_REPLACEMENT_HARNESSES))
+});
+var createUsageReplacementOutput = Schema13.Struct({
+  replacementId,
+  startHourUtc: isoUtcString,
+  endHourUtc: isoUtcString,
+  harnesses: Schema13.Array(harnessEnum),
+  expiresAt: isoUtcString
+});
+var stageUsageReplacementBatchInput = Schema13.Struct({
+  device: deviceNameSchema2,
+  replacementId,
+  batchIndex: boundedInteger(MAX_REPLACEMENT_BATCHES),
+  batchDigest: hex64,
+  buckets: Schema13.Array(bucketInput).check(Schema13.isMaxLength(MAX_BUCKETS_PER_SYNC)),
+  sessions: Schema13.Array(sessionInput).check(Schema13.isMaxLength(MAX_SESSIONS_PER_SYNC))
+});
+var stageUsageReplacementBatchOutput = Schema13.Struct({
+  stagedBuckets: boundedInteger(MAX_BUCKETS_PER_SYNC),
+  stagedSessions: boundedInteger(MAX_SESSIONS_PER_SYNC),
+  alreadyStaged: Schema13.Boolean
+});
+var finalizeUsageReplacementInput = Schema13.Struct({
+  device: deviceNameSchema2,
+  replacementId,
+  expectedBatchCount: boundedInteger(MAX_REPLACEMENT_BATCHES),
+  expectedBucketCount: boundedInteger(MAX_REPLACEMENT_FACTS),
+  expectedSessionCount: boundedInteger(MAX_REPLACEMENT_FACTS),
+  digest: hex64
+});
+var finalizeUsageReplacementOutput = Schema13.Struct({
+  replacementId,
+  committedAt: isoUtcString,
+  replacedBuckets: boundedInteger(MAX_REPLACEMENT_FACTS),
+  replacedSessions: boundedInteger(MAX_REPLACEMENT_FACTS),
+  digest: hex64
+});
 
 // ../../packages/api/src/rpc/sync.ts
+var replacementErrors = Schema14.Union([
+  ConflictError,
+  DatabaseError,
+  NotFoundError,
+  SyncQuotaExceededError,
+  SyncTimestampRejectedError,
+  UnauthorizedError,
+  ValidationError
+]);
 var SyncRpcs = RpcGroup5.make(
   Rpc5.make("sync.getWatermark", {
     payload: getWatermarkInput,
     success: getWatermarkOutput,
-    error: Schema15.Union([DatabaseError, UnauthorizedError])
+    error: Schema14.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc5.make("sync.upsertBuckets", {
     payload: upsertBucketsInput,
     success: upsertBucketsOutput,
-    error: Schema15.Union([DatabaseError, SyncQuotaExceededError, SyncTimestampRejectedError, UnauthorizedError])
+    error: Schema14.Union([DatabaseError, SyncQuotaExceededError, SyncTimestampRejectedError, UnauthorizedError])
+  }),
+  Rpc5.make("sync.createUsageReplacement", {
+    payload: createUsageReplacementInput,
+    success: createUsageReplacementOutput,
+    error: replacementErrors
+  }),
+  Rpc5.make("sync.stageUsageReplacementBatch", {
+    payload: stageUsageReplacementBatchInput,
+    success: stageUsageReplacementBatchOutput,
+    error: replacementErrors
+  }),
+  Rpc5.make("sync.finalizeUsageReplacement", {
+    payload: finalizeUsageReplacementInput,
+    success: finalizeUsageReplacementOutput,
+    error: replacementErrors
   })
 );
 
-// src/sync/client.ts
-import { Context as Context4, Effect as Effect7, Layer as Layer3 } from "effect";
-import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-var AUTHORIZATION_HEADER = "authorization";
-var SYNC_RPC_PATH = "/rpc/sync";
-var SyncRpcClient = class extends Context4.Service()("@oopst/cli/SyncRpcClient") {
-};
-function syncRpcClientFromPromiseClient(client) {
-  const getWatermark = Effect7.fn("SyncRpcClient.fromPromise.getWatermark")(
-    (input) => Effect7.tryPromise({
-      try: () => client.sync.getWatermark.mutate(input),
-      catch: (err) => err
-    })
-  );
-  const upsertBuckets = Effect7.fn("SyncRpcClient.fromPromise.upsertBuckets")(
-    (input) => Effect7.tryPromise({
-      try: () => client.sync.upsertBuckets.mutate(input),
-      catch: (err) => err
-    })
-  );
-  return SyncRpcClient.of({ getWatermark, upsertBuckets });
-}
-function makeSyncRpcClientLayer(options) {
-  return Layer3.effect(
-    SyncRpcClient,
-    Effect7.gen(function* () {
-      const client = yield* RpcClient.make(SyncRpcs);
-      const getWatermark = Effect7.fn("SyncRpcClient.getWatermark")(
-        (input) => client["sync.getWatermark"](input)
-      );
-      const upsertBuckets = Effect7.fn("SyncRpcClient.upsertBuckets")(
-        (input) => client["sync.upsertBuckets"](input)
-      );
-      return SyncRpcClient.of({ getWatermark, upsertBuckets });
-    })
-  ).pipe(Layer3.provide(makeClientLive(options)));
-}
-function makeClientLive(options) {
-  let clientLive = RpcClient.layerProtocolHttp({
-    url: stripTrailingSlash(options.serverUrl),
-    transformClient: HttpClient.mapRequest(
-      (request) => request.pipe(
-        HttpClientRequest.appendUrl(SYNC_RPC_PATH),
-        HttpClientRequest.setHeader(AUTHORIZATION_HEADER, `Bearer ${options.token}`)
-      )
+// ../../packages/api/src/sync-replacement-canonical.ts
+function normalizedIso(value) {
+  return new Date(value).toISOString();
+}
+function canonicalReplacementLines(facts) {
+  const lines = [
+    ...facts.buckets.map(
+      (bucket) => JSON.stringify([
+        "bucket",
+        bucket.harness,
+        bucket.model,
+        normalizedIso(bucket.hourUtc),
+        bucket.inputTokens,
+        bucket.outputTokens,
+        bucket.cacheReadTokens,
+        bucket.cacheCreateTokens,
+        bucket.sessionCount
+      ])
+    ),
+    ...facts.sessions.map(
+      (session) => JSON.stringify([
+        "session",
+        session.harness,
+        session.sessionKey,
+        normalizedIso(session.startedAt),
+        normalizedIso(session.lastSeenAt)
+      ])
     )
-  }).pipe(Layer3.provide(RpcSerialization.layerJson), Layer3.provide(FetchHttpClient.layer));
-  if (options.fetch) {
-    clientLive = clientLive.pipe(Layer3.provide(Layer3.succeed(FetchHttpClient.Fetch, options.fetch)));
-  }
-  return clientLive;
+  ];
+  return lines.sort();
 }
-function stripTrailingSlash(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
+function canonicalReplacementPayload(facts) {
+  return canonicalReplacementLines(facts).join("\n");
 }
 
-// src/sync/errors.ts
-import { Schema as Schema16 } from "effect";
-var SUCCESS_EXIT_CODE = 0;
-var ZERO_BUCKETS_EXIT_CODE = 1;
-var UNAUTHORIZED_EXIT_CODE = 2;
-var NETWORK_ERROR_EXIT_CODE = 3;
-var INVALID_ARGUMENTS_EXIT_CODE = 4;
-var GENERAL_FAILURE_EXIT_CODE = 5;
-var EXIT_CODES = [
-  SUCCESS_EXIT_CODE,
-  ZERO_BUCKETS_EXIT_CODE,
-  UNAUTHORIZED_EXIT_CODE,
-  NETWORK_ERROR_EXIT_CODE,
-  INVALID_ARGUMENTS_EXIT_CODE,
-  GENERAL_FAILURE_EXIT_CODE
-];
-var EXIT = {
-  success: SUCCESS_EXIT_CODE,
-  zeroBucketsButSourcesExist: ZERO_BUCKETS_EXIT_CODE,
-  unauthorized: UNAUTHORIZED_EXIT_CODE,
-  networkError: NETWORK_ERROR_EXIT_CODE,
-  invalidArguments: INVALID_ARGUMENTS_EXIT_CODE,
-  generalFailure: GENERAL_FAILURE_EXIT_CODE
+// src/sync/run.ts
+import { Effect as Effect9, Stream as Stream4 } from "effect";
+
+// src/sync/aggregate.ts
+import { createHmac } from "crypto";
+import { Effect as Effect6, Schema as Schema15, Stream as Stream2 } from "effect";
+var UsageAggregationErrorFields = {
+  message: Schema15.String,
+  cause: Schema15.optionalKey(Schema15.Defect())
 };
-var SyncError = class extends Schema16.TaggedErrorClass()("SyncError", {
-  message: Schema16.String,
-  exitCode: Schema16.Literals(EXIT_CODES),
-  cause: Schema16.optionalKey(Schema16.Defect())
-}) {
-  constructor(exitCode, message, options = {}) {
-    super(
-      options.cause === void 0 ? { message, exitCode } : { message, exitCode, cause: options.cause }
-    );
-  }
+var UsageAggregationError = class extends Schema15.TaggedErrorClass()(
+  "UsageAggregationError",
+  UsageAggregationErrorFields
+) {
 };
-function isUnauthorizedError(err) {
-  if (err instanceof UnauthorizedError) {
-    return true;
-  }
-  if (typeof err !== "object" || err === null) {
-    return false;
-  }
-  const candidate = err;
-  return candidate._tag === "UnauthorizedError" || candidate.data?.code === "UNAUTHORIZED";
+function toIso(hourUtc) {
+  return hourUtc instanceof Date ? hourUtc.toISOString() : hourUtc;
 }
-var NETWORK_ERROR_CODES = ["ECONNREFUSED", "ENOTFOUND", "ECONNRESET", "EAI_AGAIN", "ETIMEDOUT"];
-var NETWORK_ERROR_PATTERN = /fetch failed|network|ECONN|ENOTFOUND|ETIMEDOUT/iu;
-var NETWORK_HTTP_ERROR_KINDS = ["InvalidUrlError", "TransportError"];
-function isNetworkError(err) {
-  if (typeof err !== "object" || err === null) {
-    return false;
-  }
-  const rpcReason = err.reason;
-  if (rpcReason?._tag === "HttpError" && rpcReason.kind && NETWORK_HTTP_ERROR_KINDS.includes(rpcReason.kind)) {
-    return true;
-  }
+function key(b) {
+  return `${b.harness} ${b.model} ${toIso(b.hourUtc)}`;
+}
+function finalize(acc) {
+  return {
+    harness: acc.harness,
+    model: acc.model,
+    hourUtc: acc.hourUtc,
+    inputTokens: acc.inputTokens,
+    outputTokens: acc.outputTokens,
+    cacheReadTokens: acc.cacheReadTokens,
+    cacheCreateTokens: acc.cacheCreateTokens,
+    sessionCount: acc.sessionIds.size
+  };
+}
+var SESSION_KEY_SALT_PATTERN = /^[a-f0-9]{64}$/u;
+function createSessionKey(harness, localSessionId, sessionKeySalt) {
+  if (!SESSION_KEY_SALT_PATTERN.test(sessionKeySalt)) {
+    throw new Error("invalid session key salt");
+  }
+  return createHmac("sha256", Buffer.from(sessionKeySalt, "hex")).update("oopst/session-key/v1").update("\0").update(harness).update("\0").update(localSessionId).digest("hex");
+}
+function sessionMapKey(harness, sessionKey) {
+  return `${harness} ${sessionKey}`;
+}
+function finalizeSession(acc) {
+  return {
+    harness: acc.harness,
+    sessionKey: acc.sessionKey,
+    startedAt: acc.startedAt.toISOString(),
+    lastSeenAt: acc.lastSeenAt.toISOString()
+  };
+}
+function addSessionAccumulator(sessionAccumulators, bucket, localSessionId, sessionKeySalt) {
+  const sessionKey = createSessionKey(bucket.harness, localSessionId, sessionKeySalt);
+  const sessionAccumulatorKey = sessionMapKey(bucket.harness, sessionKey);
+  const existingSession = sessionAccumulators.get(sessionAccumulatorKey);
+  if (existingSession) {
+    if (bucket.sessionStartedAt.getTime() < existingSession.startedAt.getTime()) {
+      existingSession.startedAt = bucket.sessionStartedAt;
+    }
+    if (bucket.sessionLastSeenAt.getTime() > existingSession.lastSeenAt.getTime()) {
+      existingSession.lastSeenAt = bucket.sessionLastSeenAt;
+    }
+    return;
+  }
+  sessionAccumulators.set(sessionAccumulatorKey, {
+    harness: bucket.harness,
+    sessionKey,
+    startedAt: bucket.sessionStartedAt,
+    lastSeenAt: bucket.sessionLastSeenAt
+  });
+}
+function createUsageAggregationState() {
+  return {
+    accumulators: /* @__PURE__ */ new Map(),
+    sessionAccumulators: /* @__PURE__ */ new Map()
+  };
+}
+function addBucketToAggregationState(state, bucket, sessionKeySalt, replacementRange) {
+  const includeBucket = isReplacementBucketEligible(bucket, replacementRange);
+  if (includeBucket) {
+    const k = key(bucket);
+    let acc = state.accumulators.get(k);
+    if (!acc) {
+      acc = {
+        harness: bucket.harness,
+        model: bucket.model,
+        hourUtc: toIso(bucket.hourUtc),
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheCreateTokens: 0,
+        sessionIds: /* @__PURE__ */ new Set()
+      };
+      state.accumulators.set(k, acc);
+    }
+    acc.inputTokens += bucket.inputTokens;
+    acc.outputTokens += bucket.outputTokens;
+    acc.cacheReadTokens += bucket.cacheReadTokens;
+    acc.cacheCreateTokens += bucket.cacheCreateTokens;
+    for (const id of bucket.sessionIds) {
+      acc.sessionIds.add(id);
+    }
+  }
+  if (isReplacementSessionEligible(bucket, replacementRange)) {
+    for (const id of bucket.sessionIds) {
+      addSessionAccumulator(state.sessionAccumulators, bucket, id, sessionKeySalt);
+    }
+  }
+  return state;
+}
+function isReplacementBucketEligible(bucket, range) {
+  if (!range) {
+    return true;
+  }
+  const hourMs = bucket.hourUtc.getTime();
+  return range.harnesses.has(bucket.harness) && hourMs >= range.startHourUtc.getTime() && hourMs < range.endHourUtc.getTime();
+}
+function isReplacementSessionEligible(bucket, range) {
+  if (!range) {
+    return true;
+  }
+  return range.harnesses.has(bucket.harness) && bucket.sessionStartedAt.getTime() < range.endHourUtc.getTime() && bucket.sessionLastSeenAt.getTime() >= range.startHourUtc.getTime();
+}
+function addBucketToAggregationStateEffect(state, bucket, sessionKeySalt, replacementRange) {
+  return Effect6.try({
+    try: () => addBucketToAggregationState(state, bucket, sessionKeySalt, replacementRange),
+    catch: toUsageAggregationError
+  });
+}
+function finalizeUsageBatches(state, batchSize) {
+  const finalized = [];
+  for (const acc of state.accumulators.values()) {
+    finalized.push(finalize(acc));
+  }
+  const finalizedSessions = [];
+  for (const acc of state.sessionAccumulators.values()) {
+    finalizedSessions.push(finalizeSession(acc));
+  }
+  const batches = [];
+  const maxLength = Math.max(finalized.length, finalizedSessions.length);
+  for (let i = 0; i < maxLength; i += batchSize) {
+    batches.push({
+      buckets: finalized.slice(i, i + batchSize),
+      sessions: finalizedSessions.slice(i, i + batchSize)
+    });
+  }
+  return batches;
+}
+function toUsageAggregationError(cause) {
+  return new UsageAggregationError({
+    message: `usage aggregation failed: ${errorMessage(cause)}`,
+    cause
+  });
+}
+function errorMessage(cause) {
+  return cause instanceof Error ? cause.message : "unknown aggregation error";
+}
+function aggregateUsageStream(source, options) {
+  return Stream2.fromIterableEffect(
+    source.pipe(
+      Stream2.runFoldEffect(
+        () => createUsageAggregationState(),
+        (state, bucket) => addBucketToAggregationStateEffect(state, bucket, options.sessionKeySalt, options.replacementRange)
+      ),
+      Effect6.map((state) => finalizeUsageBatches(state, options.batchSize))
+    )
+  );
+}
+
+// src/sync/client.ts
+import { Context as Context4, Effect as Effect7, Layer as Layer3 } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+var AUTHORIZATION_HEADER = "authorization";
+var SYNC_RPC_PATH = "/rpc/sync";
+var SyncRpcClient = class extends Context4.Service()("@oopst/cli/SyncRpcClient") {
+};
+function syncRpcClientFromPromiseClient(client) {
+  const getWatermark = Effect7.fn("SyncRpcClient.fromPromise.getWatermark")(
+    (input) => Effect7.tryPromise({
+      try: () => client.sync.getWatermark.mutate(input),
+      catch: (err) => err
+    })
+  );
+  const upsertBuckets = Effect7.fn("SyncRpcClient.fromPromise.upsertBuckets")(
+    (input) => Effect7.tryPromise({
+      try: () => client.sync.upsertBuckets.mutate(input),
+      catch: (err) => err
+    })
+  );
+  const createUsageReplacement = Effect7.fn("SyncRpcClient.fromPromise.createUsageReplacement")(
+    (input) => Effect7.tryPromise({
+      try: () => client.sync.createUsageReplacement.mutate(input),
+      catch: (err) => err
+    })
+  );
+  const stageUsageReplacementBatch = Effect7.fn("SyncRpcClient.fromPromise.stageUsageReplacementBatch")(
+    (input) => Effect7.tryPromise({
+      try: () => client.sync.stageUsageReplacementBatch.mutate(input),
+      catch: (err) => err
+    })
+  );
+  const finalizeUsageReplacement = Effect7.fn("SyncRpcClient.fromPromise.finalizeUsageReplacement")(
+    (input) => Effect7.tryPromise({
+      try: () => client.sync.finalizeUsageReplacement.mutate(input),
+      catch: (err) => err
+    })
+  );
+  return SyncRpcClient.of({
+    createUsageReplacement,
+    finalizeUsageReplacement,
+    getWatermark,
+    stageUsageReplacementBatch,
+    upsertBuckets
+  });
+}
+function makeSyncRpcClientLayer(options) {
+  return Layer3.effect(
+    SyncRpcClient,
+    Effect7.gen(function* () {
+      const client = yield* RpcClient.make(SyncRpcs);
+      const getWatermark = Effect7.fn("SyncRpcClient.getWatermark")(
+        (input) => client["sync.getWatermark"](input)
+      );
+      const upsertBuckets = Effect7.fn("SyncRpcClient.upsertBuckets")(
+        (input) => client["sync.upsertBuckets"](input)
+      );
+      const createUsageReplacement = Effect7.fn("SyncRpcClient.createUsageReplacement")(
+        (input) => client["sync.createUsageReplacement"](input)
+      );
+      const stageUsageReplacementBatch = Effect7.fn("SyncRpcClient.stageUsageReplacementBatch")(
+        (input) => client["sync.stageUsageReplacementBatch"](input)
+      );
+      const finalizeUsageReplacement = Effect7.fn("SyncRpcClient.finalizeUsageReplacement")(
+        (input) => client["sync.finalizeUsageReplacement"](input)
+      );
+      return SyncRpcClient.of({
+        createUsageReplacement,
+        finalizeUsageReplacement,
+        getWatermark,
+        stageUsageReplacementBatch,
+        upsertBuckets
+      });
+    })
+  ).pipe(Layer3.provide(makeClientLive(options)));
+}
+function makeClientLive(options) {
+  let clientLive = RpcClient.layerProtocolHttp({
+    url: stripTrailingSlash(options.serverUrl),
+    transformClient: HttpClient.mapRequest(
+      (request) => request.pipe(
+        HttpClientRequest.appendUrl(SYNC_RPC_PATH),
+        HttpClientRequest.setHeader(AUTHORIZATION_HEADER, `Bearer ${options.token}`)
+      )
+    )
+  }).pipe(Layer3.provide(RpcSerialization.layerJson), Layer3.provide(FetchHttpClient.layer));
+  if (options.fetch) {
+    clientLive = clientLive.pipe(Layer3.provide(Layer3.succeed(FetchHttpClient.Fetch, options.fetch)));
+  }
+  return clientLive;
+}
+function stripTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+
+// src/sync/errors.ts
+import { Schema as Schema16 } from "effect";
+var SUCCESS_EXIT_CODE = 0;
+var ZERO_BUCKETS_EXIT_CODE = 1;
+var UNAUTHORIZED_EXIT_CODE = 2;
+var NETWORK_ERROR_EXIT_CODE = 3;
+var INVALID_ARGUMENTS_EXIT_CODE = 4;
+var GENERAL_FAILURE_EXIT_CODE = 5;
+var EXIT_CODES = [
+  SUCCESS_EXIT_CODE,
+  ZERO_BUCKETS_EXIT_CODE,
+  UNAUTHORIZED_EXIT_CODE,
+  NETWORK_ERROR_EXIT_CODE,
+  INVALID_ARGUMENTS_EXIT_CODE,
+  GENERAL_FAILURE_EXIT_CODE
+];
+var EXIT = {
+  success: SUCCESS_EXIT_CODE,
+  zeroBucketsButSourcesExist: ZERO_BUCKETS_EXIT_CODE,
+  unauthorized: UNAUTHORIZED_EXIT_CODE,
+  networkError: NETWORK_ERROR_EXIT_CODE,
+  invalidArguments: INVALID_ARGUMENTS_EXIT_CODE,
+  generalFailure: GENERAL_FAILURE_EXIT_CODE
+};
+var SyncError = class extends Schema16.TaggedErrorClass()("SyncError", {
+  message: Schema16.String,
+  exitCode: Schema16.Literals(EXIT_CODES),
+  cause: Schema16.optionalKey(Schema16.Defect())
+}) {
+  constructor(exitCode, message, options = {}) {
+    super(
+      options.cause === void 0 ? { message, exitCode } : { message, exitCode, cause: options.cause }
+    );
+  }
+};
+function isUnauthorizedError(err) {
+  if (err instanceof UnauthorizedError) {
+    return true;
+  }
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const candidate = err;
+  return candidate._tag === "UnauthorizedError" || candidate.data?.code === "UNAUTHORIZED";
+}
+var NETWORK_ERROR_CODES = ["ECONNREFUSED", "ENOTFOUND", "ECONNRESET", "EAI_AGAIN", "ETIMEDOUT"];
+var NETWORK_ERROR_PATTERN = /fetch failed|network|ECONN|ENOTFOUND|ETIMEDOUT/iu;
+var NETWORK_HTTP_ERROR_KINDS = ["InvalidUrlError", "TransportError"];
+function isNetworkError(err) {
+  if (typeof err !== "object" || err === null) {
+    return false;
+  }
+  const rpcReason = err.reason;
+  if (rpcReason?._tag === "HttpError" && rpcReason.kind && NETWORK_HTTP_ERROR_KINDS.includes(rpcReason.kind)) {
+    return true;
+  }
   const code = err.cause?.code;
   if (code && NETWORK_ERROR_CODES.includes(code)) {
     return true;
@@ -1524,6 +1690,7 @@ function runSyncEffect(options) {
 function runSyncProgram(options) {
   return Effect9.gen(function* () {
     yield* validateRunSyncOptions(options);
+    const replacement = yield* validateUsageReplacement(options.replacement, options.harness);
     const client = yield* SyncRpcClient;
     const parserCollection = yield* ParserCollection;
     const color = options.color === true;
@@ -1532,42 +1699,94 @@ function runSyncProgram(options) {
       return watermarkResult.result;
     }
     const { sessionKeySalt, watermark } = watermarkResult.value;
-    const cutoff = new Date((watermark?.getTime() ?? 0) - options.lookbackDays * MS_PER_DAY2);
+    const cutoff = replacement ? /* @__PURE__ */ new Date(0) : new Date((watermark?.getTime() ?? 0) - options.lookbackDays * MS_PER_DAY2);
     if (options.verbose) {
       yield* logInfo2(options.logger, `watermark=${watermark?.toISOString() ?? "null"} cutoff=${cutoff.toISOString()}`);
     }
     const parsers = yield* Effect9.sync(() => options.parserFactory({ cutoff, device: options.device }));
-    const sources = selectSources(options.harness, parsers);
+    const sources = selectSources(options.harness, parsers, replacement?.harnesses);
     const parserStream = yield* parserCollection.stream({
       sources,
       logger: options.logger,
       color
     });
-    const usageBatches = usageBatchStream(parserStream, sessionKeySalt);
+    const usageBatches = usageBatchStream(parserStream, sessionKeySalt, replacement?.aggregationRange);
+    if (replacement) {
+      return yield* runReplacementUsage({
+        options,
+        client,
+        color,
+        replacement,
+        usageBatches
+      });
+    }
+    return yield* runOrdinaryUsage(options, client, color, usageBatches);
+  });
+}
+function runReplacementUsage(input) {
+  return Effect9.gen(function* () {
+    const { client, color, options, replacement, usageBatches } = input;
+    const batchesResult = yield* recoverSyncFailure(usageBatches.pipe(Stream4.runCollect), options.logger);
+    if (batchesResult._tag === "SyncFailure") {
+      return batchesResult.result;
+    }
+    const batches = batchesResult.value;
+    const plan = summarizeUsageBatchArray(batches);
     if (options.dryRun) {
-      const planResult = yield* recoverSyncFailure(summarizeUsageBatchStream(usageBatches), options.logger);
-      if (planResult._tag === "SyncFailure") {
-        return planResult.result;
-      }
-      const plan2 = planResult.value;
-      const dryRunResult = yield* finishDryRun(options, plan2, color);
-      if (dryRunResult) {
-        return dryRunResult;
-      }
       yield* logInfo2(
         options.logger,
-        phase2(`Aggregated usage by hour and model: ${usageRecordText(plan2.bucketCount)} ready.`, color)
+        `${dryRunPrefix(color)} atomic replacement would stage ${usageRecordText(plan.bucketCount)} and ${localSessionText2(plan.sessionCount)} in ${uploadRequestText(plan.batchCount)}.`
       );
-      const dryRunSummary = `${dryRunPrefix(color)} ${usageRecordText(plan2.bucketCount)} from ${localSessionText2(plan2.sessionCount)} would be uploaded in ${uploadRequestText(plan2.batchCount)}.`;
-      yield* logInfo2(options.logger, dryRunSummary);
       yield* logInfo2(options.logger, muted("No usage data was uploaded.", color));
-      return {
-        exitCode: EXIT.success,
-        batchesUploaded: plan2.batchCount,
-        bucketsUploaded: plan2.bucketCount,
-        sessionsUploaded: plan2.sessionCount
-      };
+      return resultFromPlan(plan);
     }
+    const uploadResult = yield* recoverSyncFailure(
+      uploadUsageReplacement({
+        batches,
+        client,
+        color,
+        device: options.device,
+        logger: options.logger,
+        replacement
+      }),
+      options.logger
+    );
+    if (uploadResult._tag === "SyncFailure") {
+      return uploadResult.result;
+    }
+    yield* logInfo2(
+      options.logger,
+      `${successPrefix(color)} atomically replaced ${usageRecordText(plan.bucketCount)} and ${localSessionText2(plan.sessionCount)}.`
+    );
+    return uploadResult.value;
+  });
+}
+function runOrdinaryUsage(options, client, color, usageBatches) {
+  return options.dryRun ? runOrdinaryDryRun(options, color, usageBatches) : uploadOrdinaryUsage(options, client, color, usageBatches);
+}
+function runOrdinaryDryRun(options, color, usageBatches) {
+  return Effect9.gen(function* () {
+    const planResult = yield* recoverSyncFailure(summarizeUsageBatchStream(usageBatches), options.logger);
+    if (planResult._tag === "SyncFailure") {
+      return planResult.result;
+    }
+    const plan = planResult.value;
+    const earlyResult = yield* finishDryRun(options, plan, color);
+    if (earlyResult) {
+      return earlyResult;
+    }
+    yield* logInfo2(
+      options.logger,
+      phase2(`Aggregated usage by hour and model: ${usageRecordText(plan.bucketCount)} ready.`, color)
+    );
+    const summary = `${dryRunPrefix(color)} ${usageRecordText(plan.bucketCount)} from ${localSessionText2(plan.sessionCount)} would be uploaded in ${uploadRequestText(plan.batchCount)}.`;
+    yield* logInfo2(options.logger, summary);
+    yield* logInfo2(options.logger, muted("No usage data was uploaded.", color));
+    return resultFromPlan(plan);
+  });
+}
+function uploadOrdinaryUsage(options, client, color, usageBatches) {
+  return Effect9.gen(function* () {
     const uploadResult = yield* recoverSyncFailure(
       uploadUsageBatchStream({
         batches: usageBatches,
@@ -1597,8 +1816,10 @@ function runSyncProgram(options) {
       return emptySuccessResult();
     }
     const verboseUploadSuffix = options.verbose ? ` in ${uploadRequestText(totals.batchesUploaded)}` : "";
-    const uploadSummary = `${successPrefix(color)} uploaded ${usageRecordText(totals.bucketsUploaded)} from ${localSessionText2(totals.sessionsUploaded)}${verboseUploadSuffix}.`;
-    yield* logInfo2(options.logger, uploadSummary);
+    yield* logInfo2(
+      options.logger,
+      `${successPrefix(color)} uploaded ${usageRecordText(totals.bucketsUploaded)} from ${localSessionText2(totals.sessionsUploaded)}${verboseUploadSuffix}.`
+    );
     return {
       exitCode: EXIT.success,
       batchesUploaded: totals.batchesUploaded,
@@ -1607,6 +1828,14 @@ function runSyncProgram(options) {
     };
   });
 }
+function resultFromPlan(plan) {
+  return {
+    exitCode: EXIT.success,
+    batchesUploaded: plan.batchCount,
+    bucketsUploaded: plan.bucketCount,
+    sessionsUploaded: plan.sessionCount
+  };
+}
 function validateRunSyncOptions(options) {
   return Effect9.gen(function* () {
     if (!options.token) {
@@ -1617,6 +1846,45 @@ function validateRunSyncOptions(options) {
     }
   });
 }
+function validateUsageReplacement(replacement, harness) {
+  if (!replacement) {
+    return Effect9.succeed(void 0);
+  }
+  return Effect9.try({
+    try: () => {
+      if (harness !== void 0) {
+        throw new SyncError(EXIT.invalidArguments, "--harness cannot be combined with replacement harnesses");
+      }
+      const start = parseUtcHour("replacement start", replacement.startHourUtc);
+      const end = parseUtcHour("replacement end", replacement.endHourUtc);
+      if (end.getTime() <= start.getTime()) {
+        throw new SyncError(EXIT.invalidArguments, "replacement end must be later than replacement start");
+      }
+      const harnesses = [...new Set(replacement.harnesses)].sort();
+      if (harnesses.length === 0 || harnesses.length !== replacement.harnesses.length) {
+        throw new SyncError(EXIT.invalidArguments, "replacement harnesses must be a non-empty set without duplicates");
+      }
+      return {
+        startHourUtc: start.toISOString(),
+        endHourUtc: end.toISOString(),
+        harnesses,
+        aggregationRange: {
+          startHourUtc: start,
+          endHourUtc: end,
+          harnesses: new Set(harnesses)
+        }
+      };
+    },
+    catch: (error) => error instanceof SyncError ? error : new SyncError(EXIT.invalidArguments, "replacement bounds must be exact UTC hours")
+  });
+}
+function parseUtcHour(field, value) {
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value || parsed.getUTCMinutes() !== 0 || parsed.getUTCSeconds() !== 0 || parsed.getUTCMilliseconds() !== 0) {
+    throw new SyncError(EXIT.invalidArguments, `${field} must be an ISO UTC timestamp aligned to an hour`);
+  }
+  return parsed;
+}
 function fetchWatermark(options, client, color) {
   return Effect9.gen(function* () {
     yield* logInfo2(options.logger, phase2("Checking server sync point...", color));
@@ -1627,29 +1895,24 @@ function fetchWatermark(options, client, color) {
     };
   });
 }
-function selectSources(harness, parsers) {
-  const sources = [];
-  if (harness === void 0 || harness === "codex") {
-    sources.push({ label: "Codex", source: parsers.codex });
-  }
-  if (harness === void 0 || harness === "claude_code") {
-    sources.push({ label: "Claude Code", source: parsers.claudeCode });
-  }
-  if (harness === void 0 || harness === "pi") {
-    sources.push({ label: "Pi", source: parsers.pi });
-  }
-  if (harness === void 0 || harness === "hermes") {
-    sources.push({ label: "Hermes", source: parsers.hermes });
-  }
-  if (harness === void 0 || harness === "opencode") {
-    sources.push({ label: "OpenCode", source: parsers.opencode });
-  }
-  return sources;
+function selectSources(harness, parsers, replacementHarnesses) {
+  const replacementSet = replacementHarnesses ? new Set(replacementHarnesses) : void 0;
+  const candidates = [
+    { harness: "codex", label: "Codex", source: parsers.codex },
+    { harness: "claude_code", label: "Claude Code", source: parsers.claudeCode },
+    { harness: "pi", label: "Pi", source: parsers.pi },
+    { harness: "hermes", label: "Hermes", source: parsers.hermes },
+    { harness: "opencode", label: "OpenCode", source: parsers.opencode }
+  ];
+  return candidates.filter(
+    (candidate) => replacementSet ? replacementSet.has(candidate.harness) : harness === void 0 || harness === candidate.harness
+  ).map(({ label, source }) => ({ label, source }));
 }
-function usageBatchStream(source, sessionKeySalt) {
+function usageBatchStream(source, sessionKeySalt, replacementRange) {
   return aggregateUsageStream(source, {
     batchSize: SYNC_BATCH_SIZE,
-    sessionKeySalt
+    sessionKeySalt,
+    replacementRange
   }).pipe(Stream4.filter((batch) => batch.buckets.length > 0 || batch.sessions.length > 0));
 }
 var summarizeUsageBatchStream = Effect9.fn("RunSync.summarizeUsageBatchStream")(
@@ -1738,6 +2001,51 @@ var uploadUsageBatchStream = Effect9.fn("RunSync.uploadUsageBatchStream")(
     return { plan, totals };
   })
 );
+var uploadUsageReplacement = Effect9.fn("RunSync.uploadUsageReplacement")(
+  (options) => Effect9.gen(function* () {
+    yield* logInfo2(options.logger, phase2("Creating atomic replacement scope...", options.color));
+    const created = yield* options.client.createUsageReplacement({
+      device: options.device,
+      startHourUtc: options.replacement.startHourUtc,
+      endHourUtc: options.replacement.endHourUtc,
+      harnesses: options.replacement.harnesses
+    });
+    const buckets = options.batches.flatMap((batch) => batch.buckets);
+    const sessions = options.batches.flatMap((batch) => batch.sessions);
+    for (const [batchIndex, batch] of options.batches.entries()) {
+      yield* logInfo2(
+        options.logger,
+        phase2(`Staging corrected usage... ${batchIndex + 1}/${options.batches.length}`, options.color)
+      );
+      yield* options.client.stageUsageReplacementBatch({
+        device: options.device,
+        replacementId: created.replacementId,
+        batchIndex,
+        batchDigest: usageReplacementDigest(batch),
+        buckets: batch.buckets,
+        sessions: batch.sessions
+      });
+    }
+    yield* logInfo2(options.logger, phase2("Finalizing corrected usage atomically...", options.color));
+    yield* options.client.finalizeUsageReplacement({
+      device: options.device,
+      replacementId: created.replacementId,
+      expectedBatchCount: options.batches.length,
+      expectedBucketCount: buckets.length,
+      expectedSessionCount: sessions.length,
+      digest: usageReplacementDigest({ buckets, sessions })
+    });
+    return {
+      exitCode: EXIT.success,
+      batchesUploaded: options.batches.length,
+      bucketsUploaded: buckets.length,
+      sessionsUploaded: sessions.length
+    };
+  })
+);
+function usageReplacementDigest(facts) {
+  return createHash("sha256").update(canonicalReplacementPayload(facts)).digest("hex");
+}
 function recoverSyncFailure(effect, logger) {
   return Effect9.gen(function* () {
     return syncStepSuccess(yield* effect);
@@ -2270,7 +2578,7 @@ import { dirname as dirname3, isAbsolute as isAbsolute3, join as join8, matchesG
 
 // ../../packages/parsers/src/claude/index.ts
 import { basename, dirname as dirname2 } from "path";
-import { Effect as Effect17, Stream as Stream10 } from "effect";
+import { Effect as Effect18, Stream as Stream11 } from "effect";
 
 // ../../packages/parsers/src/config.ts
 import { homedir as homedir2 } from "os";
@@ -2490,27 +2798,199 @@ var stderrLogger = createWarningLogger(stderr);
 
 // ../../packages/parsers/src/claude/bucketize.ts
 import { createReadStream as createReadStream2 } from "fs";
+import { normalize as normalize3 } from "path";
 import { createInterface as createInterface3 } from "readline";
-import { Cause as Cause2, Effect as Effect16, Queue as Queue2, Stream as Stream9 } from "effect";
+import { Cause as Cause2, Effect as Effect17, Queue as Queue2, Stream as Stream10 } from "effect";
 
 // ../../packages/parsers/src/codex/bucketize.ts
-import { createReadStream } from "fs";
-import { createInterface as createInterface2 } from "readline";
-import { Cause, Effect as Effect15, Queue, Stream as Stream8 } from "effect";
+import { Effect as Effect16, Stream as Stream9 } from "effect";
 
-// ../../packages/parsers/src/types.ts
-import { Schema as Schema21, Stream as Stream7 } from "effect";
-var ParserSourceReadError = class extends Schema21.TaggedErrorClass()("ParserSourceReadError", {
-  message: Schema21.String,
-  path: Schema21.String,
-  cause: Schema21.optionalKey(Schema21.Defect())
-}) {
+// ../../packages/parsers/src/codex/counters.ts
+var SEEN_RAW_TOTALS_LIMIT = 64;
+var ZERO_CODEX_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  cacheReadTokens: 0
 };
-var makeParserSourceReadError = (path, error) => new ParserSourceReadError({
-  message: `Parser source read failed: ${error instanceof Error ? error.message : String(error)}`,
-  path,
-  cause: error
-});
+function normalizeCodexUsage(usage) {
+  return {
+    inputTokens: Math.max(0, usage.input_tokens ?? 0),
+    outputTokens: Math.max(0, usage.output_tokens ?? 0),
+    cacheReadTokens: Math.max(0, usage.cached_input_tokens ?? usage.cache_read_input_tokens ?? 0)
+  };
+}
+function sameCodexUsage(a, b) {
+  return a.inputTokens === b.inputTokens && a.outputTokens === b.outputTokens && a.cacheReadTokens === b.cacheReadTokens;
+}
+function positiveCodexUsage(usage) {
+  return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.cacheReadTokens > 0;
+}
+function addCodexUsage(a, b) {
+  return {
+    inputTokens: a.inputTokens + b.inputTokens,
+    outputTokens: a.outputTokens + b.outputTokens,
+    cacheReadTokens: a.cacheReadTokens + b.cacheReadTokens
+  };
+}
+function minCodexUsage(a, b) {
+  return {
+    inputTokens: Math.min(a.inputTokens, b.inputTokens),
+    outputTokens: Math.min(a.outputTokens, b.outputTokens),
+    cacheReadTokens: Math.min(a.cacheReadTokens, b.cacheReadTokens)
+  };
+}
+function maxCodexUsage(a, b) {
+  if (a === void 0) {
+    return b;
+  }
+  return {
+    inputTokens: Math.max(a.inputTokens, b.inputTokens),
+    outputTokens: Math.max(a.outputTokens, b.outputTokens),
+    cacheReadTokens: Math.max(a.cacheReadTokens, b.cacheReadTokens)
+  };
+}
+function subtractCodexUsageFloorZero(current, baseline) {
+  return {
+    inputTokens: Math.max(0, current.inputTokens - baseline.inputTokens),
+    outputTokens: Math.max(0, current.outputTokens - baseline.outputTokens),
+    cacheReadTokens: Math.max(0, current.cacheReadTokens - baseline.cacheReadTokens)
+  };
+}
+function codexUsageContains(current, baseline) {
+  return current.inputTokens >= baseline.inputTokens && current.outputTokens >= baseline.outputTokens && current.cacheReadTokens >= baseline.cacheReadTokens;
+}
+function codexUsageAtMost(current, ceiling) {
+  return current.inputTokens <= ceiling.inputTokens && current.outputTokens <= ceiling.outputTokens && current.cacheReadTokens <= ceiling.cacheReadTokens;
+}
+function makeCodexContainmentState() {
+  return {
+    countedUsage: void 0,
+    rawBaseline: void 0,
+    watermark: void 0,
+    seenRawTotals: [],
+    sawDivergentTotals: false,
+    sawInterleavedTotals: false,
+    sawUnresolvedTotal: false
+  };
+}
+function containedCodexDelta(watermark, counted, current) {
+  const water = watermark ?? ZERO_CODEX_USAGE;
+  const accepted = counted ?? ZERO_CODEX_USAGE;
+  const component = (highWatermark, countedUsage, currentUsage) => currentUsage >= highWatermark ? Math.max(0, currentUsage - Math.max(highWatermark, countedUsage)) : Math.max(0, currentUsage - countedUsage);
+  return {
+    inputTokens: component(water.inputTokens, accepted.inputTokens, current.inputTokens),
+    outputTokens: component(water.outputTokens, accepted.outputTokens, current.outputTokens),
+    cacheReadTokens: component(water.cacheReadTokens, accepted.cacheReadTokens, current.cacheReadTokens)
+  };
+}
+function divergentCodexDelta(rawBaseline, countedBaseline, current) {
+  const raw = rawBaseline ?? ZERO_CODEX_USAGE;
+  const counted = countedBaseline ?? ZERO_CODEX_USAGE;
+  const component = (rawUsage, countedUsage, currentUsage) => currentUsage >= rawUsage ? Math.max(0, currentUsage - rawUsage) : Math.max(0, currentUsage - countedUsage);
+  return {
+    inputTokens: component(raw.inputTokens, counted.inputTokens, current.inputTokens),
+    outputTokens: component(raw.outputTokens, counted.outputTokens, current.outputTokens),
+    cacheReadTokens: component(raw.cacheReadTokens, counted.cacheReadTokens, current.cacheReadTokens)
+  };
+}
+function rememberCodexTotal(state, total) {
+  state.watermark = maxCodexUsage(state.watermark, total);
+  if (state.seenRawTotals.some((seen) => sameCodexUsage(seen, total))) {
+    return;
+  }
+  state.seenRawTotals.push(total);
+  if (state.seenRawTotals.length > SEEN_RAW_TOTALS_LIMIT) {
+    state.seenRawTotals.splice(0, state.seenRawTotals.length - SEEN_RAW_TOTALS_LIMIT);
+  }
+}
+function applyCodexSnapshotWithLast(state, last, total, watermarkBaseline) {
+  const base = state.countedUsage ?? ZERO_CODEX_USAGE;
+  if (total === void 0) {
+    state.countedUsage = addCodexUsage(base, last);
+    state.rawBaseline = state.countedUsage;
+    state.watermark = maxCodexUsage(state.watermark, state.countedUsage);
+    return last;
+  }
+  let delta = last;
+  if (state.sawInterleavedTotals) {
+    delta = minCodexUsage(last, containedCodexDelta(watermarkBaseline, state.countedUsage, total));
+  } else {
+    const totalDelta = subtractCodexUsageFloorZero(total, watermarkBaseline ?? ZERO_CODEX_USAGE);
+    const useTotalDelta = !state.sawDivergentTotals && watermarkBaseline !== void 0 && codexUsageContains(total, watermarkBaseline) && codexUsageAtMost(totalDelta, last);
+    if (useTotalDelta) {
+      delta = totalDelta;
+    }
+  }
+  state.countedUsage = addCodexUsage(base, delta);
+  state.rawBaseline = total;
+  state.sawDivergentTotals ||= !sameCodexUsage(total, state.countedUsage);
+  return delta;
+}
+function applyCodexTotalOnlySnapshot(state, total, watermarkBaseline) {
+  let delta;
+  if (state.sawInterleavedTotals) {
+    delta = containedCodexDelta(watermarkBaseline, state.countedUsage, total);
+  } else if (state.sawDivergentTotals) {
+    delta = divergentCodexDelta(watermarkBaseline, state.countedUsage, total);
+  } else {
+    delta = subtractCodexUsageFloorZero(total, watermarkBaseline ?? ZERO_CODEX_USAGE);
+  }
+  state.countedUsage = addCodexUsage(state.countedUsage ?? ZERO_CODEX_USAGE, delta);
+  state.rawBaseline = total;
+  state.sawDivergentTotals ||= !sameCodexUsage(total, state.countedUsage);
+  return delta;
+}
+function applyCodexContainedSnapshot(state, last, total, options = {}) {
+  if (total !== void 0 && state.seenRawTotals.some((seen) => sameCodexUsage(seen, total))) {
+    return void 0;
+  }
+  if (total !== void 0 && state.watermark !== void 0 && !codexUsageContains(total, state.watermark)) {
+    state.sawInterleavedTotals = true;
+  }
+  const watermarkBaseline = state.watermark ?? state.rawBaseline;
+  const effectiveLast = total !== void 0 && options.totalOnlyBeforeInterleaving === true && !state.sawInterleavedTotals ? void 0 : last;
+  let delta;
+  if (effectiveLast !== void 0) {
+    delta = applyCodexSnapshotWithLast(state, effectiveLast, total, watermarkBaseline);
+  } else if (total !== void 0) {
+    delta = applyCodexTotalOnlySnapshot(state, total, watermarkBaseline);
+  }
+  if (total !== void 0) {
+    rememberCodexTotal(state, total);
+  }
+  return delta !== void 0 && positiveCodexUsage(delta) ? delta : void 0;
+}
+function applyCodexUnresolvedSnapshot(state, last, total) {
+  if (total === void 0) {
+    return applyCodexContainedSnapshot(state, last, void 0);
+  }
+  if (state.seenRawTotals.some((seen) => sameCodexUsage(seen, total))) {
+    return void 0;
+  }
+  if (state.watermark !== void 0 && !codexUsageContains(total, state.watermark)) {
+    state.sawInterleavedTotals = true;
+  }
+  const watermarkBaseline = state.watermark ?? state.rawBaseline;
+  let delta;
+  if (state.sawUnresolvedTotal && last !== void 0) {
+    delta = minCodexUsage(last, subtractCodexUsageFloorZero(total, watermarkBaseline ?? ZERO_CODEX_USAGE));
+    state.countedUsage = addCodexUsage(state.countedUsage ?? ZERO_CODEX_USAGE, delta);
+    state.rawBaseline = state.countedUsage;
+  }
+  state.sawUnresolvedTotal = true;
+  rememberCodexTotal(state, total);
+  return delta !== void 0 && positiveCodexUsage(delta) ? delta : void 0;
+}
+function cumulativeCodexDelta(current, previous) {
+  if (previous === void 0) {
+    return current;
+  }
+  return {
+    inputTokens: current.inputTokens < previous.inputTokens ? current.inputTokens : current.inputTokens - previous.inputTokens,
+    outputTokens: current.outputTokens < previous.outputTokens ? current.outputTokens : current.outputTokens - previous.outputTokens,
+    cacheReadTokens: current.cacheReadTokens < previous.cacheReadTokens ? current.cacheReadTokens : current.cacheReadTokens - previous.cacheReadTokens
+  };
+}
 
 // ../../packages/parsers/src/codex/events.ts
 function isObject(value) {
@@ -2519,6 +2999,12 @@ function isObject(value) {
 function isFiniteNumber(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
+var MAX_CODEX_SOURCE_ID_LENGTH = 512;
+var MAX_CODEX_TIMESTAMP_LENGTH = 128;
+var MAX_CODEX_LOCAL_PATH_LENGTH = 4096;
+function isOptionalBoundedString(value, maxLength) {
+  return value === void 0 || typeof value === "string" && value.length <= maxLength;
+}
 function isCodexUsageCounters(value) {
   if (!isObject(value)) {
     return false;
@@ -2549,6 +3035,11 @@ function isCodexTokenCountEvent(value) {
   if (payload["type"] !== "token_count") {
     return false;
   }
+  for (const key6 of ["id", "turn_id", "turnId"]) {
+    if (!isOptionalBoundedString(payload[key6], MAX_CODEX_SOURCE_ID_LENGTH)) {
+      return false;
+    }
+  }
   const info = payload["info"];
   if (info !== void 0) {
     if (!isObject(info)) {
@@ -2557,6 +3048,11 @@ function isCodexTokenCountEvent(value) {
     if (info["model"] !== void 0 && typeof info["model"] !== "string") {
       return false;
     }
+    for (const key6 of ["id", "turn_id", "turnId"]) {
+      if (!isOptionalBoundedString(info[key6], MAX_CODEX_SOURCE_ID_LENGTH)) {
+        return false;
+      }
+    }
     if (info["last_token_usage"] !== void 0 && !isCodexUsageCounters(info["last_token_usage"])) {
       return false;
     }
@@ -2572,6 +3068,28 @@ function isCodexTokenCountEvent(value) {
   }
   return true;
 }
+function isCodexTaskStartedEvent(value) {
+  if (!isObject(value) || value["type"] !== "event_msg" || typeof value["timestamp"] !== "string") {
+    return false;
+  }
+  const payload = value["payload"];
+  if (!isObject(payload) || payload["type"] !== "task_started") {
+    return false;
+  }
+  for (const key6 of ["id", "turn_id", "turnId"]) {
+    if (!isOptionalBoundedString(payload[key6], MAX_CODEX_SOURCE_ID_LENGTH)) {
+      return false;
+    }
+  }
+  const info = payload["info"];
+  if (info === void 0) {
+    return true;
+  }
+  if (!isObject(info)) {
+    return false;
+  }
+  return ["id", "turn_id", "turnId"].every((key6) => isOptionalBoundedString(info[key6], MAX_CODEX_SOURCE_ID_LENGTH));
+}
 function isCodexTurnContextEvent(value) {
   if (!isObject(value)) {
     return false;
@@ -2610,18 +3128,66 @@ function isCodexSessionMetaEvent(value) {
   if (value["type"] !== "session_meta") {
     return false;
   }
-  if (value["timestamp"] !== void 0 && typeof value["timestamp"] !== "string") {
+  if (!isOptionalBoundedString(value["timestamp"], MAX_CODEX_TIMESTAMP_LENGTH)) {
     return false;
   }
+  for (const key6 of ["id", "session_id", "sessionId"]) {
+    if (!isOptionalBoundedString(value[key6], MAX_CODEX_SOURCE_ID_LENGTH)) {
+      return false;
+    }
+  }
   const payload = value["payload"];
   if (!isObject(payload)) {
     return false;
   }
-  if (payload["cwd"] !== void 0 && typeof payload["cwd"] !== "string") {
+  if (!isOptionalBoundedString(payload["cwd"], MAX_CODEX_LOCAL_PATH_LENGTH)) {
+    return false;
+  }
+  for (const key6 of [
+    "id",
+    "session_id",
+    "sessionId",
+    "forked_from_id",
+    "forkedFromId",
+    "parent_thread_id",
+    "parent_session_id",
+    "parentSessionId"
+  ]) {
+    if (!isOptionalBoundedString(payload[key6], MAX_CODEX_SOURCE_ID_LENGTH)) {
+      return false;
+    }
+  }
+  if (!isOptionalBoundedString(payload["timestamp"], MAX_CODEX_TIMESTAMP_LENGTH)) {
     return false;
   }
   return true;
 }
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed === void 0 || trimmed.length === 0 ? void 0 : trimmed;
+}
+function extractCodexSourceMetadata(event) {
+  const sourceSessionId = nonEmpty(
+    event.payload.id ?? event.id ?? event.payload.session_id ?? event.payload.sessionId ?? event.session_id ?? event.sessionId
+  );
+  const canonicalSessionId = nonEmpty(
+    event.payload.session_id ?? event.payload.sessionId ?? event.session_id ?? event.sessionId
+  );
+  return {
+    sourceSessionId,
+    canonicalSessionId,
+    lineageSessionId: canonicalSessionId ?? sourceSessionId,
+    parentSourceSessionId: nonEmpty(
+      event.payload.forked_from_id ?? event.payload.forkedFromId ?? event.payload.parent_session_id ?? event.payload.parentSessionId
+    ),
+    // Native agent files also carry parent_thread_id for structural thread
+    // ownership. It is not evidence that token counters share a cumulative
+    // scale, so retain it as bounded metadata without using it as a baseline.
+    parentThreadId: nonEmpty(event.payload.parent_thread_id),
+    forkedAt: nonEmpty(event.payload.timestamp ?? event.timestamp),
+    cwd: event.payload.cwd
+  };
+}
 function extractCodexUsageSnapshot(event) {
   return {
     last: event.payload.info?.last_token_usage,
@@ -2631,30 +3197,36 @@ function extractCodexUsageSnapshot(event) {
 function pickCodexEventModel(event) {
   return event.payload.info?.model ?? event.payload.model ?? event.model;
 }
-
-// ../../packages/parsers/src/codex/bucketize.ts
-function startOfUtcHour(d) {
-  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), 0, 0, 0));
-}
-function key2(hourUtc, model) {
-  return `${hourUtc.toISOString()}|${model}`;
-}
-function shouldExcludePath(path, excludePath) {
-  return path !== void 0 && excludePath?.(path) === true;
-}
-function makeCodexFileAccumulator() {
-  return {
-    buckets: /* @__PURE__ */ new Map(),
-    currentModel: void 0,
-    excluded: false,
-    lineNo: 0,
-    sawTurnContext: false,
-    previousTotalUsage: void 0,
-    pendingUsage: [],
-    sessionLastSeenAt: void 0,
-    sessionStartedAt: void 0
-  };
+function pickCodexTurnId(event) {
+  return nonEmpty(
+    event.payload.turn_id ?? event.payload.turnId ?? event.payload.id ?? event.payload.info?.turn_id ?? event.payload.info?.turnId ?? event.payload.info?.id
+  );
 }
+
+// ../../packages/parsers/src/codex/lineage.ts
+import { createReadStream } from "fs";
+import { open, stat } from "fs/promises";
+import { normalize as normalize2 } from "path";
+import { createInterface as createInterface2 } from "readline";
+import { Cause, Effect as Effect15, Queue, Stream as Stream8 } from "effect";
+
+// ../../packages/parsers/src/types.ts
+import { Schema as Schema21, Stream as Stream7 } from "effect";
+var ParserSourceReadError = class extends Schema21.TaggedErrorClass()("ParserSourceReadError", {
+  message: Schema21.String,
+  path: Schema21.String,
+  cause: Schema21.optionalKey(Schema21.Defect())
+}) {
+};
+var makeParserSourceReadError = (path, error) => new ParserSourceReadError({
+  message: `Parser source read failed: ${error instanceof Error ? error.message : String(error)}`,
+  path,
+  cause: error
+});
+
+// ../../packages/parsers/src/codex/lineage.ts
+var CANDIDATE_TAIL_BYTES = 262144;
+var CANDIDATE_INSPECTION_CONCURRENCY = 8;
 function lineStreamFromFile(path) {
   return Stream8.callback(
     (queue) => Effect15.acquireRelease(
@@ -2699,44 +3271,442 @@ function lineStreamFromFile(path) {
     )
   );
 }
-function normalizeUsage(usage) {
+async function inspectSourceMetadata(path) {
+  const stream = createReadStream(path, { encoding: "utf8" });
+  const lines = createInterface2({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  let first;
+  const sourceSessionIds = /* @__PURE__ */ new Set();
+  try {
+    for await (const line of lines) {
+      if (!line.includes("session_meta")) {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (isCodexSessionMetaEvent(parsed)) {
+        const metadata = extractCodexSourceMetadata(parsed);
+        first ??= metadata;
+        if (metadata.sourceSessionId !== void 0) {
+          sourceSessionIds.add(metadata.sourceSessionId);
+        }
+      }
+    }
+    return { first, containsMultipleSessionIds: sourceSessionIds.size > 1 };
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+async function hasCompleteTail(path, size) {
+  if (size <= 0) {
+    return false;
+  }
+  const handle = await open(path, "r");
+  try {
+    const bytesToRead = Math.min(size, CANDIDATE_TAIL_BYTES);
+    const tail = Buffer.allocUnsafe(bytesToRead);
+    await handle.read(tail, 0, bytesToRead, size - bytesToRead);
+    const lastLine = tail.toString("utf8").split("\n").findLast((line) => line.trim().length > 0)?.trim();
+    if (!lastLine) {
+      return false;
+    }
+    try {
+      JSON.parse(lastLine);
+      return true;
+    } catch {
+      return false;
+    }
+  } finally {
+    await handle.close();
+  }
+}
+function inspectCodexSourceCandidate(path) {
+  return Effect15.tryPromise({
+    try: async () => {
+      const info = await stat(path);
+      const inspectedMetadata = await inspectSourceMetadata(path);
+      return {
+        path,
+        normalizedPath: normalize2(path),
+        metadata: inspectedMetadata.first,
+        containsMultipleSessionIds: inspectedMetadata.containsMultipleSessionIds,
+        complete: await hasCompleteTail(path, info.size),
+        mtimeMs: info.mtimeMs,
+        size: info.size
+      };
+    },
+    catch: (error) => makeParserSourceReadError(path, error)
+  });
+}
+function candidateComesFirst(a, b) {
+  if (a.complete !== b.complete) {
+    return a.complete ? -1 : 1;
+  }
+  if (a.size !== b.size) {
+    return b.size - a.size;
+  }
+  if (a.mtimeMs !== b.mtimeMs) {
+    return b.mtimeMs - a.mtimeMs;
+  }
+  return a.normalizedPath.localeCompare(b.normalizedPath);
+}
+function candidateConflictKind(candidates) {
+  const parents = new Set(candidates.map((candidate) => candidate.metadata?.parentSourceSessionId ?? ""));
+  if (parents.size > 1) {
+    return "parent";
+  }
+  const forkBoundaries = new Set(candidates.map((candidate) => candidate.metadata?.forkedAt ?? ""));
+  return forkBoundaries.size > 1 ? "fork_boundary" : void 0;
+}
+function cycleSessionIds(sources) {
+  const parents = /* @__PURE__ */ new Map();
+  const knownIds = new Set(
+    sources.flatMap((source) => source.sourceSessionId === void 0 ? [] : [source.sourceSessionId])
+  );
+  for (const source of sources) {
+    if (source.sourceSessionId !== void 0 && source.parentSourceSessionId !== void 0 && knownIds.has(source.parentSourceSessionId)) {
+      parents.set(source.sourceSessionId, source.parentSourceSessionId);
+    }
+  }
+  const cycles = /* @__PURE__ */ new Set();
+  for (const sourceId of [...knownIds].sort()) {
+    const positions = /* @__PURE__ */ new Map();
+    const chain = [];
+    let current = sourceId;
+    while (current !== void 0) {
+      const cycleStart = positions.get(current);
+      if (cycleStart !== void 0) {
+        for (const member of chain.slice(cycleStart)) {
+          cycles.add(member);
+        }
+        break;
+      }
+      positions.set(current, chain.length);
+      chain.push(current);
+      current = parents.get(current);
+    }
+  }
+  return cycles;
+}
+function groupCodexSourceCandidates(candidates) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const sourceId = candidate.metadata?.sourceSessionId;
+    const groupKey = sourceId === void 0 ? `path:${candidate.normalizedPath}` : `session:${sourceId}`;
+    const group = groups.get(groupKey) ?? [];
+    group.push(candidate);
+    groups.set(groupKey, group);
+  }
+  return groups;
+}
+function indexedSourceFromCandidates(group, cutoffMs, logger) {
+  group.sort(candidateComesFirst);
+  const [canonical] = group;
+  if (canonical === void 0) {
+    return void 0;
+  }
+  const conflict = candidateConflictKind(group);
+  if (conflict !== void 0) {
+    logger.warn("conflicting codex source candidates", {
+      candidateCount: group.length,
+      conflict
+    });
+  }
+  const sourceSessionId = canonical.metadata?.sourceSessionId;
   return {
-    inputTokens: Math.max(0, usage.input_tokens ?? 0),
-    outputTokens: Math.max(0, usage.output_tokens ?? 0),
-    cacheReadTokens: Math.max(0, usage.cached_input_tokens ?? usage.cache_read_input_tokens ?? 0)
+    path: canonical.path,
+    sourceIdentity: sourceSessionId ?? canonical.normalizedPath,
+    sourceSessionId,
+    lineageSessionId: canonical.metadata?.lineageSessionId,
+    parentSourceSessionId: canonical.metadata?.parentSourceSessionId,
+    forkedAt: canonical.metadata?.forkedAt,
+    cwd: canonical.metadata?.cwd,
+    containsMultipleSessionIds: canonical.containsMultipleSessionIds || canonical.metadata?.canonicalSessionId !== void 0,
+    eligible: group.some((candidate) => candidate.mtimeMs >= cutoffMs)
   };
 }
-function sameUsage(a, b) {
-  return a.inputTokens === b.inputTokens && a.outputTokens === b.outputTokens && a.cacheReadTokens === b.cacheReadTokens;
+function indexCodexLineageSessions(sources) {
+  const bySessionId = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    const { lineageSessionId } = source;
+    if (lineageSessionId === void 0) {
+      continue;
+    }
+    const existing = bySessionId.get(lineageSessionId);
+    if (existing === void 0 || source.sourceSessionId === lineageSessionId && existing.sourceSessionId !== lineageSessionId) {
+      bySessionId.set(lineageSessionId, source);
+    }
+  }
+  return bySessionId;
 }
-function positiveUsage(usage) {
-  return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.cacheReadTokens > 0;
+var buildCodexSourceIndex = Effect15.fn("CodexLineage.buildSourceIndex")(function* (paths, cutoff, logger) {
+  const uniquePaths = [...new Set(paths.map(normalize2))].sort();
+  const candidates = yield* Effect15.forEach(uniquePaths, inspectCodexSourceCandidate, {
+    concurrency: CANDIDATE_INSPECTION_CONCURRENCY
+  });
+  const groups = groupCodexSourceCandidates(candidates);
+  const sources = [];
+  for (const groupKey of [...groups.keys()].sort()) {
+    const group = groups.get(groupKey) ?? [];
+    const source = indexedSourceFromCandidates(group, cutoff.getTime(), logger);
+    if (source !== void 0) {
+      sources.push(source);
+    }
+  }
+  sources.sort((a, b) => a.sourceIdentity.localeCompare(b.sourceIdentity));
+  return {
+    sources,
+    bySessionId: indexCodexLineageSessions(sources),
+    cycleSessionIds: cycleSessionIds(sources)
+  };
+});
+function parseTimestamp(timestamp) {
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : void 0;
 }
-function cumulativeDelta(current, previous) {
-  if (previous === void 0) {
-    return current;
+function parseSnapshotIncrement(state, last, total) {
+  if (last !== void 0) {
+    return normalizeCodexUsage(last);
+  }
+  return total === void 0 ? void 0 : cumulativeCodexDelta(total, state.previousTotal);
+}
+function accumulateCodexSnapshot(state, raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return state;
+  }
+  if (!isCodexTokenCountEvent(parsed)) {
+    return state;
+  }
+  const snapshot = extractCodexUsageSnapshot(parsed);
+  const total = snapshot.total === void 0 ? void 0 : normalizeCodexUsage(snapshot.total);
+  if (state.containment !== void 0) {
+    const last = snapshot.last === void 0 ? void 0 : normalizeCodexUsage(snapshot.last);
+    const increment2 = applyCodexContainedSnapshot(state.containment, last, total);
+    if (increment2 === void 0) {
+      return state;
+    }
+    state.counted = addCodexUsage(state.counted, increment2);
+    state.snapshots.push({
+      timestamp: parsed.timestamp,
+      timestampMs: parseTimestamp(parsed.timestamp),
+      usage: state.counted
+    });
+    return state;
+  }
+  if (total !== void 0 && state.previousTotal !== void 0 && sameCodexUsage(total, state.previousTotal)) {
+    return state;
+  }
+  const increment = parseSnapshotIncrement(state, snapshot.last, total);
+  if (total !== void 0) {
+    state.previousTotal = total;
+  }
+  if (increment === void 0 || !positiveCodexUsage(increment)) {
+    return state;
+  }
+  state.counted = addCodexUsage(state.counted, increment);
+  state.snapshots.push({
+    timestamp: parsed.timestamp,
+    timestampMs: parseTimestamp(parsed.timestamp),
+    usage: state.counted
+  });
+  return state;
+}
+function collectCodexSnapshots(path, containsMultipleSessionIds) {
+  return lineStreamFromFile(path).pipe(
+    Stream8.runFold(
+      () => ({
+        snapshots: [],
+        containment: containsMultipleSessionIds ? makeCodexContainmentState() : void 0,
+        counted: ZERO_CODEX_USAGE,
+        previousTotal: void 0
+      }),
+      accumulateCodexSnapshot
+    ),
+    Effect15.map((state) => state.snapshots)
+  );
+}
+function selectInheritedUsage(snapshots, forkedAt, forkedAtMs) {
+  let inherited = ZERO_CODEX_USAGE;
+  for (const snapshot of snapshots) {
+    const atOrBefore = snapshot.timestampMs === void 0 ? snapshot.timestamp <= forkedAt : snapshot.timestampMs <= forkedAtMs;
+    if (atOrBefore) {
+      inherited = snapshot.usage;
+    }
   }
+  return inherited;
+}
+function makeCodexLineageResolver(index, logger) {
+  const snapshotsBySessionId = /* @__PURE__ */ new Map();
+  const warned = /* @__PURE__ */ new Set();
+  const unresolved = (source, reason) => {
+    const warningKey = `${source.sourceIdentity}:${reason}`;
+    if (!warned.has(warningKey)) {
+      warned.add(warningKey);
+      logger.warn("codex fork baseline unresolved", { reason });
+    }
+    return { _tag: "Unresolved", reason };
+  };
+  const requestFor = (source) => {
+    const parentId = source.parentSourceSessionId;
+    if (parentId === void 0) {
+      return { _tag: "Root" };
+    }
+    if (source.sourceSessionId !== void 0 && index.cycleSessionIds.has(source.sourceSessionId)) {
+      return unresolved(source, "cycle");
+    }
+    const parent = index.bySessionId.get(parentId);
+    if (parent === void 0) {
+      return unresolved(source, "missing_parent");
+    }
+    const { forkedAt } = source;
+    const forkedAtMs = forkedAt === void 0 ? void 0 : parseTimestamp(forkedAt);
+    if (forkedAt === void 0 || forkedAtMs === void 0) {
+      return unresolved(source, "invalid_fork_boundary");
+    }
+    return { _tag: "Ready", forkedAt, forkedAtMs, parent, parentId };
+  };
   return {
-    inputTokens: current.inputTokens < previous.inputTokens ? current.inputTokens : current.inputTokens - previous.inputTokens,
-    outputTokens: current.outputTokens < previous.outputTokens ? current.outputTokens : current.outputTokens - previous.outputTokens,
-    cacheReadTokens: current.cacheReadTokens < previous.cacheReadTokens ? current.cacheReadTokens : current.cacheReadTokens - previous.cacheReadTokens
+    baselineFor: Effect15.fn("CodexLineage.baselineFor")(function* (source) {
+      const request = requestFor(source);
+      if (request._tag !== "Ready") {
+        return request;
+      }
+      let snapshots = snapshotsBySessionId.get(request.parentId);
+      if (snapshots === void 0) {
+        snapshots = yield* collectCodexSnapshots(request.parent.path, request.parent.containsMultipleSessionIds);
+        snapshotsBySessionId.set(request.parentId, snapshots);
+      }
+      return {
+        _tag: "Resolved",
+        usage: selectInheritedUsage(snapshots, request.forkedAt, request.forkedAtMs)
+      };
+    })
   };
 }
-function usageIncrement(acc, last, total) {
-  const normalizedTotal = total === void 0 ? void 0 : normalizeUsage(total);
-  if (normalizedTotal !== void 0) {
-    if (acc.previousTotalUsage !== void 0 && sameUsage(acc.previousTotalUsage, normalizedTotal)) {
+
+// ../../packages/parsers/src/codex/bucketize.ts
+function startOfUtcHour(d) {
+  return new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), 0, 0, 0));
+}
+function key2(hourUtc, model) {
+  return `${hourUtc.toISOString()}|${model}`;
+}
+function shouldExcludePath(path, excludePath) {
+  return path !== void 0 && excludePath?.(path) === true;
+}
+function makeCodexFileAccumulator(options) {
+  const lineageBaseline = options.lineageBaseline ?? { _tag: "Root" };
+  return {
+    buckets: /* @__PURE__ */ new Map(),
+    candidates: [],
+    currentModel: void 0,
+    currentTurnId: void 0,
+    containment: options.containInterleavedTotals === true ? makeCodexContainmentState() : void 0,
+    excluded: false,
+    lineNo: 0,
+    nextEventIndex: 0,
+    lineageKind: lineageBaseline._tag,
+    inheritedBaselineUsage: lineageBaseline._tag === "Resolved" ? lineageBaseline.usage : void 0,
+    sawTurnContext: false,
+    previousTotalUsage: lineageBaseline._tag === "Resolved" ? lineageBaseline.usage : void 0,
+    remainingInheritedUsage: lineageBaseline._tag === "Resolved" ? lineageBaseline.usage : void 0,
+    pendingUsage: [],
+    sessionLastSeenAt: void 0,
+    sessionStartedAt: void 0
+  };
+}
+function subtractRemainingInheritedUsage(acc, rawIncrement) {
+  const remaining = acc.remainingInheritedUsage;
+  if (remaining === void 0) {
+    return rawIncrement;
+  }
+  acc.remainingInheritedUsage = subtractCodexUsageFloorZero(remaining, rawIncrement);
+  return subtractCodexUsageFloorZero(rawIncrement, remaining);
+}
+function positiveIncrement(increment) {
+  return positiveCodexUsage(increment) ? increment : void 0;
+}
+function unresolvedUsageIncrement(acc, total) {
+  if (total === void 0) {
+    return void 0;
+  }
+  const previous = acc.previousTotalUsage;
+  acc.previousTotalUsage = total;
+  if (previous === void 0 || sameCodexUsage(previous, total)) {
+    return void 0;
+  }
+  return positiveIncrement(cumulativeCodexDelta(total, previous));
+}
+function resolvedUsageIncrement(acc, last, total) {
+  if (total !== void 0) {
+    const previous = acc.previousTotalUsage;
+    if (previous !== void 0 && sameCodexUsage(previous, total)) {
       return void 0;
     }
-    const increment2 = last === void 0 ? cumulativeDelta(normalizedTotal, acc.previousTotalUsage) : normalizeUsage(last);
-    acc.previousTotalUsage = normalizedTotal;
-    return positiveUsage(increment2) ? increment2 : void 0;
+    acc.previousTotalUsage = total;
+    acc.remainingInheritedUsage = void 0;
+    return positiveIncrement(cumulativeCodexDelta(total, previous));
   }
   if (last === void 0) {
     return void 0;
   }
-  const increment = normalizeUsage(last);
-  return positiveUsage(increment) ? increment : void 0;
+  const rawIncrement = normalizeCodexUsage(last);
+  return positiveIncrement(subtractRemainingInheritedUsage(acc, rawIncrement));
+}
+function containedUsageIncrement(acc, last, total) {
+  const { containment } = acc;
+  if (containment === void 0) {
+    return void 0;
+  }
+  const normalizedTotal = total === void 0 ? void 0 : normalizeCodexUsage(total);
+  const normalizedLast = last === void 0 ? void 0 : normalizeCodexUsage(last);
+  if (acc.lineageKind === "Unresolved") {
+    return applyCodexUnresolvedSnapshot(containment, normalizedLast, normalizedTotal);
+  }
+  if (acc.lineageKind === "Resolved") {
+    const adjustedTotal = normalizedTotal === void 0 || acc.inheritedBaselineUsage === void 0 ? normalizedTotal : subtractCodexUsageFloorZero(normalizedTotal, acc.inheritedBaselineUsage);
+    const adjustedLast = normalizedTotal === void 0 && normalizedLast !== void 0 ? subtractRemainingInheritedUsage(acc, normalizedLast) : normalizedLast;
+    const increment = applyCodexContainedSnapshot(containment, adjustedLast, adjustedTotal, {
+      totalOnlyBeforeInterleaving: true
+    });
+    if (normalizedTotal !== void 0) {
+      acc.remainingInheritedUsage = void 0;
+    }
+    return increment;
+  }
+  return applyCodexContainedSnapshot(containment, normalizedLast, normalizedTotal);
+}
+function rootUsageIncrement(acc, last, total) {
+  if (total !== void 0) {
+    const previous = acc.previousTotalUsage;
+    if (previous !== void 0 && sameCodexUsage(previous, total)) {
+      return void 0;
+    }
+    const increment = last === void 0 ? cumulativeCodexDelta(total, previous) : normalizeCodexUsage(last);
+    acc.previousTotalUsage = total;
+    return positiveIncrement(increment);
+  }
+  return last === void 0 ? void 0 : positiveIncrement(normalizeCodexUsage(last));
+}
+function usageIncrement(acc, last, total) {
+  if (acc.containment !== void 0) {
+    return containedUsageIncrement(acc, last, total);
+  }
+  const normalizedTotal = total === void 0 ? void 0 : normalizeCodexUsage(total);
+  if (acc.lineageKind === "Resolved") {
+    return resolvedUsageIncrement(acc, last, normalizedTotal);
+  }
+  if (acc.lineageKind === "Unresolved") {
+    return unresolvedUsageIncrement(acc, normalizedTotal);
+  }
+  return rootUsageIncrement(acc, last, normalizedTotal);
 }
 function addToBucket(acc, hourUtc, model, delta) {
   const { inputTokens, outputTokens, cacheReadTokens } = delta;
@@ -2761,11 +3731,16 @@ function addToBucket(acc, hourUtc, model, delta) {
   existing.cacheReadTokens += cacheReadTokens;
   return true;
 }
+function recordUsageCandidate(acc, usage, model) {
+  if (!addToBucket(acc, startOfUtcHour(usage.eventAt), model, usage.usage)) {
+    return;
+  }
+  acc.candidates.push({ ...usage, model });
+  markSessionSeen(acc, usage.eventAt);
+}
 function flushPendingUsage(acc, model) {
   for (const pending of acc.pendingUsage) {
-    if (addToBucket(acc, startOfUtcHour(pending.eventAt), model, pending.usage)) {
-      markSessionSeen(acc, pending.eventAt);
-    }
+    recordUsageCandidate(acc, pending, model);
   }
   acc.pendingUsage = [];
 }
@@ -2798,6 +3773,7 @@ function accumulateCodexLine(context, acc, raw) {
     if (shouldExcludePath(parsed.payload.cwd, options.excludePath)) {
       acc.excluded = true;
       acc.buckets.clear();
+      acc.candidates = [];
       acc.pendingUsage = [];
     }
     return acc;
@@ -2806,6 +3782,7 @@ function accumulateCodexLine(context, acc, raw) {
     if (shouldExcludePath(parsed.payload.cwd, options.excludePath)) {
       acc.excluded = true;
       acc.buckets.clear();
+      acc.candidates = [];
       acc.pendingUsage = [];
       return acc;
     }
@@ -2817,6 +3794,10 @@ function accumulateCodexLine(context, acc, raw) {
     }
     return acc;
   }
+  if (isCodexTaskStartedEvent(parsed)) {
+    acc.currentTurnId = pickCodexTurnId(parsed);
+    return acc;
+  }
   if (!isCodexTokenCountEvent(parsed)) {
     return acc;
   }
@@ -2830,24 +3811,25 @@ function accumulateCodexLine(context, acc, raw) {
     return acc;
   }
   const eventAt = new Date(tsMs);
+  const eventIndex = acc.nextEventIndex;
+  acc.nextEventIndex += 1;
+  const turnId = pickCodexTurnId(parsed) ?? acc.currentTurnId;
+  const candidate = { eventAt, eventIndex, turnId, usage: delta };
   const eventModel = pickCodexEventModel(parsed);
   const model = acc.sawTurnContext ? acc.currentModel ?? eventModel : eventModel ?? acc.currentModel;
   if (model === void 0) {
-    acc.pendingUsage.push({ eventAt, usage: delta });
+    acc.pendingUsage.push(candidate);
     return acc;
   }
-  if (addToBucket(acc, startOfUtcHour(eventAt), model, delta)) {
-    markSessionSeen(acc, eventAt);
-  }
+  recordUsageCandidate(acc, candidate, model);
   return acc;
 }
-function bucketsFromAccumulator(path, acc) {
+function bucketsFromAccumulator(path, options, acc) {
   if (acc.excluded || acc.sessionStartedAt === void 0 || acc.sessionLastSeenAt === void 0) {
     return [];
   }
-  const sessionStartedAt = acc.sessionStartedAt;
-  const sessionLastSeenAt = acc.sessionLastSeenAt;
-  const sessionIds = /* @__PURE__ */ new Set([path]);
+  const { sessionLastSeenAt, sessionStartedAt } = acc;
+  const sessionIds = /* @__PURE__ */ new Set([options.sessionIdentity ?? path]);
   return Array.from(acc.buckets.values(), (bucket) => ({
     harness: "codex",
     model: bucket.model,
@@ -2861,13 +3843,37 @@ function bucketsFromAccumulator(path, acc) {
     sessionLastSeenAt
   }));
 }
-function bucketizeCodexFileStream(path, logger, options = {}) {
+function candidatesFromAccumulator(path, options, acc) {
+  if (acc.excluded || acc.sessionStartedAt === void 0 || acc.sessionLastSeenAt === void 0) {
+    return [];
+  }
+  const sessionIdentity = options.sessionIdentity ?? path;
+  const canonicalSessionIdentity = options.canonicalSessionIdentity ?? sessionIdentity;
+  return acc.candidates.map((candidate) => ({
+    cacheReadTokens: candidate.usage.cacheReadTokens,
+    canonicalSessionIdentity,
+    eventIndex: candidate.eventIndex,
+    hourUtc: startOfUtcHour(candidate.eventAt),
+    inputTokens: candidate.usage.inputTokens,
+    model: candidate.model,
+    outputTokens: candidate.usage.outputTokens,
+    sessionIdentity,
+    sessionLastSeenAt: acc.sessionLastSeenAt,
+    sessionStartedAt: acc.sessionStartedAt,
+    turnId: candidate.turnId
+  }));
+}
+function codexFileUsageEffect(path, logger, options = {}) {
   const context = { logger, options, path };
-  return Stream8.unwrap(
-    lineStreamFromFile(path).pipe(
-      Stream8.runFold(makeCodexFileAccumulator, (acc, raw) => accumulateCodexLine(context, acc, raw)),
-      Effect15.map((acc) => Stream8.fromIterable(bucketsFromAccumulator(path, acc)))
-    )
+  return lineStreamFromFile(path).pipe(
+    Stream9.runFold(
+      () => makeCodexFileAccumulator(options),
+      (acc, raw) => accumulateCodexLine(context, acc, raw)
+    ),
+    Effect16.map((acc) => ({
+      buckets: bucketsFromAccumulator(path, options, acc),
+      candidates: candidatesFromAccumulator(path, options, acc)
+    }))
   );
 }
 
@@ -2878,6 +3884,12 @@ function isObject2(value) {
 function isFiniteNumber2(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
+var MAX_CLAUDE_SOURCE_ID_LENGTH = 512;
+var MAX_CLAUDE_TIMESTAMP_LENGTH = 128;
+var MAX_CLAUDE_LOCAL_PATH_LENGTH = 4096;
+function isOptionalBoundedString2(value, maxLength) {
+  return value === void 0 || typeof value === "string" && value.length <= maxLength;
+}
 function isClaudeUsage(value) {
   if (!isObject2(value)) {
     return false;
@@ -2898,20 +3910,23 @@ function isClaudeAssistantEvent(value) {
   if (value["type"] !== "assistant") {
     return false;
   }
-  if (typeof value["timestamp"] !== "string") {
+  if (typeof value["timestamp"] !== "string" || value["timestamp"].length > MAX_CLAUDE_TIMESTAMP_LENGTH) {
     return false;
   }
-  if (value["cwd"] !== void 0 && typeof value["cwd"] !== "string") {
+  if (!isOptionalBoundedString2(value["cwd"], MAX_CLAUDE_LOCAL_PATH_LENGTH)) {
+    return false;
+  }
+  if (!isOptionalBoundedString2(value["requestId"], MAX_CLAUDE_SOURCE_ID_LENGTH)) {
     return false;
   }
-  if (value["requestId"] !== void 0 && typeof value["requestId"] !== "string") {
+  if (value["isSidechain"] !== void 0 && typeof value["isSidechain"] !== "boolean") {
     return false;
   }
   const message = value["message"];
   if (!isObject2(message)) {
     return false;
   }
-  if (message["id"] !== void 0 && typeof message["id"] !== "string") {
+  if (!isOptionalBoundedString2(message["id"], MAX_CLAUDE_SOURCE_ID_LENGTH)) {
     return false;
   }
   if (typeof message["model"] !== "string") {
@@ -2928,25 +3943,21 @@ function key3(hourUtc, model) {
   return `${hourUtc.toISOString()}|${model}`;
 }
 function shouldExcludePath2(path, excludePath) {
-  return path !== void 0 && excludePath?.(path) === true;
-}
-function makeClaudeFileAccumulator(options) {
-  return {
-    buckets: /* @__PURE__ */ new Map(),
-    excluded: false,
-    lineNo: 0,
-    seenTuples: options.seenTuples ?? /* @__PURE__ */ new Set(),
-    sessionLastSeenAt: void 0,
-    sessionStartedAt: void 0
-  };
+  return path !== void 0 && excludePath?.(path) === true;
+}
+function makeClaudeFileCandidateAccumulator() {
+  return { excluded: false, identified: /* @__PURE__ */ new Map(), lineNo: 0, unidentified: [] };
+}
+function makeClaudeSessionAccumulator() {
+  return { buckets: /* @__PURE__ */ new Map(), sessionLastSeenAt: void 0, sessionStartedAt: void 0 };
 }
 function lineStreamFromFile2(path) {
-  return Stream9.callback(
-    (queue) => Effect16.acquireRelease(
-      Effect16.sync(() => {
+  return Stream10.callback(
+    (queue) => Effect17.acquireRelease(
+      Effect17.sync(() => {
         let done = false;
         const stream = createReadStream2(path, { encoding: "utf8" });
-        const rl = createInterface3({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+        const lines = createInterface3({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
         const offer = (line) => {
           if (!done) {
             Queue2.offerUnsafe(queue, line);
@@ -2965,61 +3976,32 @@ function lineStreamFromFile2(path) {
           }
         };
         stream.once("error", fail);
-        rl.once("error", fail);
-        rl.once("close", end);
-        rl.on("line", offer);
+        lines.once("error", fail);
+        lines.once("close", end);
+        lines.on("line", offer);
         return {
           close: () => {
             done = true;
-            rl.off("close", end);
-            rl.off("error", fail);
-            rl.off("line", offer);
+            lines.off("close", end);
+            lines.off("error", fail);
+            lines.off("line", offer);
             stream.off("error", fail);
-            rl.close();
+            lines.close();
             stream.destroy();
           }
         };
       }),
-      (resource) => Effect16.sync(() => resource.close())
+      (resource) => Effect17.sync(() => resource.close())
     )
   );
 }
-function addToBucket2(acc, hourUtc, model, usage) {
-  const inputTokens = Math.max(0, usage.input_tokens ?? 0);
-  const outputTokens = Math.max(0, usage.output_tokens ?? 0);
-  const cacheReadTokens = Math.max(0, usage.cache_read_input_tokens ?? 0);
-  const cacheCreateTokens = Math.max(0, usage.cache_creation_input_tokens ?? 0);
-  if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheCreateTokens === 0) {
+function eventIsEligible(timestampMs3, options) {
+  if (options.cutoff !== void 0 && timestampMs3 < options.cutoff.getTime()) {
     return false;
   }
-  const k = key3(hourUtc, model);
-  const existing = acc.buckets.get(k);
-  if (existing === void 0) {
-    acc.buckets.set(k, {
-      hourUtc,
-      model,
-      inputTokens,
-      outputTokens,
-      cacheReadTokens,
-      cacheCreateTokens
-    });
-    return true;
-  }
-  existing.inputTokens += inputTokens;
-  existing.outputTokens += outputTokens;
-  existing.cacheReadTokens += cacheReadTokens;
-  existing.cacheCreateTokens += cacheCreateTokens;
-  return true;
-}
-function markSessionSeen2(acc, eventAt) {
-  if (acc.sessionStartedAt === void 0 || eventAt.getTime() < acc.sessionStartedAt.getTime()) {
-    acc.sessionStartedAt = eventAt;
-  }
-  if (acc.sessionLastSeenAt === void 0 || eventAt.getTime() > acc.sessionLastSeenAt.getTime()) {
-    acc.sessionLastSeenAt = eventAt;
-  }
+  return options.endExclusive === void 0 || timestampMs3 < options.endExclusive.getTime();
 }
-function accumulateClaudeLine(context, acc, raw) {
+function accumulateClaudeCandidate(context, acc, raw) {
   const { logger, options, path } = context;
   acc.lineNo += 1;
   if (acc.excluded) {
@@ -3041,37 +4023,129 @@ function accumulateClaudeLine(context, acc, raw) {
   }
   if (shouldExcludePath2(parsed.cwd, options.excludePath)) {
     acc.excluded = true;
-    acc.buckets.clear();
+    acc.identified.clear();
+    acc.unidentified = [];
     return acc;
   }
-  const tsMs = Date.parse(parsed.timestamp);
-  if (!Number.isFinite(tsMs)) {
+  const timestampMs3 = Date.parse(parsed.timestamp);
+  if (!(Number.isFinite(timestampMs3) && eventIsEligible(timestampMs3, options))) {
     return acc;
   }
-  if (options.cutoff !== void 0 && tsMs < options.cutoff.getTime()) {
-    return acc;
+  const tupleKey = parsed.message.id === void 0 || parsed.requestId === void 0 ? void 0 : JSON.stringify([parsed.message.id, parsed.requestId]);
+  const candidate = {
+    eventAt: new Date(timestampMs3),
+    eventOrder: acc.lineNo,
+    isSidechain: parsed.isSidechain === true,
+    model: parsed.message.model,
+    pathRole: options.pathRole ?? "parent",
+    sessionId: options.sessionId ?? path,
+    sourceOrder: normalize3(path),
+    tupleKey,
+    usage: parsed.message.usage
+  };
+  if (tupleKey === void 0) {
+    acc.unidentified.push(candidate);
+  } else {
+    acc.identified.set(tupleKey, candidate);
   }
-  const { message, requestId } = parsed;
-  if (message.id !== void 0 && requestId !== void 0) {
-    const tuple = `${message.id}::${requestId}`;
-    if (acc.seenTuples.has(tuple)) {
-      return acc;
+  return acc;
+}
+function candidatesFromAccumulator2(acc) {
+  return acc.excluded ? [] : [...acc.identified.values(), ...acc.unidentified];
+}
+function collectClaudeFileCandidates(path, logger, options = {}) {
+  const context = { logger, options, path };
+  return lineStreamFromFile2(path).pipe(
+    Stream10.runFold(makeClaudeFileCandidateAccumulator, (acc, raw) => accumulateClaudeCandidate(context, acc, raw)),
+    Effect17.map(candidatesFromAccumulator2)
+  );
+}
+function normalizedUsage(usage) {
+  return {
+    inputTokens: Math.max(0, usage.input_tokens ?? 0),
+    outputTokens: Math.max(0, usage.output_tokens ?? 0),
+    cacheReadTokens: Math.max(0, usage.cache_read_input_tokens ?? 0),
+    cacheCreateTokens: Math.max(0, usage.cache_creation_input_tokens ?? 0)
+  };
+}
+function sameUsage(left, right) {
+  const a = normalizedUsage(left);
+  const b = normalizedUsage(right);
+  return a.inputTokens === b.inputTokens && a.outputTokens === b.outputTokens && a.cacheReadTokens === b.cacheReadTokens && a.cacheCreateTokens === b.cacheCreateTokens;
+}
+function candidateWins(next, current) {
+  if (next.model === current.model && sameUsage(next.usage, current.usage)) {
+    if (next.isSidechain !== current.isSidechain) {
+      return !next.isSidechain;
+    }
+    if (next.pathRole !== current.pathRole) {
+      return next.pathRole === "parent";
     }
-    acc.seenTuples.add(tuple);
   }
-  const eventAt = new Date(tsMs);
-  if (addToBucket2(acc, startOfUtcHour(eventAt), message.model, message.usage)) {
-    markSessionSeen2(acc, eventAt);
+  const timestampOrder = next.eventAt.getTime() - current.eventAt.getTime();
+  if (timestampOrder !== 0) {
+    return timestampOrder > 0;
   }
-  return acc;
+  if (next.eventOrder !== current.eventOrder) {
+    return next.eventOrder > current.eventOrder;
+  }
+  return next.sourceOrder.localeCompare(current.sourceOrder) < 0;
 }
-function bucketsFromAccumulator2(path, options, acc) {
-  if (acc.excluded || acc.sessionStartedAt === void 0 || acc.sessionLastSeenAt === void 0) {
+function reconcileClaudeCandidates(candidates) {
+  const identified = /* @__PURE__ */ new Map();
+  const unidentified = [];
+  for (const candidate of candidates) {
+    if (candidate.tupleKey === void 0) {
+      unidentified.push(candidate);
+      continue;
+    }
+    const current = identified.get(candidate.tupleKey);
+    if (current === void 0 || candidateWins(candidate, current)) {
+      identified.set(candidate.tupleKey, candidate);
+    }
+  }
+  return [...identified.values(), ...unidentified];
+}
+function addToBucket2(acc, candidate) {
+  const usage = normalizedUsage(candidate.usage);
+  const { cacheCreateTokens, cacheReadTokens, inputTokens, outputTokens } = usage;
+  if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheCreateTokens === 0) {
+    return false;
+  }
+  const hourUtc = startOfUtcHour(candidate.eventAt);
+  const bucketKey = key3(hourUtc, candidate.model);
+  const existing = acc.buckets.get(bucketKey);
+  if (existing === void 0) {
+    acc.buckets.set(bucketKey, {
+      hourUtc,
+      model: candidate.model,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens,
+      cacheCreateTokens
+    });
+    return true;
+  }
+  existing.inputTokens += inputTokens;
+  existing.outputTokens += outputTokens;
+  existing.cacheReadTokens += cacheReadTokens;
+  existing.cacheCreateTokens += cacheCreateTokens;
+  return true;
+}
+function markSessionSeen2(acc, eventAt) {
+  if (acc.sessionStartedAt === void 0 || eventAt.getTime() < acc.sessionStartedAt.getTime()) {
+    acc.sessionStartedAt = eventAt;
+  }
+  if (acc.sessionLastSeenAt === void 0 || eventAt.getTime() > acc.sessionLastSeenAt.getTime()) {
+    acc.sessionLastSeenAt = eventAt;
+  }
+}
+function bucketsForSession(sessionId, acc) {
+  const { sessionLastSeenAt, sessionStartedAt } = acc;
+  if (sessionStartedAt === void 0 || sessionLastSeenAt === void 0) {
     return [];
   }
-  const sessionStartedAt = acc.sessionStartedAt;
-  const sessionLastSeenAt = acc.sessionLastSeenAt;
-  const sessionIds = /* @__PURE__ */ new Set([options.sessionId ?? path]);
+  const sessionIds = /* @__PURE__ */ new Set([sessionId]);
   return Array.from(acc.buckets.values(), (bucket) => ({
     harness: "claude_code",
     model: bucket.model,
@@ -3085,70 +4159,80 @@ function bucketsFromAccumulator2(path, options, acc) {
     sessionLastSeenAt
   }));
 }
+function bucketizeClaudeCandidates(candidates) {
+  const sessions = /* @__PURE__ */ new Map();
+  for (const candidate of reconcileClaudeCandidates(candidates)) {
+    const acc = sessions.get(candidate.sessionId) ?? makeClaudeSessionAccumulator();
+    if (addToBucket2(acc, candidate)) {
+      markSessionSeen2(acc, candidate.eventAt);
+    }
+    sessions.set(candidate.sessionId, acc);
+  }
+  return [...sessions.entries()].flatMap(([sessionId, acc]) => bucketsForSession(sessionId, acc));
+}
 function bucketizeClaudeFileStream(path, logger, options = {}) {
-  const context = { logger, options, path };
-  return Stream9.unwrap(
-    lineStreamFromFile2(path).pipe(
-      Stream9.runFold(
-        () => makeClaudeFileAccumulator(options),
-        (acc, raw) => accumulateClaudeLine(context, acc, raw)
-      ),
-      Effect16.map((acc) => Stream9.fromIterable(bucketsFromAccumulator2(path, options, acc)))
+  return Stream10.unwrap(
+    collectClaudeFileCandidates(path, logger, options).pipe(
+      Effect17.map((candidates) => Stream10.fromIterable(bucketizeClaudeCandidates(candidates)))
     )
   );
 }
 
 // ../../packages/parsers/src/claude/index.ts
-function sourceSessionId(path) {
+function sourceContext(path) {
   const fileDir = dirname2(path);
   if (basename(fileDir) !== "subagents") {
-    return path;
+    return { pathRole: "parent", sessionId: path };
   }
   const sessionDir = dirname2(fileDir);
-  return `${sessionDir}.jsonl`;
+  return { pathRole: "subagent", sessionId: `${sessionDir}.jsonl` };
 }
 function bucketizeClaudeSourcesStream(files, logger, options) {
-  return Stream10.suspend(() => {
-    const seenTuples = /* @__PURE__ */ new Set();
-    return files.pipe(
-      Stream10.flatMap(
-        (file) => {
-          const sessionId = sourceSessionId(file);
-          return bucketizeClaudeFileStream(file, logger, {
-            cutoff: options.cutoff,
-            excludePath: options.excludePath,
-            sessionId,
-            seenTuples
+  return Stream11.unwrap(
+    files.pipe(
+      Stream11.runCollect,
+      Effect18.map((paths) => [...paths].sort()),
+      Effect18.flatMap(
+        (paths) => Effect18.forEach(paths, (path) => {
+          const source = sourceContext(path);
+          return collectClaudeFileCandidates(path, logger, {
+            ...options,
+            pathRole: source.pathRole,
+            sessionId: source.sessionId
           });
-        },
-        { concurrency: 1 }
-      )
-    );
-  });
+        })
+      ),
+      Effect18.map((filesCandidates) => Stream11.fromIterable(bucketizeClaudeCandidates(filesCandidates.flat())))
+    )
+  );
 }
-var parseClaudeEffect = Effect17.fn("ClaudeParser.parseClaudeEffect")(
-  (opts) => Stream10.runCollect(parseClaudeStream(opts))
+var parseClaudeEffect = Effect18.fn("ClaudeParser.parseClaudeEffect")(
+  (opts) => Stream11.runCollect(parseClaudeStream(opts))
 );
-var parseClaudeStream = (opts) => Stream10.unwrap(
-  Effect17.gen(function* () {
+var parseClaudeStream = (opts) => Stream11.unwrap(
+  Effect18.gen(function* () {
     const logger = opts.logger ?? silentLogger;
     const root = opts.root ?? resolveClaudeRoot();
     if ((yield* pathKindEffectStrict(root)) === "file") {
+      const source = sourceContext(root);
       return bucketizeClaudeFileStream(root, logger, {
         cutoff: opts.cutoff,
+        endExclusive: opts.endExclusive,
         excludePath: opts.excludePath,
-        sessionId: sourceSessionId(root)
+        pathRole: source.pathRole,
+        sessionId: source.sessionId
       });
     }
     return bucketizeClaudeSourcesStream(walkStreamStrict(root, opts.cutoff), logger, {
       cutoff: opts.cutoff,
+      endExclusive: opts.endExclusive,
       excludePath: opts.excludePath
     });
   })
 );
 
 // ../../packages/parsers/src/codex/index.ts
-import { Effect as Effect18, Stream as Stream11 } from "effect";
+import { Effect as Effect19, Stream as Stream12 } from "effect";
 var codexRoots = (opts, root) => {
   const roots = [root];
   if (opts.root === void 0 && opts.archivedRoot === void 0) {
@@ -3158,52 +4242,134 @@ var codexRoots = (opts, root) => {
   }
   return roots;
 };
-var parseCodexEffect = Effect18.fn("CodexParser.parseCodexEffect")(
-  (opts) => Stream11.runCollect(parseCodexStream(opts))
+function candidateIdentity(candidate) {
+  return [
+    candidate.canonicalSessionIdentity,
+    candidate.turnId ?? "",
+    String(candidate.eventIndex),
+    candidate.hourUtc.toISOString().slice(0, 10),
+    candidate.model,
+    String(candidate.inputTokens),
+    String(candidate.cacheReadTokens),
+    String(candidate.outputTokens)
+  ].join("");
+}
+function reconcileCodexCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  const winners = [];
+  for (const candidate of candidates) {
+    const identity = candidateIdentity(candidate);
+    if (seen.has(identity)) {
+      continue;
+    }
+    seen.add(identity);
+    winners.push(candidate);
+  }
+  return winners;
+}
+function bucketsFromCodexCandidates(candidates) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const identity = `${candidate.sessionIdentity}${candidate.hourUtc.toISOString()}${candidate.model}`;
+    const existing = buckets.get(identity);
+    if (existing === void 0) {
+      buckets.set(identity, {
+        cacheReadTokens: candidate.cacheReadTokens,
+        hourUtc: candidate.hourUtc,
+        inputTokens: candidate.inputTokens,
+        model: candidate.model,
+        outputTokens: candidate.outputTokens,
+        sessionIdentity: candidate.sessionIdentity,
+        sessionLastSeenAt: candidate.sessionLastSeenAt,
+        sessionStartedAt: candidate.sessionStartedAt
+      });
+      continue;
+    }
+    existing.inputTokens += candidate.inputTokens;
+    existing.outputTokens += candidate.outputTokens;
+    existing.cacheReadTokens += candidate.cacheReadTokens;
+  }
+  return [...buckets.values()].map((bucket) => ({
+    harness: "codex",
+    model: bucket.model,
+    hourUtc: bucket.hourUtc,
+    inputTokens: bucket.inputTokens,
+    outputTokens: bucket.outputTokens,
+    cacheReadTokens: bucket.cacheReadTokens,
+    cacheCreateTokens: 0,
+    sessionIds: /* @__PURE__ */ new Set([bucket.sessionIdentity]),
+    sessionStartedAt: bucket.sessionStartedAt,
+    sessionLastSeenAt: bucket.sessionLastSeenAt
+  }));
+}
+var parseCodexEffect = Effect19.fn("CodexParser.parseCodexEffect")(
+  (opts) => Stream12.runCollect(parseCodexStream(opts))
 );
-var parseCodexStream = (opts) => Stream11.unwrap(
-  Effect18.gen(function* () {
+var parseCodexStream = (opts) => Stream12.unwrap(
+  Effect19.gen(function* () {
     const logger = opts.logger ?? silentLogger;
     const root = opts.root ?? resolveCodexSessionsRoot();
     if ((yield* pathKindEffectStrict(root)) === "file") {
-      return bucketizeCodexFileStream(root, logger, { excludePath: opts.excludePath });
+      return bucketizeIndexedCodexFilesStream(Stream12.succeed(root), opts.cutoff, logger, {
+        excludePath: opts.excludePath
+      });
     }
-    return bucketizeCodexFilesStream(walkManyStreamStrict(codexRoots(opts, root), opts.cutoff), logger, {
-      excludePath: opts.excludePath
-    });
+    return bucketizeIndexedCodexFilesStream(
+      walkManyStreamStrict(codexRoots(opts, root), /* @__PURE__ */ new Date(0)),
+      opts.cutoff,
+      logger,
+      { excludePath: opts.excludePath }
+    );
   })
 );
-function bucketizeCodexFilesStream(files, logger, options) {
-  return files.pipe(Stream11.flatMap((file) => bucketizeCodexFileStream(file, logger, options)));
+function bucketizeIndexedCodexFilesStream(files, cutoff, logger, options) {
+  return Stream12.unwrap(
+    files.pipe(
+      Stream12.runCollect,
+      Effect19.map((paths) => [...paths]),
+      Effect19.flatMap((paths) => buildCodexSourceIndex(paths, cutoff, logger)),
+      Effect19.flatMap(
+        (index) => Effect19.gen(function* () {
+          const resolver = makeCodexLineageResolver(index, logger);
+          const usages = yield* Effect19.forEach(
+            index.sources.filter((source) => source.eligible),
+            (source) => resolver.baselineFor(source).pipe(
+              Effect19.flatMap(
+                (lineageBaseline) => codexFileUsageEffect(source.path, logger, {
+                  ...options,
+                  canonicalSessionIdentity: source.lineageSessionId ?? source.sourceIdentity,
+                  containInterleavedTotals: source.containsMultipleSessionIds,
+                  lineageBaseline,
+                  sessionIdentity: source.sourceIdentity
+                })
+              )
+            )
+          );
+          const candidates = usages.flatMap((usage) => usage.candidates);
+          return Stream12.fromIterable(bucketsFromCodexCandidates(reconcileCodexCandidates(candidates)));
+        })
+      )
+    )
+  );
 }
 
 // ../../packages/parsers/src/effect/hermes-sqlite.ts
-import { Context as Context9, Effect as Effect19, Layer as Layer8, Schema as Schema22 } from "effect";
+import { Context as Context9, Effect as Effect20, Layer as Layer8, Schema as Schema22 } from "effect";
 var NODE_SQLITE_SPECIFIER = ["node", "sqlite"].join(":");
 var MILLISECONDS_PER_SECOND = 1e3;
-var HERMES_SESSION_QUERY = `
-  select
-    id,
-    model,
-    billing_provider as "billingProvider",
-    started_at as "startedAt",
-    ended_at as "endedAt",
-    input_tokens as "inputTokens",
-    output_tokens as "outputTokens",
-    cache_read_tokens as "cacheReadTokens",
-    cache_write_tokens as "cacheWriteTokens",
-    cwd
-  from sessions
-  where coalesce(ended_at, started_at) >= ?
-  order by started_at asc, id asc
-`;
 var HermesSqliteError = class extends Schema22.TaggedErrorClass()("HermesSqliteError", {
   message: Schema22.String,
-  operation: Schema22.Literals(["load", "open", "query", "close"]),
+  operation: Schema22.Literals(["close", "load", "open", "query", "schema"]),
   path: Schema22.optionalKey(Schema22.String),
   cause: Schema22.optionalKey(Schema22.Defect())
 }) {
 };
+function unsupportedSchema(message) {
+  return { _tag: "UnsupportedHermesSchema", message };
+}
+function isUnsupportedSchema(value) {
+  return typeof value === "object" && value !== null && "_tag" in value && value._tag === "UnsupportedHermesSchema";
+}
 var HermesSqlite = class extends Context9.Service()("@oopst/parsers/HermesSqlite") {
 };
 var toHermesSqliteError = (operation, path) => (error) => new HermesSqliteError({
@@ -3212,34 +4378,124 @@ var toHermesSqliteError = (operation, path) => (error) => new HermesSqliteError(
   path,
   cause: error
 });
-var loadDatabaseSync = Effect19.fn("HermesSqlite.loadDatabaseSync")(function* () {
-  const sqliteModule = yield* Effect19.tryPromise({
+var loadDatabaseSync = Effect20.fn("HermesSqlite.loadDatabaseSync")(function* () {
+  const sqliteModule = yield* Effect20.tryPromise({
     try: () => import(NODE_SQLITE_SPECIFIER),
     catch: toHermesSqliteError("load")
   });
   return sqliteModule.DatabaseSync;
 });
-var openDatabase = (path, DatabaseSync) => Effect19.try({
+var openDatabase = (path, DatabaseSync) => Effect20.try({
   try: () => new DatabaseSync(path, { readOnly: true, timeout: 1e3 }),
   catch: toHermesSqliteError("open", path)
 });
-var closeDatabase = (path, db) => Effect19.try({
+var closeDatabase = (path, db) => Effect20.try({
   try: () => {
     db.close();
   },
   catch: toHermesSqliteError("close", path)
 });
-var querySessionRows = (path, db, cutoff) => Effect19.try({
+function tableNames(db) {
+  const rows = db.prepare("select name from sqlite_master where type = 'table'").all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
+function tableColumns(db, table) {
+  const rows = db.prepare(`pragma table_info(${table})`).all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
+function requireColumns(table, columns, required) {
+  const missing = required.filter((column) => !columns.has(column));
+  if (missing.length > 0) {
+    throw unsupportedSchema(`${table} is missing required accounting columns`);
+  }
+}
+function selectedColumn(columns, column, alias, qualifier) {
+  const source = qualifier === void 0 ? column : `${qualifier}.${column}`;
+  return columns.has(column) ? `${source} as "${alias}"` : `null as "${alias}"`;
+}
+function sessionRows(db, cutoffSeconds) {
+  const columns = tableColumns(db, "sessions");
+  requireColumns("sessions", columns, ["id", "model", "started_at", "ended_at", "input_tokens", "output_tokens"]);
+  const query = `
+    select
+      id,
+      model,
+      ${selectedColumn(columns, "billing_provider", "billingProvider")},
+      started_at as "startedAt",
+      ended_at as "endedAt",
+      input_tokens as "inputTokens",
+      output_tokens as "outputTokens",
+      ${selectedColumn(columns, "cache_read_tokens", "cacheReadTokens")},
+      ${selectedColumn(columns, "cache_write_tokens", "cacheWriteTokens")},
+      ${selectedColumn(columns, "reasoning_tokens", "reasoningTokens")},
+      ${selectedColumn(columns, "cwd", "cwd")}
+    from sessions
+    where ended_at is null or ended_at >= ?
+    order by started_at asc, id asc
+  `;
+  return db.prepare(query).all(cutoffSeconds);
+}
+function modelUsageRows(db, cutoffSeconds) {
+  const columns = tableColumns(db, "session_model_usage");
+  requireColumns("session_model_usage", columns, ["session_id", "model", "input_tokens", "output_tokens"]);
+  const query = `
+    select
+      usage.session_id as "sessionId",
+      usage.model,
+		${selectedColumn(columns, "billing_provider", "billingProvider", "usage")},
+		${selectedColumn(columns, "first_seen", "firstSeen", "usage")},
+		${selectedColumn(columns, "last_seen", "lastSeen", "usage")},
+      usage.input_tokens as "inputTokens",
+      usage.output_tokens as "outputTokens",
+		${selectedColumn(columns, "cache_read_tokens", "cacheReadTokens", "usage")},
+		${selectedColumn(columns, "cache_write_tokens", "cacheWriteTokens", "usage")},
+		${selectedColumn(columns, "reasoning_tokens", "reasoningTokens", "usage")}
+    from session_model_usage as usage
+    inner join sessions on sessions.id = usage.session_id
+    where sessions.ended_at is null or sessions.ended_at >= ?
+    order by usage.session_id asc, usage.model asc
+  `;
+  return db.prepare(query).all(cutoffSeconds);
+}
+function attachModelUsageRows(sessions, usageRows) {
+  const bySession = /* @__PURE__ */ new Map();
+  for (const row of usageRows) {
+    if (typeof row.sessionId !== "string") {
+      continue;
+    }
+    const rows = bySession.get(row.sessionId) ?? [];
+    rows.push(row);
+    bySession.set(row.sessionId, rows);
+  }
+  return sessions.map((row) => ({
+    ...row,
+    modelUsageRows: typeof row.id === "string" ? bySession.get(row.id) ?? [] : []
+  }));
+}
+var querySessionRows = (path, db, cutoff) => Effect20.try({
   try: () => {
-    const statement = db.prepare(HERMES_SESSION_QUERY);
-    return statement.all(cutoff.getTime() / MILLISECONDS_PER_SECOND);
+    const tables = tableNames(db);
+    if (!tables.has("sessions")) {
+      throw unsupportedSchema("sessions table is unavailable");
+    }
+    const cutoffSeconds = cutoff.getTime() / MILLISECONDS_PER_SECOND;
+    const sessions = sessionRows(db, cutoffSeconds);
+    if (!tables.has("session_model_usage")) {
+      return sessions;
+    }
+    return attachModelUsageRows(sessions, modelUsageRows(db, cutoffSeconds));
   },
-  catch: toHermesSqliteError("query", path)
+  catch: (error) => isUnsupportedSchema(error) ? new HermesSqliteError({
+    message: "Hermes SQLite schema does not expose supported accounting aggregates",
+    operation: "schema",
+    path,
+    cause: error
+  }) : toHermesSqliteError("query", path)(error)
 });
 var makeHermesSqlite = () => ({
-  readSessionRows: Effect19.fn("HermesSqlite.readSessionRows")(function* (path, cutoff) {
+  readSessionRows: Effect20.fn("HermesSqlite.readSessionRows")(function* (path, cutoff) {
     const DatabaseSync = yield* loadDatabaseSync();
-    return yield* Effect19.acquireUseRelease(
+    return yield* Effect20.acquireUseRelease(
       openDatabase(path, DatabaseSync),
       (db) => querySessionRows(path, db, cutoff),
       (db) => closeDatabase(path, db)
@@ -3248,13 +4504,13 @@ var makeHermesSqlite = () => ({
 });
 var HermesSqliteLive = Layer8.effect(
   HermesSqlite,
-  Effect19.sync(() => HermesSqlite.of(makeHermesSqlite()))
+  Effect20.sync(() => HermesSqlite.of(makeHermesSqlite()))
 );
 
 // ../../packages/parsers/src/effect/opencode-io.ts
 import { basename as basename2, join as join6 } from "path";
 import { NodeFileSystem as NodeFileSystem5 } from "@effect/platform-node";
-import { Context as Context10, Effect as Effect20, FileSystem as FileSystem6, Layer as Layer9, Option as Option3, Schema as Schema23, Stream as Stream12 } from "effect";
+import { Context as Context10, Effect as Effect21, FileSystem as FileSystem6, Layer as Layer9, Option as Option3, Schema as Schema23, Stream as Stream13 } from "effect";
 var NODE_SQLITE_SPECIFIER2 = ["node", "sqlite"].join(":");
 var OPENCODE_DB_FILE_PATTERN2 = /^opencode(?:-[^/]+)?\.db$/u;
 var SESSION_MESSAGE_QUERY = `
@@ -3286,13 +4542,13 @@ var toOpenCodeIoError = (operation, path) => (error) => new OpenCodeIoError({
   path,
   cause: error
 });
-var readDir2 = (fs, path) => fs.readDirectory(path).pipe(Effect20.mapError(toOpenCodeIoError("readdir", path)));
-var readDirBestEffort = (fs, path) => readDir2(fs, path).pipe(Effect20.catch(() => Effect20.succeed([])));
-var readStat2 = (fs, path) => fs.stat(path).pipe(Effect20.mapError(toOpenCodeIoError("stat", path)));
-var readStatBestEffort = (fs, path) => readStat2(fs, path).pipe(Effect20.catch(() => Effect20.succeed(void 0)));
-var pathKind = Effect20.fn("OpenCodeIo.pathKind")(function* (fs, path) {
+var readDir2 = (fs, path) => fs.readDirectory(path).pipe(Effect21.mapError(toOpenCodeIoError("readdir", path)));
+var readDirBestEffort = (fs, path) => readDir2(fs, path).pipe(Effect21.catch(() => Effect21.succeed([])));
+var readStat2 = (fs, path) => fs.stat(path).pipe(Effect21.mapError(toOpenCodeIoError("stat", path)));
+var readStatBestEffort = (fs, path) => readStat2(fs, path).pipe(Effect21.catch(() => Effect21.succeed(void 0)));
+var pathKind = Effect21.fn("OpenCodeIo.pathKind")(function* (fs, path) {
   return yield* readStat2(fs, path).pipe(
-    Effect20.map((info) => {
+    Effect21.map((info) => {
       if (info.type === "File") {
         return "file";
       }
@@ -3301,10 +4557,10 @@ var pathKind = Effect20.fn("OpenCodeIo.pathKind")(function* (fs, path) {
       }
       return "missing";
     }),
-    Effect20.catch(() => Effect20.succeed("missing"))
+    Effect21.catch(() => Effect21.succeed("missing"))
   );
 });
-var listOpenCodeDatabases = Effect20.fn("OpenCodeIo.listOpenCodeDatabases")(function* (fs, root) {
+var listOpenCodeDatabases = Effect21.fn("OpenCodeIo.listOpenCodeDatabases")(function* (fs, root) {
   const entries = yield* readDirBestEffort(fs, root);
   const databasePaths = [];
   for (const entry of entries) {
@@ -3318,7 +4574,7 @@ var listOpenCodeDatabases = Effect20.fn("OpenCodeIo.listOpenCodeDatabases")(func
   }
   return databasePaths;
 });
-var listProjectLegacyRoots = Effect20.fn("OpenCodeIo.listProjectLegacyRoots")(function* (fs, root) {
+var listProjectLegacyRoots = Effect21.fn("OpenCodeIo.listProjectLegacyRoots")(function* (fs, root) {
   const projectRoot = join6(root, "project");
   const entries = yield* readDirBestEffort(fs, projectRoot);
   const roots = [];
@@ -3330,7 +4586,7 @@ var listProjectLegacyRoots = Effect20.fn("OpenCodeIo.listProjectLegacyRoots")(fu
   }
   return roots;
 });
-var legacyRoots = Effect20.fn("OpenCodeIo.legacyRoots")(function* (fs, root) {
+var legacyRoots = Effect21.fn("OpenCodeIo.legacyRoots")(function* (fs, root) {
   return [
     join6(root, "storage", "message"),
     join6(root, "storage", "session", "message"),
@@ -3341,26 +4597,26 @@ var isRecent = (info, cutoff) => Option3.match(info.mtime, {
   onNone: () => false,
   onSome: (mtime) => mtime.getTime() >= cutoff.getTime()
 });
-var streamJsonFiles = (fs, root, cutoff) => Stream12.suspend(
-  () => Stream12.fromIterableEffect(readDirBestEffort(fs, root)).pipe(
-    Stream12.flatMap((entry) => {
+var streamJsonFiles = (fs, root, cutoff) => Stream13.suspend(
+  () => Stream13.fromIterableEffect(readDirBestEffort(fs, root)).pipe(
+    Stream13.flatMap((entry) => {
       const full = join6(root, entry);
-      return Stream12.fromEffect(readStatBestEffort(fs, full)).pipe(
-        Stream12.flatMap((info) => {
+      return Stream13.fromEffect(readStatBestEffort(fs, full)).pipe(
+        Stream13.flatMap((info) => {
           if (info?.type === "Directory") {
             return streamJsonFiles(fs, full, cutoff);
           }
           if (info?.type === "File" && entry.endsWith(".json") && isRecent(info, cutoff)) {
-            return Stream12.succeed(full);
+            return Stream13.succeed(full);
           }
-          return Stream12.empty;
+          return Stream13.empty;
         })
       );
     })
   )
 );
-var streamManyJsonFiles = (fs, roots, cutoff) => Stream12.fromIterable(roots).pipe(Stream12.flatMap((root) => streamJsonFiles(fs, root, cutoff)));
-var discoverSources = Effect20.fn("OpenCodeIo.discoverSources")(function* (fs, root, cutoff) {
+var streamManyJsonFiles = (fs, roots, cutoff) => Stream13.fromIterable(roots).pipe(Stream13.flatMap((root) => streamJsonFiles(fs, root, cutoff)));
+var discoverSources = Effect21.fn("OpenCodeIo.discoverSources")(function* (fs, root, cutoff) {
   const kind = yield* pathKind(fs, root);
   if (kind === "missing") {
     return { _tag: "Missing" };
@@ -3379,26 +4635,26 @@ var discoverSources = Effect20.fn("OpenCodeIo.discoverSources")(function* (fs, r
   return { _tag: "LegacyJsonFiles", paths: streamManyJsonFiles(fs, roots, cutoff) };
 });
 var readJsonFile = (fs, path) => fs.readFileString(path, "utf8").pipe(
-  Effect20.mapError(toOpenCodeIoError("readFile", path)),
-  Effect20.flatMap(
-    (text) => Effect20.try({
+  Effect21.mapError(toOpenCodeIoError("readFile", path)),
+  Effect21.flatMap(
+    (text) => Effect21.try({
       try: () => JSON.parse(text),
       catch: toOpenCodeIoError("parseJson", path)
     })
   )
 );
-var loadDatabaseSync2 = Effect20.fn("OpenCodeIo.loadDatabaseSync")(function* () {
-  const sqliteModule = yield* Effect20.tryPromise({
+var loadDatabaseSync2 = Effect21.fn("OpenCodeIo.loadDatabaseSync")(function* () {
+  const sqliteModule = yield* Effect21.tryPromise({
     try: () => import(NODE_SQLITE_SPECIFIER2),
     catch: toOpenCodeIoError("load")
   });
   return sqliteModule.DatabaseSync;
 });
-var openDatabase2 = (path, DatabaseSync) => Effect20.try({
+var openDatabase2 = (path, DatabaseSync) => Effect21.try({
   try: () => new DatabaseSync(path, { readOnly: true, timeout: 1e3 }),
   catch: toOpenCodeIoError("open", path)
 });
-var closeDatabase2 = (path, db) => Effect20.try({
+var closeDatabase2 = (path, db) => Effect21.try({
   try: () => {
     db.close();
   },
@@ -3423,7 +4679,7 @@ function readSessionPaths(db) {
   }
   return paths;
 }
-var querySqliteRows = (path, db, cutoff) => Effect20.try({
+var querySqliteRows = (path, db, cutoff) => Effect21.try({
   try: () => {
     const statement = db.prepare(SESSION_MESSAGE_QUERY);
     return {
@@ -3433,9 +4689,9 @@ var querySqliteRows = (path, db, cutoff) => Effect20.try({
   },
   catch: toOpenCodeIoError("query", path)
 });
-var readSqlite = Effect20.fn("OpenCodeIo.readSqlite")(function* (path, cutoff) {
+var readSqlite = Effect21.fn("OpenCodeIo.readSqlite")(function* (path, cutoff) {
   const DatabaseSync = yield* loadDatabaseSync2();
-  return yield* Effect20.acquireUseRelease(
+  return yield* Effect21.acquireUseRelease(
     openDatabase2(path, DatabaseSync),
     (db) => querySqliteRows(path, db, cutoff),
     (db) => closeDatabase2(path, db)
@@ -3448,17 +4704,17 @@ var makeOpenCodeIo = (fs) => ({
 });
 var OpenCodeIoLive = Layer9.effect(
   OpenCodeIo,
-  Effect20.gen(function* () {
+  Effect21.gen(function* () {
     const fs = yield* FileSystem6.FileSystem;
     return OpenCodeIo.of(makeOpenCodeIo(fs));
   })
 ).pipe(Layer9.provide(NodeFileSystem5.layer));
 
 // ../../packages/parsers/src/opencode/index.ts
-import { Effect as Effect22, Stream as Stream13 } from "effect";
+import { Effect as Effect23, Stream as Stream14 } from "effect";
 
 // ../../packages/parsers/src/opencode/bucketize.ts
-import { Effect as Effect21 } from "effect";
+import { Effect as Effect22 } from "effect";
 
 // ../../packages/parsers/src/opencode/events.ts
 function isObject3(value) {
@@ -3679,7 +4935,7 @@ function* finalizedBuckets(accumulators) {
 function parseJson(value) {
   return typeof value === "string" ? JSON.parse(value) : value;
 }
-var bucketizeOpenCodeDatabaseEffect = Effect21.fn("bucketizeOpenCodeDatabaseEffect")(
+var bucketizeOpenCodeDatabaseEffect = Effect22.fn("bucketizeOpenCodeDatabaseEffect")(
   function* (path, cutoff, logger, excludePath) {
     const io = yield* OpenCodeIo;
     const rows = yield* io.readSqlite(path, cutoff);
@@ -3702,7 +4958,7 @@ var bucketizeOpenCodeDatabaseEffect = Effect21.fn("bucketizeOpenCodeDatabaseEffe
     return [...finalizedBuckets(accumulators)];
   }
 );
-var bucketizeOpenCodeJsonFileEffect = Effect21.fn("bucketizeOpenCodeJsonFileEffect")(
+var bucketizeOpenCodeJsonFileEffect = Effect22.fn("bucketizeOpenCodeJsonFileEffect")(
   function* (path) {
     const io = yield* OpenCodeIo;
     const parsed = yield* io.readJsonFile(path);
@@ -3717,23 +4973,23 @@ var bucketizeOpenCodeJsonFileEffect = Effect21.fn("bucketizeOpenCodeJsonFileEffe
 );
 
 // ../../packages/parsers/src/opencode/index.ts
-var discoverOpenCodeSourcesEffect = Effect22.fn("discoverOpenCodeSourcesEffect")(function* (root, cutoff) {
+var discoverOpenCodeSourcesEffect = Effect23.fn("discoverOpenCodeSourcesEffect")(function* (root, cutoff) {
   const io = yield* OpenCodeIo;
   return yield* io.discoverSources(root, cutoff);
 });
-var parseOpenCodeEffect = Effect22.fn(
+var parseOpenCodeEffect = Effect23.fn(
   "OpenCodeParser.parseOpenCodeEffect"
-)((opts) => Stream13.runCollect(parseOpenCodeStream(opts)));
-var parseOpenCodeStream = (opts) => Stream13.unwrap(
-  Effect22.gen(function* () {
+)((opts) => Stream14.runCollect(parseOpenCodeStream(opts)));
+var parseOpenCodeStream = (opts) => Stream14.unwrap(
+  Effect23.gen(function* () {
     const logger = opts.logger ?? silentLogger;
     const root = opts.root ?? resolveOpenCodeRoot();
     const sources = yield* discoverOpenCodeSourcesEffect(root, opts.cutoff);
     if (sources._tag === "Missing") {
-      return Stream13.empty;
+      return Stream14.empty;
     }
     if (sources._tag === "JsonFile") {
-      return openCodeJsonFileStreams(Stream13.succeed(sources.path));
+      return openCodeJsonFileStreams(Stream14.succeed(sources.path));
     }
     if (sources._tag === "DatabaseFiles") {
       return openCodeDatabaseStreams(sources.paths, opts, logger);
@@ -3742,28 +4998,28 @@ var parseOpenCodeStream = (opts) => Stream13.unwrap(
   })
 );
 function openCodeDatabaseStreams(paths, opts, logger) {
-  let stream = Stream13.empty;
+  let stream = Stream14.empty;
   for (const dbPath of paths) {
     stream = stream.pipe(
-      Stream13.concat(
-        Stream13.fromIterableEffect(bucketizeOpenCodeDatabaseEffect(dbPath, opts.cutoff, logger, opts.excludePath))
+      Stream14.concat(
+        Stream14.fromIterableEffect(bucketizeOpenCodeDatabaseEffect(dbPath, opts.cutoff, logger, opts.excludePath))
       )
     );
   }
   return stream;
 }
 function openCodeJsonFileStreams(paths) {
-  return paths.pipe(Stream13.flatMap((file) => Stream13.fromIterableEffect(bucketizeOpenCodeJsonFileEffect(file))));
+  return paths.pipe(Stream14.flatMap((file) => Stream14.fromIterableEffect(bucketizeOpenCodeJsonFileEffect(file))));
 }
 
 // ../../packages/parsers/src/pi/index.ts
 import { basename as basename3, join as join7 } from "path";
-import { Effect as Effect24, Layer as Layer10, Stream as Stream15 } from "effect";
+import { Effect as Effect25, Layer as Layer10, Stream as Stream16 } from "effect";
 
 // ../../packages/parsers/src/pi/bucketize.ts
 import { createReadStream as createReadStream3 } from "fs";
 import { createInterface as createInterface4 } from "readline";
-import { Cause as Cause3, Effect as Effect23, Queue as Queue3, Stream as Stream14 } from "effect";
+import { Cause as Cause3, Effect as Effect24, Queue as Queue3, Stream as Stream15 } from "effect";
 
 // ../../packages/parsers/src/pi/events.ts
 function isObject4(value) {
@@ -3842,9 +5098,9 @@ function key5(hourUtc, model) {
   return `${hourUtc.toISOString()}|${model}`;
 }
 function lineStreamFromFile3(path) {
-  return Stream14.callback(
-    (queue) => Effect23.acquireRelease(
-      Effect23.sync(() => {
+  return Stream15.callback(
+    (queue) => Effect24.acquireRelease(
+      Effect24.sync(() => {
         let done = false;
         const stream = createReadStream3(path, { encoding: "utf8" });
         const rl = createInterface4({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
@@ -3881,7 +5137,7 @@ function lineStreamFromFile3(path) {
           }
         };
       }),
-      (resource) => Effect23.sync(() => resource.close())
+      (resource) => Effect24.sync(() => resource.close())
     )
   );
 }
@@ -3899,6 +5155,33 @@ function modelId2(provider, model) {
   }
   return `${trimmedProvider}/${trimmedModel}`;
 }
+function hermesModelId(provider, model, fallbackProvider) {
+  if (typeof model !== "string") {
+    return void 0;
+  }
+  const trimmedModel = model.trim();
+  if (trimmedModel.length === 0) {
+    return void 0;
+  }
+  const directProvider = typeof provider === "string" ? provider.trim() : "";
+  const fallback = typeof fallbackProvider === "string" ? fallbackProvider.trim() : "";
+  const sourceProvider = directProvider.length > 0 ? directProvider : fallback;
+  if (sourceProvider.length > 0) {
+    const normalizedProvider = normalizeProvider(sourceProvider);
+    if (trimmedModel.startsWith(`${sourceProvider}/`)) {
+      return `${normalizedProvider}/${trimmedModel.slice(sourceProvider.length + 1)}`;
+    }
+    if (trimmedModel.startsWith(`${normalizedProvider}/`)) {
+      return trimmedModel;
+    }
+    return `${normalizedProvider}/${trimmedModel}`;
+  }
+  const separator = trimmedModel.indexOf("/");
+  if (separator <= 0) {
+    return void 0;
+  }
+  return `${normalizeProvider(trimmedModel.slice(0, separator))}/${trimmedModel.slice(separator + 1)}`;
+}
 function normalizeProvider(provider) {
   return provider === "openai-codex" ? "openai" : provider;
 }
@@ -3915,53 +5198,134 @@ function timestampMs2(value) {
   }
   return Math.abs(n) < UNIX_MILLISECONDS_THRESHOLD ? n * MILLISECONDS_PER_SECOND2 : n;
 }
-function hermesRowToBucket(row, excludePath) {
-  if (typeof row.cwd === "string" && excludePath?.(row.cwd) === true) {
-    return void 0;
-  }
-  const sessionId = typeof row.id === "string" ? row.id : void 0;
-  const startedAtMs = timestampMs2(row.startedAt);
-  const lastSeenAtMs = timestampMs2(row.endedAt) ?? startedAtMs;
-  const provider = typeof row.billingProvider === "string" ? row.billingProvider : void 0;
-  const sourceModel = typeof row.model === "string" ? row.model : void 0;
-  if (sessionId === void 0 || startedAtMs === void 0 || lastSeenAtMs === void 0 || provider === void 0 || sourceModel === void 0) {
-    return void 0;
-  }
-  const model = modelId2(provider, sourceModel);
-  if (model === void 0) {
-    return void 0;
+function normalizeHermesUsage(row) {
+  return {
+    inputTokens: positive2(row.inputTokens),
+    outputTokens: positive2(row.outputTokens),
+    cacheReadTokens: positive2(row.cacheReadTokens),
+    cacheCreateTokens: positive2(row.cacheWriteTokens)
+  };
+}
+function addHermesUsage(left, right) {
+  return {
+    inputTokens: left.inputTokens + right.inputTokens,
+    outputTokens: left.outputTokens + right.outputTokens,
+    cacheReadTokens: left.cacheReadTokens + right.cacheReadTokens,
+    cacheCreateTokens: left.cacheCreateTokens + right.cacheCreateTokens
+  };
+}
+function subtractHermesUsageFloorZero(current, baseline) {
+  return {
+    inputTokens: Math.max(0, current.inputTokens - baseline.inputTokens),
+    outputTokens: Math.max(0, current.outputTokens - baseline.outputTokens),
+    cacheReadTokens: Math.max(0, current.cacheReadTokens - baseline.cacheReadTokens),
+    cacheCreateTokens: Math.max(0, current.cacheCreateTokens - baseline.cacheCreateTokens)
+  };
+}
+function hasHermesUsage(usage) {
+  return usage.inputTokens > 0 || usage.outputTokens > 0 || usage.cacheReadTokens > 0 || usage.cacheCreateTokens > 0;
+}
+function maxModelLastSeen(rows) {
+  let latest;
+  for (const row of rows) {
+    const at = timestampMs2(row.lastSeen) ?? timestampMs2(row.firstSeen);
+    if (at !== void 0 && (latest === void 0 || at > latest)) {
+      latest = at;
+    }
   }
-  const inputTokens = positive2(row.inputTokens);
-  const outputTokens = positive2(row.outputTokens);
-  const cacheReadTokens = positive2(row.cacheReadTokens);
-  const cacheCreateTokens = positive2(row.cacheWriteTokens);
-  if (inputTokens === 0 && outputTokens === 0 && cacheReadTokens === 0 && cacheCreateTokens === 0) {
+  return latest;
+}
+function makeHermesBucket(options) {
+  if (!hasHermesUsage(options.usage)) {
     return void 0;
   }
-  const startedAt = new Date(startedAtMs);
+  const startedAt = new Date(options.startedAtMs);
   return {
     harness: "hermes",
-    model,
-    hourUtc: startOfUtcHour(startedAt),
-    inputTokens,
-    outputTokens,
-    cacheReadTokens,
-    cacheCreateTokens,
-    sessionIds: /* @__PURE__ */ new Set([`hermes:${sessionId}`]),
+    model: options.model,
+    hourUtc: startOfUtcHour(new Date(options.attributedAtMs)),
+    inputTokens: options.usage.inputTokens,
+    outputTokens: options.usage.outputTokens,
+    cacheReadTokens: options.usage.cacheReadTokens,
+    cacheCreateTokens: options.usage.cacheCreateTokens,
+    sessionIds: /* @__PURE__ */ new Set([`hermes:${options.sessionId}`]),
     sessionStartedAt: startedAt,
-    sessionLastSeenAt: new Date(lastSeenAtMs)
+    sessionLastSeenAt: new Date(options.lastSeenAtMs)
   };
 }
-function bucketizeHermesRows(rows, excludePath) {
+function bucketizeHermesModelUsage(options) {
   const buckets = [];
-  for (const row of rows) {
-    const bucket = hermesRowToBucket(row, excludePath);
+  let attributedUsage = {
+    cacheCreateTokens: 0,
+    cacheReadTokens: 0,
+    inputTokens: 0,
+    outputTokens: 0
+  };
+  for (const usageRow of options.rows) {
+    const model = hermesModelId(usageRow.billingProvider, usageRow.model, options.fallbackProvider);
+    if (model === void 0) {
+      continue;
+    }
+    const usage = normalizeHermesUsage(usageRow);
+    const bucket = makeHermesBucket({
+      attributedAtMs: timestampMs2(usageRow.firstSeen) ?? options.startedAtMs,
+      lastSeenAtMs: options.lastSeenAtMs,
+      model,
+      sessionId: options.sessionId,
+      startedAtMs: options.startedAtMs,
+      usage
+    });
     if (bucket !== void 0) {
       buckets.push(bucket);
+      attributedUsage = addHermesUsage(attributedUsage, usage);
+    }
+  }
+  return { attributedUsage, buckets };
+}
+function hermesRowToBuckets(row, excludePath) {
+  if (typeof row.cwd === "string" && excludePath?.(row.cwd) === true) {
+    return [];
+  }
+  const sessionId = typeof row.id === "string" ? row.id : void 0;
+  const startedAtMs = timestampMs2(row.startedAt);
+  if (sessionId === void 0 || startedAtMs === void 0) {
+    return [];
+  }
+  const modelUsageRows2 = row.modelUsageRows ?? [];
+  const lastSeenAtMs = timestampMs2(row.endedAt) ?? maxModelLastSeen(modelUsageRows2) ?? startedAtMs;
+  const modelUsage = bucketizeHermesModelUsage({
+    fallbackProvider: row.billingProvider,
+    lastSeenAtMs,
+    rows: modelUsageRows2,
+    sessionId,
+    startedAtMs
+  });
+  const buckets = [...modelUsage.buckets];
+  const aggregateUsage = normalizeHermesUsage(row);
+  const residualUsage = subtractHermesUsageFloorZero(aggregateUsage, modelUsage.attributedUsage);
+  const residualModel = hermesModelId(row.billingProvider, row.model);
+  if (residualModel !== void 0) {
+    const residual = makeHermesBucket({
+      attributedAtMs: startedAtMs,
+      lastSeenAtMs,
+      model: residualModel,
+      sessionId,
+      startedAtMs,
+      usage: residualUsage
+    });
+    if (residual !== void 0) {
+      buckets.push(residual);
     }
   }
   return buckets;
 }
+function bucketizeHermesRows(rows, excludePath) {
+  const buckets = [];
+  for (const row of rows) {
+    buckets.push(...hermesRowToBuckets(row, excludePath));
+  }
+  return buckets;
+}
 function makePiStyleFileAccumulator(options) {
   return {
     buckets: /* @__PURE__ */ new Map(),
@@ -4054,12 +5418,11 @@ function accumulatePiStyleLine(context, acc, raw) {
   existing.cacheCreateTokens += cacheCreateTokens;
   return acc;
 }
-function bucketsFromAccumulator3(path, harness, acc) {
+function bucketsFromAccumulator2(path, harness, acc) {
   if (acc.excluded || acc.sessionStartedAt === void 0 || acc.sessionLastSeenAt === void 0) {
     return [];
   }
-  const sessionStartedAt = acc.sessionStartedAt;
-  const sessionLastSeenAt = acc.sessionLastSeenAt;
+  const { sessionLastSeenAt, sessionStartedAt } = acc;
   const sessionIds = /* @__PURE__ */ new Set([path]);
   return Array.from(acc.buckets.values(), (bucket) => ({
     harness,
@@ -4076,17 +5439,17 @@ function bucketsFromAccumulator3(path, harness, acc) {
 }
 function bucketizePiStyleFileStream(path, harness, logger, options = {}) {
   const context = { logger, options, path };
-  return Stream14.unwrap(
+  return Stream15.unwrap(
     lineStreamFromFile3(path).pipe(
-      Stream14.runFold(
+      Stream15.runFold(
         () => makePiStyleFileAccumulator(options),
         (acc, raw) => accumulatePiStyleLine(context, acc, raw)
       ),
-      Effect23.map((acc) => Stream14.fromIterable(bucketsFromAccumulator3(path, harness, acc)))
+      Effect24.map((acc) => Stream15.fromIterable(bucketsFromAccumulator2(path, harness, acc)))
     )
   );
 }
-var bucketizeHermesDatabaseEffect = Effect23.fn(
+var bucketizeHermesDatabaseEffect = Effect24.fn(
   "bucketizeHermesDatabaseEffect"
 )(function* (path, cutoff, excludePath) {
   const sqlite = yield* HermesSqlite;
@@ -4095,14 +5458,14 @@ var bucketizeHermesDatabaseEffect = Effect23.fn(
 });
 
 // ../../packages/parsers/src/pi/index.ts
-var isFileBestEffortEffect = (path) => pathKindEffect(path).pipe(Effect24.map((kind) => kind === "file"));
+var isFileBestEffortEffect = (path) => pathKindEffect(path).pipe(Effect25.map((kind) => kind === "file"));
 function bucketizePiStyleSourcesStream(files, harness, logger, options) {
   return files.pipe(
-    Stream15.flatMap((file) => bucketizePiStyleFileStream(file, harness, logger, options), { concurrency: 1 })
+    Stream16.flatMap((file) => bucketizePiStyleFileStream(file, harness, logger, options), { concurrency: 1 })
   );
 }
-var parsePiStyleStream = (opts, harness, defaultRoot) => Stream15.unwrap(
-  Effect24.gen(function* () {
+var parsePiStyleStream = (opts, harness, defaultRoot) => Stream16.unwrap(
+  Effect25.gen(function* () {
     const logger = opts.logger ?? silentLogger;
     const root = opts.root ?? defaultRoot();
     const kind = yield* pathKindEffectStrict(root);
@@ -4120,25 +5483,23 @@ var parsePiStyleStream = (opts, harness, defaultRoot) => Stream15.unwrap(
     });
   })
 );
-var parsePiEffect = Effect24.fn("PiParser.parsePiEffect")((opts) => Stream15.runCollect(parsePiStream(opts)));
+var parsePiEffect = Effect25.fn("PiParser.parsePiEffect")((opts) => Stream16.runCollect(parsePiStream(opts)));
 var parsePiStream = (opts) => parsePiStyleStream(opts, "pi", resolvePiRoot);
 var parserLive = Layer10.mergeAll(FileWalkerLive, HermesSqliteLive);
-var parseHermesEffect = Effect24.fn(
+var parseHermesEffect = Effect25.fn(
   "HermesParser.parseHermesEffect"
-)((opts) => Stream15.runCollect(parseHermesStream(opts)));
-var parseHermesStream = (opts) => Stream15.unwrap(
-  Effect24.gen(function* () {
+)((opts) => Stream16.runCollect(parseHermesStream(opts)));
+var parseHermesStream = (opts) => Stream16.unwrap(
+  Effect25.gen(function* () {
     const logger = opts.logger ?? silentLogger;
     const root = opts.root ?? resolveHermesRoot();
     const kind = yield* pathKindEffectStrict(root);
     if (kind === "missing") {
-      return asHermesStream(Stream15.empty);
+      return asHermesStream(Stream16.empty);
     }
     if (kind === "file") {
       if (basename3(root).endsWith(".db")) {
-        return asHermesStream(
-          Stream15.fromIterableEffect(bucketizeHermesDatabaseEffect(root, opts.cutoff, opts.excludePath))
-        );
+        return asHermesStream(collectHermesDatabaseStream(root, logger, opts));
       }
       return asHermesStream(
         bucketizePiStyleFileStream(root, "hermes", logger, { cutoff: opts.cutoff, excludePath: opts.excludePath })
@@ -4146,9 +5507,7 @@ var parseHermesStream = (opts) => Stream15.unwrap(
     }
     const stateDb = join7(root, "state.db");
     if (yield* isFileBestEffortEffect(stateDb)) {
-      return asHermesStream(
-        Stream15.fromIterableEffect(bucketizeHermesDatabaseEffect(stateDb, opts.cutoff, opts.excludePath))
-      );
+      return asHermesStream(collectHermesDatabaseStream(stateDb, logger, opts));
     }
     const sessionsRoot2 = join7(root, "sessions");
     if ((yield* pathKindEffect(sessionsRoot2)) === "directory") {
@@ -4164,8 +5523,20 @@ var parseHermesStream = (opts) => Stream15.unwrap(
 function asHermesStream(stream) {
   return stream;
 }
-var collectHermesPiStyleDirectoryStream = (root, logger, opts) => Stream15.unwrap(
-  Effect24.sync(() => {
+function collectHermesDatabaseStream(path, logger, opts) {
+  return Stream16.fromIterableEffect(bucketizeHermesDatabaseEffect(path, opts.cutoff, opts.excludePath)).pipe(
+    Stream16.catchTag("HermesSqliteError", (error) => {
+      if (error.operation !== "schema") {
+        return Stream16.fail(error);
+      }
+      return Stream16.fromEffectDrain(
+        Effect25.sync(() => logger.warn("unsupported hermes sqlite schema", { reason: "unsupported_schema" }))
+      );
+    })
+  );
+}
+var collectHermesPiStyleDirectoryStream = (root, logger, opts) => Stream16.unwrap(
+  Effect25.sync(() => {
     const seenMessageIds = /* @__PURE__ */ new Set();
     return bucketizePiStyleSourcesStream(walkStreamStrict(root, opts.cutoff), "hermes", logger, {
       cutoff: opts.cutoff,
@@ -4176,7 +5547,7 @@ var collectHermesPiStyleDirectoryStream = (root, logger, opts) => Stream15.unwra
 );
 
 // src/sync/parser-factory.ts
-import { Effect as Effect25, Layer as Layer11, Stream as Stream16 } from "effect";
+import { Effect as Effect26, Layer as Layer11, Stream as Stream17 } from "effect";
 var GLOB_PATTERN = /[*?[\]{}]/u;
 var HermesParserLive = Layer11.mergeAll(FileWalkerLive, HermesSqliteLive);
 function sessionsRoot(agentDir, sessionDir, fallbackAgentDir) {
@@ -4241,7 +5612,7 @@ function createExcludeMatcher(options) {
   };
 }
 function resolveParserSourcePlanEffect(options = {}) {
-  return Effect25.gen(function* () {
+  return Effect26.gen(function* () {
     const sources = yield* ParserSources;
     const home = yield* sources.homeDir;
     const env = options.env ?? (yield* sources.cliEnv);
@@ -4280,49 +5651,43 @@ function resolveParserSourcePlanEffect(options = {}) {
   });
 }
 function provideFileWalker(stream) {
-  return stream.pipe(Stream16.provide(FileWalkerLive));
-}
-function concatParserStreams(streams) {
-  let stream = Stream16.empty;
-  for (const next of streams) {
-    stream = stream.pipe(Stream16.concat(next));
+  return stream.pipe(Stream17.provide(FileWalkerLive));
+}
+function codexStreamForPlan(plan, cutoff, excludePath) {
+  if (plan.codexSessionsSourceExisted) {
+    return provideFileWalker(
+      parseCodexStream({
+        archivedRoot: plan.codexArchivedSourceExisted ? plan.codexArchivedRoot : void 0,
+        cutoff,
+        excludePath,
+        root: plan.codexSessionsRoot
+      })
+    );
   }
-  return stream;
+  if (plan.codexArchivedSourceExisted) {
+    return provideFileWalker(
+      parseCodexStream({ cutoff, excludePath, root: plan.codexArchivedRoot })
+    );
+  }
+  return Stream17.empty;
 }
 function buildFactoryFromPlan(plan) {
   const excludePath = createExcludeMatcher({ exclude: plan.exclude, home: plan.home });
-  return (ctx) => {
-    const codexStreams = [];
-    if (plan.codexSessionsSourceExisted) {
-      codexStreams.push(
-        provideFileWalker(
-          parseCodexStream({ cutoff: ctx.cutoff, excludePath, root: plan.codexSessionsRoot })
-        )
-      );
-    }
-    if (plan.codexArchivedSourceExisted) {
-      codexStreams.push(
-        provideFileWalker(
-          parseCodexStream({ cutoff: ctx.cutoff, excludePath, root: plan.codexArchivedRoot })
-        )
-      );
-    }
-    return {
-      anySourceExisted: plan.anySourceExisted,
-      codex: concatParserStreams(codexStreams),
-      claudeCode: plan.claudeSourceExisted ? provideFileWalker(parseClaudeStream({ cutoff: ctx.cutoff, excludePath, root: plan.claudeRoot })) : Stream16.empty,
-      pi: plan.piSourceExisted ? provideFileWalker(parsePiStream({ cutoff: ctx.cutoff, excludePath, root: plan.piRoot })) : Stream16.empty,
-      hermes: plan.hermesSourceExisted ? parseHermesStream({ cutoff: ctx.cutoff, excludePath, root: plan.hermesRoot }).pipe(
-        Stream16.provide(HermesParserLive)
-      ) : Stream16.empty,
-      opencode: plan.opencodeSourceExisted ? parseOpenCodeStream({ cutoff: ctx.cutoff, excludePath, root: plan.opencodeRoot }).pipe(
-        Stream16.provide(OpenCodeIoLive)
-      ) : Stream16.empty
-    };
-  };
+  return (ctx) => ({
+    anySourceExisted: plan.anySourceExisted,
+    codex: codexStreamForPlan(plan, ctx.cutoff, excludePath),
+    claudeCode: plan.claudeSourceExisted ? provideFileWalker(parseClaudeStream({ cutoff: ctx.cutoff, excludePath, root: plan.claudeRoot })) : Stream17.empty,
+    pi: plan.piSourceExisted ? provideFileWalker(parsePiStream({ cutoff: ctx.cutoff, excludePath, root: plan.piRoot })) : Stream17.empty,
+    hermes: plan.hermesSourceExisted ? parseHermesStream({ cutoff: ctx.cutoff, excludePath, root: plan.hermesRoot }).pipe(
+      Stream17.provide(HermesParserLive)
+    ) : Stream17.empty,
+    opencode: plan.opencodeSourceExisted ? parseOpenCodeStream({ cutoff: ctx.cutoff, excludePath, root: plan.opencodeRoot }).pipe(
+      Stream17.provide(OpenCodeIoLive)
+    ) : Stream17.empty
+  });
 }
 function buildRealParserFactoryEffect(options = {}) {
-  return Effect25.map(resolveParserSourcePlanEffect(options), buildFactoryFromPlan);
+  return Effect26.map(resolveParserSourcePlanEffect(options), buildFactoryFromPlan);
 }
 
 // src/index.ts
@@ -4356,8 +5721,40 @@ function parseHarnessFilter(value) {
   }
   throw new SyncError(EXIT.invalidArguments, `error: --harness must be one of ${SUPPORTED_HARNESSES.join("|")}`);
 }
+function parseReplacementFlags(raw) {
+  const startHourUtc = optionalValue(raw.replaceStart);
+  const endHourUtc = optionalValue(raw.replaceEnd);
+  const harnessList = optionalValue(raw.replaceHarnesses);
+  if (startHourUtc === void 0 && endHourUtc === void 0 && harnessList === void 0) {
+    if (raw.confirmReplacement) {
+      throw new SyncError(EXIT.invalidArguments, "error: --confirm-replacement requires an atomic replacement scope");
+    }
+    return void 0;
+  }
+  if (!(startHourUtc && endHourUtc && harnessList)) {
+    throw new SyncError(
+      EXIT.invalidArguments,
+      "error: --replace-start, --replace-end, and --replace-harnesses must be provided together"
+    );
+  }
+  const harnesses = harnessList.split(",").map((value) => parseHarnessFilter(value.trim()));
+  if (harnesses.some((harness) => harness === void 0)) {
+    throw new SyncError(EXIT.invalidArguments, "error: replacement harness list cannot be empty");
+  }
+  if (!(raw.dryRun || raw.confirmReplacement)) {
+    throw new SyncError(
+      EXIT.invalidArguments,
+      "error: atomic replacement uploads require --confirm-replacement (use --dry-run to inspect first)"
+    );
+  }
+  return {
+    startHourUtc,
+    endHourUtc,
+    harnesses
+  };
+}
 function syncCommandErrorExitCode(err) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const console = yield* CliConsole;
     if (err instanceof CliConfigError) {
       yield* console.writeStderrLine(err.message);
@@ -4372,7 +5769,7 @@ function syncCommandErrorExitCode(err) {
   });
 }
 function setupCommandErrorExitCode(err) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const console = yield* CliConsole;
     if (err instanceof CliConfigError || err instanceof SetupError) {
       yield* console.writeStderrLine(err.message);
@@ -4384,26 +5781,26 @@ function setupCommandErrorExitCode(err) {
 }
 function recoverCommandExitCode(effect) {
   return effect.pipe(
-    Effect26.catch((err) => syncCommandErrorExitCode(err)),
-    Effect26.catchDefect((err) => syncCommandErrorExitCode(err))
+    Effect27.catch((err) => syncCommandErrorExitCode(err)),
+    Effect27.catchDefect((err) => syncCommandErrorExitCode(err))
   );
 }
 function recoverSetupExitCode(effect) {
   return effect.pipe(
-    Effect26.catch((err) => setupCommandErrorExitCode(err)),
-    Effect26.catchDefect((err) => setupCommandErrorExitCode(err))
+    Effect27.catch((err) => setupCommandErrorExitCode(err)),
+    Effect27.catchDefect((err) => setupCommandErrorExitCode(err))
   );
 }
 function exitCodeToCommandEffect(exitCode) {
-  return exitCode === EXIT.success ? Effect26.void : Effect26.fail(new CliExit(exitCode));
+  return exitCode === EXIT.success ? Effect27.void : Effect27.fail(new CliExit(exitCode));
 }
 function runSyncCommand(raw) {
   return recoverCommandExitCode(
-    Effect26.gen(function* () {
+    Effect27.gen(function* () {
       const configReader = yield* CliConfigReader;
       const console = yield* CliConsole;
       const env = yield* configReader.read();
-      const config = yield* Effect26.try({
+      const config = yield* Effect27.try({
         try: () => resolveSyncConfig(
           {
             api: optionalValue(raw.api),
@@ -4417,10 +5814,14 @@ function runSyncCommand(raw) {
         catch: (err) => err
       });
       const { device, token } = config;
-      const harness = yield* Effect26.try({
+      const harness = yield* Effect27.try({
         try: () => parseHarnessFilter(optionalValue(raw.harness)),
         catch: (err) => err
       });
+      const replacement = yield* Effect27.try({
+        try: () => parseReplacementFlags(raw),
+        catch: (err) => err
+      });
       if (!(token && device)) {
         yield* console.writeStderrLine(
           "error: --token and --device are required (or set ~/.oopst.yml / OOPST_TOKEN / OOPST_DEVICE)"
@@ -4428,7 +5829,7 @@ function runSyncCommand(raw) {
         return EXIT.invalidArguments;
       }
       const factory = yield* buildRealParserFactoryEffect({ env, exclude: config.exclude }).pipe(
-        Effect26.provide(ParserSourcesLive)
+        Effect27.provide(ParserSourcesLive)
       );
       let sourcesExistedHint = false;
       const parserFactory = (ctx) => {
@@ -4442,6 +5843,7 @@ function runSyncCommand(raw) {
         serverUrl: config.serverUrl,
         lookbackDays: config.lookbackDays,
         harness,
+        replacement,
         dryRun: raw.dryRun,
         verbose: raw.verbose,
         color: yield* console.stdoutIsTTY,
@@ -4453,16 +5855,16 @@ function runSyncCommand(raw) {
       });
       return result.exitCode;
     })
-  ).pipe(Effect26.flatMap(exitCodeToCommandEffect));
+  ).pipe(Effect27.flatMap(exitCodeToCommandEffect));
 }
 function runSetupCommand(raw) {
   return recoverSetupExitCode(
-    Effect26.gen(function* () {
+    Effect27.gen(function* () {
       const console = yield* CliConsole;
       const metadata = yield* CliPackageMetadata;
       const cliProcess = yield* CliProcess;
       const nodePath = yield* cliProcess.execPath;
-      const result = yield* Effect26.tryPromise({
+      const result = yield* Effect27.tryPromise({
         try: () => runSetup({
           api: optionalValue(raw.api),
           server: optionalValue(raw.server),
@@ -4475,7 +5877,7 @@ function runSetupCommand(raw) {
       });
       return result.exitCode;
     })
-  ).pipe(Effect26.flatMap(exitCodeToCommandEffect));
+  ).pipe(Effect27.flatMap(exitCodeToCommandEffect));
 }
 var apiFlag = Flag.string("api").pipe(
   Flag.withDescription("API base URL (or server.api / OOPST_SERVER)"),
@@ -4498,6 +5900,22 @@ var harnessFlag = Flag.string("harness").pipe(
   Flag.withDescription("Restrict to codex|claude_code|pi|hermes|opencode"),
   Flag.optional
 );
+var replaceStartFlag = Flag.string("replace-start").pipe(
+  Flag.withDescription("Atomic replacement start as an inclusive UTC hour"),
+  Flag.optional
+);
+var replaceEndFlag = Flag.string("replace-end").pipe(
+  Flag.withDescription("Atomic replacement end as an exclusive UTC hour"),
+  Flag.optional
+);
+var replaceHarnessesFlag = Flag.string("replace-harnesses").pipe(
+  Flag.withDescription("Comma-separated harness set for an atomic replacement"),
+  Flag.optional
+);
+var confirmReplacementFlag = Flag.boolean("confirm-replacement").pipe(
+  Flag.withDescription("Confirm that the declared replacement scope may overwrite live facts"),
+  Flag.withDefault(false)
+);
 var dryRunFlag = Flag.boolean("dry-run").pipe(
   Flag.withDescription("Parse and print without uploading"),
   Flag.withDefault(false)
@@ -4513,6 +5931,10 @@ function buildCli() {
       server: serverFlag,
       lookbackDays: lookbackDaysFlag,
       harness: harnessFlag,
+      replaceStart: replaceStartFlag,
+      replaceEnd: replaceEndFlag,
+      replaceHarnesses: replaceHarnessesFlag,
+      confirmReplacement: confirmReplacementFlag,
       dryRun: dryRunFlag,
       verbose: verboseFlag
     },
@@ -4532,10 +5954,10 @@ function buildCli() {
   );
 }
 function runCli() {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const metadata = yield* CliPackageMetadata;
     yield* buildCli().pipe(Command.run({ version: metadata.version }));
-  }).pipe(Effect26.provide(CliRuntimeLayer));
+  }).pipe(Effect27.provide(CliRuntimeLayer));
 }
 if (isEntrypoint()) {
   runCli().pipe(NodeRuntime.runMain);