@cookielab.io/oopst 0.6.3 → 0.6.4

package/dist/index.js

@@ -4,7 +4,7 @@ const require = createRequire(import.meta.url);
 
 // src/index.ts
 import { realpathSync } from "fs";
-import process4 from "process";
+import process2 from "process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { NodeRuntime, NodeServices as NodeServices2 } from "@effect/platform-node";
 import { Effect as Effect27, Layer as Layer12, Option as Option4, Runtime } from "effect";
@@ -14,13 +14,13 @@ import { CliOutput, Command, Flag } from "effect/unstable/cli";
 import { readFileSync } from "fs";
 import { homedir as readHomedir, hostname as readHostname } from "os";
 import { isAbsolute, join, normalize, resolve } from "path";
-import process from "process";
+import { env as processEnv } from "process";
 import { Config, ConfigProvider, Effect, FileSystem, Option, Schema } from "effect";
 import { parse as parseYaml } from "yaml";
 var DEFAULT_SERVER_URL = "http://localhost:15433";
 var DEFAULT_LOOKBACK_DAYS = 2;
 var USER_CONFIG_FILE = ".oopst.yml";
-var runtimeEnv = process["env"];
+var runtimeEnv = processEnv;
 var NonEmptyString = Schema.String.check(Schema.isNonEmpty());
 var NonNegativeInteger = Schema.Number.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0));
 var CliConfigSourceSchema = Schema.Struct({
@@ -261,31 +261,42 @@ function resolveSyncConfig(flags, env) {
 
 // src/services/command-platform.ts
 import { homedir as readHomedir2, hostname as readHostname2 } from "os";
-import process2 from "process";
+import process from "process";
 import { fileURLToPath } from "url";
 import { NodeFileSystem, NodeServices } from "@effect/platform-node";
-import { Context, Effect as Effect2, FileSystem as FileSystem2, Layer, Stream } from "effect";
+import { Effect as Effect2, FileSystem as FileSystem2, Layer, Stream } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-var PACKAGE_JSON_PATHS = [
-  fileURLToPath(new URL("../package.json", import.meta.url)),
-  fileURLToPath(new URL("../../package.json", import.meta.url))
-];
+
+// src/services/command-console-services.ts
+import { Context } from "effect";
 var CliConsole = class extends Context.Service()("@oopst/cli/CliConsole") {
 };
 var CliProcess = class extends Context.Service()("@oopst/cli/CliProcess") {
 };
-var CliHost = class extends Context.Service()("@oopst/cli/CliHost") {
+
+// src/services/command-host-services.ts
+import { Context as Context2 } from "effect";
+var CliHost = class extends Context2.Service()("@oopst/cli/CliHost") {
 };
-var CliCommandRunner = class extends Context.Service()(
+var CliCommandRunner = class extends Context2.Service()(
   "@oopst/cli/CliCommandRunner"
 ) {
 };
-var CliPackageMetadata = class extends Context.Service()(
+
+// src/services/command-metadata-services.ts
+import { Context as Context3 } from "effect";
+var CliPackageMetadata = class extends Context3.Service()(
   "@oopst/cli/CliPackageMetadata"
 ) {
 };
-var CliConfigReader = class extends Context.Service()("@oopst/cli/CliConfigReader") {
+var CliConfigReader = class extends Context3.Service()("@oopst/cli/CliConfigReader") {
 };
+
+// src/services/command-platform.ts
+var PACKAGE_JSON_PATHS = [
+  fileURLToPath(new URL("../package.json", import.meta.url)),
+  fileURLToPath(new URL("../../package.json", import.meta.url))
+];
 function writeLine(output, message) {
   output.write(`${message}
 `);
@@ -340,9 +351,9 @@ var CliConsoleLive = Layer.effect(
   Effect2.sync(
     () => CliConsole.of(
       makeCliConsole({
-        stdin: process2.stdin,
-        stdout: process2.stdout,
-        stderr: process2.stderr
+        stdin: process.stdin,
+        stdout: process.stdout,
+        stderr: process.stderr
       })
     )
   )
@@ -353,7 +364,7 @@ var CliProcessLive = Layer.effect(
     () => CliProcess.of({
       execPath: Effect2.fn("CliProcess.execPath")(
         () => Effect2.try({
-          try: () => process2.execPath,
+          try: () => process.execPath,
           catch: (err) => err
         })
       )()
@@ -443,8 +454,8 @@ var CliCommandPlatformLive = Layer.mergeAll(
 import { homedir } from "os";
 import { join as join2 } from "path";
 import { NodeFileSystem as NodeFileSystem2 } from "@effect/platform-node";
-import { Context as Context2, Effect as Effect3, FileSystem as FileSystem3, Layer as Layer2, Schema as Schema2 } from "effect";
-var ParserSources = class extends Context2.Service()("@oopst/cli/ParserSources") {
+import { Context as Context4, Effect as Effect3, FileSystem as FileSystem3, Layer as Layer2, Schema as Schema2 } from "effect";
+var ParserSources = class extends Context4.Service()("@oopst/cli/ParserSources") {
 };
 var ParserSourceError = class extends Schema2.TaggedErrorClass()("ParserSourceError", {
   cause: Schema2.optionalKey(Schema2.Defect()),
@@ -521,77 +532,106 @@ var ParserSourcesLive = Layer2.effect(
 ).pipe(Layer2.provide(NodeFileSystem2.layer));
 
 // src/services/sync-program.ts
-import { Context as Context6, Effect as Effect10, Layer as Layer5 } from "effect";
+import { Context as Context8, Effect as Effect10, Layer as Layer5 } from "effect";
 
 // src/sync/run.ts
 import { createHash } from "crypto";
 
-// ../../packages/api/src/errors.ts
+// ../../packages/api/src/errors/auth-errors.ts
 import { Schema as Schema3 } from "effect";
 var ErrorFields = {
   message: Schema3.String
 };
-var InfrastructureErrorFields = {
-  ...ErrorFields,
-  cause: Schema3.optionalKey(Schema3.Defect())
-};
 var UnauthorizedError = class extends Schema3.TaggedErrorClass()("UnauthorizedError", ErrorFields) {
 };
 var ForbiddenError = class extends Schema3.TaggedErrorClass()("ForbiddenError", ErrorFields) {
 };
-var NotFoundError = class extends Schema3.TaggedErrorClass()("NotFoundError", ErrorFields) {
+
+// ../../packages/api/src/errors/config-errors.ts
+import { Schema as Schema4 } from "effect";
+var InfrastructureErrorFields = {
+  message: Schema4.String,
+  cause: Schema4.optionalKey(Schema4.Defect())
 };
-var ConflictError = class extends Schema3.TaggedErrorClass()("ConflictError", ErrorFields) {
+var AppConfigError = class extends Schema4.TaggedErrorClass()("AppConfigError", InfrastructureErrorFields) {
 };
-var ValidationError = class extends Schema3.TaggedErrorClass()("ValidationError", ErrorFields) {
+var PricingRefreshError = class extends Schema4.TaggedErrorClass()(
+  "PricingRefreshError",
+  InfrastructureErrorFields
+) {
 };
-var RateLimitedError = class extends Schema3.TaggedErrorClass()("RateLimitedError", ErrorFields) {
+
+// ../../packages/api/src/errors/infrastructure-errors.ts
+import { Schema as Schema5 } from "effect";
+var InfrastructureErrorFields2 = {
+  message: Schema5.String,
+  cause: Schema5.optionalKey(Schema5.Defect())
 };
-var ExternalHttpError = class extends Schema3.TaggedErrorClass()(
+var ExternalHttpError = class extends Schema5.TaggedErrorClass()(
   "ExternalHttpError",
-  InfrastructureErrorFields
+  InfrastructureErrorFields2
 ) {
 };
-var DatabaseError = class extends Schema3.TaggedErrorClass()(
-  "DatabaseError",
-  InfrastructureErrorFields
-) {
+var DatabaseError = class extends Schema5.TaggedErrorClass()("DatabaseError", InfrastructureErrorFields2) {
 };
-var AppConfigError = class extends Schema3.TaggedErrorClass()(
-  "AppConfigError",
-  InfrastructureErrorFields
-) {
+
+// ../../packages/api/src/errors/request-errors.ts
+import { Schema as Schema6 } from "effect";
+var ErrorFields2 = {
+  message: Schema6.String
 };
-var PricingRefreshError = class extends Schema3.TaggedErrorClass()(
-  "PricingRefreshError",
-  InfrastructureErrorFields
-) {
+var ValidationError = class extends Schema6.TaggedErrorClass()("ValidationError", ErrorFields2) {
+};
+var RateLimitedError = class extends Schema6.TaggedErrorClass()("RateLimitedError", ErrorFields2) {
+};
+
+// ../../packages/api/src/errors/resource-errors.ts
+import { Schema as Schema7 } from "effect";
+var ErrorFields3 = {
+  message: Schema7.String
 };
-var ParserSourceError2 = class extends Schema3.TaggedErrorClass()(
+var NotFoundError = class extends Schema7.TaggedErrorClass()("NotFoundError", ErrorFields3) {
+};
+var ConflictError = class extends Schema7.TaggedErrorClass()("ConflictError", ErrorFields3) {
+};
+
+// ../../packages/api/src/errors/source-errors.ts
+import { Schema as Schema8 } from "effect";
+var ErrorFields4 = {
+  message: Schema8.String
+};
+var InfrastructureErrorFields3 = {
+  ...ErrorFields4,
+  cause: Schema8.optionalKey(Schema8.Defect())
+};
+var ParserSourceError2 = class extends Schema8.TaggedErrorClass()(
   "ParserSourceError",
-  InfrastructureErrorFields
+  InfrastructureErrorFields3
 ) {
 };
-var SyncQuotaExceededError = class extends Schema3.TaggedErrorClass()(
+var SyncQuotaExceededError = class extends Schema8.TaggedErrorClass()(
   "SyncQuotaExceededError",
-  ErrorFields
+  ErrorFields4
 ) {
 };
-var SyncTimestampRejectedError = class extends Schema3.TaggedErrorClass()(
+
+// ../../packages/api/src/errors/sync-errors.ts
+import { Schema as Schema9 } from "effect";
+var SyncTimestampRejectedError = class extends Schema9.TaggedErrorClass()(
   "SyncTimestampRejectedError",
-  ErrorFields
+  { message: Schema9.String }
 ) {
 };
 
 // ../../packages/api/src/rpc/auth.ts
-import { Context as Context3, Schema as Schema6 } from "effect";
+import { Context as Context5, Schema as Schema12 } from "effect";
 import { Rpc, RpcGroup } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/auth.ts
-import { Schema as Schema4, SchemaGetter } from "effect";
+import { Schema as Schema10, SchemaGetter } from "effect";
 var MAX_DISPLAY_NAME_LENGTH = 80;
-var displayNameInput = Schema4.String.check(Schema4.isMaxLength(MAX_DISPLAY_NAME_LENGTH)).pipe(
-  Schema4.decodeTo(Schema4.NullOr(Schema4.String), {
+var displayNameInput = Schema10.String.check(Schema10.isMaxLength(MAX_DISPLAY_NAME_LENGTH)).pipe(
+  Schema10.decodeTo(Schema10.NullOr(Schema10.String), {
     decode: SchemaGetter.transform((value) => {
       const trimmed = value.trim();
       return trimmed.length === 0 ? null : trimmed;
@@ -599,12 +639,12 @@ var displayNameInput = Schema4.String.check(Schema4.isMaxLength(MAX_DISPLAY_NAME
     encode: SchemaGetter.transform((value) => value ?? "")
   })
 );
-var updateProfileInput = Schema4.Struct({
+var updateProfileInput = Schema10.Struct({
   displayName: displayNameInput
 });
 
 // ../../packages/api/src/schemas/common.ts
-import { Schema as Schema5 } from "effect";
+import { Schema as Schema11 } 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;
@@ -649,49 +689,49 @@ var isApiUrl = (value) => {
     return false;
   }
 };
-var nonEmptyTrimmedString = Schema5.String.check(
-  Schema5.isTrimmed(),
-  Schema5.isNonEmpty({ message: "Expected a non-empty string" })
+var nonEmptyTrimmedString = Schema11.String.check(
+  Schema11.isTrimmed(),
+  Schema11.isNonEmpty({ message: "Expected a non-empty string" })
 );
-var safeInteger = Schema5.Number.check(
-  Schema5.isInt(),
-  Schema5.isBetween({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER })
+var safeInteger = Schema11.Number.check(
+  Schema11.isInt(),
+  Schema11.isBetween({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER })
 );
-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 nonNegativeSafeInteger = safeInteger.check(Schema11.isGreaterThanOrEqualTo(0));
+var isoUtcString = Schema11.String.check(
+  Schema11.makeFilter(isExactUtcInstant, { expected: "an ISO-8601 UTC timestamp with millisecond precision" })
 );
-var civilDate = Schema5.String.check(
-  Schema5.makeFilter(isCivilDate, { expected: "a valid calendar date formatted as YYYY-MM-DD" })
+var civilDate = Schema11.String.check(
+  Schema11.makeFilter(isCivilDate, { expected: "a valid calendar date formatted as YYYY-MM-DD" })
 );
-var ianaTimezone = Schema5.String.check(
-  Schema5.makeFilter(isIanaTimezone, { expected: "an IANA timezone identifier" })
+var ianaTimezone = Schema11.String.check(
+  Schema11.makeFilter(isIanaTimezone, { expected: "an IANA timezone identifier" })
 );
-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 uuidV7 = Schema11.String.check(Schema11.isUUID(UUID_V7_VERSION)).pipe(Schema11.brand("UuidV7"));
+var generalUuid = Schema11.String.check(Schema11.isUUID()).pipe(Schema11.brand("GeneralUuid"));
+var hex64 = Schema11.String.check(
+  Schema11.isPattern(HEX64_PATTERN, { expected: "a 64-character lowercase hex string" })
 );
-var apiUrl = Schema5.String.check(Schema5.makeFilter(isApiUrl, { expected: "an HTTP(S) URL" }));
+var apiUrl = Schema11.String.check(Schema11.makeFilter(isApiUrl, { expected: "an HTTP(S) URL" }));
 
 // ../../packages/api/src/rpc/auth.ts
-var AuthUserResponse = Schema6.Struct({
-  user: Schema6.Struct({
-    id: Schema6.String,
-    email: Schema6.String,
-    displayName: Schema6.NullOr(Schema6.String),
+var AuthUserResponse = Schema12.Struct({
+  user: Schema12.Struct({
+    id: Schema12.String,
+    email: Schema12.String,
+    displayName: Schema12.NullOr(Schema12.String),
     createdAt: isoUtcString
   })
 });
-var LogoutResponse = Schema6.Struct({
-  ok: Schema6.Boolean
+var LogoutResponse = Schema12.Struct({
+  ok: Schema12.Boolean
 });
-var WebRpcContext = class extends Context3.Service()("@oopst/api/WebRpcContext") {
+var WebRpcContext = class extends Context5.Service()("@oopst/api/WebRpcContext") {
 };
 var AuthRpcs = RpcGroup.make(
   Rpc.make("auth.logout", {
     success: LogoutResponse,
-    error: Schema6.Union([DatabaseError, UnauthorizedError])
+    error: Schema12.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc.make("auth.me", {
     success: AuthUserResponse,
@@ -700,42 +740,42 @@ var AuthRpcs = RpcGroup.make(
   Rpc.make("auth.updateProfile", {
     payload: updateProfileInput,
     success: AuthUserResponse,
-    error: Schema6.Union([DatabaseError, UnauthorizedError])
+    error: Schema12.Union([DatabaseError, UnauthorizedError])
   })
 );
 
 // ../../packages/api/src/rpc/devices.ts
-import { Schema as Schema8 } from "effect";
+import { Schema as Schema14 } from "effect";
 import { Rpc as Rpc2, RpcGroup as RpcGroup2 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/devices.ts
-import { Schema as Schema7 } from "effect";
+import { Schema as Schema13 } from "effect";
 var MIN_DEVICE_NAME_LENGTH = 1;
 var MAX_DEVICE_NAME_LENGTH = 80;
 var UUID_V7_VERSION2 = 7;
-var deviceNameSchema = Schema7.String.check(
-  Schema7.isMinLength(MIN_DEVICE_NAME_LENGTH),
-  Schema7.isMaxLength(MAX_DEVICE_NAME_LENGTH)
+var deviceNameSchema = Schema13.String.check(
+  Schema13.isMinLength(MIN_DEVICE_NAME_LENGTH),
+  Schema13.isMaxLength(MAX_DEVICE_NAME_LENGTH)
 );
-var editableDeviceNameSchema = Schema7.Trim.check(
-  Schema7.isMinLength(MIN_DEVICE_NAME_LENGTH),
-  Schema7.isMaxLength(MAX_DEVICE_NAME_LENGTH)
+var editableDeviceNameSchema = Schema13.Trim.check(
+  Schema13.isMinLength(MIN_DEVICE_NAME_LENGTH),
+  Schema13.isMaxLength(MAX_DEVICE_NAME_LENGTH)
 );
-var deviceIdSchema = Schema7.String.check(Schema7.isUUID(UUID_V7_VERSION2));
-var renameDeviceInput = Schema7.Struct({
+var deviceIdSchema = Schema13.String.check(Schema13.isUUID(UUID_V7_VERSION2));
+var renameDeviceInput = Schema13.Struct({
   id: deviceIdSchema,
   name: editableDeviceNameSchema
 });
-var deleteDeviceInput = Schema7.Struct({
+var deleteDeviceInput = Schema13.Struct({
   id: deviceIdSchema
 });
-var renameDeviceOutput = Schema7.Struct({
+var renameDeviceOutput = Schema13.Struct({
   id: deviceIdSchema,
-  name: Schema7.String,
+  name: Schema13.String,
   lastSeen: isoUtcString
 });
-var deleteDeviceOutput = Schema7.Struct({
-  ok: Schema7.Boolean
+var deleteDeviceOutput = Schema13.Struct({
+  ok: Schema13.Boolean
 });
 
 // ../../packages/api/src/rpc/devices.ts
@@ -743,27 +783,27 @@ var DevicesRpcs = RpcGroup2.make(
   Rpc2.make("devices.rename", {
     payload: renameDeviceInput,
     success: renameDeviceOutput,
-    error: Schema8.Union([ConflictError, DatabaseError, NotFoundError, UnauthorizedError])
+    error: Schema14.Union([ConflictError, DatabaseError, NotFoundError, UnauthorizedError])
   }),
   Rpc2.make("devices.delete", {
     payload: deleteDeviceInput,
     success: deleteDeviceOutput,
-    error: Schema8.Union([DatabaseError, NotFoundError, UnauthorizedError])
+    error: Schema14.Union([DatabaseError, NotFoundError, UnauthorizedError])
   })
 );
 
 // ../../packages/api/src/rpc/stats.ts
-import { Schema as Schema10 } from "effect";
+import { Schema as Schema16 } from "effect";
 import { Rpc as Rpc3, RpcGroup as RpcGroup3 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/stats.ts
-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);
+import { Effect as Effect4, Schema as Schema15 } from "effect";
+var scopeEnum = Schema15.Literals(["all", "me"]);
+var costStackByValueEnum = Schema15.Literals(["device", "harness", "model"]);
+var costStackByEnum = Schema15.optional(costStackByValueEnum);
+var usageDetailStackByEnum = Schema15.Literals(["device", "harness", "model"]);
+var stackByValueEnum = Schema15.Literals(["device", "harness"]);
+var stackByEnum = Schema15.optional(stackByValueEnum);
 var MAX_TIME_ZONE_LENGTH = 64;
 var DEFAULT_DAYS = 90;
 var MAX_DAYS = 365;
@@ -781,16 +821,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(Schema9.isMaxLength(MAX_TIME_ZONE_LENGTH));
+var timeZoneSchema = ianaTimezone.check(Schema15.isMaxLength(MAX_TIME_ZONE_LENGTH));
 var civilDateSchema = civilDate;
-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 daysSchema = safeInteger.check(Schema15.isBetween({ minimum: MIN_LEADERBOARD_LIMIT, maximum: MAX_DAYS })).pipe(Schema15.withDecodingDefaultTypeKey(Effect4.succeed(DEFAULT_DAYS)));
+var leaderboardLimitSchema = safeInteger.check(Schema15.isBetween({ minimum: MIN_LEADERBOARD_LIMIT, maximum: MAX_LEADERBOARD_LIMIT })).pipe(Schema15.withDecodingDefaultTypeKey(Effect4.succeed(DEFAULT_LEADERBOARD_LIMIT)));
+var defaultTimeZoneSchema = timeZoneSchema.pipe(Schema15.withDecodingDefaultTypeKey(Effect4.succeed("UTC")));
+var uuidSchema = Schema15.String.check(Schema15.isUUID(UUID_V7_VERSION3));
 var rangeFields = {
   days: daysSchema,
-  endDate: Schema9.optional(civilDateSchema),
-  startDate: Schema9.optional(civilDateSchema)
+  endDate: Schema15.optional(civilDateSchema),
+  startDate: Schema15.optional(civilDateSchema)
 };
 function validateDateRange(input) {
   if (!(input.startDate || input.endDate)) {
@@ -830,216 +870,216 @@ function parseCivilDateUtcMs(date) {
   }
   return parsed.getTime();
 }
-var dailyCostInput = Schema9.Struct({
+var dailyCostInput = Schema15.Struct({
   scope: scopeEnum,
   stackBy: costStackByEnum,
   ...rangeFields,
   timeZone: defaultTimeZoneSchema
-}).check(Schema9.makeFilter(validateDateRange));
-var dailyPointSchema = Schema9.Struct({
+}).check(Schema15.makeFilter(validateDateRange));
+var dailyPointSchema = Schema15.Struct({
   /** Local civil date in YYYY-MM-DD for the requested stats timezone. */
   date: civilDateSchema,
   /** null when stackBy is undefined. */
-  seriesName: Schema9.NullOr(Schema9.String),
+  seriesName: Schema15.NullOr(Schema15.String),
   /** USD; 0 or positive. */
-  usd: Schema9.Number
+  usd: Schema15.Number
 });
-var dailyCostOutput = Schema9.Array(dailyPointSchema);
-var dailySessionsInput = Schema9.Struct({
+var dailyCostOutput = Schema15.Array(dailyPointSchema);
+var dailySessionsInput = Schema15.Struct({
   scope: scopeEnum,
   stackBy: stackByEnum,
   ...rangeFields,
   timeZone: defaultTimeZoneSchema
-}).check(Schema9.makeFilter(validateDateRange));
-var dailySessionsPointSchema = Schema9.Struct({
+}).check(Schema15.makeFilter(validateDateRange));
+var dailySessionsPointSchema = Schema15.Struct({
   date: civilDateSchema,
-  seriesName: Schema9.NullOr(Schema9.String),
+  seriesName: Schema15.NullOr(Schema15.String),
   sessions: nonNegativeSafeInteger
 });
-var dailySessionsOutput = Schema9.Array(dailySessionsPointSchema);
+var dailySessionsOutput = Schema15.Array(dailySessionsPointSchema);
 var weekdaySessionsInput = dailySessionsInput;
-var weekdaySessionsPointSchema = Schema9.Struct({
+var weekdaySessionsPointSchema = Schema15.Struct({
   /** Local ISO weekday for the requested stats timezone: 1=Monday, 7=Sunday. */
-  weekday: safeInteger.check(Schema9.isBetween({ minimum: MIN_ISO_WEEKDAY, maximum: MAX_ISO_WEEKDAY })),
-  seriesName: Schema9.NullOr(Schema9.String),
+  weekday: safeInteger.check(Schema15.isBetween({ minimum: MIN_ISO_WEEKDAY, maximum: MAX_ISO_WEEKDAY })),
+  seriesName: Schema15.NullOr(Schema15.String),
   sessions: nonNegativeSafeInteger
 });
-var weekdaySessionsOutput = Schema9.Array(weekdaySessionsPointSchema);
+var weekdaySessionsOutput = Schema15.Array(weekdaySessionsPointSchema);
 var hourlySessionsInput = dailySessionsInput;
-var hourlySessionsPointSchema = Schema9.Struct({
+var hourlySessionsPointSchema = Schema15.Struct({
   /** Local hour of day for the requested stats timezone: 0-23. */
-  hour: safeInteger.check(Schema9.isBetween({ minimum: MIN_HOUR_OF_DAY, maximum: MAX_HOUR_OF_DAY })),
-  seriesName: Schema9.NullOr(Schema9.String),
+  hour: safeInteger.check(Schema15.isBetween({ minimum: MIN_HOUR_OF_DAY, maximum: MAX_HOUR_OF_DAY })),
+  seriesName: Schema15.NullOr(Schema15.String),
   sessions: nonNegativeSafeInteger
 });
-var hourlySessionsOutput = Schema9.Array(hourlySessionsPointSchema);
-var summaryInput = Schema9.Struct({
+var hourlySessionsOutput = Schema15.Array(hourlySessionsPointSchema);
+var summaryInput = Schema15.Struct({
   ...rangeFields,
   scope: scopeEnum,
   timeZone: defaultTimeZoneSchema
-}).check(Schema9.makeFilter(validateDateRange));
-var summaryOutput = Schema9.Struct({
-  rangeUsd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
+}).check(Schema15.makeFilter(validateDateRange));
+var summaryOutput = Schema15.Struct({
+  rangeUsd: Schema15.Number.check(Schema15.isGreaterThanOrEqualTo(0)),
   rangeSessions: nonNegativeSafeInteger,
   rangeSubjectCount: nonNegativeSafeInteger,
-  totalUsd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
+  totalUsd: Schema15.Number.check(Schema15.isGreaterThanOrEqualTo(0)),
   totalSessions: nonNegativeSafeInteger
 });
-var deviceSummarySchema = Schema9.Struct({
+var deviceSummarySchema = Schema15.Struct({
   id: uuidSchema,
-  name: Schema9.String,
+  name: Schema15.String,
   /** ISO-8601 UTC. */
   lastSeen: isoUtcString
 });
-var devicesOutput = Schema9.Array(deviceSummarySchema);
-var participantSyncSchema = Schema9.Struct({
+var devicesOutput = Schema15.Array(deviceSummarySchema);
+var participantSyncSchema = Schema15.Struct({
   userId: uuidSchema,
-  userLabel: Schema9.String,
+  userLabel: Schema15.String,
   /** ISO-8601 UTC, null when the participant has no synced devices yet. */
-  latestSyncAt: Schema9.NullOr(isoUtcString)
+  latestSyncAt: Schema15.NullOr(isoUtcString)
 });
-var participantsOutput = Schema9.Array(participantSyncSchema);
-var leaderboardInput = Schema9.Struct({
+var participantsOutput = Schema15.Array(participantSyncSchema);
+var leaderboardInput = Schema15.Struct({
   ...rangeFields,
   limit: leaderboardLimitSchema,
   timeZone: defaultTimeZoneSchema
-}).check(Schema9.makeFilter(validateDateRange));
-var leaderboardRowSchema = Schema9.Struct({
-  rank: safeInteger.check(Schema9.isGreaterThanOrEqualTo(1)),
+}).check(Schema15.makeFilter(validateDateRange));
+var leaderboardRowSchema = Schema15.Struct({
+  rank: safeInteger.check(Schema15.isGreaterThanOrEqualTo(1)),
   userId: uuidSchema,
-  userLabel: Schema9.String,
-  usd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
+  userLabel: Schema15.String,
+  usd: Schema15.Number.check(Schema15.isGreaterThanOrEqualTo(0)),
   tokens: nonNegativeSafeInteger,
   sessions: nonNegativeSafeInteger
 });
-var leaderboardOutput = Schema9.Array(leaderboardRowSchema);
+var leaderboardOutput = Schema15.Array(leaderboardRowSchema);
 var topDimensionsInput = leaderboardInput;
-var topDimensionRowSchema = Schema9.Struct({
-  rank: safeInteger.check(Schema9.isGreaterThanOrEqualTo(1)),
-  name: Schema9.String,
-  usd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
+var topDimensionRowSchema = Schema15.Struct({
+  rank: safeInteger.check(Schema15.isGreaterThanOrEqualTo(1)),
+  name: Schema15.String,
+  usd: Schema15.Number.check(Schema15.isGreaterThanOrEqualTo(0)),
   tokens: nonNegativeSafeInteger,
-  sessions: Schema9.NullOr(nonNegativeSafeInteger)
+  sessions: Schema15.NullOr(nonNegativeSafeInteger)
 });
-var topDimensionsOutput = Schema9.Struct({
-  harnesses: Schema9.Array(topDimensionRowSchema),
-  models: Schema9.Array(topDimensionRowSchema)
+var topDimensionsOutput = Schema15.Struct({
+  harnesses: Schema15.Array(topDimensionRowSchema),
+  models: Schema15.Array(topDimensionRowSchema)
 });
-var usageDetailsInput = Schema9.Struct({
+var usageDetailsInput = Schema15.Struct({
   ...rangeFields,
   stackBy: usageDetailStackByEnum,
   timeZone: defaultTimeZoneSchema
-}).check(Schema9.makeFilter(validateDateRange));
-var usageDetailsRowSchema = Schema9.Struct({
-  id: Schema9.String,
-  name: Schema9.String,
+}).check(Schema15.makeFilter(validateDateRange));
+var usageDetailsRowSchema = Schema15.Struct({
+  id: Schema15.String,
+  name: Schema15.String,
   tokens: nonNegativeSafeInteger,
-  sessions: Schema9.NullOr(nonNegativeSafeInteger),
-  usd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0)),
-  totalUsd: Schema9.Number.check(Schema9.isGreaterThanOrEqualTo(0))
+  sessions: Schema15.NullOr(nonNegativeSafeInteger),
+  usd: Schema15.Number.check(Schema15.isGreaterThanOrEqualTo(0)),
+  totalUsd: Schema15.Number.check(Schema15.isGreaterThanOrEqualTo(0))
 });
-var usageDetailsOutput = Schema9.Array(usageDetailsRowSchema);
+var usageDetailsOutput = Schema15.Array(usageDetailsRowSchema);
 
 // ../../packages/api/src/rpc/stats.ts
 var StatsRpcs = RpcGroup3.make(
   Rpc3.make("stats.devices", {
     success: devicesOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.participants", {
     success: participantsOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.leaderboard", {
     payload: leaderboardInput,
     success: leaderboardOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.topDimensions", {
     payload: topDimensionsInput,
     success: topDimensionsOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.summary", {
     payload: summaryInput,
     success: summaryOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.dailyCost", {
     payload: dailyCostInput,
     success: dailyCostOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.dailySessions", {
     payload: dailySessionsInput,
     success: dailySessionsOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.weekdaySessions", {
     payload: weekdaySessionsInput,
     success: weekdaySessionsOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.hourlySessions", {
     payload: hourlySessionsInput,
     success: hourlySessionsOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc3.make("stats.usageDetails", {
     payload: usageDetailsInput,
     success: usageDetailsOutput,
-    error: Schema10.Union([DatabaseError, UnauthorizedError])
+    error: Schema16.Union([DatabaseError, UnauthorizedError])
   })
 );
 
 // ../../packages/api/src/rpc/tokens.ts
-import { Schema as Schema12 } from "effect";
+import { Schema as Schema18 } from "effect";
 import { Rpc as Rpc4, RpcGroup as RpcGroup4 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/tokens.ts
-import { Schema as Schema11 } from "effect";
+import { Schema as Schema17 } from "effect";
 var MIN_TOKEN_NAME_LENGTH = 1;
 var MAX_TOKEN_NAME_LENGTH = 80;
-var createTokenInput = Schema11.Struct({
-  name: Schema11.String.check(Schema11.isMinLength(MIN_TOKEN_NAME_LENGTH), Schema11.isMaxLength(MAX_TOKEN_NAME_LENGTH))
+var createTokenInput = Schema17.Struct({
+  name: Schema17.String.check(Schema17.isMinLength(MIN_TOKEN_NAME_LENGTH), Schema17.isMaxLength(MAX_TOKEN_NAME_LENGTH))
 });
-var revokeTokenInput = Schema11.Struct({
+var revokeTokenInput = Schema17.Struct({
   id: uuidV7
 });
-var tokenMetadata = Schema11.Struct({
+var tokenMetadata = Schema17.Struct({
   id: uuidV7,
-  name: Schema11.String,
-  prefix: Schema11.String,
+  name: Schema17.String,
+  prefix: Schema17.String,
   createdAt: isoUtcString,
-  lastUsedAt: Schema11.NullOr(isoUtcString),
-  revokedAt: Schema11.NullOr(isoUtcString)
+  lastUsedAt: Schema17.NullOr(isoUtcString),
+  revokedAt: Schema17.NullOr(isoUtcString)
 });
-var listTokensOutput = Schema11.Struct({
-  tokens: Schema11.Array(tokenMetadata)
+var listTokensOutput = Schema17.Struct({
+  tokens: Schema17.Array(tokenMetadata)
 });
-var createTokenOutput = Schema11.Struct({
-  token: Schema11.String,
+var createTokenOutput = Schema17.Struct({
+  token: Schema17.String,
   metadata: tokenMetadata
 });
-var revokeTokenOutput = Schema11.Struct({
-  ok: Schema11.Boolean
+var revokeTokenOutput = Schema17.Struct({
+  ok: Schema17.Boolean
 });
 
 // ../../packages/api/src/rpc/tokens.ts
 var TokensRpcs = RpcGroup4.make(
   Rpc4.make("tokens.list", {
     success: listTokensOutput,
-    error: Schema12.Union([DatabaseError, UnauthorizedError])
+    error: Schema18.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc4.make("tokens.create", {
     payload: createTokenInput,
     success: createTokenOutput,
-    error: Schema12.Union([DatabaseError, UnauthorizedError])
+    error: Schema18.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc4.make("tokens.revoke", {
     payload: revokeTokenInput,
     success: revokeTokenOutput,
-    error: Schema12.Union([DatabaseError, NotFoundError, UnauthorizedError])
+    error: Schema18.Union([DatabaseError, NotFoundError, UnauthorizedError])
   })
 );
 
@@ -1047,13 +1087,15 @@ var TokensRpcs = RpcGroup4.make(
 var WebRpcs = AuthRpcs.merge(StatsRpcs).merge(TokensRpcs).merge(DevicesRpcs);
 
 // ../../packages/api/src/rpc/sync.ts
-import { Schema as Schema14 } from "effect";
+import { Schema as Schema20 } from "effect";
 import { Rpc as Rpc5, RpcGroup as RpcGroup5 } from "effect/unstable/rpc";
 
 // ../../packages/api/src/schemas/sync.ts
-import { Effect as Effect5, Schema as Schema13 } from "effect";
+import { Effect as Effect5, Schema as Schema19 } from "effect";
 var MIN_DEVICE_NAME_LENGTH2 = 1;
 var MAX_DEVICE_NAME_LENGTH2 = 80;
+var MIN_CLI_VERSION_LENGTH = 1;
+var MAX_CLI_VERSION_LENGTH = 100;
 var MIN_MODEL_LENGTH = 1;
 var MAX_MODEL_LENGTH = 200;
 var SESSION_KEY_LENGTH = 64;
@@ -1066,27 +1108,34 @@ var MAX_REPLACEMENT_BATCHES = 1e4;
 var MAX_REPLACEMENT_FACTS = 1e5;
 var HARNESSES = ["codex", "claude_code", "pi", "hermes", "opencode"];
 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 harnessEnum = Schema19.Literals(HARNESSES);
+var deviceNameSchema2 = Schema19.String.check(
+  Schema19.isMinLength(MIN_DEVICE_NAME_LENGTH2),
+  Schema19.isMaxLength(MAX_DEVICE_NAME_LENGTH2)
+);
+var cliVersionSchema = Schema19.String.check(
+  Schema19.isMinLength(MIN_CLI_VERSION_LENGTH),
+  Schema19.isMaxLength(MAX_CLI_VERSION_LENGTH)
 );
-var getWatermarkInput = Schema13.Struct({
+var legacyCompatibleCliVersionSchema = Schema19.NullOr(cliVersionSchema).pipe(
+  Schema19.withDecodingDefaultTypeKey(Effect5.succeed(null))
+);
+var getWatermarkInput = Schema19.Struct({
   device: deviceNameSchema2
 });
-var getWatermarkOutput = Schema13.Struct({
-  watermarkHourUtc: Schema13.NullOr(isoUtcString),
-  sessionKeySalt: hex64.check(Schema13.isLengthBetween(SESSION_KEY_SALT_LENGTH, SESSION_KEY_SALT_LENGTH))
+var getWatermarkOutput = Schema19.Struct({
+  watermarkHourUtc: Schema19.NullOr(isoUtcString),
+  sessionKeySalt: hex64.check(Schema19.isLengthBetween(SESSION_KEY_SALT_LENGTH, SESSION_KEY_SALT_LENGTH))
 });
 function boundedInteger(max) {
   if (max === null) {
     return nonNegativeSafeInteger;
   }
-  return nonNegativeSafeInteger.check(Schema13.isLessThanOrEqualTo(max));
+  return nonNegativeSafeInteger.check(Schema19.isLessThanOrEqualTo(max));
 }
-var bucketInput = Schema13.Struct({
+var bucketInput = Schema19.Struct({
   harness: harnessEnum,
-  model: Schema13.String.check(Schema13.isMinLength(MIN_MODEL_LENGTH), Schema13.isMaxLength(MAX_MODEL_LENGTH)),
+  model: Schema19.String.check(Schema19.isMinLength(MIN_MODEL_LENGTH), Schema19.isMaxLength(MAX_MODEL_LENGTH)),
   hourUtc: isoUtcString,
   inputTokens: boundedInteger(MAX_BUCKET_TOKEN_COUNT),
   outputTokens: boundedInteger(MAX_BUCKET_TOKEN_COUNT),
@@ -1094,49 +1143,51 @@ var bucketInput = Schema13.Struct({
   cacheCreateTokens: boundedInteger(MAX_BUCKET_TOKEN_COUNT),
   sessionCount: boundedInteger(MAX_BUCKET_SESSION_COUNT)
 });
-var sessionInput = Schema13.Struct({
+var sessionInput = Schema19.Struct({
   harness: harnessEnum,
-  sessionKey: hex64.check(Schema13.isLengthBetween(SESSION_KEY_LENGTH, SESSION_KEY_LENGTH)),
+  sessionKey: hex64.check(Schema19.isLengthBetween(SESSION_KEY_LENGTH, SESSION_KEY_LENGTH)),
   startedAt: isoUtcString,
   lastSeenAt: isoUtcString
 });
-var upsertBucketsInput = Schema13.Struct({
+var upsertBucketsInput = Schema19.Struct({
   device: deviceNameSchema2,
-  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([])))
+  cliVersion: legacyCompatibleCliVersionSchema,
+  buckets: Schema19.Array(bucketInput).check(Schema19.isMaxLength(MAX_BUCKETS_PER_SYNC)),
+  sessions: Schema19.Array(sessionInput).check(Schema19.isMaxLength(MAX_SESSIONS_PER_SYNC)).pipe(Schema19.withDecodingDefaultTypeKey(Effect5.succeed([])))
 });
-var upsertBucketsOutput = Schema13.Struct({
+var upsertBucketsOutput = Schema19.Struct({
   upserted: boundedInteger(null),
   upsertedSessions: boundedInteger(null)
 });
 var replacementId = uuidV7;
-var createUsageReplacementInput = Schema13.Struct({
+var createUsageReplacementInput = Schema19.Struct({
   device: deviceNameSchema2,
+  cliVersion: legacyCompatibleCliVersionSchema,
   startHourUtc: isoUtcString,
   endHourUtc: isoUtcString,
-  harnesses: Schema13.Array(harnessEnum).check(Schema13.isMinLength(1), Schema13.isMaxLength(MAX_REPLACEMENT_HARNESSES))
+  harnesses: Schema19.Array(harnessEnum).check(Schema19.isMinLength(1), Schema19.isMaxLength(MAX_REPLACEMENT_HARNESSES))
 });
-var createUsageReplacementOutput = Schema13.Struct({
+var createUsageReplacementOutput = Schema19.Struct({
   replacementId,
   startHourUtc: isoUtcString,
   endHourUtc: isoUtcString,
-  harnesses: Schema13.Array(harnessEnum),
+  harnesses: Schema19.Array(harnessEnum),
   expiresAt: isoUtcString
 });
-var stageUsageReplacementBatchInput = Schema13.Struct({
+var stageUsageReplacementBatchInput = Schema19.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))
+  buckets: Schema19.Array(bucketInput).check(Schema19.isMaxLength(MAX_BUCKETS_PER_SYNC)),
+  sessions: Schema19.Array(sessionInput).check(Schema19.isMaxLength(MAX_SESSIONS_PER_SYNC))
 });
-var stageUsageReplacementBatchOutput = Schema13.Struct({
+var stageUsageReplacementBatchOutput = Schema19.Struct({
   stagedBuckets: boundedInteger(MAX_BUCKETS_PER_SYNC),
   stagedSessions: boundedInteger(MAX_SESSIONS_PER_SYNC),
-  alreadyStaged: Schema13.Boolean
+  alreadyStaged: Schema19.Boolean
 });
-var finalizeUsageReplacementInput = Schema13.Struct({
+var finalizeUsageReplacementInput = Schema19.Struct({
   device: deviceNameSchema2,
   replacementId,
   expectedBatchCount: boundedInteger(MAX_REPLACEMENT_BATCHES),
@@ -1144,7 +1195,7 @@ var finalizeUsageReplacementInput = Schema13.Struct({
   expectedSessionCount: boundedInteger(MAX_REPLACEMENT_FACTS),
   digest: hex64
 });
-var finalizeUsageReplacementOutput = Schema13.Struct({
+var finalizeUsageReplacementOutput = Schema19.Struct({
   replacementId,
   committedAt: isoUtcString,
   replacedBuckets: boundedInteger(MAX_REPLACEMENT_FACTS),
@@ -1153,7 +1204,7 @@ var finalizeUsageReplacementOutput = Schema13.Struct({
 });
 
 // ../../packages/api/src/rpc/sync.ts
-var replacementErrors = Schema14.Union([
+var replacementErrors = Schema20.Union([
   ConflictError,
   DatabaseError,
   NotFoundError,
@@ -1166,12 +1217,12 @@ var SyncRpcs = RpcGroup5.make(
   Rpc5.make("sync.getWatermark", {
     payload: getWatermarkInput,
     success: getWatermarkOutput,
-    error: Schema14.Union([DatabaseError, UnauthorizedError])
+    error: Schema20.Union([DatabaseError, UnauthorizedError])
   }),
   Rpc5.make("sync.upsertBuckets", {
     payload: upsertBucketsInput,
     success: upsertBucketsOutput,
-    error: Schema14.Union([DatabaseError, SyncQuotaExceededError, SyncTimestampRejectedError, UnauthorizedError])
+    error: Schema20.Union([DatabaseError, SyncQuotaExceededError, SyncTimestampRejectedError, UnauthorizedError])
   }),
   Rpc5.make("sync.createUsageReplacement", {
     payload: createUsageReplacementInput,
@@ -1230,12 +1281,12 @@ 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";
+import { Effect as Effect6, Schema as Schema21, Stream as Stream2 } from "effect";
 var UsageAggregationErrorFields = {
-  message: Schema15.String,
-  cause: Schema15.optionalKey(Schema15.Defect())
+  message: Schema21.String,
+  cause: Schema21.optionalKey(Schema21.Defect())
 };
-var UsageAggregationError = class extends Schema15.TaggedErrorClass()(
+var UsageAggregationError = class extends Schema21.TaggedErrorClass()(
   "UsageAggregationError",
   UsageAggregationErrorFields
 ) {
@@ -1395,12 +1446,12 @@ function aggregateUsageStream(source, options) {
 }
 
 // src/sync/client.ts
-import { Context as Context4, Effect as Effect7, Layer as Layer3 } from "effect";
+import { Context as Context6, 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") {
+var SyncRpcClient = class extends Context6.Service()("@oopst/cli/SyncRpcClient") {
 };
 function syncRpcClientFromPromiseClient(client) {
   const getWatermark = Effect7.fn("SyncRpcClient.fromPromise.getWatermark")(
@@ -1491,7 +1542,7 @@ function stripTrailingSlash(url) {
 }
 
 // src/sync/errors.ts
-import { Schema as Schema16 } from "effect";
+import { Schema as Schema22 } from "effect";
 var SUCCESS_EXIT_CODE = 0;
 var ZERO_BUCKETS_EXIT_CODE = 1;
 var UNAUTHORIZED_EXIT_CODE = 2;
@@ -1514,10 +1565,10 @@ var EXIT = {
   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())
+var SyncError = class extends Schema22.TaggedErrorClass()("SyncError", {
+  message: Schema22.String,
+  exitCode: Schema22.Literals(EXIT_CODES),
+  cause: Schema22.optionalKey(Schema22.Defect())
 }) {
   constructor(exitCode, message, options = {}) {
     super(
@@ -1550,24 +1601,25 @@ function isNetworkError(err) {
   if (code && NETWORK_ERROR_CODES.includes(code)) {
     return true;
   }
-  const message = err.message ?? "";
+  const candidateMessage = err.message;
+  const message = typeof candidateMessage === "string" ? candidateMessage : "";
   return NETWORK_ERROR_PATTERN.test(message);
 }
 
 // src/sync/parser-collection.ts
-import { Context as Context5, Effect as Effect8, Layer as Layer4, Schema as Schema17, Stream as Stream3 } from "effect";
+import { Context as Context7, Effect as Effect8, Layer as Layer4, Schema as Schema23, Stream as Stream3 } from "effect";
 var SCAN_PROGRESS_SESSION_STEP = 500;
 var ParserCollectionErrorFields = {
-  message: Schema17.String,
-  source: Schema17.String,
-  cause: Schema17.optionalKey(Schema17.Defect())
+  message: Schema23.String,
+  source: Schema23.String,
+  cause: Schema23.optionalKey(Schema23.Defect())
 };
-var ParserCollectionError = class extends Schema17.TaggedErrorClass()(
+var ParserCollectionError = class extends Schema23.TaggedErrorClass()(
   "ParserCollectionError",
   ParserCollectionErrorFields
 ) {
 };
-var ParserCollection = class extends Context5.Service()(
+var ParserCollection = class extends Context7.Service()(
   "@oopst/cli/ParserCollection"
 ) {
 };
@@ -1744,6 +1796,7 @@ function runReplacementUsage(input) {
       uploadUsageReplacement({
         batches,
         client,
+        cliVersion: options.cliVersion,
         color,
         device: options.device,
         logger: options.logger,
@@ -1791,6 +1844,7 @@ function uploadOrdinaryUsage(options, client, color, usageBatches) {
       uploadUsageBatchStream({
         batches: usageBatches,
         client,
+        cliVersion: options.cliVersion,
         color,
         device: options.device,
         logger: options.logger
@@ -1986,6 +2040,7 @@ var uploadUsageBatchStream = Effect9.fn("RunSync.uploadUsageBatchStream")(
             );
             const result = yield* options.client.upsertBuckets({
               device: options.device,
+              cliVersion: options.cliVersion,
               buckets: batch.buckets,
               sessions: batch.sessions
             });
@@ -2006,6 +2061,7 @@ var uploadUsageReplacement = Effect9.fn("RunSync.uploadUsageReplacement")(
     yield* logInfo2(options.logger, phase2("Creating atomic replacement scope...", options.color));
     const created = yield* options.client.createUsageReplacement({
       device: options.device,
+      cliVersion: options.cliVersion,
       startHourUtc: options.replacement.startHourUtc,
       endHourUtc: options.replacement.endHourUtc,
       harnesses: options.replacement.harnesses
@@ -2120,7 +2176,7 @@ function uploadRequestText(value) {
 }
 
 // src/services/sync-program.ts
-var SyncProgram = class extends Context6.Service()("@oopst/cli/SyncProgram") {
+var SyncProgram = class extends Context8.Service()("@oopst/cli/SyncProgram") {
 };
 var SyncProgramLive = Layer5.effect(
   SyncProgram,
@@ -2141,49 +2197,60 @@ function runSyncProgram2(options) {
 import { dirname, join as join3 } from "path";
 import { createInterface } from "readline/promises";
 import { NodeCrypto, NodeFileSystem as NodeFileSystem3 } from "@effect/platform-node";
-import { Context as Context7, Crypto, Effect as Effect11, FileSystem as FileSystem4, Layer as Layer6, Schema as Schema18 } from "effect";
-var CRON_START_MARKER = "# OopsT sync start";
-var CRON_END_MARKER = "# OopsT sync end";
-var DEFAULT_CRON_PATHS = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
-var DEFAULT_PACKAGE_NAME = "@cookielab.io/oopst";
-var CONFIG_FILE_MODE = 384;
-var LINE_SPLIT_PATTERN = /\r?\n/u;
-var SetupError = class extends Schema18.TaggedErrorClass()("SetupError", {
-  message: Schema18.String,
-  exitCode: Schema18.Number,
-  cause: Schema18.optionalKey(Schema18.Defect())
-}) {
-  constructor(message, options = {}) {
-    const exitCode = options.exitCode ?? EXIT.generalFailure;
-    super(
-      options.cause === void 0 ? { message, exitCode } : { message, exitCode, cause: options.cause }
-    );
-  }
-};
-var SetupPromptService = class extends Context7.Service()(
-  "@oopst/cli/SetupPromptService"
+import { Crypto, Effect as Effect11, FileSystem as FileSystem4, Layer as Layer6, Schema as Schema24 } from "effect";
+
+// src/services/setup-cron-services.ts
+import { Context as Context9 } from "effect";
+var SetupCronCommandService = class extends Context9.Service()(
+  "@oopst/cli/SetupCronCommandService"
 ) {
 };
-var SetupConfigFileService = class extends Context7.Service()(
-  "@oopst/cli/SetupConfigFileService"
+var SetupRandomService = class extends Context9.Service()(
+  "@oopst/cli/SetupRandomService"
 ) {
 };
-var SetupCronCommandService = class extends Context7.Service()(
-  "@oopst/cli/SetupCronCommandService"
+
+// src/services/setup-prompt-services.ts
+import { Context as Context10 } from "effect";
+var SetupPromptService = class extends Context10.Service()(
+  "@oopst/cli/SetupPromptService"
 ) {
 };
-var SetupRandomService = class extends Context7.Service()(
-  "@oopst/cli/SetupRandomService"
+var SetupConfigFileService = class extends Context10.Service()(
+  "@oopst/cli/SetupConfigFileService"
 ) {
 };
-var SetupOutputService = class extends Context7.Service()(
+
+// src/services/setup-runtime-services.ts
+import { Context as Context11 } from "effect";
+var SetupOutputService = class extends Context11.Service()(
   "@oopst/cli/SetupOutputService"
 ) {
 };
-var SetupEnvironmentService = class extends Context7.Service()(
+var SetupEnvironmentService = class extends Context11.Service()(
   "@oopst/cli/SetupEnvironmentService"
 ) {
 };
+
+// src/setup.ts
+var CRON_START_MARKER = "# OopsT sync start";
+var CRON_END_MARKER = "# OopsT sync end";
+var DEFAULT_CRON_PATHS = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"];
+var DEFAULT_PACKAGE_NAME = "@cookielab.io/oopst";
+var CONFIG_FILE_MODE = 384;
+var LINE_SPLIT_PATTERN = /\r?\n/u;
+var SetupError = class extends Schema24.TaggedErrorClass()("SetupError", {
+  message: Schema24.String,
+  exitCode: Schema24.Number,
+  cause: Schema24.optionalKey(Schema24.Defect())
+}) {
+  constructor(message, options = {}) {
+    const exitCode = options.exitCode ?? EXIT.generalFailure;
+    super(
+      options.cause === void 0 ? { message, exitCode } : { message, exitCode, cause: options.cause }
+    );
+  }
+};
 function errorMessage3(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
@@ -2373,7 +2440,11 @@ function commandFailureOptions(result) {
   return result.error === void 0 ? {} : { cause: result.error };
 }
 function commandFailureReason(result, fallback) {
-  return result.error?.message ?? result.stderr.trim() ?? fallback;
+  if (result.error !== void 0) {
+    return result.error.message;
+  }
+  const stderr2 = result.stderr.trim();
+  return stderr2.length > 0 ? stderr2 : fallback;
 }
 function existingCrontabFromResult(result) {
   if (result.status === 0) {
@@ -2583,24 +2654,24 @@ import { Effect as Effect18, Stream as Stream11 } from "effect";
 // ../../packages/parsers/src/config.ts
 import { homedir as homedir2 } from "os";
 import { isAbsolute as isAbsolute2, join as join4 } from "path";
-import process3 from "process";
-import { Config as Config2, ConfigProvider as ConfigProvider2, Effect as Effect12, Schema as Schema19 } from "effect";
-var runtimeEnv2 = process3["env"];
-var RawParserEnvSchema = Schema19.Struct({
+import { env as processEnv2 } from "process";
+import { Config as Config2, ConfigProvider as ConfigProvider2, Effect as Effect12, Schema as Schema25 } from "effect";
+var runtimeEnv2 = processEnv2;
+var RawParserEnvSchema = Schema25.Struct({
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  CLAUDE_CONFIG_DIR: Schema19.optional(Schema19.Trim),
+  CLAUDE_CONFIG_DIR: Schema25.optional(Schema25.Trim),
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  HERMES_CODING_AGENT_DIR: Schema19.optional(Schema19.Trim),
+  HERMES_CODING_AGENT_DIR: Schema25.optional(Schema25.Trim),
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  HERMES_CODING_AGENT_SESSION_DIR: Schema19.optional(Schema19.Trim),
+  HERMES_CODING_AGENT_SESSION_DIR: Schema25.optional(Schema25.Trim),
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  OPENCODE_DATA_DIR: Schema19.optional(Schema19.Trim),
+  OPENCODE_DATA_DIR: Schema25.optional(Schema25.Trim),
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  OPENCODE_DB: Schema19.optional(Schema19.Trim),
+  OPENCODE_DB: Schema25.optional(Schema25.Trim),
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  PI_CODING_AGENT_DIR: Schema19.optional(Schema19.Trim),
+  PI_CODING_AGENT_DIR: Schema25.optional(Schema25.Trim),
   // biome-ignore lint/style/useNamingConvention: ENV vars are SCREAMING_SNAKE_CASE by convention
-  PI_CODING_AGENT_SESSION_DIR: Schema19.optional(Schema19.Trim)
+  PI_CODING_AGENT_SESSION_DIR: Schema25.optional(Schema25.Trim)
 });
 var parserEnvConfig = Config2.schema(RawParserEnvSchema);
 var emptyToUndefined = (value) => value === void 0 || value.length === 0 ? void 0 : value;
@@ -2654,18 +2725,18 @@ function resolveOpenCodeRoot(config = loadParserConfig(), homeDir = readParserHo
 // ../../packages/parsers/src/effect/file-walker.ts
 import { join as join5 } from "path";
 import { NodeFileSystem as NodeFileSystem4 } from "@effect/platform-node";
-import { Context as Context8, Effect as Effect13, FileSystem as FileSystem5, Layer as Layer7, Option as Option2, Schema as Schema20, Stream as Stream5 } from "effect";
-var FileWalkerFilesystemError = class extends Schema20.TaggedErrorClass()(
+import { Context as Context12, Effect as Effect13, FileSystem as FileSystem5, Layer as Layer7, Option as Option2, Schema as Schema26, Stream as Stream5 } from "effect";
+var FileWalkerFilesystemError = class extends Schema26.TaggedErrorClass()(
   "FileWalkerFilesystemError",
   {
-    message: Schema20.String,
-    operation: Schema20.Literals(["readdir", "stat"]),
-    path: Schema20.String,
-    cause: Schema20.optionalKey(Schema20.Defect())
+    message: Schema26.String,
+    operation: Schema26.Literals(["readdir", "stat"]),
+    path: Schema26.String,
+    cause: Schema26.optionalKey(Schema26.Defect())
   }
 ) {
 };
-var FileWalker = class extends Context8.Service()("@oopst/parsers/FileWalker") {
+var FileWalker = class extends Context12.Service()("@oopst/parsers/FileWalker") {
 };
 var toFileWalkerFilesystemError = (operation, path) => (error) => makeFileWalkerFilesystemError(operation, path, error);
 var makeFileWalkerFilesystemError = (operation, path, error) => new FileWalkerFilesystemError({
@@ -3211,11 +3282,11 @@ 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())
+import { Schema as Schema27, Stream as Stream7 } from "effect";
+var ParserSourceReadError = class extends Schema27.TaggedErrorClass()("ParserSourceReadError", {
+  message: Schema27.String,
+  path: Schema27.String,
+  cause: Schema27.optionalKey(Schema27.Defect())
 }) {
 };
 var makeParserSourceReadError = (path, error) => new ParserSourceReadError({
@@ -4354,14 +4425,14 @@ function bucketizeIndexedCodexFilesStream(files, cutoff, logger, options) {
 }
 
 // ../../packages/parsers/src/effect/hermes-sqlite.ts
-import { Context as Context9, Effect as Effect20, Layer as Layer8, Schema as Schema22 } from "effect";
+import { Context as Context13, Effect as Effect20, Layer as Layer8, Schema as Schema28 } from "effect";
 var NODE_SQLITE_SPECIFIER = ["node", "sqlite"].join(":");
 var MILLISECONDS_PER_SECOND = 1e3;
-var HermesSqliteError = class extends Schema22.TaggedErrorClass()("HermesSqliteError", {
-  message: Schema22.String,
-  operation: Schema22.Literals(["close", "load", "open", "query", "schema"]),
-  path: Schema22.optionalKey(Schema22.String),
-  cause: Schema22.optionalKey(Schema22.Defect())
+var HermesSqliteError = class extends Schema28.TaggedErrorClass()("HermesSqliteError", {
+  message: Schema28.String,
+  operation: Schema28.Literals(["close", "load", "open", "query", "schema"]),
+  path: Schema28.optionalKey(Schema28.String),
+  cause: Schema28.optionalKey(Schema28.Defect())
 }) {
 };
 function unsupportedSchema(message) {
@@ -4370,7 +4441,7 @@ function unsupportedSchema(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 HermesSqlite = class extends Context13.Service()("@oopst/parsers/HermesSqlite") {
 };
 var toHermesSqliteError = (operation, path) => (error) => new HermesSqliteError({
   message: `HermesSqlite.${operation} failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -4510,9 +4581,15 @@ var HermesSqliteLive = Layer8.effect(
 // ../../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 Effect21, FileSystem as FileSystem6, Layer as Layer9, Option as Option3, Schema as Schema23, Stream as Stream13 } from "effect";
+import { Context as Context14, Effect as Effect21, FileSystem as FileSystem6, Layer as Layer9, Option as Option3, Schema as Schema29, Stream as Stream13 } from "effect";
 var NODE_SQLITE_SPECIFIER2 = ["node", "sqlite"].join(":");
 var OPENCODE_DB_FILE_PATTERN2 = /^opencode(?:-[^/]+)?\.db$/u;
+var MESSAGE_QUERY = `
+    select session_id as "sessionId", time_created as "timeCreated", data
+    from message
+    where time_created >= ?
+    order by time_created asc, id asc
+  `;
 var SESSION_MESSAGE_QUERY = `
     select session_id as "sessionId", time_created as "timeCreated", data
     from session_message
@@ -4527,14 +4604,14 @@ var SESSION_PATH_QUERIES = [
        join project p on p.id = s.project_id
        where p.worktree is not null`
 ];
-var OpenCodeIoError = class extends Schema23.TaggedErrorClass()("OpenCodeIoError", {
-  message: Schema23.String,
-  operation: Schema23.Literals(["stat", "readdir", "readFile", "parseJson", "load", "open", "query", "close"]),
-  path: Schema23.optionalKey(Schema23.String),
-  cause: Schema23.optionalKey(Schema23.Defect())
+var OpenCodeIoError = class extends Schema29.TaggedErrorClass()("OpenCodeIoError", {
+  message: Schema29.String,
+  operation: Schema29.Literals(["stat", "readdir", "readFile", "parseJson", "load", "open", "query", "close"]),
+  path: Schema29.optionalKey(Schema29.String),
+  cause: Schema29.optionalKey(Schema29.Defect())
 }) {
 };
-var OpenCodeIo = class extends Context10.Service()("@oopst/parsers/OpenCodeIo") {
+var OpenCodeIo = class extends Context14.Service()("@oopst/parsers/OpenCodeIo") {
 };
 var toOpenCodeIoError = (operation, path) => (error) => new OpenCodeIoError({
   message: `OpenCodeIo.${operation} failed: ${error instanceof Error ? error.message : String(error)}`,
@@ -4679,14 +4756,38 @@ function readSessionPaths(db) {
   }
   return paths;
 }
+function queryMessageRows(db, sql, cutoff) {
+  return db.prepare(sql).all(cutoff.getTime());
+}
+function isMissingTableError(error, table) {
+  return error instanceof Error && error.message.includes(`no such table: ${table}`);
+}
+function readOpenCodeMessages(db, cutoff) {
+  let messages;
+  try {
+    messages = queryMessageRows(db, MESSAGE_QUERY, cutoff);
+    if (messages.length > 0) {
+      return messages;
+    }
+  } catch (error) {
+    if (!isMissingTableError(error, "message")) {
+      throw error;
+    }
+  }
+  try {
+    return queryMessageRows(db, SESSION_MESSAGE_QUERY, cutoff);
+  } catch (error) {
+    if (messages !== void 0 && isMissingTableError(error, "session_message")) {
+      return messages;
+    }
+    throw error;
+  }
+}
 var querySqliteRows = (path, db, cutoff) => Effect21.try({
-  try: () => {
-    const statement = db.prepare(SESSION_MESSAGE_QUERY);
-    return {
-      sessionMessages: statement.all(cutoff.getTime()),
-      sessionPaths: readSessionPaths(db)
-    };
-  },
+  try: () => ({
+    sessionMessages: readOpenCodeMessages(db, cutoff),
+    sessionPaths: readSessionPaths(db)
+  }),
   catch: toOpenCodeIoError("query", path)
 });
 var readSqlite = Effect21.fn("OpenCodeIo.readSqlite")(function* (path, cutoff) {
@@ -5709,7 +5810,7 @@ function optionalValue(value) {
   return Option4.getOrUndefined(value);
 }
 function isEntrypoint() {
-  const [, argvPath] = process4.argv;
+  const [, argvPath] = process2.argv;
   return argvPath ? realpathSync(fileURLToPath2(import.meta.url)) === realpathSync(argvPath) : false;
 }
 function parseHarnessFilter(value) {
@@ -5799,6 +5900,7 @@ function runSyncCommand(raw) {
     Effect27.gen(function* () {
       const configReader = yield* CliConfigReader;
       const console = yield* CliConsole;
+      const metadata = yield* CliPackageMetadata;
       const env = yield* configReader.read();
       const config = yield* Effect27.try({
         try: () => resolveSyncConfig(
@@ -5839,6 +5941,7 @@ function runSyncCommand(raw) {
       };
       const result = yield* runSyncProgram2({
         token,
+        cliVersion: metadata.version,
         device,
         serverUrl: config.serverUrl,
         lookbackDays: config.lookbackDays,